/******* command.h *******/ class CommandCallParameters { public: // The actual type of this doesn't matter but of course needs to be // decided on at some point. It's probably worth looking towards // Avisynth's filter parameter design. typename CommandCallParameterValue; CommandCallParameterValue GetValue(const wxString &name) const; void SetValue(const wxString &name, const CommandCallParameterValue &value); }; // Should probably derive from another more specific exception base class class CommandInvalidParametersException : public Aegisub::Exception; class Command { public: /// @brief Invoke the command in interactive mode /// @param project The subtitle project to perform the command on /// @param main_frame The main window the command was invoked in, usable /// for parenting dialogue boxes and obtaining various /// other GUI state. virtual void InvokeInteractive( SubtitleProject *project, FrameMain *main_frame ) const = 0; /// @brief Invoke the command in scripted mode /// @param project The subtitle project to perform the command on /// @param parameters The parameters to the command /// /// This method should throw CommandInvalidParametersException if the /// passed parameters are insufficient or invalid for the command. virtual void InvokeScripted( SubtitleProject *project, const CommandCallParameters ¶meters ) const = 0; /// @brief Determine whether the command can meaningfully be invoked in /// interactive mode /// @param project The subtitle project to test whether the command can /// be invoked on /// @param main_frame The main window to test whether the command can be /// invoked on /// @return False if the command can't successfully complete in the given /// state, true if all conditions for the command to successfully /// complete are satisfied /// /// Takes the same parameters as InvokeInteractive() and should check /// whether the user should be allowed to run the command in the current /// combination of project and UI state. In practice this will control /// whether the command's menu item and toolbar button will apppear grayed /// out or clickable. /// /// @todo Possibly commands should react to certain UI events like changing /// selection so this can be updated in a sensible way without /// polling or other ugly hacks. virtual bool CanInvokeInteractive( const SubtitleProject *project, const FrameMain *main_frame ) const = 0; /// @brief Get the internal name for the command /// @return A static store null-terminated character string without spaces /// uniquely identifying the command virtual const char * GetName() const = 0; /// @brief Get the translated menu name for the command /// @return The name for the command, suitable for being displayed on /// a menu item. The name should be translated into the user's /// UI language and have an appropriate character prepended by // an ampersand to denote the access key. virtual wxString GetMenuName() const = 0; /// @brief Get the translated display name for the command /// @return The name for the command, suitable for display to the user in /// all other cases than being on a menu. The name must not /// contain an ampersand denoting access key or any formatting /// relating to access keys, but should be translated into the /// user's UI language. virtual wxString GetDisplayName() const = 0; /// @brief Get the translated help string for the command /// @return The help string concisely describing the purpose of the command /// to the user, translated into the UI language. virtual wxString GetHelpString() const = 0; /// @brief Get the default hotkeys assigned to the command /// @return A vector of hotkey keystrokes assigned to the command by /// default. The first hotkey will be displayed in menu items and /// on toolbar tooltips. /// /// The default hotkeys are only used if the command hasn't been seen /// before and there is no known hotkey list associated with it. It may /// also be used if the user requests resetting the hotkeys for the /// command. If a default hotkey keystroke has already been registered for /// another command, the second command to claim the keystroke will not /// get it assigned. virtual std::vector GetDefaultHotkeys() const = 0; /// @todo Some way of specifying default menu and toolbar layouts and /// the behaviour if a new command appears after the menu and toolbar /// layout has been initially built, how the command can specify /// where it wants to sit. }; class CommandRepository { public: /// @brief Register a new command /// @param cmd The command object to register /// /// The registration will be ignored if there is already a command with /// the same internal name as the new command. /// /// If the command hasn't been seen before its default hotkeys and default /// menu and toolbar positions are registered and the UI is updated. /// /// The command object must have been allocated with operator new and will /// be owned by the command repository after having been registered. One /// command object can only belong to one command repository at a time. void RegisterCommand(Command *cmd); /// @brief Find a command by internal name /// @param name Internal name of the command to locate /// @return A const pointer to the command requested if it exists, /// otherwise 0. const Command * FindCommand(const char *name) const; }; /******* timing_commands.h *******/ class CommandRepository; void RegisterTimingCommands(CommandRepository *repository); /******* timing_commands.cpp *******/ #include "timing_commands.h" #include "command.h" namespace { class MakeContinuous : public Command { void DoWork(std::vector &lines) const; public: void InvokeInteractive(SubtitleProject *project, FrameMain *main_frame) const; void InvokeScripted(SubtitleProject *project, const CommandCallParameters ¶meters) const; bool CanInvokeInteractive(const SubtitleProject *project, const FrameMain *main_frame) const; const char * GetName() const { return "timing_make_continuous"; } wxString GetMenuName() const { return _("Make &continuous"); } wxString GetDisplayName() const { return _("Make continuous"); } wxString GetHelpString() const { return _("Adjust the timings of the selected lines so there are no gaps between them"); } std::vector GetDefaultHotkeys() const { return std::vector(); } }; class ShiftTimes : public Command { void ShiftByTime(std::vector &lines, int amount_ms, bool adjust_start, bool adjust_end) const; void ShiftByFrames(std::vector &lines, int amount_frames, const FramerateData &vfr, bool adjust_start, bool adjust_end) const; public: void InvokeInteractive(SubtitleProject *project, FrameMain *main_frame) const; void InvokeScripted(SubtitleProject *project, const CommandCallParameters ¶meters) const; bool CanInvokeInteractive(const SubtitleProject *project, const FrameMain *main_frame) const; const char * GetName() const { return "timing_shift"; } wxString GetMenuName() const { return _("&Shift times"); } wxString GetDisplayName() const { return _("Shift times"); } wxString GetHelpString() const { return _("Change the timings of many lines by a fixed amount at once"); } std::vector GetDefaultHotkeys() const { return std::vector(); } }; }; void MakeContinuous::DoWork(std::vector &lines) const { // Implement the algorithm here } void MakeContinuous::InvokeInteractive(SubtitleProject *project, FrameMain *main_frame) const { // Should probably do some sanity checks here first std::vector lines; main_frame->subs_grid->GetSelected(lines); DoWork(lines); } void MakeContinuous::InvokeScripted(SubtitleProject *project, const CommandCallParameters ¶meters) const { std::vector lines; int first_line = parameters.GetValue(_T("from")); int last_line = parameters.GetValue(_T("to")); for (int i = first_line; i <= last_line; ++i) lines.push_back(project->subtitles->GetDialogueByIndex(i)); DoWork(lines); } bool MakeContinuous::CanInvokeInteractive(const SubtitleProject *project, const FrameMain *main_frame) const { bool multiple_lines_selected_and_adjacent; // Do some checks here return multiple_lines_selected_and_adjacent; } void ShiftTimes::ShiftByTime(std::vector &lines, int amount_ms, bool adjust_start, bool adjust_end) const { // Do work } void ShiftTimes::ShiftByFrames(std::vector &lines, int amount_frames, const FramerateData &vfr, bool adjust_start, bool adjust_end) const { // Do work } void ShiftTimes::InvokeInteractive(SubtitleProject *project, FrameMain *main_frame) const { bool by_frames, adjust_start, adjust_end; int amount_ms, amount_frames; std::vector lines; ShiftTimesDialogue dlg(main_frame, project); if (dlg.ShowModal() == ID_OK) { // fill variables from dialogue // invoke command (also see below for scripted version) } } void ShiftTimes::InvokeScripted(SubtitleProject *project, const CommandCallParameters ¶meters) const { wxString mode = parameters.GetValue(_T("mode")); bool start = parameters.GetValue(_T("start")); bool end = parameters.GetValue(_T("end")); std::vector lines; // Do some more stuff to fill in lines, probably involving more parameters if (!mode || mode == _T("time")) { int amount_ms = parameters.GetValue(_T("ms")); ShiftByTime(lines, ms, start, end); } else if (mode == _T("frames")) { int amount_frames = parameters.GetValue(_T("frames")); ShiftByFrames(lines, frames, project->vfr, start, end); } else { throw CommandInvalidParametersException(GetName(), _T("mode"), _T("Value must be \"time\" or \"frames\", or empty to default to \"time\"")); } } bool ShiftTimes::CanInvokeInteractive(const SubtitleProject *project, const FrameMain *main_frame) const { return true; } void RegisterTimingCommands(CommandRepository *repository) { repository.RegisterCommand(new MakeContinuous); repository.RegisterCommand(new ShiftTimes); }