13
0
livetrax/gtk2_ardour/editor_summary.cc
Carl Hetherington 3386070014 Fix warning.
git-svn-id: svn://localhost/ardour2/branches/3.0@5648 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-09-09 16:38:45 +00:00

438 lines
11 KiB
C++

/*
Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "ardour/session.h"
#include "time_axis_view.h"
#include "streamview.h"
#include "editor_summary.h"
#include "gui_thread.h"
#include "editor.h"
#include "region_view.h"
#include "rgb_macros.h"
#include "keyboard.h"
using namespace std;
using namespace sigc;
using namespace ARDOUR;
/** Construct an EditorSummary.
* @param e Editor to represent.
*/
EditorSummary::EditorSummary (Editor* e)
: EditorComponent (e),
_x_scale (1),
_y_scale (1),
_last_playhead (-1),
_move_dragging (false),
_moved (false),
_zoom_dragging (false)
{
}
/** Connect to a session.
* @param s Session.
*/
void
EditorSummary::connect_to_session (Session* s)
{
EditorComponent::connect_to_session (s);
Region::RegionPropertyChanged.connect (sigc::hide (mem_fun (*this, &EditorSummary::set_dirty)));
_session_connections.push_back (_session->RegionRemoved.connect (sigc::hide (mem_fun (*this, &EditorSummary::set_dirty))));
_session_connections.push_back (_session->EndTimeChanged.connect (mem_fun (*this, &EditorSummary::set_dirty)));
_session_connections.push_back (_session->StartTimeChanged.connect (mem_fun (*this, &EditorSummary::set_dirty)));
_editor->playhead_cursor->PositionChanged.connect (mem_fun (*this, &EditorSummary::playhead_position_changed));
set_dirty ();
}
/** Handle an expose event.
* @param event Event from GTK.
*/
bool
EditorSummary::on_expose_event (GdkEventExpose* event)
{
CairoWidget::on_expose_event (event);
if (_session == 0) {
return false;
}
cairo_t* cr = gdk_cairo_create (get_window()->gobj());
/* Render the view rectangle */
pair<double, double> x;
pair<double, double> y;
get_editor (&x, &y);
cairo_move_to (cr, x.first, y.first);
cairo_line_to (cr, x.second, y.first);
cairo_line_to (cr, x.second, y.second);
cairo_line_to (cr, x.first, y.second);
cairo_line_to (cr, x.first, y.first);
cairo_set_source_rgba (cr, 1, 1, 1, 0.25);
cairo_fill_preserve (cr);
cairo_set_line_width (cr, 1);
cairo_set_source_rgba (cr, 1, 1, 1, 0.5);
cairo_stroke (cr);
/* Playhead */
cairo_set_line_width (cr, 1);
/* XXX: colour should be set from configuration file */
cairo_set_source_rgba (cr, 1, 0, 0, 1);
double const p = _editor->playhead_cursor->current_frame * _x_scale;
cairo_move_to (cr, p, 0);
cairo_line_to (cr, p, _height);
cairo_stroke (cr);
_last_playhead = p;
cairo_destroy (cr);
return true;
}
/** Render the required regions to a cairo context.
* @param cr Context.
*/
void
EditorSummary::render (cairo_t* cr)
{
/* background */
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_rectangle (cr, 0, 0, _width, _height);
cairo_fill (cr);
if (_session == 0) {
return;
}
/* compute total height of all tracks */
int h = 0;
int max_height = 0;
for (PublicEditor::TrackViewList::const_iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
int const t = (*i)->effective_height ();
h += t;
max_height = max (max_height, t);
}
nframes_t const start = _session->current_start_frame ();
_x_scale = static_cast<double> (_width) / (_session->current_end_frame() - start);
_y_scale = static_cast<double> (_height) / h;
/* tallest a region should ever be in the summary, in pixels */
int const tallest_region_pixels = 4;
if (max_height * _y_scale > tallest_region_pixels) {
_y_scale = static_cast<double> (tallest_region_pixels) / max_height;
}
/* render regions */
double y = 0;
for (PublicEditor::TrackViewList::const_iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
StreamView* s = (*i)->view ();
if (s) {
double const h = (*i)->effective_height () * _y_scale;
cairo_set_line_width (cr, h);
s->foreach_regionview (bind (
mem_fun (*this, &EditorSummary::render_region),
cr,
start,
y + h / 2
));
y += h;
}
}
}
/** Render a region for the summary.
* @param r Region view.
* @param cr Cairo context.
* @param start Frame offset that the summary starts at.
* @param y y coordinate to render at.
*/
void
EditorSummary::render_region (RegionView* r, cairo_t* cr, nframes_t start, double y) const
{
uint32_t const c = r->get_fill_color ();
cairo_set_source_rgb (cr, UINT_RGBA_R (c) / 255.0, UINT_RGBA_G (c) / 255.0, UINT_RGBA_B (c) / 255.0);
cairo_move_to (cr, (r->region()->position() - start) * _x_scale, y);
cairo_line_to (cr, ((r->region()->position() - start + r->region()->length())) * _x_scale, y);
cairo_stroke (cr);
}
/** Set the summary so that just the overlays (viewbox, playhead etc.) will be re-rendered */
void
EditorSummary::set_overlays_dirty ()
{
ENSURE_GUI_THREAD (mem_fun (*this, &EditorSummary::set_overlays_dirty));
queue_draw ();
}
/** Handle a size request.
* @param req GTK requisition
*/
void
EditorSummary::on_size_request (Gtk::Requisition *req)
{
/* Use a dummy, small width and the actual height that we want */
req->width = 64;
req->height = 32;
}
void
EditorSummary::centre_on_click (GdkEventButton* ev)
{
pair<double, double> xr;
pair<double, double> yr;
get_editor (&xr, &yr);
double const w = xr.second - xr.first;
double const h = yr.second - yr.first;
xr.first = ev->x - w / 2;
xr.second = ev->x + w / 2;
yr.first = ev->y - h / 2;
yr.second = ev->y + h / 2;
if (xr.first < 0) {
xr.first = 0;
xr.second = w;
} else if (xr.second > _width) {
xr.second = _width;
xr.first = _width - w;
}
if (yr.first < 0) {
yr.first = 0;
yr.second = h;
} else if (yr.second > _height) {
yr.second = _height;
yr.first = _height - h;
}
set_editor (xr, yr);
}
/** Handle a button press.
* @param ev GTK event.
*/
bool
EditorSummary::on_button_press_event (GdkEventButton* ev)
{
if (ev->button == 1) {
pair<double, double> xr;
pair<double, double> yr;
get_editor (&xr, &yr);
_start_editor_x = xr;
_start_editor_y = yr;
_start_mouse_x = ev->x;
_start_mouse_y = ev->y;
if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
/* primary-modifier-click: start a zoom drag */
double const hx = (xr.first + xr.second) * 0.5;
_zoom_left = ev->x < hx;
_zoom_dragging = true;
_editor->_dragging_playhead = true;
/* In theory, we could support vertical dragging, which logically
might scale track heights in order to make the editor reflect
the dragged viewbox. However, having tried this:
a) it's hard to do
b) it's quite slow
c) it doesn't seem particularly useful, especially with the
limited height of the summary
So at the moment we don't support that...
*/
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
/* secondary-modifier-click: locate playhead */
if (_session) {
_session->request_locate (ev->x / _x_scale + _session->current_start_frame());
}
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
centre_on_click (ev);
} else {
/* ordinary click: start a move drag */
_move_dragging = true;
_moved = false;
_editor->_dragging_playhead = true;
}
}
return true;
}
void
EditorSummary::get_editor (pair<double, double>* x, pair<double, double>* y) const
{
x->first = (_editor->leftmost_position () - _session->current_start_frame ()) * _x_scale;
x->second = x->first + _editor->current_page_frames() * _x_scale;
y->first = _editor->vertical_adjustment.get_value() * _y_scale;
y->second = y->first + _editor->canvas_height () * _y_scale;
}
bool
EditorSummary::on_motion_notify_event (GdkEventMotion* ev)
{
pair<double, double> xr = _start_editor_x;
pair<double, double> yr = _start_editor_y;
if (_move_dragging) {
_moved = true;
xr.first += ev->x - _start_mouse_x;
xr.second += ev->x - _start_mouse_x;
yr.first += ev->y - _start_mouse_y;
yr.second += ev->y - _start_mouse_y;
set_editor (xr, yr);
} else if (_zoom_dragging) {
double const dx = ev->x - _start_mouse_x;
if (_zoom_left) {
xr.first += dx;
} else {
xr.second += dx;
}
set_editor (xr, yr);
}
return true;
}
bool
EditorSummary::on_button_release_event (GdkEventButton*)
{
_move_dragging = false;
_zoom_dragging = false;
_editor->_dragging_playhead = false;
return true;
}
bool
EditorSummary::on_scroll_event (GdkEventScroll* ev)
{
/* mouse wheel */
pair<double, double> xr;
pair<double, double> yr;
get_editor (&xr, &yr);
double const amount = 8;
if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
if (ev->direction == GDK_SCROLL_UP) {
xr.first += amount;
xr.second += amount;
} else {
xr.first -= amount;
xr.second -= amount;
}
} else {
if (ev->direction == GDK_SCROLL_DOWN) {
yr.first += amount;
yr.second += amount;
} else {
yr.first -= amount;
yr.second -= amount;
}
}
set_editor (xr, yr);
return true;
}
void
EditorSummary::set_editor (pair<double,double> const & x, pair<double, double> const & y)
{
if (_editor->pending_visual_change.idle_handler_id < 0) {
/* As a side-effect, the Editor's visual change idle handler processes
pending GTK events. Hence this motion notify handler can be called
in the middle of a visual change idle handler, and if this happens,
the queue_visual_change calls below modify the variables that the
idle handler is working with. This causes problems. Hence the
check above. It ensures that we won't modify the pending visual change
while a visual change idle handler is in progress. It's not perfect,
as it also means that we won't change these variables if an idle handler
is merely pending but not executing. But c'est la vie.
*/
_editor->reset_x_origin (x.first / _x_scale);
_editor->reset_y_origin (y.first / _y_scale);
double const nx = (
((x.second - x.first) / _x_scale) /
_editor->frame_to_unit (_editor->current_page_frames())
);
if (nx != _editor->get_current_zoom ()) {
_editor->reset_zoom (nx);
}
}
}
void
EditorSummary::playhead_position_changed (nframes64_t p)
{
if (int (p * _x_scale) != int (_last_playhead)) {
set_overlays_dirty ();
}
}