--- /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;
+
+public class TrackClipPair {
+ public TrackClipPair(Model.Track track, Model.Clip clip) {
+ this.track = track;
+ this.clip = clip;
+ }
+ public Model.Track track;
+ public Model.Clip clip;
+}
+
+public class Clipboard {
+ public Gee.ArrayList<TrackClipPair> clips = new Gee.ArrayList<TrackClipPair>();
+ int64 minimum_time = -1;
+
+ public void select(Gee.ArrayList<ClipView> selected_clips) {
+ clips.clear();
+ minimum_time = -1;
+ foreach(ClipView clip_view in selected_clips) {
+ TrackView track_view = clip_view.parent as TrackView;
+ if (minimum_time < 0 || clip_view.clip.start < minimum_time) {
+ minimum_time = clip_view.clip.start;
+ }
+ TrackClipPair track_clip_pair = new TrackClipPair(track_view.get_track(), clip_view.clip);
+ clips.add(track_clip_pair);
+ }
+ }
+
+ public void paste(Model.Track selected_track, int64 time) {
+ if (clips.size != 1) {
+ foreach (TrackClipPair pair in clips) {
+ pair.track.do_clip_paste(pair.clip.copy(), time + pair.clip.start - minimum_time);
+ }
+ } else {
+ selected_track.do_clip_paste(clips[0].clip.copy(), time);
+ }
+ }
+}
+
+public class TimeLine : Gtk.EventBox {
+ public Model.Project project;
+ public weak Model.TimeSystem provider;
+ public View.Ruler ruler;
+ Gtk.Widget drag_widget = null;
+ bool copying;
+ public Gee.ArrayList<TrackView> tracks = new Gee.ArrayList<TrackView>();
+ Gtk.VBox vbox;
+
+ public Gee.ArrayList<ClipView> selected_clips = new Gee.ArrayList<ClipView>();
+ public Clipboard clipboard = new Clipboard();
+
+ public const int BAR_HEIGHT = 32;
+ public const int BORDER = 4;
+
+ public signal void selection_changed(bool selected);
+ public signal void track_changed();
+ public signal void trackview_added(TrackView trackview);
+ public signal void trackview_removed(TrackView trackview);
+
+ float pixel_div;
+ float pixel_min = 0.1f;
+ float pixel_max = 4505.0f;
+ Gtk.Label high_water;
+
+ public const int RULER_HEIGHT = 32;
+ // GapView will re-emerge after 0.1 release
+ // public GapView gap_view;
+
+ public TimeLine(Model.Project p, Model.TimeSystem provider, Gdk.DragAction actions) {
+ add_events(Gdk.EventMask.POINTER_MOTION_MASK);
+ drag_widget = null;
+ can_focus = true;
+ project = p;
+ this.provider = provider;
+ provider.geometry_changed.connect(on_geometry_changed);
+
+ vbox = new Gtk.VBox(false, 0);
+ ruler = new View.Ruler(provider, RULER_HEIGHT);
+ ruler.position_changed.connect(on_ruler_position_changed);
+ vbox.pack_start(ruler, false, false, 0);
+
+ project.track_added.connect(on_track_added);
+ project.track_removed.connect(on_track_removed);
+ project.media_engine.position_changed.connect(on_position_changed);
+ add(vbox);
+
+ modify_bg(Gtk.StateType.NORMAL, parse_color("#444"));
+ modify_fg(Gtk.StateType.NORMAL, parse_color("#f00"));
+
+ pixel_div = pixel_max / pixel_min;
+ provider.calculate_pixel_step (0.5f, pixel_min, pixel_div);
+ Gtk.drag_dest_set(this, Gtk.DestDefaults.ALL, drag_target_entries, actions);
+ }
+
+ public void zoom_to_project(double width) {
+ if (project.get_length() == 0)
+ return;
+
+ // The 12.0 is just a magic number to completely get rid of the scrollbar on this operation
+ width -= 12.0;
+
+ double numerator = GLib.Math.log(
+ (width * Gst.SECOND) / ((double) project.get_length() * (double) pixel_min));
+ double denominator = GLib.Math.log((double) pixel_div);
+
+ zoom((float) (numerator / denominator) - provider.get_pixel_percentage());
+ }
+
+ public void zoom(float inc) {
+ provider.calculate_pixel_step(inc, pixel_min, pixel_div);
+ foreach (TrackView track in tracks) {
+ track.resize();
+ }
+ project.media_engine.position_changed(project.transport_get_position());
+ queue_draw();
+ }
+
+ void on_geometry_changed() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_geometry_changed");
+ provider.calculate_pixel_step(0, pixel_min, pixel_div);
+ ruler.queue_draw();
+ }
+
+ void on_position_changed() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_position_changed");
+ queue_draw();
+ }
+
+ void on_track_added(Model.Track track) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_added");
+ TrackView track_view = ClassFactory.get_class_factory().get_track_view(track, this);
+ track_view.clip_view_added.connect(on_clip_view_added);
+ tracks.add(track_view);
+ vbox.pack_start(track_view, false, false, 0);
+ trackview_added(track_view);
+ if (track.media_type() == Model.MediaType.VIDEO) {
+ vbox.reorder_child(track_view, 1);
+ }
+ vbox.show_all();
+ }
+
+ void on_track_removed(Model.Track track) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_track_removed");
+ foreach (TrackView track_view in tracks) {
+ if (track_view.get_track() == track) {
+ trackview_removed(track_view);
+ vbox.remove(track_view);
+ tracks.remove(track_view);
+ break;
+ }
+ }
+ }
+
+ public void on_clip_view_added(ClipView clip_view) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_clip_view_added");
+ clip_view.selection_request.connect(on_clip_view_selection_request);
+ clip_view.move_request.connect(on_clip_view_move_request);
+ clip_view.move_commit.connect(on_clip_view_move_commit);
+ clip_view.move_begin.connect(on_clip_view_move_begin);
+ clip_view.trim_begin.connect(on_clip_view_trim_begin);
+ clip_view.trim_commit.connect(on_clip_view_trim_commit);
+ }
+
+ public void deselect_all_clips() {
+ foreach(ClipView selected_clip_view in selected_clips) {
+ selected_clip_view.is_selected = false;
+ }
+ selected_clips.clear();
+ }
+
+ void on_clip_view_move_begin(ClipView clip_view, bool copy) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_move_begin");
+ copying = copy;
+ if (copy) {
+ project.undo_manager.start_transaction("Copy Clip");
+ }
+ ClipView max_clip = null;
+ //The first pass removes the clips from the track model and makes any copies
+ foreach (ClipView selected_clip in selected_clips) {
+ if (max_clip == null) {
+ max_clip = selected_clip;
+ } else if (max_clip.clip.end < selected_clip.clip.end) {
+ max_clip = selected_clip;
+ }
+ selected_clip.initial_time = selected_clip.clip.start;
+ selected_clip.clip.gnonlin_disconnect();
+ TrackView track_view = selected_clip.get_parent() as TrackView;
+ if (track_view != null) {
+ track_view.get_track().remove_clip_from_array(selected_clip.clip);
+ }
+ if (copy) {
+ // TODO: When adding in linking/groups, this should be moved into track_view
+ // We'll want to call move_begin for each clip that is linked, or in a group
+ // or selected and not iterate over them in this fashion in the timeline.
+ Model.Clip clip = selected_clip.clip.copy();
+ track_view.get_track().append_at_time(clip, selected_clip.clip.start, false);
+ }
+ }
+
+ high_water = new Gtk.Label(null);
+ Gtk.Fixed the_parent = clip_view.get_parent() as Gtk.Fixed;
+ the_parent.put(high_water,
+ max_clip.allocation.x + max_clip.allocation.width, max_clip.allocation.y);
+
+ //The second pass moves the selected clips to the top. We can't do this in one pass
+ //because creating a copy inserts the new copy in the z-order at the top.
+ foreach (ClipView selected_clip in selected_clips) {
+ TrackView track_view = selected_clip.get_parent() as TrackView;
+ track_view.move_to_top(selected_clip);
+ }
+ }
+
+ void on_clip_view_trim_begin(ClipView clip, Gdk.WindowEdge edge) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_trim_begin");
+ switch (edge) {
+ case Gdk.WindowEdge.WEST:
+ clip.initial_time = clip.clip.start;
+ break;
+ case Gdk.WindowEdge.EAST:
+ clip.initial_time = clip.clip.duration;
+ break;
+ default:
+ assert(false); // We only support trimming east and west;
+ break;
+ }
+ }
+
+ void on_clip_view_selection_request(ClipView clip_view, bool extend) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_selection_request");
+/*
+ if (gap_view != null) {
+ gap_view.unselect();
+ }
+*/
+ bool in_selected_clips = selected_clips.contains(clip_view);
+ if (!extend) {
+ if (!in_selected_clips) {
+ deselect_all_clips();
+ clip_view.is_selected = true;
+ selected_clips.add(clip_view);
+ }
+ } else {
+ if (selected_clips.size > 1) {
+ if (in_selected_clips && clip_view.is_selected) {
+ clip_view.is_selected = false;
+ // just deselected with multiple clips, so moving is not allowed
+ drag_widget = null;
+ selected_clips.remove(clip_view);
+ }
+ }
+ if (!in_selected_clips) {
+ clip_view.is_selected = true;
+ selected_clips.add(clip_view);
+ }
+ }
+ track_changed();
+ selection_changed(is_clip_selected());
+ queue_draw();
+ }
+
+ void on_clip_view_move_commit(ClipView clip_view, int64 delta) {
+ window.set_cursor(null);
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_move_request");
+ Gtk.Fixed fixed = high_water.get_parent() as Gtk.Fixed;
+ fixed.remove(high_water);
+ high_water = null;
+
+ project.undo_manager.start_transaction("Move Clip");
+ foreach (ClipView selected_clip_view in selected_clips) {
+ TrackView track_view = selected_clip_view.get_parent() as TrackView;
+ selected_clip_view.clip.gnonlin_connect();
+ track_view.get_track().move(selected_clip_view.clip,
+ selected_clip_view.clip.start, selected_clip_view.initial_time);
+ }
+ project.undo_manager.end_transaction("Move Clip");
+ if (copying) {
+ copying = false;
+ project.undo_manager.end_transaction("Copy Clip");
+ }
+ }
+
+ void on_clip_view_trim_commit(ClipView clip_view, Gdk.WindowEdge edge) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_move_commit");
+ window.set_cursor(null);
+ TrackView track_view = clip_view.get_parent() as TrackView;
+ int64 delta = 0;
+ switch (edge) {
+ case Gdk.WindowEdge.WEST:
+ delta = clip_view.clip.start - clip_view.initial_time;
+ break;
+ case Gdk.WindowEdge.EAST:
+ delta = clip_view.clip.duration - clip_view.initial_time;
+ break;
+ default:
+ assert(false); // We only handle WEST and EAST
+ break;
+ }
+ //restore back to pre-trim state
+ project.undo_manager.start_transaction("Trim Clip");
+ clip_view.clip.trim(-delta, edge);
+ clip_view.clip.gnonlin_connect();
+ track_view.get_track().trim(clip_view.clip, delta, edge);
+ project.undo_manager.end_transaction("Trim Clip");
+ }
+
+ void constrain_move(ClipView clip_view, ref int64 delta) {
+ int min_delta = clip_view.SNAP_DELTA;
+ int delta_xsize = provider.time_to_xsize(delta);
+ TrackView track_view = (TrackView) clip_view.parent as TrackView;
+ Model.Track track = track_view.get_track();
+ if (delta_xsize.abs() < min_delta) {
+ int64 range = provider.xsize_to_time(min_delta);
+ int64 adjustment;
+ if (track.clip_is_near(clip_view.clip, range, out adjustment)) {
+ delta = adjustment;
+ clip_view.snap(provider.time_to_xsize(adjustment));
+ }
+ }
+ }
+
+ void on_clip_view_move_request(ClipView clip_view, int64 delta) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_view_move_request");
+ if (project.snap_to_clip) {
+ constrain_move(clip_view, ref delta);
+ }
+ if (move_allowed(ref delta)) {
+ move_the_clips(delta);
+ }
+ }
+
+ bool move_allowed(ref int64 move_distance) {
+ if (drag_widget == null) {
+ return false;
+ }
+
+ ClipView max_clip = null;
+
+ foreach(ClipView clip_view in selected_clips) {
+ if (max_clip == null) {
+ max_clip = clip_view;
+ } else if (clip_view.clip.end > max_clip.clip.end){
+ max_clip = clip_view;
+ }
+ int position = provider.time_to_xpos(clip_view.clip.start + move_distance);
+ if (position < BORDER) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ void move_the_clips(int64 move_distance) {
+ foreach (ClipView clip_view in selected_clips) {
+ do_clip_move(clip_view, move_distance);
+ }
+ }
+
+ public void do_clip_move(ClipView clip_view, int64 delta) {
+ clip_view.clip.start += delta;
+ }
+
+ public void on_ruler_position_changed(int x) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_ruler_position_changed");
+ if (!project.transport_is_recording()) {
+ update_pos(x);
+ }
+ }
+
+ public bool is_clip_selected() {
+ return selected_clips.size > 0;
+ }
+
+ public bool gap_selected() {
+ return false;
+// return gap_view != null;
+ }
+
+ public void delete_selection() {
+ project.undo_manager.start_transaction("Delete Clips From Timeline");
+ drag_widget = null;
+ if (is_clip_selected()) {
+ while (selected_clips.size > 0) {
+ selected_clips[0].delete_clip();
+ selected_clips.remove_at(0);
+ }
+ track_changed();
+ } else {
+/*
+ if (gap_view != null) {
+ if (!project.can_delete_gap(gap_view.gap)) {
+ if (DialogUtils.delete_cancel("Really delete single-track gap?") ==
+ Gtk.ResponseType.YES) {
+ gap_view.remove();
+ }
+ } else {
+ project.delete_gap(gap_view.gap);
+ }
+
+ gap_view.unselect();
+ }
+*/
+ }
+ project.undo_manager.end_transaction("Delete Clips From Timeline");
+ }
+
+ public void do_cut() {
+ clipboard.select(selected_clips);
+ delete_selection();
+ }
+
+ public void do_copy() {
+ clipboard.select(selected_clips);
+ selection_changed(true);
+ }
+
+ public void paste() {
+ do_paste(project.transport_get_position());
+ }
+
+ public void do_paste(int64 pos) {
+ TrackView? view = null;
+ foreach (TrackView track_view in tracks) {
+ if (track_view.get_track().get_is_selected()) {
+ view = track_view;
+ }
+ }
+ // TODO: Lombard doesn't use selected state. The following check should be removed
+ // when it does
+ if (view == null) {
+ view = clipboard.clips[0].clip.type == Model.MediaType.VIDEO ?
+ find_video_track_view() : find_audio_track_view();
+ }
+ project.undo_manager.start_transaction("Paste");
+ clipboard.paste(view.get_track(), pos);
+ project.undo_manager.end_transaction("Paste");
+ queue_draw();
+ }
+
+ public void select_all() {
+ foreach (TrackView track in tracks) {
+ track.select_all();
+ }
+ }
+
+ public override bool expose_event(Gdk.EventExpose event) {
+ base.expose_event(event);
+
+ int xpos = provider.time_to_xpos(project.transport_get_position());
+ Gdk.draw_line(window, style.fg_gc[(int) Gtk.StateType.NORMAL],
+ xpos, 0,
+ xpos, allocation.height);
+
+ return true;
+ }
+
+ public override void drag_data_received(Gdk.DragContext context, int x, int y,
+ Gtk.SelectionData selection_data, uint drag_info,
+ uint time) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_drag_data_received");
+ string[] a = selection_data.get_uris();
+ Gtk.drag_finish(context, true, false, time);
+
+ Model.Track? track = null;
+ TrackView? track_view = find_child(x, y) as TrackView;
+
+ if (track_view == null) {
+ return;
+ }
+
+ bool timeline_add = true;
+
+ if (a.length > 1) {
+ if (Gtk.drag_get_source_widget(context) != null) {
+ DialogUtils.warning("Cannot add files",
+ "Files must be dropped onto the timeline individually.");
+ return;
+ }
+
+ if (DialogUtils.add_cancel(
+ "Files must be dropped onto the timeline individually.\n" +
+ "Do you wish to add these files to the library?") != Gtk.ResponseType.YES) {
+ return;
+ }
+ timeline_add = false;
+ } else {
+ track = track_view.get_track();
+ }
+
+ project.create_clip_importer(track, timeline_add, provider.xpos_to_time(x),
+ context.action == Gdk.DragAction.COPY, (Gtk.Window) get_toplevel(), a.length);
+ try {
+ foreach (string s in a) {
+ string filename;
+ try {
+ filename = GLib.Filename.from_uri(s);
+ } catch (GLib.ConvertError e) { continue; }
+ project.importer.add_file(filename);
+ }
+ project.importer.start();
+ } catch (Error e) {
+ project.error_occurred("Error importing", e.message);
+ }
+ }
+
+ public void update_pos(int event_x) {
+ int64 time = provider.xpos_to_time(event_x);
+ if (project.snap_to_clip) {
+ project.snap_coord(out time, provider.get_pixel_snap_time());
+ }
+ project.media_engine.go(time);
+ }
+
+ public Gtk.Widget? find_child(double x, double y) {
+ foreach (Gtk.Widget w in vbox.get_children()) {
+ if (w.allocation.y <= y && y < w.allocation.y + w.allocation.height)
+ return w;
+ }
+ return null;
+ }
+
+ void deselect_all() {
+ foreach (ClipView clip_view in selected_clips) {
+ clip_view.is_selected = false;
+ }
+ selected_clips.clear();
+ selection_changed(false);
+ }
+
+ public override bool button_press_event(Gdk.EventButton event) {
+/*
+ if (gap_view != null)
+ gap_view.unselect();
+*/
+ drag_widget = null;
+ Gtk.Widget? child = find_child(event.x, event.y);
+
+ if (child is View.Ruler) {
+ View.Ruler ruler = child as View.Ruler;
+ ruler.button_press_event(event);
+ drag_widget = child;
+ } else if (child is TrackView) {
+ TrackView track_view = child as TrackView;
+
+ drag_widget = track_view.find_child(event.x, event.y);
+ if (drag_widget != null) {
+ drag_widget.button_press_event(event);
+ } else {
+ deselect_all();
+ // want to select the track_views track as selected
+ track_view.get_track().set_selected(true);
+ }
+ } else {
+ deselect_all();
+ }
+ queue_draw();
+
+ return true;
+ }
+
+ public override bool button_release_event(Gdk.EventButton event) {
+ if (drag_widget != null) {
+ drag_widget.button_release_event(event);
+ drag_widget = null;
+ }
+ return true;
+ }
+
+ public override bool motion_notify_event(Gdk.EventMotion event) {
+ if (drag_widget != null) {
+ drag_widget.motion_notify_event(event);
+ } else {
+ Gtk.Widget widget = find_child(event.x, event.y);
+ if (widget is TrackView) {
+ TrackView? track_view = widget as TrackView;
+ if (track_view != null) {
+ ClipView? clip_view = track_view.find_child(event.x, event.y) as ClipView;
+ if (clip_view != null) {
+ clip_view.motion_notify_event(event);
+ } else {
+ window.set_cursor(null);
+ }
+ }
+ } else if (widget is View.Ruler) {
+ widget.motion_notify_event(event);
+ } else {
+ window.set_cursor(null);
+ }
+ }
+ return true;
+ }
+
+ TrackView? find_video_track_view() {
+ foreach (TrackView track in tracks) {
+ if (track.get_track().media_type() == Model.MediaType.VIDEO) {
+ return track;
+ }
+ }
+
+ return null;
+ }
+
+ TrackView? find_audio_track_view() {
+ foreach (TrackView track in tracks) {
+ if (track.get_track().media_type() == Model.MediaType.AUDIO) {
+ return track;
+ }
+ }
+
+ return null;
+ }
+}
projects / fillmore / blobdiff