Fixed separator lines between marker "tracks". Fixed track alignment with track controls. Changed track controls bevel to better fit in with canvas. Made selected track controls colour match selected region colour (could maybe use a better colour for both though...). Added frame to time labels to match toolbar. git-svn-id: svn://localhost/ardour2/trunk@1622 d708f5d6-7413-0410-9779-e7cbd77b26cf
1090 lines
26 KiB
C++
1090 lines
26 KiB
C++
/*
|
|
Copyright (C) 2000 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 <cstdlib>
|
|
#include <cmath>
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <list>
|
|
|
|
#include <libgnomecanvasmm.h>
|
|
#include <libgnomecanvasmm/canvas.h>
|
|
#include <libgnomecanvasmm/item.h>
|
|
|
|
#include <pbd/error.h>
|
|
|
|
#include <gtkmm2ext/utils.h>
|
|
#include <gtkmm2ext/selector.h>
|
|
#include <gtkmm2ext/stop_signal.h>
|
|
|
|
#include <ardour/session.h>
|
|
#include <ardour/utils.h>
|
|
#include <ardour/ladspa_plugin.h>
|
|
#include <ardour/insert.h>
|
|
#include <ardour/location.h>
|
|
|
|
#include "ardour_ui.h"
|
|
#include "public_editor.h"
|
|
#include "time_axis_view.h"
|
|
#include "simplerect.h"
|
|
#include "selection.h"
|
|
#include "keyboard.h"
|
|
#include "rgb_macros.h"
|
|
#include "utils.h"
|
|
|
|
#include "i18n.h"
|
|
|
|
using namespace Gtk;
|
|
using namespace Gdk;
|
|
using namespace sigc;
|
|
using namespace ARDOUR;
|
|
using namespace PBD;
|
|
using namespace Editing;
|
|
using namespace ArdourCanvas;
|
|
|
|
const double trim_handle_size = 6.0; /* pixels */
|
|
|
|
uint32_t TimeAxisView::hLargest = 0;
|
|
uint32_t TimeAxisView::hLarge = 0;
|
|
uint32_t TimeAxisView::hLarger = 0;
|
|
uint32_t TimeAxisView::hNormal = 0;
|
|
uint32_t TimeAxisView::hSmaller = 0;
|
|
uint32_t TimeAxisView::hSmall = 0;
|
|
bool TimeAxisView::need_size_info = true;
|
|
|
|
TimeAxisView::TimeAxisView (ARDOUR::Session& sess, PublicEditor& ed, TimeAxisView* rent, Canvas& canvas)
|
|
: AxisView (sess),
|
|
editor (ed),
|
|
controls_table (2, 8)
|
|
{
|
|
if (need_size_info) {
|
|
compute_controls_size_info ();
|
|
need_size_info = false;
|
|
}
|
|
|
|
canvas_display = new Group (*canvas.root(), 0.0, 0.0);
|
|
|
|
selection_group = new Group (*canvas_display);
|
|
selection_group->hide();
|
|
|
|
control_parent = 0;
|
|
display_menu = 0;
|
|
size_menu = 0;
|
|
_marked_for_display = false;
|
|
_hidden = false;
|
|
height = 0;
|
|
effective_height = 0;
|
|
parent = rent;
|
|
_has_state = false;
|
|
last_name_entry_key_press_event = 0;
|
|
name_packing = NamePackingBits (0);
|
|
|
|
/*
|
|
Create the standard LHS Controls
|
|
We create the top-level container and name add the name label here,
|
|
subclasses can add to the layout as required
|
|
*/
|
|
|
|
name_entry.set_name ("EditorTrackNameDisplay");
|
|
name_entry.signal_button_release_event().connect (mem_fun (*this, &TimeAxisView::name_entry_button_release));
|
|
name_entry.signal_button_press_event().connect (mem_fun (*this, &TimeAxisView::name_entry_button_press));
|
|
name_entry.signal_key_release_event().connect (mem_fun (*this, &TimeAxisView::name_entry_key_release));
|
|
name_entry.signal_activate().connect (mem_fun(*this, &TimeAxisView::name_entry_activated));
|
|
name_entry.signal_focus_in_event().connect (mem_fun (*this, &TimeAxisView::name_entry_focus_in));
|
|
name_entry.signal_focus_out_event().connect (mem_fun (*this, &TimeAxisView::name_entry_focus_out));
|
|
Gtkmm2ext::set_size_request_to_display_given_text (name_entry, N_("gTortnam"), 10, 10); // just represents a short name
|
|
|
|
name_label.set_name ("TrackLabel");
|
|
name_label.set_alignment (0.0, 0.5);
|
|
|
|
/* typically, either name_label OR name_entry are visible,
|
|
but not both. its up to derived classes to show/hide them as they
|
|
wish.
|
|
*/
|
|
|
|
name_hbox.show ();
|
|
|
|
controls_table.set_border_width (2);
|
|
controls_table.set_row_spacings (0);
|
|
controls_table.set_col_spacings (0);
|
|
controls_table.set_homogeneous (true);
|
|
|
|
controls_table.attach (name_hbox, 0, 4, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
|
|
controls_table.show_all ();
|
|
controls_table.set_no_show_all ();
|
|
|
|
controls_vbox.pack_start (controls_table, false, false);
|
|
controls_vbox.show ();
|
|
|
|
controls_ebox.set_name ("TimeAxisViewControlsBaseUnselected");
|
|
controls_ebox.add (controls_vbox);
|
|
controls_ebox.add_events (BUTTON_PRESS_MASK|BUTTON_RELEASE_MASK|SCROLL_MASK);
|
|
controls_ebox.set_flags (CAN_FOCUS);
|
|
|
|
controls_ebox.signal_button_release_event().connect (mem_fun (*this, &TimeAxisView::controls_ebox_button_release));
|
|
controls_ebox.signal_scroll_event().connect (mem_fun (*this, &TimeAxisView::controls_ebox_scroll), true);
|
|
|
|
controls_lhs_pad.set_name ("TimeAxisViewControlsPadding");
|
|
controls_hbox.pack_start (controls_lhs_pad,false,false);
|
|
controls_hbox.pack_start (controls_ebox,true,true);
|
|
controls_hbox.show ();
|
|
|
|
controls_frame.add (controls_hbox);
|
|
controls_frame.set_name ("TimeAxisViewControlsBaseUnselected");
|
|
controls_frame.set_shadow_type (Gtk::SHADOW_ETCHED_OUT);
|
|
|
|
ColorChanged.connect (mem_fun (*this, &TimeAxisView::color_handler));
|
|
}
|
|
|
|
TimeAxisView::~TimeAxisView()
|
|
{
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
delete *i;
|
|
}
|
|
|
|
for (list<SelectionRect*>::iterator i = free_selection_rects.begin(); i != free_selection_rects.end(); ++i) {
|
|
delete (*i)->rect;
|
|
delete (*i)->start_trim;
|
|
delete (*i)->end_trim;
|
|
|
|
}
|
|
|
|
for (list<SelectionRect*>::iterator i = used_selection_rects.begin(); i != used_selection_rects.end(); ++i) {
|
|
delete (*i)->rect;
|
|
delete (*i)->start_trim;
|
|
delete (*i)->end_trim;
|
|
}
|
|
|
|
if (selection_group) {
|
|
delete selection_group;
|
|
selection_group = 0;
|
|
}
|
|
|
|
if (canvas_display) {
|
|
delete canvas_display;
|
|
canvas_display = 0;
|
|
}
|
|
|
|
if (display_menu) {
|
|
delete display_menu;
|
|
display_menu = 0;
|
|
}
|
|
}
|
|
|
|
guint32
|
|
TimeAxisView::show_at (double y, int& nth, VBox *parent)
|
|
{
|
|
gdouble ix1, ix2, iy1, iy2;
|
|
effective_height = 0;
|
|
|
|
if (control_parent) {
|
|
control_parent->reorder_child (controls_frame, nth);
|
|
} else {
|
|
control_parent = parent;
|
|
parent->pack_start (controls_frame, false, false);
|
|
parent->reorder_child (controls_frame, nth);
|
|
}
|
|
controls_frame.show ();
|
|
controls_ebox.show ();
|
|
|
|
/* the coordinates used here are in the system of the
|
|
item's parent ...
|
|
*/
|
|
|
|
canvas_display->get_bounds (ix1, iy1, ix2, iy2);
|
|
Group* pg = canvas_display->property_parent();
|
|
pg->i2w (ix1, iy1);
|
|
|
|
if (iy1 < 0) {
|
|
iy1 = 0;
|
|
}
|
|
|
|
canvas_display->move (0.0, y - iy1);
|
|
canvas_display->show();/* XXX not necessary */
|
|
y_position = y;
|
|
order = nth;
|
|
_hidden = false;
|
|
|
|
effective_height = height;
|
|
|
|
/* now show children */
|
|
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
|
|
if ((*i)->marked_for_display()) {
|
|
(*i)->canvas_display->show();
|
|
}
|
|
|
|
if (canvas_item_visible ((*i)->canvas_display)) {
|
|
++nth;
|
|
effective_height += (*i)->show_at (y + effective_height, nth, parent);
|
|
}
|
|
}
|
|
|
|
return effective_height;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::controls_ebox_scroll (GdkEventScroll* ev)
|
|
{
|
|
switch (ev->direction) {
|
|
case GDK_SCROLL_UP:
|
|
if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
|
|
step_height (true);
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case GDK_SCROLL_DOWN:
|
|
if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
|
|
step_height (false);
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
/* no handling for left/right, yet */
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::controls_ebox_button_release (GdkEventButton* ev)
|
|
{
|
|
switch (ev->button) {
|
|
case 1:
|
|
selection_click (ev);
|
|
break;
|
|
|
|
case 3:
|
|
popup_display_menu (ev->time);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
TimeAxisView::selection_click (GdkEventButton* ev)
|
|
{
|
|
Selection::Operation op = Keyboard::selection_type (ev->state);
|
|
editor.set_selected_track (*this, op, false);
|
|
}
|
|
|
|
void
|
|
TimeAxisView::hide ()
|
|
{
|
|
if (_hidden) {
|
|
return;
|
|
}
|
|
|
|
canvas_display->hide();
|
|
controls_frame.hide ();
|
|
|
|
if (control_parent) {
|
|
control_parent->remove (controls_frame);
|
|
control_parent = 0;
|
|
}
|
|
|
|
y_position = -1;
|
|
_hidden = true;
|
|
|
|
/* now hide children */
|
|
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->hide ();
|
|
}
|
|
|
|
Hiding ();
|
|
}
|
|
|
|
void
|
|
TimeAxisView::step_height (bool bigger)
|
|
{
|
|
|
|
if (height == hLargest) {
|
|
if (!bigger) set_height (Large);
|
|
return;
|
|
}
|
|
if (height == hLarge) {
|
|
if (bigger) set_height (Largest);
|
|
else set_height (Larger);
|
|
return;
|
|
}
|
|
if (height == hLarger) {
|
|
if (bigger) set_height (Large);
|
|
else set_height (Normal);
|
|
return;
|
|
}
|
|
if (height == hNormal) {
|
|
if (bigger) set_height (Larger);
|
|
else set_height (Smaller);
|
|
return;
|
|
}
|
|
if (height == hSmaller) {
|
|
if (bigger) set_height (Normal);
|
|
else set_height (Small);
|
|
return;
|
|
}
|
|
if (height == hSmall) {
|
|
if (bigger) set_height (Smaller);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::set_height (TrackHeight h)
|
|
{
|
|
height_style = h;
|
|
set_height_pixels (height_to_pixels (h));
|
|
}
|
|
|
|
void
|
|
TimeAxisView::set_height_pixels (uint32_t h)
|
|
{
|
|
height = h;
|
|
controls_frame.set_size_request (-1, height + ((order == 0) ? 1 : 0));
|
|
|
|
if (canvas_item_visible (selection_group)) {
|
|
/* resize the selection rect */
|
|
show_selection (editor.get_selection().time);
|
|
}
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::name_entry_key_release (GdkEventKey* ev)
|
|
{
|
|
PublicEditor::TrackViewList *allviews = 0;
|
|
PublicEditor::TrackViewList::iterator i;
|
|
|
|
switch (ev->keyval) {
|
|
case GDK_Escape:
|
|
name_entry.select_region (0,0);
|
|
controls_ebox.grab_focus ();
|
|
name_entry_changed ();
|
|
return true;
|
|
|
|
/* Shift+Tab Keys Pressed. Note that for Shift+Tab, GDK actually
|
|
* generates a different ev->keyval, rather than setting
|
|
* ev->state.
|
|
*/
|
|
case GDK_ISO_Left_Tab:
|
|
case GDK_Tab:
|
|
name_entry_changed ();
|
|
allviews = editor.get_valid_views (0);
|
|
if (allviews != 0) {
|
|
i = find (allviews->begin(), allviews->end(), this);
|
|
if (ev->keyval == GDK_Tab) {
|
|
if (i != allviews->end()) {
|
|
do {
|
|
if (++i == allviews->end()) { return true; }
|
|
} while((*i)->hidden());
|
|
}
|
|
} else {
|
|
if (i != allviews->begin()) {
|
|
do {
|
|
if (--i == allviews->begin()) { return true; }
|
|
} while ((*i)->hidden());
|
|
}
|
|
}
|
|
|
|
if ((*i)->height_style == Small) {
|
|
(*i)->set_height(Smaller);
|
|
}
|
|
|
|
(*i)->name_entry.grab_focus();
|
|
}
|
|
return true;
|
|
|
|
case GDK_Up:
|
|
case GDK_Down:
|
|
name_entry_changed ();
|
|
return true;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
#ifdef TIMEOUT_NAME_EDIT
|
|
/* adapt the timeout to reflect the user's typing speed */
|
|
|
|
guint32 name_entry_timeout;
|
|
|
|
if (last_name_entry_key_press_event) {
|
|
/* timeout is 1/2 second or 5 times their current inter-char typing speed */
|
|
name_entry_timeout = std::max (500U, (5 * (ev->time - last_name_entry_key_press_event)));
|
|
} else {
|
|
/* start with a 1 second timeout */
|
|
name_entry_timeout = 1000;
|
|
}
|
|
|
|
last_name_entry_key_press_event = ev->time;
|
|
|
|
/* wait 1 seconds and if no more keys are pressed, act as if they pressed enter */
|
|
|
|
name_entry_key_timeout.disconnect();
|
|
name_entry_key_timeout = Glib::signal_timeout().connect (mem_fun (*this, &TimeAxisView::name_entry_key_timed_out), name_entry_timeout);
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::name_entry_focus_in (GdkEventFocus* ev)
|
|
{
|
|
name_entry.select_region (0, -1);
|
|
name_entry.set_name ("EditorActiveTrackNameDisplay");
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::name_entry_focus_out (GdkEventFocus* ev)
|
|
{
|
|
/* clean up */
|
|
|
|
last_name_entry_key_press_event = 0;
|
|
name_entry_key_timeout.disconnect ();
|
|
name_entry.set_name ("EditorTrackNameDisplay");
|
|
name_entry.select_region (0,0);
|
|
|
|
/* do the real stuff */
|
|
|
|
name_entry_changed ();
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::name_entry_key_timed_out ()
|
|
{
|
|
name_entry_activated();
|
|
return false;
|
|
}
|
|
|
|
void
|
|
TimeAxisView::name_entry_activated ()
|
|
{
|
|
controls_ebox.grab_focus();
|
|
}
|
|
|
|
void
|
|
TimeAxisView::name_entry_changed ()
|
|
{
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::name_entry_button_press (GdkEventButton *ev)
|
|
{
|
|
if (ev->button == 3) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::name_entry_button_release (GdkEventButton *ev)
|
|
{
|
|
if (ev->button == 3) {
|
|
popup_display_menu (ev->time);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
TimeAxisView::popup_display_menu (guint32 when)
|
|
{
|
|
if (display_menu == 0) {
|
|
build_display_menu ();
|
|
}
|
|
editor.set_selected_track (*this, Selection::Add);
|
|
display_menu->popup (1, when);
|
|
}
|
|
|
|
gint
|
|
TimeAxisView::size_click (GdkEventButton *ev)
|
|
{
|
|
editor.set_selected_track (*this, Selection::Add);
|
|
popup_size_menu (ev->time);
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
TimeAxisView::popup_size_menu (guint32 when)
|
|
{
|
|
if (size_menu == 0) {
|
|
build_size_menu ();
|
|
}
|
|
size_menu->popup (1, when);
|
|
}
|
|
|
|
void
|
|
TimeAxisView::set_selected (bool yn)
|
|
{
|
|
AxisView::set_selected (yn);
|
|
|
|
if (_selected) {
|
|
controls_ebox.set_name (controls_base_selected_name);
|
|
controls_frame.set_name (controls_base_selected_name);
|
|
|
|
/* propagate any existing selection, if the mode is right */
|
|
|
|
if (editor.current_mouse_mode() == Editing::MouseRange && !editor.get_selection().time.empty()) {
|
|
show_selection (editor.get_selection().time);
|
|
}
|
|
|
|
} else {
|
|
controls_ebox.set_name (controls_base_unselected_name);
|
|
controls_frame.set_name (controls_base_unselected_name);
|
|
|
|
hide_selection ();
|
|
|
|
/* children will be set for the yn=true case. but when deselecting
|
|
the editor only has a list of top-level trackviews, so we
|
|
have to do this here.
|
|
*/
|
|
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->set_selected (false);
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::build_size_menu ()
|
|
{
|
|
using namespace Menu_Helpers;
|
|
|
|
size_menu = new Menu;
|
|
size_menu->set_name ("ArdourContextMenu");
|
|
MenuList& items = size_menu->items();
|
|
|
|
items.push_back (MenuElem (_("Largest"), bind (mem_fun (*this, &TimeAxisView::set_height), Largest)));
|
|
items.push_back (MenuElem (_("Large"), bind (mem_fun (*this, &TimeAxisView::set_height), Large)));
|
|
items.push_back (MenuElem (_("Larger"), bind (mem_fun (*this, &TimeAxisView::set_height), Larger)));
|
|
items.push_back (MenuElem (_("Normal"), bind (mem_fun (*this, &TimeAxisView::set_height), Normal)));
|
|
items.push_back (MenuElem (_("Smaller"), bind (mem_fun (*this, &TimeAxisView::set_height),Smaller)));
|
|
items.push_back (MenuElem (_("Small"), bind (mem_fun (*this, &TimeAxisView::set_height), Small)));
|
|
}
|
|
|
|
void
|
|
TimeAxisView::build_display_menu ()
|
|
{
|
|
using namespace Menu_Helpers;
|
|
|
|
display_menu = new Menu;
|
|
display_menu->set_name ("ArdourContextMenu");
|
|
|
|
// Just let implementing classes define what goes into the manu
|
|
}
|
|
|
|
void
|
|
TimeAxisView::set_samples_per_unit (double spu)
|
|
{
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->set_samples_per_unit (spu);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::show_timestretch (nframes_t start, nframes_t end)
|
|
{
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->show_timestretch (start, end);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::hide_timestretch ()
|
|
{
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->hide_timestretch ();
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::show_selection (TimeSelection& ts)
|
|
{
|
|
double x1;
|
|
double x2;
|
|
double y2;
|
|
SelectionRect *rect;
|
|
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->show_selection (ts);
|
|
}
|
|
|
|
if (canvas_item_visible (selection_group)) {
|
|
while (!used_selection_rects.empty()) {
|
|
free_selection_rects.push_front (used_selection_rects.front());
|
|
used_selection_rects.pop_front();
|
|
free_selection_rects.front()->rect->hide();
|
|
free_selection_rects.front()->start_trim->hide();
|
|
free_selection_rects.front()->end_trim->hide();
|
|
}
|
|
selection_group->hide();
|
|
}
|
|
|
|
selection_group->show();
|
|
selection_group->raise_to_top();
|
|
|
|
for (list<AudioRange>::iterator i = ts.begin(); i != ts.end(); ++i) {
|
|
nframes_t start, end, cnt;
|
|
|
|
start = (*i).start;
|
|
end = (*i).end;
|
|
cnt = end - start + 1;
|
|
|
|
rect = get_selection_rect ((*i).id);
|
|
|
|
x1 = editor.frame_to_unit (start);
|
|
x2 = editor.frame_to_unit (start + cnt - 1);
|
|
y2 = height;
|
|
|
|
rect->rect->property_x1() = x1;
|
|
rect->rect->property_y1() = 1.0;
|
|
rect->rect->property_x2() = x2;
|
|
rect->rect->property_y2() = y2;
|
|
|
|
// trim boxes are at the top for selections
|
|
|
|
if (x2 > x1) {
|
|
rect->start_trim->property_x1() = x1;
|
|
rect->start_trim->property_y1() = 1.0;
|
|
rect->start_trim->property_x2() = x1 + trim_handle_size;
|
|
rect->start_trim->property_y2() = 1.0 + trim_handle_size;
|
|
|
|
rect->end_trim->property_x1() = x2 - trim_handle_size;
|
|
rect->end_trim->property_y1() = 1.0;
|
|
rect->end_trim->property_x2() = x2;
|
|
rect->end_trim->property_y2() = 1.0 + trim_handle_size;
|
|
|
|
rect->start_trim->show();
|
|
rect->end_trim->show();
|
|
} else {
|
|
rect->start_trim->hide();
|
|
rect->end_trim->hide();
|
|
}
|
|
|
|
rect->rect->show ();
|
|
used_selection_rects.push_back (rect);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::reshow_selection (TimeSelection& ts)
|
|
{
|
|
show_selection (ts);
|
|
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->show_selection (ts);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::hide_selection ()
|
|
{
|
|
if (canvas_item_visible (selection_group)) {
|
|
while (!used_selection_rects.empty()) {
|
|
free_selection_rects.push_front (used_selection_rects.front());
|
|
used_selection_rects.pop_front();
|
|
free_selection_rects.front()->rect->hide();
|
|
free_selection_rects.front()->start_trim->hide();
|
|
free_selection_rects.front()->end_trim->hide();
|
|
}
|
|
selection_group->hide();
|
|
}
|
|
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->hide_selection ();
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::order_selection_trims (ArdourCanvas::Item *item, bool put_start_on_top)
|
|
{
|
|
/* find the selection rect this is for. we have the item corresponding to one
|
|
of the trim handles.
|
|
*/
|
|
|
|
for (list<SelectionRect*>::iterator i = used_selection_rects.begin(); i != used_selection_rects.end(); ++i) {
|
|
if ((*i)->start_trim == item || (*i)->end_trim == item) {
|
|
|
|
/* make one trim handle be "above" the other so that if they overlap,
|
|
the top one is the one last used.
|
|
*/
|
|
|
|
(*i)->rect->raise_to_top ();
|
|
(put_start_on_top ? (*i)->start_trim : (*i)->end_trim)->raise_to_top ();
|
|
(put_start_on_top ? (*i)->end_trim : (*i)->start_trim)->raise_to_top ();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
SelectionRect *
|
|
TimeAxisView::get_selection_rect (uint32_t id)
|
|
{
|
|
SelectionRect *rect;
|
|
|
|
/* check to see if we already have a visible rect for this particular selection ID */
|
|
|
|
for (list<SelectionRect*>::iterator i = used_selection_rects.begin(); i != used_selection_rects.end(); ++i) {
|
|
if ((*i)->id == id) {
|
|
return (*i);
|
|
}
|
|
}
|
|
|
|
/* ditto for the free rect list */
|
|
|
|
for (list<SelectionRect*>::iterator i = free_selection_rects.begin(); i != free_selection_rects.end(); ++i) {
|
|
if ((*i)->id == id) {
|
|
SelectionRect* ret = (*i);
|
|
free_selection_rects.erase (i);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* no existing matching rect, so go get a new one from the free list, or create one if there are none */
|
|
|
|
if (free_selection_rects.empty()) {
|
|
|
|
rect = new SelectionRect;
|
|
|
|
rect->rect = new SimpleRect (*selection_group);
|
|
rect->rect->property_x1() = 0.0;
|
|
rect->rect->property_y1() = 0.0;
|
|
rect->rect->property_x2() = 0.0;
|
|
rect->rect->property_y2() = 0.0;
|
|
rect->rect->property_fill_color_rgba() = color_map[cSelectionRectFill];
|
|
rect->rect->property_outline_color_rgba() = color_map[cSelectionRectOutline];
|
|
|
|
rect->start_trim = new SimpleRect (*selection_group);
|
|
rect->start_trim->property_x1() = 0.0;
|
|
rect->start_trim->property_x2() = 0.0;
|
|
rect->start_trim->property_fill_color_rgba() = color_map[cSelectionStartFill];
|
|
rect->start_trim->property_outline_color_rgba() = color_map[cSelectionStartOutline];
|
|
|
|
rect->end_trim = new SimpleRect (*selection_group);
|
|
rect->end_trim->property_x1() = 0.0;
|
|
rect->end_trim->property_x2() = 0.0;
|
|
rect->end_trim->property_fill_color_rgba() = color_map[cSelectionEndFill];
|
|
rect->end_trim->property_outline_color_rgba() = color_map[cSelectionEndOutline];
|
|
|
|
free_selection_rects.push_front (rect);
|
|
|
|
rect->rect->signal_event().connect (bind (mem_fun (editor, &PublicEditor::canvas_selection_rect_event), rect->rect, rect));
|
|
rect->start_trim->signal_event().connect (bind (mem_fun (editor, &PublicEditor::canvas_selection_start_trim_event), rect->rect, rect));
|
|
rect->end_trim->signal_event().connect (bind (mem_fun (editor, &PublicEditor::canvas_selection_end_trim_event), rect->rect, rect));
|
|
}
|
|
|
|
rect = free_selection_rects.front();
|
|
rect->id = id;
|
|
free_selection_rects.pop_front();
|
|
return rect;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::is_child (TimeAxisView* tav)
|
|
{
|
|
return find (children.begin(), children.end(), tav) != children.end();
|
|
}
|
|
|
|
void
|
|
TimeAxisView::add_child (TimeAxisView* child)
|
|
{
|
|
children.push_back (child);
|
|
}
|
|
|
|
void
|
|
TimeAxisView::remove_child (TimeAxisView* child)
|
|
{
|
|
vector<TimeAxisView*>::iterator i;
|
|
|
|
if ((i = find (children.begin(), children.end(), child)) != children.end()) {
|
|
children.erase (i);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& result)
|
|
{
|
|
return;
|
|
}
|
|
|
|
void
|
|
TimeAxisView::get_inverted_selectables (Selection& sel, list<Selectable*>& result)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::touched (double top, double bot)
|
|
{
|
|
/* remember: this is X Window - coordinate space starts in upper left and moves down.
|
|
y_position is the "origin" or "top" of the track.
|
|
*/
|
|
|
|
double mybot = y_position + height;
|
|
|
|
return ((y_position <= bot && y_position >= top) ||
|
|
((mybot <= bot) && (top < mybot)) ||
|
|
(mybot >= bot && y_position < top));
|
|
}
|
|
|
|
void
|
|
TimeAxisView::set_parent (TimeAxisView& p)
|
|
{
|
|
parent = &p;
|
|
}
|
|
|
|
bool
|
|
TimeAxisView::has_state () const
|
|
{
|
|
return _has_state;
|
|
}
|
|
|
|
TimeAxisView*
|
|
TimeAxisView::get_parent_with_state ()
|
|
{
|
|
if (parent == 0) {
|
|
return 0;
|
|
}
|
|
|
|
if (parent->has_state()) {
|
|
return parent;
|
|
}
|
|
|
|
return parent->get_parent_with_state ();
|
|
}
|
|
|
|
void
|
|
TimeAxisView::set_state (const XMLNode& node)
|
|
{
|
|
const XMLProperty *prop;
|
|
|
|
if ((prop = node.property ("track_height")) != 0) {
|
|
|
|
if (prop->value() == "largest") {
|
|
set_height (Largest);
|
|
} else if (prop->value() == "large") {
|
|
set_height (Large);
|
|
} else if (prop->value() == "larger") {
|
|
set_height (Larger);
|
|
} else if (prop->value() == "normal") {
|
|
set_height (Normal);
|
|
} else if (prop->value() == "smaller") {
|
|
set_height (Smaller);
|
|
} else if (prop->value() == "small") {
|
|
set_height (Small);
|
|
} else {
|
|
error << string_compose(_("unknown track height name \"%1\" in XML GUI information"), prop->value()) << endmsg;
|
|
set_height (Normal);
|
|
}
|
|
|
|
} else {
|
|
set_height (Normal);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::reset_height()
|
|
{
|
|
set_height_pixels (height);
|
|
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
(*i)->set_height_pixels ((TrackHeight)(*i)->height);
|
|
}
|
|
}
|
|
|
|
uint32_t
|
|
TimeAxisView::height_to_pixels (TrackHeight h)
|
|
{
|
|
switch (h) {
|
|
case Largest:
|
|
return hLargest;
|
|
case Large:
|
|
return hLarge;
|
|
case Larger:
|
|
return hLarger;
|
|
case Normal:
|
|
return hNormal;
|
|
case Smaller:
|
|
return hSmaller;
|
|
case Small:
|
|
return hSmall;
|
|
}
|
|
|
|
// what is wrong with gcc ?
|
|
|
|
return hNormal;
|
|
}
|
|
|
|
void
|
|
TimeAxisView::compute_controls_size_info ()
|
|
{
|
|
Gtk::Window window (Gtk::WINDOW_TOPLEVEL);
|
|
Gtk::Table two_row_table (2, 8);
|
|
Gtk::Table one_row_table (1, 8);
|
|
Button* buttons[5];
|
|
const int border_width = 2;
|
|
const int extra_height = (2 * border_width) + 2; // 2 pixels for the controls frame
|
|
|
|
window.add (one_row_table);
|
|
|
|
one_row_table.set_border_width (border_width);
|
|
one_row_table.set_row_spacings (0);
|
|
one_row_table.set_col_spacings (0);
|
|
one_row_table.set_homogeneous (true);
|
|
|
|
two_row_table.set_border_width (border_width);
|
|
two_row_table.set_row_spacings (0);
|
|
two_row_table.set_col_spacings (0);
|
|
two_row_table.set_homogeneous (true);
|
|
|
|
for (int i = 0; i < 5; ++i) {
|
|
buttons[i] = manage (new Button (X_("f")));
|
|
buttons[i]->set_name ("TrackMuteButton");
|
|
}
|
|
|
|
one_row_table.attach (*buttons[0], 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
|
|
|
|
one_row_table.show_all ();
|
|
Gtk::Requisition req(one_row_table.size_request ());
|
|
|
|
|
|
// height required to show 1 row of buttons
|
|
|
|
hSmaller = req.height + extra_height;
|
|
|
|
window.remove ();
|
|
window.add (two_row_table);
|
|
|
|
two_row_table.attach (*buttons[1], 5, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
|
|
two_row_table.attach (*buttons[2], 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
|
|
two_row_table.attach (*buttons[3], 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
|
|
two_row_table.attach (*buttons[4], 8, 9, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
|
|
|
|
two_row_table.show_all ();
|
|
req = two_row_table.size_request ();
|
|
|
|
// height required to show all normal buttons
|
|
|
|
hNormal = req.height + extra_height;
|
|
|
|
// these heights are all just larger than normal. no more
|
|
// elements are visible (yet).
|
|
|
|
hLarger = hNormal + 50;
|
|
hLarge = hNormal + 150;
|
|
hLargest = hNormal + 250;
|
|
|
|
// height required to show track name
|
|
|
|
hSmall = 27;
|
|
}
|
|
|
|
void
|
|
TimeAxisView::show_name_label ()
|
|
{
|
|
if (!(name_packing & NameLabelPacked)) {
|
|
name_hbox.pack_start (name_label, true, true);
|
|
name_packing = NamePackingBits (name_packing | NameLabelPacked);
|
|
name_hbox.show ();
|
|
name_label.show ();
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::show_name_entry ()
|
|
{
|
|
if (!(name_packing & NameEntryPacked)) {
|
|
name_hbox.pack_start (name_entry, true, true);
|
|
name_packing = NamePackingBits (name_packing | NameEntryPacked);
|
|
name_hbox.show ();
|
|
name_entry.show ();
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::hide_name_label ()
|
|
{
|
|
if (name_packing & NameLabelPacked) {
|
|
name_hbox.remove (name_label);
|
|
name_packing = NamePackingBits (name_packing & ~NameLabelPacked);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::hide_name_entry ()
|
|
{
|
|
if (name_packing & NameEntryPacked) {
|
|
name_hbox.remove (name_entry);
|
|
name_packing = NamePackingBits (name_packing & ~NameEntryPacked);
|
|
}
|
|
}
|
|
|
|
void
|
|
TimeAxisView::color_handler (ColorID id, uint32_t val)
|
|
{
|
|
switch (id) {
|
|
case cSelectionRectFill:
|
|
break;
|
|
case cSelectionRectOutline:
|
|
break;
|
|
case cSelectionStartFill:
|
|
break;
|
|
case cSelectionStartOutline:
|
|
break;
|
|
case cSelectionEndFill:
|
|
break;
|
|
case cSelectionEndOutline:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
TimeAxisView*
|
|
TimeAxisView::covers_y_position (double y)
|
|
{
|
|
if (hidden()) {
|
|
return 0;
|
|
}
|
|
|
|
if (y_position <= y && y < (y_position + height)) {
|
|
return this;
|
|
}
|
|
|
|
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
|
|
TimeAxisView* tv;
|
|
|
|
if ((tv = (*i)->covers_y_position (y)) != 0) {
|
|
return tv;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|