#include "audio_time_axis.h"
#include "editor_drag.h"
#include "region_view.h"
+#include "editor_group_tabs.h"
+#include "editor_routes.h"
#include "i18n.h"
bool
Editor::track_canvas_size_allocated ()
{
- bool height_changed = canvas_height != canvas_allocation.get_height();
+ bool height_changed = _canvas_height != canvas_allocation.get_height();
- canvas_width = canvas_allocation.get_width();
- canvas_height = canvas_allocation.get_height();
+ _canvas_width = canvas_allocation.get_width();
+ _canvas_height = canvas_allocation.get_height();
if (session) {
TrackViewList::iterator i;
if (height_changed) {
if (playhead_cursor) {
- playhead_cursor->set_length (canvas_height);
+ playhead_cursor->set_length (_canvas_height);
}
for (MarkerSelection::iterator x = selection->markers.begin(); x != selection->markers.end(); ++x) {
- (*x)->set_line_vpos (0, canvas_height);
+ (*x)->set_line_vpos (0, _canvas_height);
}
- vertical_adjustment.set_page_size (canvas_height);
+ vertical_adjustment.set_page_size (_canvas_height);
last_trackview_group_vertical_offset = get_trackview_group_vertical_offset ();
- if ((vertical_adjustment.get_value() + canvas_height) >= vertical_adjustment.get_upper()) {
+ if ((vertical_adjustment.get_value() + _canvas_height) >= vertical_adjustment.get_upper()) {
/*
We're increasing the size of the canvas while the bottom is visible.
We scroll down to keep in step with the controls layout.
*/
- vertical_adjustment.set_value (full_canvas_height - canvas_height);
+ vertical_adjustment.set_value (full_canvas_height - _canvas_height);
}
}
reset_hscrollbar_stepping ();
update_fixed_rulers();
redisplay_tempo (false);
- _summary->set_bounds_dirty ();
+ _summary->set_overlays_dirty ();
Resized (); /* EMIT_SIGNAL */
void
Editor::controls_layout_size_request (Requisition* req)
{
- TreeModel::Children rows = route_display_model->children();
- TreeModel::Children::iterator i;
- double pos;
- bool changed = false;
-
- for (pos = 0, i = rows.begin(); i != rows.end(); ++i) {
- TimeAxisView *tv = (*i)[route_display_columns.tv];
- if (tv != 0) {
- pos += tv->effective_height ();
- tv->clip_to_viewport ();
- }
+ double pos = 0;
+ for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ pos += (*i)->effective_height ();
+ (*i)->clip_to_viewport ();
}
gint height = min ((gint) pos, (gint) (physical_screen_height - 600));
- gint width = max (edit_controls_vbox.get_width(), controls_layout.get_width());
+
+ bool changed = false;
+
+ gint w = edit_controls_vbox.get_width();
+ if (_group_tabs->is_mapped()) {
+ w += _group_tabs->get_width ();
+ }
+
+ gint width = max (w, controls_layout.get_width());
/* don't get too big. the fudge factors here are just guesses */
if (req->width != width) {
gint vbox_width = edit_controls_vbox.get_width();
+ if (_group_tabs->is_mapped()) {
+ vbox_width += _group_tabs->get_width();
+ }
req->width = width;
/* this one is important: it determines how big the layout thinks it really is, as
controls_layout.property_width () = vbox_width;
controls_layout.property_width_request () = vbox_width;
- time_button_event_box.property_width_request () = vbox_width;
- zoom_box.property_width_request () = vbox_width;
+ // time_button_event_box.property_width_request () = vbox_width;
+ // zoom_box.property_width_request () = vbox_width;
}
if (req->height != height) {
}
bool
-Editor::track_canvas_map_handler (GdkEventAny* ev)
+Editor::track_canvas_map_handler (GdkEventAny* /*ev*/)
{
- track_canvas->get_window()->set_cursor (*current_canvas_cursor);
+ if (current_canvas_cursor) {
+ track_canvas->get_window()->set_cursor (*current_canvas_cursor);
+ }
return false;
}
}
void
-Editor::drop_regions (const RefPtr<Gdk::DragContext>& context,
- int x, int y,
- const SelectionData& data,
- guint info, guint time)
+Editor::drop_regions (const RefPtr<Gdk::DragContext>& /*context*/,
+ int /*x*/, int /*y*/,
+ const SelectionData& /*data*/,
+ guint /*info*/, guint /*time*/)
{
assert (_drag);
_drag->end_grab (0);
}
void
-Editor::maybe_autoscroll (GdkEventMotion* event)
+Editor::maybe_autoscroll (GdkEventMotion* event, bool allow_vert)
{
nframes64_t rightmost_frame = leftmost_frame + current_page_frames();
nframes64_t frame = _drag->current_pointer_frame();
autoscroll_y = 0;
autoscroll_x = 0;
- if (event->y < canvas_timebars_vsize) {
+ if (event->y < canvas_timebars_vsize && allow_vert) {
autoscroll_y = -1;
startit = true;
- } else if (event->y > canvas_height) {
+ } else if (event->y > _canvas_height) {
autoscroll_y = 1;
startit = true;
}
double new_pixel;
double target_pixel;
+ assert (_drag);
+
if (autoscroll_x_distance != 0) {
if (autoscroll_x > 0) {
autoscroll_x_distance = (unit_to_frame (_drag->current_pointer_x()) - (leftmost_frame + current_page_frames())) / 3;
if (autoscroll_y_distance != 0) {
if (autoscroll_y > 0) {
- autoscroll_y_distance = (_drag->current_pointer_y() - (get_trackview_group_vertical_offset() + canvas_height)) / 3;
+ autoscroll_y_distance = (_drag->current_pointer_y() - (get_trackview_group_vertical_offset() + _canvas_height)) / 3;
} else if (autoscroll_y < 0) {
autoscroll_y_distance = (vertical_adjustment.get_value () - _drag->current_pointer_y()) / 3;
} else if (autoscroll_y > 0) {
- double top_of_bottom_of_canvas = full_canvas_height - canvas_height;
+ double top_of_bottom_of_canvas = full_canvas_height - _canvas_height;
if (vertical_pos > full_canvas_height - autoscroll_y_distance) {
new_pixel = full_canvas_height;
}
bool
-Editor::left_track_canvas (GdkEventCrossing *ev)
+Editor::left_track_canvas (GdkEventCrossing */*ev*/)
{
set_entered_track (0);
set_entered_regionview (0);
}
bool
-Editor::entered_track_canvas (GdkEventCrossing *ev)
+Editor::entered_track_canvas (GdkEventCrossing */*ev*/)
{
reset_canvas_action_sensitivity (true);
return FALSE;
/* this will do an immediate redraw */
controls_layout.get_vadjustment()->set_value (vertical_adjustment.get_value());
+
+ if (pending_visual_change.idle_handler_id < 0) {
+ _summary->set_overlays_dirty ();
+ }
}
void
update_fixed_rulers ();
redisplay_tempo (true);
- _summary->set_bounds_dirty ();
+ if (pending_visual_change.idle_handler_id < 0) {
+ _summary->set_overlays_dirty ();
+ }
#ifndef GTKOSX
if (!autoscroll_active) {
}
last_trackview_group_vertical_offset = get_trackview_group_vertical_offset ();
/* required to keep the controls_layout in lock step with the canvas group */
- track_canvas->update_now ();
+ update_canvas_now ();
}
void
Editor::flush_canvas ()
{
if (is_mapped()) {
- track_canvas->update_now ();
+ update_canvas_now ();
// gdk_window_process_updates (GTK_LAYOUT(track_canvas->gobj())->bin_window, true);
}
}
+void
+Editor::update_canvas_now ()
+{
+ /* GnomeCanvas has a bug whereby if its idle handler is not scheduled between
+ two calls to update_now, an assert will trip. This wrapper works around
+ that problem by only calling update_now if the assert will not trip.
+
+ I think the GC bug is due to the fact that its code will reset need_update
+ and need_redraw to FALSE without checking to see if an idle handler is scheduled.
+ If one is scheduled, GC should probably remove it.
+ */
+
+ GnomeCanvas* c = track_canvas->gobj ();
+ if (c->need_update || c->need_redraw) {
+ track_canvas->update_now ();
+ }
+}