--- /dev/null
+/* Copyright 2009-2010 Yorba Foundation
+ *
+ * This software is licensed under the GNU Lesser General Public License
+ * (version 2.1 or later). See the COPYING file in this distribution.
+ */
+
+using Logging;
+
+int debug_level;
+const OptionEntry[] options = {
+ { "debug-level", 0, 0, OptionArg.INT, &debug_level,
+ "Control amount of diagnostic information",
+ "[0 (minimal),5 (maximum)]" },
+ { null }
+};
+
+class App : Gtk.Window, TransportDelegate {
+ Gtk.DrawingArea drawing_area;
+
+ Model.VideoProject project;
+ View.VideoOutput video_output;
+ View.AudioOutput audio_output;
+ View.OggVorbisExport export_connector;
+
+ TimeLine timeline;
+ ClipLibraryView library;
+ View.StatusBar status_bar;
+
+ Gtk.HPaned h_pane;
+
+ Gtk.ScrolledWindow library_scrolled;
+ Gtk.ScrolledWindow timeline_scrolled;
+ Gtk.Adjustment h_adjustment;
+
+ double prev_adjustment_lower;
+ double prev_adjustment_upper;
+
+ Gtk.ActionGroup main_group;
+
+ int64 center_time = -1;
+
+ Gtk.VBox vbox = null;
+ Gtk.MenuBar menubar;
+ Gtk.UIManager manager;
+
+ string project_filename;
+ Gee.ArrayList<string> load_errors;
+ bool loading;
+
+ public const string NAME = "Lombard";
+ const string LibraryToggle = "Library";
+
+ const Gtk.ActionEntry[] entries = {
+ { "Project", null, "_Project", null, null, null },
+ { "Open", Gtk.STOCK_OPEN, "_Open...", null, null, on_open },
+ { "Save", Gtk.STOCK_SAVE, null, null, null, on_save },
+ { "SaveAs", Gtk.STOCK_SAVE_AS, "Save _As...", "<Shift><Control>S", null, on_save_as },
+ { "Play", Gtk.STOCK_MEDIA_PLAY, "_Play / Pause", "space", null, on_play_pause },
+ { "Export", null, "_Export...", "<Control>E", null, on_export },
+ { "Quit", Gtk.STOCK_QUIT, null, null, null, on_quit },
+
+ { "Edit", null, "_Edit", null, null, null },
+ { "Undo", Gtk.STOCK_UNDO, null, "<Control>Z", null, on_undo },
+ { "Cut", Gtk.STOCK_CUT, null, null, null, on_cut },
+ { "Copy", Gtk.STOCK_COPY, null, null, null, on_copy },
+ { "Paste", Gtk.STOCK_PASTE, null, null, null, on_paste },
+ { "Delete", Gtk.STOCK_DELETE, null, "Delete", null, on_delete },
+ { "SelectAll", Gtk.STOCK_SELECT_ALL, null, "<Control>A", null, on_select_all },
+ { "SplitAtPlayhead", null, "_Split at Playhead", "<Control>P", null, on_split_at_playhead },
+ { "TrimToPlayhead", null, "Trim to Play_head", "<Control>H", null, on_trim_to_playhead },
+ { "ClipProperties", Gtk.STOCK_PROPERTIES, "Properti_es", "<Alt>Return",
+ null, on_clip_properties },
+
+ { "View", null, "_View", null, null, null },
+ { "ZoomIn", Gtk.STOCK_ZOOM_IN, "Zoom _In", "<Control>plus", null, on_zoom_in },
+ { "ZoomOut", Gtk.STOCK_ZOOM_OUT, "Zoom _Out", "<Control>minus", null, on_zoom_out },
+ { "ZoomProject", null, "Fit to _Window", "<Shift>Z", null, on_zoom_to_project },
+
+ { "Go", null, "_Go", null, null, null },
+ { "Start", Gtk.STOCK_GOTO_FIRST, "_Start", "Home", null, on_go_start },
+ { "End", Gtk.STOCK_GOTO_LAST, "_End", "End", null, on_go_end },
+
+ { "Help", null, "_Help", null, null, null },
+ { "Contents", Gtk.STOCK_HELP, "_Contents", "F1",
+ "More information on Lombard", on_help_contents},
+ { "About", Gtk.STOCK_ABOUT, null, null, null, on_about },
+ { "SaveGraph", null, "Save _Graph", null, "Save graph", on_save_graph }
+ };
+
+ const Gtk.ToggleActionEntry[] check_actions = {
+ { LibraryToggle, null, "_Library", "F9", null, on_view_library, true },
+ { "Snap", null, "_Snap to Clip Edges", null, null, on_snap, true }
+ };
+
+ const string ui = """
+<ui>
+ <menubar name="MenuBar">
+ <menu name="Project" action="Project">
+ <menuitem name="Open" action="Open"/>
+ <menuitem name="Save" action="Save"/>
+ <menuitem name="SaveAs" action="SaveAs"/>
+ <separator/>
+ <menuitem name="Play" action="Play"/>
+ <separator/>
+ <menuitem name="Export" action="Export"/>
+ <menuitem name="Quit" action="Quit"/>
+ </menu>
+ <menu name="EditMenu" action="Edit">
+ <menuitem name="EditUndo" action="Undo"/>
+ <separator/>
+ <menuitem name="EditCut" action="Cut"/>
+ <menuitem name="EditCopy" action="Copy"/>
+ <menuitem name="EditPaste" action="Paste"/>
+ <menuitem name="EditDelete" action="Delete"/>
+ <separator/>
+ <menuitem name="EditSelectAll" action="SelectAll"/>
+ <separator/>
+ <menuitem name="ClipSplitAtPlayhead" action="SplitAtPlayhead"/>
+ <menuitem name="ClipTrimToPlayhead" action="TrimToPlayhead"/>
+ <separator/>
+ <menuitem name="ClipViewProperties" action="ClipProperties"/>
+ </menu>
+ <menu name="ViewMenu" action="View">
+ <menuitem name="ViewLibrary" action="Library"/>
+ <separator/>
+ <menuitem name="ViewZoomIn" action="ZoomIn"/>
+ <menuitem name="ViewZoomOut" action="ZoomOut"/>
+ <menuitem name="ViewZoomProject" action="ZoomProject"/>
+ <separator/>
+ <menuitem name="Snap" action="Snap"/>
+ </menu>
+ <menu name="GoMenu" action="Go">
+ <menuitem name="GoStart" action="Start"/>
+ <menuitem name="GoEnd" action="End"/>
+ </menu>
+ <menu name="HelpMenu" action="Help">
+ <menuitem name="HelpContents" action="Contents"/>
+ <separator/>
+ <menuitem name="HelpAbout" action="About"/>
+ <menuitem name="SaveGraph" action="SaveGraph"/>
+ </menu>
+ </menubar>
+
+ <popup name="ClipContextMenu">
+ <menuitem name="ClipContextCut" action="Cut"/>
+ <menuitem name="ClipContextCopy" action="Copy"/>
+ <separator/>
+ <menuitem name="ClipContextProperties" action="ClipProperties"/>
+ </popup>
+ <popup name="LibraryContextMenu">
+ <menuitem name="ClipContextProperties" action="ClipProperties"/>
+ </popup>
+</ui>
+""";
+
+ const DialogUtils.filter_description_struct[] filters = {
+ { "Lombard Project Files", Model.Project.LOMBARD_FILE_EXTENSION },
+ { "Fillmore Project Files", Model.Project.FILLMORE_FILE_EXTENSION }
+ };
+
+ const DialogUtils.filter_description_struct[] export_filters = {
+ { "Ogg Files", "ogg" }
+ };
+
+ public App(string? project_file) throws Error {
+ try {
+ set_icon_from_file(
+ AppDirs.get_resources_dir().get_child("lombard_icon.png").get_path());
+ } catch (GLib.Error e) {
+ warning("Could not load application icon: %s", e.message);
+ }
+
+ if (debug_level > -1) {
+ set_logging_level((Logging.Level)debug_level);
+ }
+ ClassFactory.set_transport_delegate(this);
+ set_default_size(600, 500);
+ project_filename = project_file;
+
+ load_errors = new Gee.ArrayList<string>();
+ drawing_area = new Gtk.DrawingArea();
+ drawing_area.realize.connect(on_drawing_realize);
+ drawing_area.modify_bg(Gtk.StateType.NORMAL, parse_color("#000"));
+
+ main_group = new Gtk.ActionGroup("main");
+ main_group.add_actions(entries, this);
+ main_group.add_toggle_actions(check_actions, this);
+
+ manager = new Gtk.UIManager();
+ manager.insert_action_group(main_group, 0);
+ try {
+ manager.add_ui_from_string(ui, -1);
+ } catch (Error e) { error("%s", e.message); }
+
+ menubar = (Gtk.MenuBar) get_widget(manager, "/MenuBar");
+
+ project = new Model.VideoProject(project_filename);
+ project.snap_to_clip = true;
+ project.name_changed.connect(set_project_name);
+ project.load_error.connect(on_load_error);
+ project.load_complete.connect(on_load_complete);
+ project.error_occurred.connect(do_error_dialog);
+ project.undo_manager.undo_changed.connect(on_undo_changed);
+ project.media_engine.post_export.connect(on_post_export);
+ project.playstate_changed.connect(on_playstate_changed);
+
+ audio_output = new View.AudioOutput(project.media_engine.get_project_audio_caps());
+ project.media_engine.connect_output(audio_output);
+
+ timeline = new TimeLine(project, project.time_provider,
+ Gdk.DragAction.COPY | Gdk.DragAction.MOVE);
+ timeline.selection_changed.connect(on_timeline_selection_changed);
+ timeline.track_changed.connect(on_track_changed);
+ timeline.drag_data_received.connect(on_drag_data_received);
+ timeline.size_allocate.connect(on_timeline_size_allocate);
+ project.media_engine.position_changed.connect(on_position_changed);
+ project.media_engine.callback_pulse.connect(on_callback_pulse);
+ ClipView.context_menu = (Gtk.Menu) manager.get_widget("/ClipContextMenu");
+ ClipLibraryView.context_menu = (Gtk.Menu) manager.get_widget("/LibraryContextMenu");
+
+ library = new ClipLibraryView(project, project.time_provider, "Drag clips here.",
+ Gdk.DragAction.COPY | Gdk.DragAction.MOVE);
+ library.selection_changed.connect(on_library_selection_changed);
+ library.drag_data_received.connect(on_drag_data_received);
+
+ status_bar = new View.StatusBar(project, project.time_provider, TimeLine.BAR_HEIGHT);
+
+ library_scrolled = new Gtk.ScrolledWindow(null, null);
+ library_scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
+ library_scrolled.add_with_viewport(library);
+
+ toggle_library(true);
+
+ Gtk.MenuItem? save_graph = (Gtk.MenuItem?)
+ get_widget(manager, "/MenuBar/HelpMenu/SaveGraph");
+
+ // TODO: only destroy it if --debug is not specified on the command line
+ // or conversely, only add it if --debug is specified on the command line
+ if (save_graph != null) {
+ save_graph.destroy();
+ }
+
+ add_accel_group(manager.get_accel_group());
+
+ on_undo_changed(false);
+
+ delete_event.connect(on_delete_event);
+
+ if (project_filename == null) {
+ default_track_set();
+ on_load_complete();
+ }
+
+ update_menu();
+ show_all();
+ }
+
+ void default_track_set() {
+ project.add_track(new Model.VideoTrack(project));
+ project.add_track(new Model.AudioTrack(project, "Audio Track"));
+ }
+
+ bool on_delete_event() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_delete_event");
+ on_quit();
+ return true;
+ }
+
+ void on_quit() {
+ if (project.undo_manager.is_dirty) {
+ switch (DialogUtils.save_close_cancel(this, null, "Save changes before closing?")) {
+ case Gtk.ResponseType.ACCEPT:
+ if (!do_save()) {
+ return;
+ }
+ break;
+ case Gtk.ResponseType.CLOSE:
+ break;
+ case Gtk.ResponseType.DELETE_EVENT: // when user presses escape.
+ case Gtk.ResponseType.CANCEL:
+ return;
+ default:
+ assert(false);
+ break;
+ }
+ }
+
+ Gtk.main_quit();
+ }
+
+ void toggle_library(bool showing) {
+ if (vbox == null) {
+ vbox = new Gtk.VBox(false, 0);
+ vbox.pack_start(menubar, false, false, 0);
+
+ Gtk.VPaned v_pane = new Gtk.VPaned();
+ v_pane.set_position(290);
+
+ h_pane = new Gtk.HPaned();
+ h_pane.set_position(300);
+ h_pane.child2_resize = 1;
+ h_pane.child1_resize = 0;
+
+ if (showing) {
+ h_pane.add1(library_scrolled);
+ h_pane.add2(drawing_area);
+ } else {
+ h_pane.add2(drawing_area);
+ }
+ h_pane.child2.size_allocate.connect(on_library_size_allocate);
+ v_pane.add1(h_pane);
+
+ timeline_scrolled = new Gtk.ScrolledWindow(null, null);
+ timeline_scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
+ timeline_scrolled.add_with_viewport(timeline);
+
+ Gtk.VBox timeline_vbox = new Gtk.VBox(false, 0);
+ timeline_vbox.pack_start(status_bar, false, false, 0);
+ timeline_vbox.pack_start(timeline_scrolled, true, true, 0);
+ v_pane.add2(timeline_vbox);
+
+ v_pane.child1_resize = 1;
+ v_pane.child2_resize = 0;
+
+ h_adjustment = timeline_scrolled.get_hadjustment();
+ h_adjustment.changed.connect(on_adjustment_changed);
+ prev_adjustment_lower = h_adjustment.get_lower();
+ prev_adjustment_upper = h_adjustment.get_upper();
+
+ vbox.pack_start(v_pane, true, true, 0);
+
+ add(vbox);
+ } else {
+ project.library_visible = showing;
+ if (showing) {
+ h_pane.add1(library_scrolled);
+ } else {
+ h_pane.remove(library_scrolled);
+ }
+ }
+ show_all();
+ }
+
+ void on_drawing_realize() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_drawing_realize");
+ loading = true;
+ project.load(project_filename);
+ try {
+ video_output = new View.VideoOutput(drawing_area);
+ project.media_engine.connect_output(video_output);
+ } catch (Error e) {
+ do_error_dialog("Could not create video output", e.message);
+ }
+ }
+
+ void on_adjustment_changed(Gtk.Adjustment a) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_adjustment_changed");
+ if (prev_adjustment_upper != a.get_upper() ||
+ prev_adjustment_lower != a.get_lower()) {
+
+ prev_adjustment_lower = a.get_lower();
+ prev_adjustment_upper = a.get_upper();
+ }
+ }
+
+ void on_drag_data_received(Gtk.Widget w, Gdk.DragContext context, int x, int y,
+ Gtk.SelectionData selection_data, uint drag_info, uint time) {
+ present();
+ }
+
+ public void set_project_name(string? filename) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "set_project_name");
+ set_title(project.get_file_display_name());
+ }
+
+ public static void do_error_dialog(string message, string? minor_message) {
+ DialogUtils.error(message, minor_message);
+ }
+
+ public void on_load_error(string message) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_error");
+ load_errors.add(message);
+ }
+
+ public void on_load_complete() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_load_complete");
+ queue_draw();
+ if (project.find_video_track() == null) {
+ project.add_track(new Model.VideoTrack(project));
+ }
+
+ project.media_engine.pipeline.set_state(Gst.State.PAUSED);
+ h_pane.set_position(h_pane.allocation.width - project.library_width);
+ Gtk.ToggleAction action = main_group.get_action(LibraryToggle) as Gtk.ToggleAction;
+ if (action.get_active() != project.library_visible) {
+ action.set_active(project.library_visible);
+ }
+
+ action = main_group.get_action("Snap") as Gtk.ToggleAction;
+ if (action.get_active() != project.snap_to_clip) {
+ action.set_active(project.snap_to_clip);
+ }
+
+ if (project.library_visible) {
+ if (h_pane.child1 != library_scrolled) {
+ h_pane.add1(library_scrolled);
+ }
+ } else {
+ if (h_pane.child1 == library_scrolled) {
+ h_pane.remove(library_scrolled);
+ }
+ }
+
+ if (load_errors.size > 0) {
+ string message = "";
+ foreach (string s in load_errors) {
+ message = message + s + "\n";
+ }
+ do_error_dialog("An error occurred loading the project.", message);
+ }
+ loading = false;
+ }
+
+ void on_library_size_allocate(Gdk.Rectangle rectangle) {
+ if (!loading && h_pane.child1 == library_scrolled) {
+ project.library_width = rectangle.width;
+ }
+ }
+
+ // Loader code
+
+ public void load_file(string name, Model.LibraryImporter im) {
+ if (get_file_extension(name) == Model.Project.LOMBARD_FILE_EXTENSION ||
+ get_file_extension(name) == Model.Project.FILLMORE_FILE_EXTENSION)
+ load_project(name);
+ else {
+ try {
+ im.add_file(name);
+ } catch (Error e) {
+ do_error_dialog("Error loading file", e.message);
+ }
+ }
+ }
+
+ void on_open() {
+ load_errors.clear();
+ GLib.SList<string> filenames;
+ if (DialogUtils.open(this, filters, true, true, out filenames)) {
+ project.create_clip_importer(null, false, 0, false, null, 0);
+ project.importer.started.connect(on_importer_started);
+ try {
+ foreach (string s in filenames) {
+ string str;
+ try {
+ str = GLib.Filename.from_uri(s);
+ } catch (GLib.ConvertError e) { str = s; }
+ load_file(str, project.importer);
+ }
+ project.importer.start();
+ } catch (Error e) {
+ do_error_dialog("Could not open file", e.message);
+ }
+ }
+ }
+
+ void on_importer_started(Model.ClipImporter i, int num) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_importer_started");
+ new MultiFileProgress(this, num, "Import", i);
+ }
+
+ bool do_save_dialog() {
+ string? filename = project.get_project_file();
+ bool create_directory = filename == null;
+ if (DialogUtils.save(this, "Save Project", create_directory, filters, ref filename)) {
+ project.save(filename);
+ return true;
+ }
+ return false;
+ }
+
+ void on_save_as() {
+ do_save_dialog();
+ }
+
+ void on_save() {
+ do_save();
+ }
+
+ bool do_save() {
+ if (project.get_project_file() != null) {
+ project.save(null);
+ return true;
+ }
+ return do_save_dialog();
+ }
+
+ public void load_project(string filename) {
+ loading = true;
+
+ try {
+ project.media_engine.disconnect_output(video_output);
+ video_output = new View.VideoOutput(drawing_area);
+ project.media_engine.connect_output(video_output);
+ } catch (Error e) {
+ do_error_dialog("Could not create video output", e.message);
+ }
+
+ project.load(filename);
+
+ }
+
+ const float SCROLL_MARGIN = 0.05f;
+
+ void scroll_toward_center(int xpos) {
+ int cursor_pos = xpos - (int) h_adjustment.value;
+
+ // Move the cursor position toward the center of the window. We compute
+ // the remaining distance and move by its square root; this results in
+ // a smooth decelerating motion.
+ int page_size = (int) h_adjustment.page_size;
+ int diff = page_size / 2 - cursor_pos;
+ int d = sign(diff) * (int) Math.sqrt(diff.abs());
+ cursor_pos += d;
+
+ int x = int.max(0, xpos - cursor_pos);
+ int max_value = (int)(h_adjustment.upper - timeline_scrolled.allocation.width);
+ if (x > max_value) {
+ x = max_value;
+ }
+ h_adjustment.set_value(x);
+
+ h_adjustment.set_value(x);
+ }
+
+ public void on_split_at_playhead() {
+ project.split_at_playhead();
+ }
+
+ public void on_trim_to_playhead() {
+ project.trim_to_playhead();
+ }
+
+ public void on_clip_properties() {
+ Fraction? frames_per_second = null;
+ project.get_framerate_fraction(out frames_per_second);
+ if (library.has_selection()) {
+ Gee.ArrayList<string> files = library.get_selected_files();
+ if (files.size == 1) {
+ string file_name = files.get(0);
+ Model.ClipFile? clip_file = project.find_clipfile(file_name);
+ DialogUtils.show_clip_properties(this, null, clip_file, frames_per_second);
+ }
+ } else {
+ Gee.ArrayList<ClipView> clips = timeline.selected_clips;
+ if (clips.size == 1) {
+ ClipView clip_view = clips.get(0);
+ DialogUtils.show_clip_properties(this, clip_view, null, frames_per_second);
+ }
+ }
+ }
+
+ public void on_position_changed() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_position_changed");
+ update_menu();
+ }
+
+ void on_callback_pulse() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_callback_pulse");
+ if (project.transport_is_playing()) {
+ scroll_toward_center(project.time_provider.time_to_xpos(project.media_engine.position));
+ }
+ timeline.queue_draw();
+ }
+
+ public void on_track_changed() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_changed");
+ update_menu();
+ }
+
+ void update_menu() {
+ bool library_selected = library.has_selection();
+ bool clip_selected = timeline.is_clip_selected();
+ bool stopped = is_stopped();
+ bool clip_is_trimmed = false;
+ bool playhead_on_clip = project.playhead_on_clip();
+ bool dir;
+ bool can_trim = project.can_trim(out dir);
+ bool one_selected = false;
+ if (library_selected) {
+ one_selected = library.get_selected_files().size == 1;
+ } else if (clip_selected) {
+ one_selected = timeline.selected_clips.size == 1;
+ }
+
+ if (clip_selected) {
+ foreach (ClipView clip_view in timeline.selected_clips) {
+ clip_is_trimmed = clip_view.clip.is_trimmed();
+ if (clip_is_trimmed) {
+ break;
+ }
+ }
+ }
+ // File menu
+ set_sensitive_group(main_group, "Open", stopped);
+ set_sensitive_group(main_group, "Save", stopped);
+ set_sensitive_group(main_group, "SaveAs", stopped);
+ set_sensitive_group(main_group, "Export", project.can_export());
+
+ // Edit Menu
+ set_sensitive_group(main_group, "Undo", stopped && project.undo_manager.can_undo);
+ set_sensitive_group(main_group, "Delete", stopped && (clip_selected || library_selected));
+ set_sensitive_group(main_group, "Cut", stopped && clip_selected);
+ set_sensitive_group(main_group, "Copy", stopped && clip_selected);
+ set_sensitive_group(main_group, "Paste", stopped && timeline.clipboard.clips.size > 0);
+ set_sensitive_group(main_group, "ClipProperties", one_selected);
+
+ set_sensitive_group(main_group, "SplitAtPlayhead", stopped && playhead_on_clip);
+ set_sensitive_group(main_group, "TrimToPlayhead", stopped && can_trim);
+
+ // View Menu
+ set_sensitive_group(main_group, "ZoomProject", project.get_length() != 0);
+
+ }
+
+ public void on_timeline_selection_changed(bool selected) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_timeline_selection_changed");
+ if (selected)
+ library.unselect_all();
+ update_menu();
+ }
+
+ public void on_library_selection_changed(bool selected) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_library_selection_changed");
+ if (selected) {
+ timeline.deselect_all_clips();
+ timeline.queue_draw();
+ }
+ update_menu();
+ }
+
+ // We must use a key press event to handle the up arrow and down arrow keys,
+ // since GTK does not allow them to be used as accelerators.
+ public override bool key_press_event(Gdk.EventKey event) {
+ switch (event.keyval) {
+ case KeySyms.KP_Enter:
+ case KeySyms.Return:
+ if ((event.state & GDK_SHIFT_ALT_CONTROL_MASK) != 0)
+ return base.key_press_event(event);
+ on_go_start();
+ break;
+ case KeySyms.Left:
+ if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) {
+ project.go_previous();
+ } else {
+ project.go_previous_frame();
+ }
+ break;
+ case KeySyms.Right:
+ if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) {
+ project.go_next();
+ } else {
+ project.go_next_frame();
+ }
+ break;
+ case KeySyms.KP_Add:
+ case KeySyms.equal:
+ case KeySyms.plus:
+ on_zoom_in();
+ break;
+ case KeySyms.KP_Subtract:
+ case KeySyms.minus:
+ case KeySyms.underscore:
+ on_zoom_out();
+ break;
+ default:
+ return base.key_press_event(event);
+ }
+ return true;
+ }
+
+ void on_snap() {
+ project.snap_to_clip = !project.snap_to_clip;
+ }
+
+ void on_view_library() {
+ Gtk.ToggleAction action = main_group.get_action(LibraryToggle) as Gtk.ToggleAction;
+ toggle_library(action.get_active());
+ }
+
+ int64 get_zoom_center_time() {
+ return project.transport_get_position();
+ }
+
+ void do_zoom(float increment) {
+ center_time = get_zoom_center_time();
+ timeline.zoom(increment);
+ }
+
+ void on_zoom_in() {
+ do_zoom(0.1f);
+ }
+
+ void on_zoom_out() {
+ do_zoom(-0.1f);
+ }
+
+ void on_zoom_to_project() {
+ timeline.zoom_to_project(h_adjustment.page_size);
+ }
+
+ void on_timeline_size_allocate(Gdk.Rectangle rectangle) {
+ if (center_time != -1) {
+ int new_center_pixel = project.time_provider.time_to_xpos(center_time);
+ int page_size = (int)(h_adjustment.get_page_size() / 2);
+ h_adjustment.clamp_page(new_center_pixel - page_size, new_center_pixel + page_size);
+ center_time = -1;
+ }
+ }
+
+ void set_sensitive_group(Gtk.ActionGroup group, string group_path, bool sensitive) {
+ Gtk.Action action = group.get_action(group_path);
+ action.set_sensitive(sensitive);
+ }
+
+ // File commands
+
+ void on_play_pause() {
+ if (project.transport_is_playing())
+ project.media_engine.pause();
+ else {
+ // TODO: we should be calling play() here, which in turn would call
+ // do_play(Model.PlayState). This is not currently how the code is organized.
+ // This is part of a checkin that is already large, so putting this off for another
+ // checkin for ease of testing.
+ project.media_engine.do_play(PlayState.PLAYING);
+ }
+ }
+
+ void on_export() {
+ string filename = null;
+ if (DialogUtils.save(this, "Export", false, export_filters, ref filename)) {
+ new MultiFileProgress(this, 1, "Export", project.media_engine);
+ project.media_engine.disconnect_output(audio_output);
+ project.media_engine.disconnect_output(video_output);
+ try {
+ export_connector = new View.OggVorbisExport(
+ View.MediaConnector.MediaTypes.Audio | View.MediaConnector.MediaTypes.Video,
+ filename, project.media_engine.get_project_audio_export_caps());
+ project.media_engine.connect_output(export_connector);
+ project.media_engine.start_export(filename);
+ } catch (Error e) {
+ do_error_dialog("Could not export file", e.message);
+ }
+ }
+ }
+
+ void on_post_export(bool canceled) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_post_export");
+ project.media_engine.disconnect_output(export_connector);
+ project.media_engine.connect_output(audio_output);
+ project.media_engine.connect_output(video_output);
+ if (canceled) {
+ GLib.FileUtils.remove(export_connector.get_filename());
+ }
+ export_connector = null;
+ }
+
+ // Edit commands
+
+ void on_undo() {
+ project.undo();
+ }
+
+ void on_delete() {
+ if (library.has_selection())
+ library.delete_selection();
+ else
+ timeline.delete_selection();
+ }
+
+ void on_cut() {
+ timeline.do_cut();
+ }
+
+ void on_copy() {
+ timeline.do_copy();
+ }
+
+ void on_paste() {
+ timeline.paste();
+ }
+
+ void on_playstate_changed(PlayState playstate) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_playstate_changed");
+ if (playstate == PlayState.STOPPED) {
+ update_menu();
+ }
+ }
+
+ void on_undo_changed(bool can_undo) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_undo_changed");
+ Gtk.MenuItem? undo = (Gtk.MenuItem?) get_widget(manager, "/MenuBar/EditMenu/EditUndo");
+ assert(undo != null);
+ //undo.set_label("_Undo " + project.undo_manager.get_undo_title());
+ set_sensitive_group(main_group, "Undo", is_stopped() && project.undo_manager.can_undo);
+ }
+
+ void on_select_all() {
+ if (library.has_selection()) {
+ library.select_all();
+ } else {
+ timeline.select_all();
+ }
+ }
+
+ // Go commands
+
+ void on_go_start() { project.go_start(); }
+
+ void on_go_end() { project.go_end(); }
+
+ // Help commands
+
+ void on_help_contents() {
+ try {
+ Gtk.show_uri(null, "http://trac.yorba.org/wiki/UsingLombard0.1", 0);
+ } catch (GLib.Error e) {
+ }
+ }
+
+ void on_about() {
+ Gtk.show_about_dialog(this,
+ "version", project.get_version(),
+ "comments", "A video editor",
+ "copyright", "Copyright 2009-2010 Yorba Foundation",
+ "website", "http://www.yorba.org",
+ "license", project.get_license(),
+ "website-label", "Visit the Yorba web site",
+ "authors", project.authors
+ );
+ }
+
+ void on_save_graph() {
+ project.print_graph(project.media_engine.pipeline, "save_graph");
+ }
+
+ // Transport Delegate methods
+ bool is_recording() {
+ return project.transport_is_recording();
+ }
+
+ bool is_playing() {
+ return project.transport_is_playing();
+ }
+
+ bool is_stopped() {
+ return !(is_playing() || is_recording());
+ }
+}
+
+extern const string _PROGRAM_NAME;
+
+void main(string[] args) {
+ debug_level = -1;
+ OptionContext context = new OptionContext(
+ " [project file] - Create and edit movies");
+ context.add_main_entries(options, null);
+ context.add_group(Gst.init_get_option_group());
+
+ try {
+ context.parse(ref args);
+ } catch (GLib.Error arg_error) {
+ stderr.printf("%s\nRun 'lombard --help' for a full list of available command line options.",
+ arg_error.message);
+ return;
+ }
+ Gtk.init(ref args);
+
+ try {
+ GLib.Environment.set_application_name("Lombard");
+
+ AppDirs.init(args[0], _PROGRAM_NAME);
+ Gst.init(ref args);
+
+ if (args.length > 2) {
+ stderr.printf("usage: %s [project-file]\n", args[0]);
+ return;
+ }
+
+ string? project_file = null;
+ if (args.length > 1) {
+ project_file = args[1];
+ try {
+ project_file = GLib.Filename.from_uri(project_file);
+ } catch (GLib.Error e) { }
+ }
+
+ string str = GLib.Environment.get_variable("LOMBARD_DEBUG");
+ debug_enabled = (str != null && (str[0] >= '1'));
+ ClassFactory.set_class_factory(new ClassFactory());
+ View.MediaEngine.can_run();
+
+ new App(project_file);
+ Gtk.main();
+ } catch (Error e) {
+ App.do_error_dialog("Could not launch application", "%s.".printf(e.message));
+ }
+}
+
projects / fillmore / blobdiff