The Olive Global class.
More...
#include <oliveglobal.h>
The Olive Global class.
A resource for various global functions used throughout Olive.
◆ OliveGlobal()
| OliveGlobal::OliveGlobal |
( |
| ) |
|
OliveGlobal Constructor.
Creates Olive Global object. Also sets some default runtime settings and the application name.
◆ can_close_project
| bool OliveGlobal::can_close_project |
( |
| ) |
|
|
slot |
Determine whether the current project can be closed.
Queried any time the current project is going to be closed (e.g. starting a new project, loading a project, exiting Olive, etc.) If the project has unsaved changes, this function asks the user whether they want to save or not. If the user does, calls save_project() (which may in turn call save_project_as() if the project has never been saved).
- Returns
- TRUE if the project can be closed. FALSE if not. If the project does NOT have unsaved changes, always returns TRUE. If it does and the user clicks YES, this returns the result of save_project(). If the user clicks NO, this returns TRUE. If the user clicks CANCEL, this returns FALSE.
◆ check_for_autorecovery_file()
| void OliveGlobal::check_for_autorecovery_file |
( |
| ) |
|
Check whether an auto-recovery file exists and ask the user if they want to load it.
Usually called on initialization. Checks if an auto-recovery file exists (meaning the last session of Olive didn't close correctly). If it finds one, asks the user if they want to load it. If so, loads the auto-recovery project.
◆ clear_undo_stack
| void OliveGlobal::clear_undo_stack |
( |
| ) |
|
|
slot |
Clears the current undo stack.
Clears all current commands in the undo stack. Mostly used for debugging.
◆ finished_initialize
| void OliveGlobal::finished_initialize |
( |
| ) |
|
|
slot |
Function called when Olive has finished starting up.
Sets up some last things for Olive that must be run after Olive has completed initialization. If a project was loaded as a command line argument, it's loaded here.
◆ get_project_file_filter()
| const QString & OliveGlobal::get_project_file_filter |
( |
| ) |
|
Returns the file dialog filter used when interfacing with Olive project files.
- Returns
- The file filter string used by QFileDialog to limit the files shown to Olive (*.ove) files.
◆ get_recent_project_list_file()
| QString OliveGlobal::get_recent_project_list_file |
( |
| ) |
|
Retrieves the URL of the config file containing the autorecovery projects.
- Returns
- The URL as a string
◆ load_project_on_launch()
| void OliveGlobal::load_project_on_launch |
( |
const QString & |
s | ) |
|
Set a project to load just after launching.
Called by main() if Olive was called with a project file as a running argument. Sets up Olive to load the specified project once its finished initializing.
- Parameters
-
| s | The URL of the project file to load. |
◆ load_translation_from_config()
| void OliveGlobal::load_translation_from_config |
( |
| ) |
|
(Re)load translation file from olive::config
◆ new_project
| void OliveGlobal::new_project |
( |
| ) |
|
|
slot |
Create new project.
Confirms whether the current project can be closed, and if so, clears all current project data and resets program state. Standard File > New behavior.
◆ open_about_dialog
| void OliveGlobal::open_about_dialog |
( |
| ) |
|
|
slot |
Open the About Olive dialog.
◆ open_action_search
| void OliveGlobal::open_action_search |
( |
| ) |
|
|
slot |
Open the Action Search overlay.
◆ open_debug_log
| void OliveGlobal::open_debug_log |
( |
| ) |
|
|
slot |
Open the Debug Log window.
◆ open_export_dialog
| void OliveGlobal::open_export_dialog |
( |
| ) |
|
|
slot |
Open the Export dialog to trigger an export of the current sequence.
◆ open_preferences
| void OliveGlobal::open_preferences |
( |
| ) |
|
|
slot |
Opens the Preferences dialog.
◆ open_project
| void OliveGlobal::open_project |
( |
| ) |
|
|
slot |
Open a project from file.
Confirms whether the current project can be closed, and if so, shows an open file dialog to allow the user to select a project file and then triggers a project load with it.
◆ open_project_worker()
| void OliveGlobal::open_project_worker |
( |
const QString & |
fn, |
|
|
bool |
autorecovery |
|
) |
| |
|
private |
Internal function to handle loading a project from file.
Start loading a project. Doesn't check if the current project can be closed, doesn't check if the project exists. In most cases, you'll want open_project() to be end-user friendly.
- Parameters
-
| fn | The URL to the project to load. |
| autorecovery | Whether this file is an autorecovery file. If it is, after the load Olive will set the project URL to a new file beside the original project file so that it does not overwrite the original and so that the user is not working on the autorecovery project in Olive's application data directory. |
◆ open_recent
| void OliveGlobal::open_recent |
( |
int |
index | ) |
|
|
slot |
Open recent project from list.
Triggers a project load from the internal recent projects list.
- Parameters
-
| index | Index in the list of the project fille to load |
◆ open_speed_dialog
| void OliveGlobal::open_speed_dialog |
( |
| ) |
|
|
slot |
Open the Speed/Duration dialog.
◆ paste
| void OliveGlobal::paste |
( |
| ) |
|
|
slot |
Paste contents of clipboard.
Pastes contents of clipboard. Seeing as several types of data can be copied into the clipboard, this function will automatically determine what type of data is in the clipboard and paste it in the correct location (e.g. clip data will go to the Timeline, effect data will go to Effect Controls).
◆ paste_insert
| void OliveGlobal::paste_insert |
( |
| ) |
|
|
slot |
Paste contents of clipboard, making space for it when possible.
Pastes contents of clipboard (same as paste()). If the clipboard contains clip data, the clips are cut at the current playhead and ripple forward to make space for the clips in the clipboard. Can be considered semi-non-destructive as a result (as opposed to paste() overwriting clips). If the clipboard contains effect data, the functionality is identical to paste().
◆ redo
| void OliveGlobal::redo |
( |
| ) |
|
|
slot |
◆ save_autorecovery_file
| void OliveGlobal::save_autorecovery_file |
( |
| ) |
|
|
slot |
Save an auto-recovery file of the current project.
Call this function to save the current state of the project as an auto-recovery project. Called regularly by autorecovery_timer.
◆ save_project
| bool OliveGlobal::save_project |
( |
| ) |
|
|
slot |
Saves the current project to file.
If the project has been saved already, this function will overwrite the project file with the current project data. Calls save_project_as() if the file has not been saved before.
- Returns
- TRUE if the project has been saved before and was successfully overwritten. Otherwise returns the value of save_project_as(). Useful if the user closing an unsaved project, clicks "Yes" to save, we know if they actually saved or not and won't continue closing the project if they didn't.
◆ save_project_as
| bool OliveGlobal::save_project_as |
( |
| ) |
|
|
slot |
Shows a save file dialog and saves the project as the resulting filename.
Shows a save file dialog for the user to save their current project as a different filename from the current one. Also triggered by save_project() if the file hasn't been saved yet.
- Returns
- TRUE if the user saved the project. FALSE if they cancelled out of the save file dialog. Useful if a user is closing an unsaved project, clicks "Yes" to save, we know if they actually saved or not and won't continue closing the project if they didn't.
◆ set_rendering_state()
| void OliveGlobal::set_rendering_state |
( |
bool |
rendering | ) |
|
Set the application state depending on if the user is exporting a video.
Some background functions shouldn't run while Olive is exporting a video. This function will disable/enable them as necessary.
The current functions are as follows:
- Auto-recovery interval. Olive saves an auto-recovery just before exporting anyway and seeing as the user cannot make changes while rendering, there's no reason to continue saving auto-recovery files.
- Audio device playback. Olive uses the same internal audio buffer for exporting as it does for playback, but this buffer does not need to be forwarded to the output device when exporting.
- Parameters
-
| rendering | TRUE if Olive is about to export a video. FALSE if Olive has finished exporting. |
◆ undo
| void OliveGlobal::undo |
( |
| ) |
|
|
slot |
◆ update_project_filename()
| void OliveGlobal::update_project_filename |
( |
const QString & |
s | ) |
|
Change the current active project filename.
Triggered to change the current active project filename. Call this before calling any internal project saving or loading functions in order to set which file to work with (OliveGlobal::open_project() and OliveGlobal::save_project_as() do this automatically). Also updates the main window title to reflect the project filename.
- Parameters
-
| s | The URL of the project file to work with. Can be an empty string, in which case Olive will treat the project as an unsaved project. |
◆ autorecovery_timer
| QTimer OliveGlobal::autorecovery_timer |
|
private |
Regular interval to save an auto-recovery project.
◆ enable_load_project_on_init
| bool OliveGlobal::enable_load_project_on_init |
|
private |
Internal variable set to TRUE by main() if a project file was set as an argument.
◆ project_file_filter
| QString OliveGlobal::project_file_filter |
|
private |
File filter used for any file dialogs relating to Olive project files.
◆ translator
| std::unique_ptr<QTranslator> OliveGlobal::translator |
|
private |
Internal translator object that interfaces with the currently loaded language file.
The documentation for this class was generated from the following files:
