--- /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;
+
+extern const string _PROGRAM_NAME;
+bool do_print_graph = false;
+int debug_level;
+
+const OptionEntry[] options = {
+ { "print-graph", 0, 0, OptionArg.NONE, &do_print_graph,
+ "Show Print Graph in help menu", null },
+ { "debug-level", 0, 0, OptionArg.INT, &debug_level,
+ "Control amount of diagnostic information",
+ "[0 (minimal),5 (maximum)]" },
+ { null }
+};
+
+class Recorder : Gtk.Window, TransportDelegate {
+ public Model.AudioProject project;
+ public TimeLine timeline;
+ View.ClickTrack click_track;
+ HeaderArea header_area;
+ ClipLibraryView library;
+ Model.TimeSystem provider;
+ Gtk.Adjustment h_adjustment;
+ Gtk.HPaned timeline_library_pane;
+ Gtk.ScrolledWindow library_scrolled;
+ Gtk.ScrolledWindow timeline_scrolled;
+ int cursor_pos = -1;
+ int64 center_time = -1;
+ bool loading;
+ const int scroll_speed = 8;
+
+ Gtk.ActionGroup main_group;
+
+ Gtk.ToggleButton play_button;
+ Gtk.ToggleButton record_button;
+ Gtk.Button addnew_button;
+ Gtk.Button rewind_button;
+ Gtk.Button forward_button;
+ Gtk.Button zoomin_button;
+ Gtk.Button zoomout_button;
+ Gtk.Button volume_button;
+
+ Hildon.PannableArea scrollwin;
+ int scrollwin_pos_y = 0;
+
+ Gtk.UIManager manager;
+ // TODO: Have a MediaExportConnector that extends MediaConnector rather than concrete type.
+ View.OggVorbisExport audio_export;
+ View.AudioOutput audio_output;
+ Gee.ArrayList<string> load_errors;
+
+ public const string NAME = "Fillmore";
+ const Gtk.ActionEntry[] entries = {
+ { "Project", null, "_Project", null, null, null },
+ { "Open", Gtk.STOCK_OPEN, "_Open...", null, "Open a project", on_project_open },
+ { "NewProject", Gtk.STOCK_NEW, "_New", null, "Create new project", on_project_new },
+ { "Save", Gtk.STOCK_SAVE, "_Save", "<Control>S", "Save project", on_project_save },
+ { "SaveAs", Gtk.STOCK_SAVE_AS, "Save _As...", "<Control><Shift>S",
+ "Save project with new name", on_project_save_as },
+ { "Export", Gtk.STOCK_JUMP_TO, "_Export...", "<Control>E", null, on_export },
+ { "Settings", Gtk.STOCK_PROPERTIES, "Se_ttings", "<Control><Alt>Return", null, on_properties },
+ { "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 },
+
+ { "Track", null, "_Track", null, null, null },
+ { "NewTrack", Gtk.STOCK_ADD, "_New...", "<Control><Shift>N",
+ "Create new track", on_track_new },
+ { "Rename", null, "_Rename...", null, "Rename Track", on_track_rename },
+ { "DeleteTrack", null, "_Delete", "<Control><Shift>Delete",
+ "Delete track", on_track_remove },
+ { "MoveTrackUp", null, "Move Track Up", "<Control>Up", null, on_track_move_up },
+ { "MoveTrackDown", null, "Move Track Down", "<Control>Down", null, on_track_move_down },
+ { "ScrollTracksUp", null, "Scroll Tracks Up", "<Shift>Up", null, on_tracks_scroll_up },
+ { "ScrollTracksDown", null, "Scroll Tracks Down", "<Shift>Down", null, on_tracks_scroll_down },
+
+
+ { "Help", null, "_Help", null, null, null },
+ { "Contents", Gtk.STOCK_HELP, "_Contents", "F1",
+ "More information on Fillmore", on_help_contents},
+ { "About", Gtk.STOCK_ABOUT, null, null, null, on_about },
+ { "SaveGraph", null, "Save _Graph", null, "Save graph", on_save_graph },
+
+ { "Rewind", Gtk.STOCK_MEDIA_PREVIOUS, "Rewind", "Home", "Go to beginning", on_rewind },
+ { "End", Gtk.STOCK_MEDIA_NEXT, "End", "End", "Go to end", on_end }
+ };
+
+ const Gtk.ToggleActionEntry[] toggle_entries = {
+ { "Play", Gtk.STOCK_MEDIA_PLAY, null, "space", "Play", on_play },
+ { "Record", Gtk.STOCK_MEDIA_RECORD, null, "r", "Record", on_record },
+ { "Library", null, "_Library", "F9", null, on_view_library, false },
+ { "Snap", null, "_Snap to Clip Edges", null, null, on_snap, false }
+ };
+
+ const string ui = """
+<ui>
+ <menubar name="MenuBar">
+ <menu name="ProjectMenu" action="Project">
+ <menuitem name="New" action="NewProject"/>
+ <menuitem name="Open" action="Open"/>
+ <menuitem name="Save" action="Save"/>
+ <menuitem name="SaveAs" action="SaveAs"/>
+ <separator/>
+ <menuitem name="Export" action="Export"/>
+ <separator/>
+ <menuitem name="Property" action="Settings"/>
+ <separator/>
+ <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="TrackMenu" action="Track">
+ <menuitem name="TrackNew" action="NewTrack"/>
+ <menuitem name="TrackRename" action="Rename"/>
+ <menuitem name="TrackDelete" action="DeleteTrack"/>
+ <separator/>
+ <menuitem name="TrackMoveUp" action="MoveTrackUp"/>
+ <menuitem name="TrackMoveDown" action="MoveTrackDown"/>
+ <menuitem name="TrackScrollUp" action="ScrollTracksUp"/>
+ <menuitem name="TrackScrollDown" action="ScrollTracksDown"/>
+ </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="Cut" action="Cut"/>
+ <menuitem name="Copy" action="Copy"/>
+ <separator/>
+ <menuitem name="ClipContextProperties" action="ClipProperties"/>
+ </popup>
+ <popup name="LibraryContextMenu">
+ <menuitem name="ClipContextProperties" action="ClipProperties"/>
+ </popup>
+ <toolbar name="Toolbar">
+ <toolitem name="New" action="NewTrack"/>
+ <separator/>
+ <toolitem name="Rewind" action="Rewind"/>
+ <toolitem name="End" action="End"/>
+ <toolitem name="Play" action="Play"/>
+ <toolitem name="Record" action="Record"/>
+ </toolbar>
+ <accelerator name="Rewind" action="Rewind"/>
+ <accelerator name="End" action="End"/>
+ <accelerator name="Play" action="Play"/>
+ <accelerator name="Record" action="Record"/>
+</ui>
+""";
+
+ const DialogUtils.filter_description_struct[] filters = {
+ { "Fillmore Project Files", Model.Project.FILLMORE_FILE_EXTENSION },
+ { "Lombard Project Files", Model.Project.LOMBARD_FILE_EXTENSION }
+ };
+
+ const DialogUtils.filter_description_struct[] export_filters = {
+ { "Ogg Files", "ogg" }
+ };
+
+ public signal void finished_closing(bool project_did_close);
+
+ public Recorder(string? project_file) throws Error {
+ ClassFactory.set_transport_delegate(this);
+ GLib.DirUtils.create(get_fillmore_directory(), 0777);
+ load_errors = new Gee.ArrayList<string>();
+ try {
+ set_icon_from_file(
+ AppDirs.get_resources_dir().get_child("fillmore_icon.png").get_path());
+ } catch (GLib.Error e) {
+ warning("Could not load application icon: %s", e.message);
+ }
+
+
+ project = new Model.AudioProject(project_file);
+ project.snap_to_clip = false;
+ provider = new Model.BarBeatTimeSystem(project);
+
+ project.media_engine.callback_pulse.connect(on_callback_pulse);
+ project.media_engine.post_export.connect(on_post_export);
+ project.media_engine.position_changed.connect(on_position_changed);
+
+ project.load_error.connect(on_load_error);
+ project.name_changed.connect(on_name_changed);
+ project.undo_manager.dirty_changed.connect(on_dirty_changed);
+ project.undo_manager.undo_changed.connect(on_undo_changed);
+ project.error_occurred.connect(on_error_occurred);
+ project.playstate_changed.connect(on_playstate_changed);
+ project.track_added.connect(on_track_added);
+ project.track_removed.connect(on_track_removed);
+ project.load_complete.connect(on_load_complete);
+ project.closed.connect(on_project_close);
+
+ audio_output = new View.AudioOutput(project.media_engine.get_project_audio_caps());
+ project.media_engine.connect_output(audio_output);
+ click_track = new View.ClickTrack(project.media_engine, project);
+ set_position(Gtk.WindowPosition.CENTER);
+ title = "Fillmore";
+ set_default_size(800, 1200);
+
+ main_group = new Gtk.ActionGroup("main");
+ main_group.add_actions(entries, this);
+ main_group.add_toggle_actions(toggle_entries, 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); }
+
+ Gtk.MenuBar menubar = (Gtk.MenuBar) get_widget(manager, "/MenuBar");
+ Gtk.Toolbar toolbar = (Gtk.Toolbar) get_widget(manager, "/Toolbar");
+ //play_button = (Gtk.ToggleToolButton) get_widget(manager, "/Toolbar/Play");
+ //record_button = (Gtk.ToggleToolButton) get_widget(manager, "/Toolbar/Record");
+ //rewind_button = (Gtk.ToolButton) get_widget(manager, "/Toolbar/Rewind");
+ //forward_button = (Gtk.ToolButton) get_widget(manager, "/Toolbar/End");
+ //addnew_button = (Gtk.ToolButton) get_widget(manager, "/Toolbar/New");
+ on_undo_changed(false);
+
+ library = new ClipLibraryView(project, provider, null, Gdk.DragAction.COPY);
+ library.selection_changed.connect(on_library_selection_changed);
+ library.drag_data_received.connect(on_drag_data_received);
+
+ timeline = new TimeLine(project, provider, Gdk.DragAction.COPY);
+ timeline.track_changed.connect(on_track_changed);
+ timeline.drag_data_received.connect(on_drag_data_received);
+ timeline.size_allocate.connect(on_timeline_size_allocate);
+ timeline.selection_changed.connect(on_timeline_selection_changed);
+
+ ClipView.context_menu = (Gtk.Menu) manager.get_widget("/ClipContextMenu");
+ ClipLibraryView.context_menu = (Gtk.Menu) manager.get_widget("/LibraryContextMenu");
+ update_menu();
+
+ library_scrolled = new Gtk.ScrolledWindow(null, null);
+ library_scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
+ library_scrolled.add_with_viewport(library);
+
+ Gtk.HBox hbox = new Gtk.HBox(false, 0);
+ header_area = new HeaderArea(this, provider, TimeLine.RULER_HEIGHT);
+ hbox.pack_start(header_area, false, false, 0);
+
+
+ timeline_scrolled = new Gtk.ScrolledWindow(null, null);
+ timeline_scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER);
+ timeline_scrolled.add_with_viewport(timeline);
+ hbox.pack_start(timeline_scrolled, true, true, 0);
+ h_adjustment = timeline_scrolled.get_hadjustment();
+
+
+
+ Gtk.HButtonBox buttons = new Gtk.HButtonBox();
+ addnew_button = new Gtk.Button(); //.with_label("Pl");
+ addnew_button.set_image(new Gtk.Image.from_icon_name("general_add", Gtk.IconSize.BUTTON));
+ addnew_button.clicked.connect(on_track_new);
+ buttons.add(addnew_button);
+ play_button = new Gtk.ToggleButton(); //.with_label("Pl");
+ play_button.set_image(new Gtk.Image.from_icon_name("camera_playback", Gtk.IconSize.BUTTON));
+ play_button.toggled.connect(on_play);
+ buttons.add(play_button);
+ record_button = new Gtk.ToggleButton(); //.with_label("Re");
+ record_button.set_image(new Gtk.Image.from_icon_name("camera_video_recording", Gtk.IconSize.BUTTON));
+ record_button.toggled.connect(on_record);
+ buttons.add(record_button);
+ rewind_button = new Gtk.Button(); //.with_label("Re");
+ rewind_button.set_image(new Gtk.Image.from_icon_name("pdf_viewer_first_page", Gtk.IconSize.BUTTON));
+ rewind_button.clicked.connect(on_rewind);
+ buttons.add(rewind_button);
+ forward_button = new Gtk.Button(); //.with_label("Re");
+ forward_button.set_image(new Gtk.Image.from_icon_name("pdf_viewer_last_page", Gtk.IconSize.BUTTON));
+ forward_button.clicked.connect(on_end);
+ buttons.add(forward_button);
+ zoomin_button = new Gtk.Button(); //.with_label("Re");
+ zoomin_button.set_image(new Gtk.Image.from_icon_name("pdf_zoomin", Gtk.IconSize.BUTTON));
+ zoomin_button.clicked.connect(on_zoom_in);
+ buttons.add(zoomin_button);
+ zoomout_button = new Gtk.Button(); //.with_label("Re");
+ zoomout_button.set_image(new Gtk.Image.from_icon_name("pdf_zoomout", Gtk.IconSize.BUTTON));
+ zoomout_button.clicked.connect(on_zoom_out);
+ buttons.add(zoomout_button);
+ volume_button = new Gtk.Button(); //.with_label("Re");
+ volume_button.set_image(new Gtk.Image.from_icon_name("statusarea_volumelevel4", Gtk.IconSize.BUTTON));
+ volume_button.clicked.connect(on_volume);
+ buttons.add(volume_button);
+
+
+ Gtk.VBox vbox = new Gtk.VBox(false, 0);
+ vbox.pack_start(menubar, false, false, 0);
+ //vbox.pack_start(toolbar, false, false, 0);
+ vbox.pack_start(buttons, false, false, 0);
+
+ Gtk.VBox main_view = new Gtk.VBox(false, 0);
+
+ timeline_library_pane = new Gtk.HPaned();
+ timeline_library_pane.set_position(project.library_width);
+ timeline_library_pane.add1(hbox);
+ timeline_library_pane.child1_resize = 1;
+ timeline_library_pane.add2(library_scrolled);
+ timeline_library_pane.child2_resize = 0;
+ timeline_library_pane.child1.size_allocate.connect(on_library_size_allocate);
+
+
+ main_view.pack_start(timeline_library_pane, true, true, 0);
+
+
+ scrollwin = new Hildon.PannableArea();
+ scrollwin.add_with_viewport(main_view);
+ vbox.add(scrollwin);
+
+ add(vbox);
+ // toggle the library pane off.
+ on_view_library();
+
+ Gtk.MenuItem? save_graph = (Gtk.MenuItem?)
+ get_widget(manager, "/MenuBar/HelpMenu/SaveGraph");
+
+ if (!do_print_graph && save_graph != null) {
+ save_graph.destroy();
+ }
+
+ add_accel_group(manager.get_accel_group());
+ timeline.grab_focus();
+ delete_event.connect(on_delete_event);
+ loading = true;
+ project.load(project_file);
+ if (project_file == null) {
+ default_track_set();
+ loading = false;
+ }
+ project.media_engine.pipeline.set_state(Gst.State.PAUSED);
+ }
+
+ void default_track_set() {
+ project.add_track(new Model.AudioTrack(project, get_default_track_name()));
+ project.tracks[0].set_selected(true);
+ }
+
+ static int default_track_number_compare(void *a, void *b) {
+ string* s1 = (string *) a;
+ string* s2 = (string *) b;
+ int i = -1;
+ int j = -1;
+ s1->scanf("track %d", &i);
+ s2->scanf("track %d", &j);
+ assert(i > 0);
+ assert(j > 0);
+ if (i == j) {
+ return 0;
+ } else if (i < j) {
+ return -1;
+ } else {
+ return 1;
+ }
+ }
+
+ public string get_default_track_name() {
+ List<string> default_track_names = new List<string>();
+ foreach(Model.Track track in project.tracks) {
+ if (track.display_name.has_prefix("track ")) {
+ default_track_names.append(track.display_name);
+ }
+ }
+ default_track_names.sort(default_track_number_compare);
+
+ int i = 1;
+ foreach(string s in default_track_names) {
+ string track_name = "track %d".printf(i);
+ if (s != track_name) {
+ return track_name;
+ }
+ ++i;
+ }
+ return "track %d".printf(i);
+ }
+
+ Gtk.Widget get_widget(Gtk.UIManager manager, string name) {
+ Gtk.Widget widget = manager.get_widget(name);
+ if (widget == null)
+ error("can't find widget");
+ return widget;
+ }
+
+ void on_track_move_up() {
+ int index = -1;
+ int position = 0;
+ int track_ct = project.tracks.size;
+ if (0 < track_ct) {
+ foreach(Model.Track track in project.tracks) {
+ ++index;
+ if (selected_track() == track) {
+ position = index;
+ }
+ }
+ if (0 < position) {
+ Model.AudioTrack track = selected_track() as Model.AudioTrack;
+ project.tracks.remove(track);
+ project.tracks.insert(position - 1, track);
+ }
+ }
+ }
+ void on_track_move_down() {
+ // if current track < position last
+ int index = -1;
+ int position = 0;
+ int track_ct = project.tracks.size;
+ if (0 < track_ct) {
+ foreach(Model.Track track in project.tracks) {
+ ++index;
+ if (selected_track() == track) {
+ position = index;
+ }
+ }
+ if (track_ct - 1 > position) {
+ Model.AudioTrack audio_track = selected_track() as Model.AudioTrack;
+ project.tracks.remove(audio_track);
+ project.tracks.insert(position + 1, audio_track);
+ }
+ }
+ }
+ void on_tracks_scroll_up() {
+ // if track count > 4 = Visible tracks
+ /*int track_ct = project.tracks.size;
+ if (4 < track_ct) {
+ // take bottom track and move to start
+ Model.AudioTrack track = project.tracks.get(track_ct - 1) as Model.AudioTrack;
+ project.tracks.remove(track);
+ project.tracks.insert(0, track);
+ }*/
+ scrollwin_pos_y -= scrollwin_pos_y < 4 ? 0 : 64;
+ scrollwin.scroll_to(0, scrollwin_pos_y);
+ }
+ void on_tracks_scroll_down() {
+ // if track count > 4 = visible tracks
+ /*int track_ct = project.tracks.size;
+ if (4 < track_ct) {
+ // take top track and move to end
+ Model.AudioTrack track = project.tracks.get(0) as Model.AudioTrack;
+ project.tracks.remove(track);
+ project.tracks.add(track);
+ }*/
+ scrollwin_pos_y += 64;
+ scrollwin.scroll_to(0, scrollwin_pos_y);
+ }
+
+ void set_sensitive_group(Gtk.ActionGroup group, string group_path, bool sensitive) {
+ Gtk.Action action = group.get_action(group_path);
+ action.set_sensitive(sensitive);
+ }
+
+ void on_track_changed() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_changed");
+ update_menu();
+ }
+
+ void on_position_changed() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_position_changed");
+ update_menu();
+ }
+
+ void on_track_added(Model.Track track) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_added");
+ update_menu();
+ track.clip_added.connect(on_clip_added);
+ track.clip_removed.connect(on_clip_removed);
+ track.track_selection_changed.connect(on_track_selection_changed);
+ }
+
+ void on_track_removed(Model.Track unused) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_removed");
+ update_menu();
+ }
+
+ void on_clip_added(Model.Clip clip) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_added");
+ clip.moved.connect(on_clip_moved);
+ update_menu();
+ }
+
+ void on_clip_removed(Model.Clip clip) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_removed");
+ clip.moved.disconnect(on_clip_moved);
+ update_menu();
+ }
+
+ void on_track_selection_changed(Model.Track track) {
+ if (track.get_is_selected()) {
+ foreach (Model.Track t in project.tracks) {
+ if (t != track) {
+ t.set_selected(false);
+ }
+ }
+ }
+ }
+
+ void on_clip_moved(Model.Clip clip) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_moved");
+ update_menu();
+ }
+
+ 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();
+ }
+
+ void update_menu() {
+ bool library_selected = library.has_selection();
+ bool selected = timeline.is_clip_selected();
+ bool playhead_on_clip = project.playhead_on_clip();
+ int number_of_tracks = project.tracks.size;
+ bool is_stopped = is_stopped();
+ bool one_selected = false;
+ if (library_selected) {
+ one_selected = library.get_selected_files().size == 1;
+ } else if (selected) {
+ one_selected = timeline.selected_clips.size == 1;
+ }
+
+ // File menu
+ set_sensitive_group(main_group, "NewProject", is_stopped);
+ set_sensitive_group(main_group, "Open", is_stopped);
+ set_sensitive_group(main_group, "Save", is_stopped);
+ set_sensitive_group(main_group, "SaveAs", is_stopped);
+ set_sensitive_group(main_group, "Settings", is_stopped);
+ set_sensitive_group(main_group, "Export", project.can_export());
+ set_sensitive_group(main_group, "Quit", !project.transport_is_recording());
+
+ // Edit menu
+ set_sensitive_group(main_group, "Undo", is_stopped && project.undo_manager.can_undo);
+ set_sensitive_group(main_group, "Copy", is_stopped && selected);
+ set_sensitive_group(main_group, "Cut", is_stopped && selected);
+ set_sensitive_group(main_group, "Paste", timeline.clipboard.clips.size != 0 && is_stopped);
+ set_sensitive_group(main_group, "Delete", (selected || library_selected) && is_stopped);
+ set_sensitive_group(main_group, "SplitAtPlayhead",
+ selected && playhead_on_clip && is_stopped);
+ set_sensitive_group(main_group, "TrimToPlayhead",
+ selected && playhead_on_clip && is_stopped);
+ set_sensitive_group(main_group, "ClipProperties", one_selected);
+
+ // View menu
+ set_sensitive_group(main_group, "ZoomProject", project.get_length() != 0);
+
+ // Track menu
+ set_sensitive_group(main_group, "Rename", number_of_tracks > 0 && is_stopped);
+ set_sensitive_group(main_group, "DeleteTrack", number_of_tracks > 0 && is_stopped);
+ set_sensitive_group(main_group, "NewTrack", is_stopped);
+
+ // toolbar
+ set_sensitive_group(main_group, "Play", true);
+ set_sensitive_group(main_group, "Record", number_of_tracks > 0 && is_stopped);
+ }
+
+ public Model.Track? selected_track() {
+ foreach (Model.Track track in project.tracks) {
+ if (track.get_is_selected()) {
+ return track;
+ }
+ }
+ error("can't find selected track");
+ return null;
+ }
+
+ public void scroll_to_beginning() {
+ h_adjustment.set_value(0.0);
+ }
+
+ public void page_to_time(int64 time) {
+ double location_in_window = timeline.provider.time_to_xpos(time) - h_adjustment.get_value();
+ int window_width = timeline.parent.allocation.width;
+ if (location_in_window > 0.9 * window_width ||
+ location_in_window < 0.1 * window_width) {
+ scroll_to_time(time);
+ }
+ }
+
+ public void scroll_to_time(int64 time) {
+ int new_adjustment = timeline.provider.time_to_xpos(time);
+ int window_width = timeline.parent.allocation.width;
+ if (new_adjustment < timeline.parent.allocation.width) {
+ new_adjustment = 0;
+ } else {
+ new_adjustment = new_adjustment - window_width / 2;
+ }
+
+ int max_value = (int)(h_adjustment.upper - timeline_scrolled.allocation.width);
+ if (new_adjustment > max_value) {
+ new_adjustment = max_value;
+ }
+
+ h_adjustment.set_value(new_adjustment);
+ }
+
+ public void scroll_to_end() {
+ scroll_to_time(project.get_length());
+ }
+
+ static int sgn(int x) {
+ if (x == 0)
+ return 0;
+ return x < 0 ? -1 : 1;
+ }
+
+ public void scroll_toward_center(int xpos) {
+ if (cursor_pos == -1) {
+ 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 = sgn(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);
+ }
+
+ public override bool key_press_event(Gdk.EventKey event) {
+ switch (event.keyval) {
+ case KeySyms.KP_Enter:
+ case KeySyms.Return:
+ if (project.transport_is_recording()) {
+ break;
+ }
+ if ((event.state & GDK_SHIFT_ALT_CONTROL_MASK) != 0)
+ return base.key_press_event(event);
+ on_rewind();
+ break;
+ case KeySyms.Left:
+ if (project.transport_is_recording()) {
+ break;
+ }
+ if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) {
+ project.go_previous();
+ } else {
+ project.media_engine.go(project.transport_get_position() - Gst.SECOND);
+ }
+ page_to_time(project.transport_get_position());
+ break;
+ case KeySyms.Right:
+ if (project.transport_is_recording()) {
+ break;
+ }
+ if ((event.state & Gdk.ModifierType.CONTROL_MASK) != 0) {
+ project.go_next();
+ } else {
+ project.media_engine.go(project.transport_get_position() + Gst.SECOND);
+ }
+ page_to_time(project.transport_get_position());
+ 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;
+ }
+
+ // File menu
+ void on_export() {
+ string filename = null;
+ if (DialogUtils.save(this, "Export", false, export_filters, ref filename)) {
+ try {
+ new MultiFileProgress(this, 1, "Export", project.media_engine);
+ project.media_engine.disconnect_output(audio_output);
+ audio_export = new View.OggVorbisExport(View.MediaConnector.MediaTypes.Audio,
+ filename, project.media_engine.get_project_audio_export_caps());
+ project.media_engine.connect_output(audio_export);
+ 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(audio_export);
+ project.media_engine.connect_output(audio_output);
+
+ if (canceled) {
+ GLib.FileUtils.remove(audio_export.get_filename());
+ }
+
+ audio_export = null;
+ }
+
+ void on_project_new_finished_closing(bool project_did_close) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_project_new_finished_closing");
+ project.closed.disconnect(on_project_close);
+ finished_closing.disconnect(on_project_new_finished_closing);
+ if (project_did_close) {
+ project.media_engine.set_play_state(PlayState.LOADING);
+ project.load(null);
+ default_track_set();
+ project.media_engine.pipeline.set_state(Gst.State.PAUSED);
+ project.undo_manager.reset();
+ }
+ }
+
+ void on_project_new() {
+ load_errors.clear();
+ project.closed.connect(on_project_close);
+ finished_closing.connect(on_project_new_finished_closing);
+ project.close();
+ }
+
+ void on_project_open_finished_closing(bool project_did_close) {
+ project.closed.disconnect(on_project_close);
+ finished_closing.disconnect(on_project_open_finished_closing);
+ if (project_did_close) {
+ GLib.SList<string> filenames;
+ if (DialogUtils.open(this, filters, false, false, out filenames)) {
+ loading = true;
+ project.load(filenames.data);
+ }
+ }
+ }
+
+ void on_project_open() {
+ load_errors.clear();
+ project.closed.connect(on_project_close);
+ finished_closing.connect(on_project_open_finished_closing);
+ project.close();
+ }
+
+ void on_project_save_as() {
+ save_dialog();
+ }
+
+ void on_project_save() {
+ do_save();
+ }
+
+ void on_save_new_file_finished_closing(bool did_close) {
+ project.closed.disconnect(on_project_close);
+ finished_closing.disconnect(on_save_new_file_finished_closing);
+ project.load(project.get_project_file());
+ }
+
+ bool do_save() {
+ if (project.get_project_file() != null) {
+ project.save(null);
+ return true;
+ }
+ else {
+ return save_dialog();
+ }
+ }
+
+ bool save_dialog() {
+ bool saving_new_file = project.get_project_file() == null;
+
+ string filename = project.get_project_file();
+ bool create_directory = project.get_project_file() == null;
+ if (DialogUtils.save(this, "Save Project", create_directory, filters, ref filename)) {
+ project.save(filename);
+ if (saving_new_file && project.get_project_file() != null) {
+ project.closed.connect(on_project_close);
+ finished_closing.connect(on_save_new_file_finished_closing);
+ project.close();
+ }
+ return true;
+ }
+ return false;
+ }
+
+ void on_properties() {
+ Gtk.Builder builder = new Gtk.Builder();
+ try {
+ builder.add_from_file(AppDirs.get_exec_dir().get_path() + "/resources/fillmore.glade");
+ //"/home/developer/Fillmore/resources/fillmore.glade");
+ //AppDirs.get_resources_dir().get_child("fillmore.glade").get_path());
+ } catch(GLib.Error e) {
+ stdout.printf("%s\n", e.message);
+ return;
+ }
+ builder.connect_signals(null);
+ ProjectProperties properties = (ProjectProperties)builder.get_object("projectproperties1");
+ properties.setup(project, builder);
+
+ int response = properties.run();
+ if (response == Gtk.ResponseType.APPLY) {
+ string description = "Set Project Properties";
+ project.undo_manager.start_transaction(description);
+ project.set_bpm(properties.get_tempo());
+ project.set_time_signature(properties.get_time_signature());
+ project.click_during_record = properties.during_record();
+ project.click_during_play = properties.during_play();
+ project.click_volume = properties.get_click_volume();
+ project.undo_manager.end_transaction(description);
+ }
+ properties.destroy();
+ }
+
+ void on_quit_finished_closing(bool project_did_close) {
+ project.closed.disconnect(on_project_close);
+ finished_closing.disconnect(on_quit_finished_closing);
+ if (project_did_close) {
+ Gtk.main_quit();
+ }
+ }
+
+ void on_quit() {
+ if (!project.transport_is_recording()) {
+ project.closed.connect(on_project_close);
+ finished_closing.connect(on_quit_finished_closing);
+ project.close();
+ }
+ }
+
+ bool on_delete_event() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_delete_event");
+ on_quit();
+ return true;
+ }
+
+ void on_project_close() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_project_close");
+ if (project.undo_manager.is_dirty) {
+ switch(DialogUtils.save_close_cancel(this, null, "Save changes before closing?")) {
+ case Gtk.ResponseType.ACCEPT:
+ if (!do_save()) {
+ finished_closing(false);
+ return;
+ }
+ break;
+ case Gtk.ResponseType.NO:
+ // if the user has never saved the file but quits anyway, save in .fillmore
+ if (project.get_project_file() == null) {
+ project.save(null);
+ }
+ break;
+ case Gtk.ResponseType.DELETE_EVENT: // when user presses escape.
+ case Gtk.ResponseType.CANCEL:
+ finished_closing(false);
+ return;
+ default:
+ assert(false);
+ break;
+ }
+ }
+ finished_closing(true);
+ }
+
+ // Edit menu
+ void on_cut() {
+ timeline.do_cut();
+ }
+
+ void on_copy() {
+ timeline.do_copy();
+ }
+
+ void on_paste() {
+ timeline.paste();
+ }
+
+ void on_undo() {
+ project.undo();
+ }
+
+ void on_delete() {
+ if (library.has_selection()) {
+ library.delete_selection();
+ } else {
+ timeline.delete_selection();
+ }
+ }
+
+ void on_select_all() {
+ if (library.has_selection()) {
+ library.select_all();
+ } else {
+ timeline.select_all();
+ }
+ }
+
+ 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() {
+ 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, null);
+ }
+ } 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, null);
+ }
+ }
+ }
+
+ // Track menu
+
+ void on_track_new() {
+ UI.TrackInformation dialog = new UI.TrackInformation();
+ dialog.set_track_name(get_default_track_name());
+ if (track_name_dialog(dialog, null)) {
+ project.add_track(new Model.AudioTrack(project, dialog.get_track_name()));
+ }
+ dialog.destroy();
+ }
+
+ void on_track_rename() {
+ UI.TrackInformation dialog = new UI.TrackInformation();
+ Model.Track track = selected_track();
+ dialog.set_title("Rename Track");
+ dialog.set_track_name(selected_track().display_name);
+ if (track_name_dialog(dialog, track)) {
+ track.set_display_name(dialog.get_track_name());
+ }
+ dialog.destroy();
+ }
+
+ bool track_name_dialog(UI.TrackInformation dialog, Model.Track? track) {
+ Gtk.ResponseType result = Gtk.ResponseType.OK;
+ bool is_ok = true;
+ do {
+ result = (Gtk.ResponseType) dialog.run();
+ string new_name = dialog.get_track_name();
+
+ if (result == Gtk.ResponseType.OK) {
+ if (new_name == "") {
+ is_ok = false;
+ DialogUtils.error("Invalid track name.", "The track name cannot be empty.");
+ } else {
+ is_ok = !project.is_duplicate_track_name(track, new_name);
+ if (!is_ok) {
+ DialogUtils.error("Duplicate track name.",
+ "A track with this name already exists.");
+ }
+ }
+ }
+ } while (result == Gtk.ResponseType.OK && !is_ok);
+ return result == Gtk.ResponseType.OK && is_ok;
+ }
+
+ void on_track_remove() {
+ project.remove_track(selected_track());
+ }
+
+ // View menu
+ 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_snap() {
+ project.snap_to_clip = !project.snap_to_clip;
+ }
+
+ void on_view_library() {
+ if (timeline_library_pane.child2 == library_scrolled) {
+ timeline_library_pane.remove(library_scrolled);
+ project.library_visible = false;
+ } else {
+ timeline_library_pane.add2(library_scrolled);
+ timeline_library_pane.show_all();
+ project.library_visible = true;
+ }
+ }
+
+ void on_library_size_allocate(Gdk.Rectangle rectangle) {
+ if (!loading && timeline_library_pane.child2 == library_scrolled) {
+ project.library_width = rectangle.width;
+ }
+ }
+
+ // Help menu
+
+ void on_help_contents() {
+ try {
+ Gtk.show_uri(null, "http://trac.yorba.org/wiki/UsingFillmore0.1", 0);
+ } catch (GLib.Error e) {
+ }
+ }
+
+ void on_about() {
+ Gtk.show_about_dialog(this,
+ "version", project.get_version(),
+ "comments", "An audio editor and recorder",
+ "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");
+ }
+
+ // toolbar
+
+ void on_volume() {
+ /// TODO
+ }
+
+ void on_rewind() {
+ project.media_engine.go(0);
+ scroll_to_beginning();
+ }
+
+ void on_end() {
+ project.go_end();
+ scroll_to_end();
+ }
+
+ void on_play() {
+ if (project.transport_is_recording()) {
+ set_sensitive_group(main_group, "Record", true);
+ record_button.set_active(false);
+ play_button.set_active(false);
+ project.media_engine.pause();
+ } else if (play_button.get_active())
+ project.media_engine.do_play(PlayState.PLAYING);
+ else
+ project.media_engine.pause();
+ }
+
+ void on_record() {
+ if (record_button.get_active()) {
+ Model.AudioTrack audio_track = selected_track() as Model.AudioTrack;
+ int number_of_channels;
+ if (audio_track.get_num_channels(out number_of_channels)) {
+ if (number_of_channels > CHANNELS_PER_TRACK_RECORD) {
+ record_button.set_active(false);
+ on_error_occurred("Can not record onto a stereo track", null);
+ return;
+ }
+ }
+ set_sensitive_group(main_group, "Record", false);
+ set_sensitive_group(main_group, "Play", false);
+ project.record(audio_track);
+ }
+ else {
+ on_play();
+ }
+ }
+
+ void on_callback_pulse() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_callback_pulse");
+ if (project.transport_is_playing()) {
+ scroll_toward_center(provider.time_to_xpos(project.media_engine.position));
+ }
+ timeline.queue_draw();
+ }
+
+ 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_timeline_size_allocate(Gdk.Rectangle rectangle) {
+ if (center_time != -1) {
+ int new_center_pixel = 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 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();
+ }
+
+ // main
+
+ /*static void main(string[] args) {
+ Hildon.gtk_init(ref args);
+ debug_level = -1;
+ OptionContext context = new OptionContext(
+ " [project file] - Record and edit multitrack audio");
+ 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 'fillmore --help' for a full list of available command line options.",
+ arg_error.message);
+ return;
+ }
+ Gtk.init(ref args);
+ try {
+ GLib.Environment.set_application_name("Fillmore");
+ if (debug_level > -1) {
+ set_logging_level((Logging.Level)debug_level);
+ }
+
+ AppDirs.init(args[0], _PROGRAM_NAME);
+ string rc_file = AppDirs.get_resources_dir().get_child("fillmore.rc").get_path();
+
+ Gtk.rc_parse(rc_file);
+ Gst.init(ref args);
+
+ 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) { }
+ }
+
+ ClassFactory.set_class_factory(new FillmoreClassFactory());
+ View.MediaEngine.can_run();
+
+ Recorder recorder = new Recorder(project_file);
+ recorder.show_all();
+ Gtk.main();
+ } catch (Error e) {
+ do_error_dialog("Could not start application.",e.message);
+ }
+ }*/
+
+ public static void do_error_dialog(string major_message, string? minor_message) {
+ DialogUtils.error(major_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");
+ project.media_engine.pipeline.set_state(Gst.State.PAUSED);
+ timeline_library_pane.set_position(project.library_width);
+
+ Gtk.ToggleAction action = main_group.get_action("Library") 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 (timeline_library_pane.child2 != library_scrolled) {
+ timeline_library_pane.add2(library_scrolled);
+ }
+ } else {
+ if (timeline_library_pane.child2 == library_scrolled) {
+ timeline_library_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_name_changed() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_name_changed");
+ set_title(project.get_file_display_name());
+ }
+
+ void on_dirty_changed(bool isDirty) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_dirty_changed");
+ Gtk.MenuItem? file_save = (Gtk.MenuItem?) get_widget(manager, "/MenuBar/ProjectMenu/Save");
+ assert(file_save != null);
+ file_save.set_sensitive(isDirty);
+ }
+
+ 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_playstate_changed(PlayState playstate) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_playstate_changed");
+ if (playstate == PlayState.STOPPED) {
+ cursor_pos = -1;
+ play_button.set_active(false);
+ set_sensitive_group(main_group, "Export", project.can_export());
+ update_menu();
+ }
+ }
+
+ void on_error_occurred(string major_message, string? minor_message) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_error_occurred");
+ DialogUtils.error(major_message, minor_message);
+ }
+
+ string get_fillmore_directory() {
+ return Path.build_filename(GLib.Environment.get_home_dir(), ".fillmore");
+ }
+
+ // TransportDelegate methods
+ bool is_playing() {
+ return project.transport_is_playing();
+ }
+
+ bool is_recording() {
+ return project.transport_is_recording();
+ }
+
+ bool is_stopped() {
+ return !(is_playing() || is_recording());
+ }
+}
+
+public class Fillmore : Hildon.Program {
+ construct { }
+
+ public void run(string[] args) {
+ debug_level = -1;
+ OptionContext context = new OptionContext(
+ " [project file] - Record and edit multitrack audio");
+ 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 'fillmore --help' for a full list of available command line options.",
+ arg_error.message);
+ return;
+ }
+ //Gtk.init(ref args);
+ try {
+ GLib.Environment.set_application_name("Fillmore");
+ if (debug_level > -1) {
+ set_logging_level((Logging.Level)debug_level);
+ }
+
+ AppDirs.init(args[0], _PROGRAM_NAME);
+ string rc_file = AppDirs.get_resources_dir().get_child("fillmore.rc").get_path();
+
+ Gtk.rc_parse(rc_file);
+ //Gst.init(ref args);
+
+ 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) { }
+ }
+
+ ClassFactory.set_class_factory(new FillmoreClassFactory());
+ View.MediaEngine.can_run();
+
+ Recorder recorder = new Recorder(project_file);
+ recorder.show_all();
+ Gtk.main();
+ } catch (Error e) {
+ Recorder.do_error_dialog("Could not start application.",e.message);
+ }
+ }
+}
+
+public static int main(string[] args) {
+ Gtk.init(ref args);
+ Gst.init(ref args);
+ Fillmore fillmore = new Fillmore();
+ fillmore.run(args);
+ return 0;
+}
+
+static void NO_main(string[] args) {
+ Hildon.gtk_init(ref args);
+ debug_level = -1;
+ OptionContext context = new OptionContext(
+ " [project file] - Record and edit multitrack audio");
+ 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 'fillmore --help' for a full list of available command line options.",
+ arg_error.message);
+ return;
+ }
+ Gtk.init(ref args);
+ try {
+ GLib.Environment.set_application_name("Fillmore");
+ if (debug_level > -1) {
+ set_logging_level((Logging.Level)debug_level);
+ }
+
+ AppDirs.init(args[0], _PROGRAM_NAME);
+ string rc_file = AppDirs.get_resources_dir().get_child("fillmore.rc").get_path();
+
+ Gtk.rc_parse(rc_file);
+ Gst.init(ref args);
+
+ 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) { }
+ }
+
+ ClassFactory.set_class_factory(new FillmoreClassFactory());
+ View.MediaEngine.can_run();
+
+ Recorder recorder = new Recorder(project_file);
+ recorder.show_all();
+ Gtk.main();
+ } catch (Error e) {
+ Recorder.do_error_dialog("Could not start application.",e.message);
+ }
+}
projects / fillmore / blobdiff