--- /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 GapView : Gtk.DrawingArea {
+ public Model.Gap gap;
+ Gdk.Color fill_color;
+
+ public GapView(int64 start, int64 length, int width, int height) {
+
+ gap = new Model.Gap(start, start + length);
+
+ Gdk.Color.parse("#777", out fill_color);
+
+ set_flags(Gtk.WidgetFlags.NO_WINDOW);
+
+ set_size_request(width, height);
+ }
+
+ public signal void removed(GapView gap_view);
+ public signal void unselected(GapView gap_view);
+
+ public void remove() {
+ removed(this);
+ }
+
+ public void unselect() {
+ unselected(this);
+ }
+
+ public override bool expose_event(Gdk.EventExpose e) {
+ draw_rounded_rectangle(window, fill_color, true, allocation.x, allocation.y,
+ allocation.width - 1, allocation.height - 1);
+ return true;
+ }
+}
+
+public class ClipView : Gtk.DrawingArea {
+ enum MotionMode {
+ NONE,
+ DRAGGING,
+ LEFT_TRIM,
+ RIGHT_TRIM
+ }
+
+ public Model.Clip clip;
+ public int64 initial_time;
+ weak Model.TimeSystem time_provider;
+ public bool is_selected;
+ public int height; // TODO: We request size of height, but we aren't allocated this height.
+ // We should be using the allocated height, not the requested height.
+ public static Gtk.Menu context_menu;
+ TransportDelegate transport_delegate;
+ Gdk.Color color_black;
+ Gdk.Color color_normal;
+ Gdk.Color color_selected;
+ int drag_point;
+ int snap_amount;
+ bool snapped;
+ MotionMode motion_mode = MotionMode.NONE;
+ bool button_down = false;
+ bool pending_selection;
+ const int MIN_DRAG = 5;
+ const int TRIM_WIDTH = 10;
+ public const int SNAP_DELTA = 10;
+
+ static Gdk.Cursor left_trim_cursor = new Gdk.Cursor(Gdk.CursorType.LEFT_SIDE);
+ static Gdk.Cursor right_trim_cursor = new Gdk.Cursor(Gdk.CursorType.RIGHT_SIDE);
+ static Gdk.Cursor hand_cursor = new Gdk.Cursor.from_name(Gdk.Display.get_default(), "dnd-none");
+ // will be used for drag
+ static Gdk.Cursor plus_cursor = new Gdk.Cursor.from_name(Gdk.Display.get_default(), "dnd-copy");
+
+ public signal void clip_deleted(Model.Clip clip);
+ public signal void clip_moved(ClipView clip);
+ public signal void selection_request(ClipView clip_view, bool extend_selection);
+ public signal void move_request(ClipView clip_view, int64 delta);
+ public signal void move_commit(ClipView clip_view, int64 delta);
+ public signal void move_begin(ClipView clip_view, bool copy);
+ public signal void trim_begin(ClipView clip_view, Gdk.WindowEdge edge);
+ public signal void trim_commit(ClipView clip_view, Gdk.WindowEdge edge);
+
+ public ClipView(TransportDelegate transport_delegate, Model.Clip clip,
+ Model.TimeSystem time_provider, int height) {
+ this.transport_delegate = transport_delegate;
+ this.clip = clip;
+ this.time_provider = time_provider;
+ this.height = height;
+ is_selected = false;
+
+ clip.moved.connect(on_clip_moved);
+ clip.updated.connect(on_clip_updated);
+
+ Gdk.Color.parse("000", out color_black);
+ get_clip_colors();
+
+ set_flags(Gtk.WidgetFlags.NO_WINDOW);
+
+ adjust_size(height);
+ }
+
+ void get_clip_colors() {
+ if (clip.clipfile.is_online()) {
+ Gdk.Color.parse(clip.type == Model.MediaType.VIDEO ? "#d82" : "#84a",
+ out color_selected);
+ Gdk.Color.parse(clip.type == Model.MediaType.VIDEO ? "#da5" : "#b9d",
+ out color_normal);
+ } else {
+ Gdk.Color.parse("red", out color_selected);
+ Gdk.Color.parse("#AA0000", out color_normal);
+ }
+ }
+
+ void on_clip_updated() {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_updated");
+ get_clip_colors();
+ queue_draw();
+ }
+
+ // Note that a view's size may vary slightly (by a single pixel) depending on its
+ // starting position. This is because the clip's length may not be an integer number of
+ // pixels, and may get rounded either up or down depending on the clip position.
+ public void adjust_size(int height) {
+ int width = time_provider.time_to_xpos(clip.start + clip.duration) -
+ time_provider.time_to_xpos(clip.start);
+ set_size_request(width + 1, height);
+ }
+
+ public void on_clip_moved(Model.Clip clip) {
+ emit(this, Facility.SIGNAL_HANDLERS, Level.INFO, "on_clip_moved");
+ adjust_size(height);
+ clip_moved(this);
+ }
+
+ public void delete_clip() {
+ clip_deleted(clip);
+ }
+
+ public void draw() {
+ weak Gdk.Color fill = is_selected ? color_selected : color_normal;
+
+ bool left_trimmed = clip.media_start != 0 && !clip.is_recording;
+
+ bool right_trimmed = clip.clipfile.is_online() ?
+ (clip.media_start + clip.duration != clip.clipfile.length) : false;
+
+ if (!left_trimmed && !right_trimmed) {
+ draw_rounded_rectangle(window, fill, true, allocation.x + 1, allocation.y + 1,
+ allocation.width - 2, allocation.height - 2);
+ draw_rounded_rectangle(window, color_black, false, allocation.x, allocation.y,
+ allocation.width - 1, allocation.height - 1);
+
+ } else if (!left_trimmed && right_trimmed) {
+ draw_left_rounded_rectangle(window, fill, true, allocation.x + 1, allocation.y + 1,
+ allocation.width - 2, allocation.height - 2);
+ draw_left_rounded_rectangle(window, color_black, false, allocation.x, allocation.y,
+ allocation.width - 1, allocation.height - 1);
+
+ } else if (left_trimmed && !right_trimmed) {
+ draw_right_rounded_rectangle(window, fill, true, allocation.x + 1, allocation.y + 1,
+ allocation.width - 2, allocation.height - 2);
+ draw_right_rounded_rectangle(window, color_black, false, allocation.x, allocation.y,
+ allocation.width - 1, allocation.height - 1);
+
+ } else {
+ draw_square_rectangle(window, fill, true, allocation.x + 1, allocation.y + 1,
+ allocation.width - 2, allocation.height - 2);
+ draw_square_rectangle(window, color_black, false, allocation.x, allocation.y,
+ allocation.width - 1, allocation.height - 1);
+ }
+
+ Gdk.GC gc = new Gdk.GC(window);
+ Gdk.Rectangle r = { 0, 0, 0, 0 };
+
+ // Due to a Vala compiler bug, we have to do this initialization here...
+ r.x = allocation.x;
+ r.y = allocation.y;
+ r.width = allocation.width;
+ r.height = allocation.height;
+
+ gc.set_clip_rectangle(r);
+
+ Pango.Layout layout;
+ if (clip.is_recording) {
+ layout = create_pango_layout("Recording");
+ } else if (!clip.clipfile.is_online()) {
+ layout = create_pango_layout("%s (Offline)".printf(clip.name));
+ }
+ else {
+ layout = create_pango_layout("%s".printf(clip.name));
+ }
+ int width, height;
+ layout.get_pixel_size(out width, out height);
+ Gdk.draw_layout(window, gc, allocation.x + 10, allocation.y + height, layout);
+ }
+
+ public override bool expose_event(Gdk.EventExpose event) {
+ draw();
+ return true;
+ }
+
+ public override bool button_press_event(Gdk.EventButton event) {
+ if (!transport_delegate.is_stopped()) {
+ return true;
+ }
+
+ event.x -= allocation.x;
+ bool primary_press = event.button == 1;
+ if (primary_press) {
+ button_down = true;
+ drag_point = (int)event.x;
+ snap_amount = 0;
+ snapped = false;
+ }
+
+ bool extend_selection = (event.state & Gdk.ModifierType.CONTROL_MASK) != 0;
+ // The clip is not responsible for changing the selection state.
+ // It may depend upon knowledge of multiple clips. Let anyone who is interested
+ // update our state.
+ if (is_left_trim(event.x, event.y)) {
+ selection_request(this, false);
+ if (primary_press) {
+ trim_begin(this, Gdk.WindowEdge.WEST);
+ motion_mode = MotionMode.LEFT_TRIM;
+ }
+ } else if (is_right_trim(event.x, event.y)){
+ selection_request(this, false);
+ if (primary_press) {
+ trim_begin(this, Gdk.WindowEdge.EAST);
+ motion_mode = MotionMode.RIGHT_TRIM;
+ }
+ } else {
+ if (!is_selected) {
+ pending_selection = false;
+ selection_request(this, extend_selection);
+ } else {
+ pending_selection = true;
+ }
+ }
+
+ if (event.button == 3) {
+ context_menu.select_first(true);
+ context_menu.popup(null, null, null, event.button, event.time);
+ } else {
+ context_menu.popdown();
+ }
+
+ return true;
+ }
+
+ public override bool button_release_event(Gdk.EventButton event) {
+ if (!transport_delegate.is_stopped()) {
+ return true;
+ }
+
+ event.x -= allocation.x;
+ button_down = false;
+ if (event.button == 1) {
+ switch (motion_mode) {
+ case MotionMode.NONE: {
+ if (pending_selection) {
+ selection_request(this, true);
+ }
+ }
+ break;
+ case MotionMode.DRAGGING: {
+ int64 delta = time_provider.xsize_to_time((int) event.x - drag_point);
+ if (motion_mode == MotionMode.DRAGGING) {
+ move_commit(this, delta);
+ }
+ }
+ break;
+ case MotionMode.LEFT_TRIM:
+ trim_commit(this, Gdk.WindowEdge.WEST);
+ break;
+ case MotionMode.RIGHT_TRIM:
+ trim_commit(this, Gdk.WindowEdge.EAST);
+ break;
+ }
+ }
+ motion_mode = MotionMode.NONE;
+ return true;
+ }
+
+ public override bool motion_notify_event(Gdk.EventMotion event) {
+ if (!transport_delegate.is_stopped()) {
+ return true;
+ }
+
+ event.x -= allocation.x;
+ int delta_pixels = (int)(event.x - drag_point) - snap_amount;
+ if (snapped) {
+ snap_amount += delta_pixels;
+ if (snap_amount.abs() < SNAP_DELTA) {
+ return true;
+ }
+ delta_pixels += snap_amount;
+ snap_amount = 0;
+ snapped = false;
+ }
+
+ int64 delta_time = time_provider.xsize_to_time(delta_pixels);
+
+ switch (motion_mode) {
+ case MotionMode.NONE:
+ if (!button_down && is_left_trim(event.x, event.y)) {
+ window.set_cursor(left_trim_cursor);
+ } else if (!button_down && is_right_trim(event.x, event.y)) {
+ window.set_cursor(right_trim_cursor);
+ } else if (is_selected && button_down) {
+ if (delta_pixels.abs() > MIN_DRAG) {
+ bool do_copy = (event.state & Gdk.ModifierType.CONTROL_MASK) != 0;
+ if (do_copy) {
+ window.set_cursor(plus_cursor);
+ } else {
+ window.set_cursor(hand_cursor);
+ }
+ motion_mode = MotionMode.DRAGGING;
+ move_begin(this, do_copy);
+ }
+ } else {
+ window.set_cursor(null);
+ }
+ break;
+ case MotionMode.RIGHT_TRIM:
+ case MotionMode.LEFT_TRIM:
+ if (button_down) {
+ if (motion_mode == MotionMode.LEFT_TRIM) {
+ clip.trim(delta_time, Gdk.WindowEdge.WEST);
+ } else {
+ int64 duration = clip.duration;
+ clip.trim(delta_time, Gdk.WindowEdge.EAST);
+ if (duration != clip.duration) {
+ drag_point += (int)delta_pixels;
+ }
+ }
+ }
+ return true;
+ case MotionMode.DRAGGING:
+ move_request(this, delta_time);
+ return true;
+ }
+ return false;
+ }
+
+ bool is_trim_height(double y) {
+ return y - allocation.y > allocation.height / 2;
+ }
+
+ bool is_left_trim(double x, double y) {
+ return is_trim_height(y) && x > 0 && x < TRIM_WIDTH;
+ }
+
+ bool is_right_trim(double x, double y) {
+ return is_trim_height(y) && x > allocation.width - TRIM_WIDTH &&
+ x < allocation.width;
+ }
+
+ public void select() {
+ if (!is_selected) {
+ selection_request(this, true);
+ }
+ }
+
+ public void snap(int64 amount) {
+ snap_amount = time_provider.time_to_xsize(amount);
+ snapped = true;
+ }
+}
projects / fillmore / blobdiff