gtk2_ardour/time_axis_view.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <cstdlib>
  21 #include <cmath>
  22 #include <algorithm>
  23 #include <string>
  24 #include <list>
  25
  26 #include <libgnomecanvasmm.h>
  27 #include <libgnomecanvasmm/canvas.h>
  28 #include <libgnomecanvasmm/item.h>
  29
  30 #include <pbd/error.h>
  31
  32 #include <gtkmm2ext/utils.h>
  33 #include <gtkmm2ext/selector.h>
  34 #include <gtkmm2ext/stop_signal.h>
  35
  36 #include <ardour/session.h>
  37 #include <ardour/utils.h>
  38 #include <ardour/ladspa_plugin.h>
  39 #include <ardour/insert.h>
  40 #include <ardour/location.h>
  41
  42 #include "ardour_ui.h"
  43 #include "public_editor.h"
  44 #include "time_axis_view.h"
  45 #include "simplerect.h"
  46 #include "simpleline.h"
  47 #include "selection.h"
  48 #include "keyboard.h"
  49 #include "rgb_macros.h"
  50 #include "utils.h"
  51
  52 #include "i18n.h"
  53
  54 using namespace Gtk;
  55 using namespace Gdk;
  56 using namespace sigc;
  57 using namespace ARDOUR;
  58 using namespace PBD;
  59 using namespace Editing;
  60 using namespace ArdourCanvas;
  61
  62 const double trim_handle_size = 6.0; /* pixels */
  63
  64 uint32_t TimeAxisView::hLargest = 0;
  65 uint32_t TimeAxisView::hLarge = 0;
  66 uint32_t TimeAxisView::hLarger = 0;
  67 uint32_t TimeAxisView::hNormal = 0;
  68 uint32_t TimeAxisView::hSmaller = 0;
  69 uint32_t TimeAxisView::hSmall = 0;
  70 bool TimeAxisView::need_size_info = true;
  71
  72 TimeAxisView::TimeAxisView (ARDOUR::Session& sess, PublicEditor& ed, TimeAxisView* rent, Canvas& canvas)
  73         : AxisView (sess),
  74           editor (ed),
  75           controls_table (2, 8)
  76 {
  77         if (need_size_info) {
  78                 compute_controls_size_info ();
  79                 need_size_info = false;
  80         }
  81
  82         canvas_display = new Group (*canvas.root(), 0.0, 0.0);
  83
  84         selection_group = new Group (*canvas_display);
  85         selection_group->hide();
  86
  87         control_parent = 0;
  88         display_menu = 0;
  89         size_menu = 0;
  90         _marked_for_display = false;
  91         _hidden = false;
  92         height = 0;
  93         effective_height = 0;
  94         parent = rent;
  95         _has_state = false;
  96         last_name_entry_key_press_event = 0;
  97         name_packing = NamePackingBits (0);
  98         resize_drag_start = -1;
  99         resize_idle_id = -1;
 100
 101         /*
 102           Create the standard LHS Controls
 103           We create the top-level container and name add the name label here,
 104           subclasses can add to the layout as required
 105         */
 106
 107         name_entry.set_name ("EditorTrackNameDisplay");
 108         name_entry.signal_button_release_event().connect (mem_fun (*this, &TimeAxisView::name_entry_button_release));
 109         name_entry.signal_button_press_event().connect (mem_fun (*this, &TimeAxisView::name_entry_button_press));
 110         name_entry.signal_key_release_event().connect (mem_fun (*this, &TimeAxisView::name_entry_key_release));
 111         name_entry.signal_activate().connect (mem_fun(*this, &TimeAxisView::name_entry_activated));
 112         name_entry.signal_focus_in_event().connect (mem_fun (*this, &TimeAxisView::name_entry_focus_in));
 113         name_entry.signal_focus_out_event().connect (mem_fun (*this, &TimeAxisView::name_entry_focus_out));
 114         Gtkmm2ext::set_size_request_to_display_given_text (name_entry, N_("gTortnam"), 10, 10); // just represents a short name
 115
 116         name_label.set_name ("TrackLabel");
 117         name_label.set_alignment (0.0, 0.5);
 118
 119         /* typically, either name_label OR name_entry are visible,
 120            but not both. its up to derived classes to show/hide them as they
 121            wish.
 122         */
 123
 124         name_hbox.show ();
 125
 126         controls_table.set_border_width (2);
 127         controls_table.set_row_spacings (0);
 128         controls_table.set_col_spacings (0);
 129         controls_table.set_homogeneous (true);
 130
 131         controls_table.attach (name_hbox, 0, 5, 0, 1,  Gtk::FILL|Gtk::EXPAND,  Gtk::FILL|Gtk::EXPAND, 3, 0);
 132         controls_table.show_all ();
 133         controls_table.set_no_show_all ();
 134
 135         resizer.set_size_request (10, 10);
 136         resizer.signal_expose_event().connect (mem_fun (*this, &TimeAxisView::resizer_expose));
 137         resizer.signal_button_press_event().connect (mem_fun (*this, &TimeAxisView::resizer_button_press));
 138         resizer.signal_button_release_event().connect (mem_fun (*this, &TimeAxisView::resizer_button_release));
 139         resizer.signal_motion_notify_event().connect (mem_fun (*this, &TimeAxisView::resizer_motion));
 140         resizer.set_events (Gdk::BUTTON_PRESS_MASK|
 141                             Gdk::BUTTON_RELEASE_MASK|
 142                             Gdk::POINTER_MOTION_MASK|
 143                             Gdk::SCROLL_MASK);
 144
 145         resizer_box.pack_start (resizer, false, false);
 146         resizer.show ();
 147         resizer_box.show();
 148
 149         controls_vbox.pack_start (controls_table, false, false);
 150         controls_vbox.pack_end (resizer_box, false, true);
 151         controls_vbox.show ();
 152
 153         controls_ebox.set_name ("TimeAxisViewControlsBaseUnselected");
 154         controls_ebox.add (controls_vbox);
 155         controls_ebox.add_events (BUTTON_PRESS_MASK|BUTTON_RELEASE_MASK|SCROLL_MASK);
 156         controls_ebox.set_flags (CAN_FOCUS);
 157
 158         controls_ebox.signal_button_release_event().connect (mem_fun (*this, &TimeAxisView::controls_ebox_button_release));
 159         controls_ebox.signal_scroll_event().connect (mem_fun (*this, &TimeAxisView::controls_ebox_scroll), true);
 160
 161         controls_hbox.pack_start (controls_ebox,true,true);
 162         controls_hbox.show ();
 163
 164         controls_frame.add (controls_hbox);
 165         controls_frame.set_name ("TimeAxisViewControlsBaseUnselected");
 166         controls_vbox.set_name ("TimeAxisViewControlsBaseUnselected");
 167         controls_frame.set_shadow_type (Gtk::SHADOW_ETCHED_OUT);
 168
 169         ColorsChanged.connect (mem_fun (*this, &TimeAxisView::color_handler));
 170 }
 171
 172 TimeAxisView::~TimeAxisView()
 173 {
 174         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 175                 delete *i;
 176         }
 177
 178         for (list<SelectionRect*>::iterator i = free_selection_rects.begin(); i != free_selection_rects.end(); ++i) {
 179                 delete (*i)->rect;
 180                 delete (*i)->start_trim;
 181                 delete (*i)->end_trim;
 182
 183         }
 184
 185         for (list<SelectionRect*>::iterator i = used_selection_rects.begin(); i != used_selection_rects.end(); ++i) {
 186                 delete (*i)->rect;
 187                 delete (*i)->start_trim;
 188                 delete (*i)->end_trim;
 189         }
 190
 191         for (list<SimpleLine*>::iterator i = feature_lines.begin(); i != feature_lines.end(); ++i) {
 192                 delete (*i);
 193         }
 194
 195         if (selection_group) {
 196                 delete selection_group;
 197                 selection_group = 0;
 198         }
 199
 200         if (canvas_display) {
 201                 delete canvas_display;
 202                 canvas_display = 0;
 203         }
 204
 205         if (display_menu) {
 206                 delete display_menu;
 207                 display_menu = 0;
 208         }
 209 }
 210
 211 guint32
 212 TimeAxisView::show_at (double y, int& nth, VBox *parent)
 213 {
 214         gdouble ix1, ix2, iy1, iy2;
 215         effective_height = 0;
 216
 217         if (control_parent) {
 218                 control_parent->reorder_child (controls_frame, nth);
 219         } else {
 220                 control_parent = parent;
 221                 parent->pack_start (controls_frame, false, false);
 222                 parent->reorder_child (controls_frame, nth);
 223         }
 224         controls_frame.show ();
 225         controls_ebox.show ();
 226
 227         /* the coordinates used here are in the system of the
 228            item's parent ...
 229         */
 230
 231         canvas_display->get_bounds (ix1, iy1, ix2, iy2);
 232         Group* pg = canvas_display->property_parent();
 233         pg->i2w (ix1, iy1);
 234
 235         if (iy1 < 0) {
 236                 iy1 = 0;
 237         }
 238
 239         canvas_display->move (0.0, y - iy1);
 240         canvas_display->show();/* XXX not necessary */
 241         y_position = y;
 242         order = nth;
 243         _hidden = false;
 244
 245         /* height in pixels depends on _order, so update it now we've changed _order */
 246         set_height (height);
 247
 248         effective_height = current_height();
 249
 250         /* now show children */
 251
 252         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 253
 254                 if ((*i)->marked_for_display()) {
 255                         (*i)->canvas_display->show();
 256                 }
 257
 258                 if (canvas_item_visible ((*i)->canvas_display)) {
 259                         ++nth;
 260                         effective_height += (*i)->show_at (y + effective_height, nth, parent);
 261                 }
 262         }
 263
 264         return effective_height;
 265 }
 266
 267 bool
 268 TimeAxisView::controls_ebox_scroll (GdkEventScroll* ev)
 269 {
 270         switch (ev->direction) {
 271         case GDK_SCROLL_UP:
 272                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 273                         step_height (true);
 274                         return true;
 275                 }
 276                 break;
 277
 278         case GDK_SCROLL_DOWN:
 279                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 280                         step_height (false);
 281                         return true;
 282                 }
 283                 break;
 284
 285         default:
 286                 /* no handling for left/right, yet */
 287                 break;
 288         }
 289
 290         return false;
 291 }
 292
 293 bool
 294 TimeAxisView::controls_ebox_button_release (GdkEventButton* ev)
 295 {
 296         switch (ev->button) {
 297         case 1:
 298                 selection_click (ev);
 299                 break;
 300
 301         case 3:
 302                 popup_display_menu (ev->time);
 303                 break;
 304         }
 305
 306         return true;
 307 }
 308
 309 void
 310 TimeAxisView::selection_click (GdkEventButton* ev)
 311 {
 312         Selection::Operation op = Keyboard::selection_type (ev->state);
 313         editor.set_selected_track (*this, op, false);
 314 }
 315
 316 void
 317 TimeAxisView::hide ()
 318 {
 319         if (_hidden) {
 320                 return;
 321         }
 322
 323         canvas_display->hide();
 324         controls_frame.hide ();
 325
 326         if (control_parent) {
 327                 control_parent->remove (controls_frame);
 328                 control_parent = 0;
 329         }
 330
 331         y_position = -1;
 332         _hidden = true;
 333
 334         /* now hide children */
 335
 336         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 337                 (*i)->hide ();
 338         }
 339
 340         Hiding ();
 341 }
 342
 343 void
 344 TimeAxisView::step_height (bool bigger)
 345 {
 346         if (bigger) {
 347                 set_height (height + 4);
 348         } else {
 349                 if (height > 4) {
 350                         set_height (std::max (height - 4, hSmall));
 351                 } else if (height != hSmall) {
 352                         set_height (hSmall);
 353                 }
 354         }
 355 }
 356
 357 void
 358 TimeAxisView::set_heights (uint32_t h)
 359 {
 360         TrackSelection& ts (editor.get_selection().tracks);
 361
 362         for (TrackSelection::iterator i = ts.begin(); i != ts.end(); ++i) {
 363                 (*i)->set_height (h);
 364         }
 365 }
 366
 367 void
 368 TimeAxisView::set_height(uint32_t h)
 369 {
 370         height = h;
 371
 372         controls_frame.set_size_request (-1, current_height() + ((order == 0) ? 1 : 0));
 373
 374         if (canvas_item_visible (selection_group)) {
 375                 /* resize the selection rect */
 376                 show_selection (editor.get_selection().time);
 377         }
 378
 379 }
 380
 381 bool
 382 TimeAxisView::name_entry_key_release (GdkEventKey* ev)
 383 {
 384         PublicEditor::TrackViewList *allviews = 0;
 385         PublicEditor::TrackViewList::iterator i;
 386
 387         switch (ev->keyval) {
 388         case GDK_Escape:
 389                 name_entry.select_region (0,0);
 390                 controls_ebox.grab_focus ();
 391                 name_entry_changed ();
 392                 return true;
 393
 394         /* Shift+Tab Keys Pressed. Note that for Shift+Tab, GDK actually
 395          * generates a different ev->keyval, rather than setting
 396          * ev->state.
 397          */
 398         case GDK_ISO_Left_Tab:
 399         case GDK_Tab:
 400                 name_entry_changed ();
 401                 allviews = editor.get_valid_views (0);
 402                 if (allviews != 0) {
 403                         i = find (allviews->begin(), allviews->end(), this);
 404                         if (ev->keyval == GDK_Tab) {
 405                                 if (i != allviews->end()) {
 406                                         do {
 407                                                 if (++i == allviews->end()) { return true; }
 408                                         } while((*i)->hidden());
 409                                 }
 410                         } else {
 411                                 if (i != allviews->begin()) {
 412                                         do {
 413                                                 if (--i == allviews->begin()) { return true; }
 414                                         } while ((*i)->hidden());
 415                                 }
 416                         }
 417
 418
 419                         /* resize to show editable name display */
 420
 421                         if ((*i)->current_height() >= hSmall && (*i)->current_height() < hNormal) {
 422                                 (*i)->set_height (hSmaller);
 423                         }
 424
 425                         (*i)->name_entry.grab_focus();
 426                 }
 427                 return true;
 428
 429         case GDK_Up:
 430         case GDK_Down:
 431                 name_entry_changed ();
 432                 return true;
 433
 434         default:
 435                 break;
 436         }
 437
 438 #ifdef TIMEOUT_NAME_EDIT
 439         /* adapt the timeout to reflect the user's typing speed */
 440
 441         guint32 name_entry_timeout;
 442
 443         if (last_name_entry_key_press_event) {
 444                 /* timeout is 1/2 second or 5 times their current inter-char typing speed */
 445                 name_entry_timeout = std::max (500U, (5 * (ev->time - last_name_entry_key_press_event)));
 446         } else {
 447                 /* start with a 1 second timeout */
 448                 name_entry_timeout = 1000;
 449         }
 450
 451         last_name_entry_key_press_event = ev->time;
 452
 453         /* wait 1 seconds and if no more keys are pressed, act as if they pressed enter */
 454
 455         name_entry_key_timeout.disconnect();
 456         name_entry_key_timeout = Glib::signal_timeout().connect (mem_fun (*this, &TimeAxisView::name_entry_key_timed_out), name_entry_timeout);
 457 #endif
 458
 459         return false;
 460 }
 461
 462 bool
 463 TimeAxisView::name_entry_focus_in (GdkEventFocus* ev)
 464 {
 465         name_entry.select_region (0, -1);
 466         name_entry.set_name ("EditorActiveTrackNameDisplay");
 467         return false;
 468 }
 469
 470 bool
 471 TimeAxisView::name_entry_focus_out (GdkEventFocus* ev)
 472 {
 473         /* clean up */
 474
 475         last_name_entry_key_press_event = 0;
 476         name_entry_key_timeout.disconnect ();
 477         name_entry.set_name ("EditorTrackNameDisplay");
 478         name_entry.select_region (0,0);
 479
 480         /* do the real stuff */
 481
 482         name_entry_changed ();
 483
 484         return false;
 485 }
 486
 487 bool
 488 TimeAxisView::name_entry_key_timed_out ()
 489 {
 490         name_entry_activated();
 491         return false;
 492 }
 493
 494 void
 495 TimeAxisView::name_entry_activated ()
 496 {
 497         controls_ebox.grab_focus();
 498 }
 499
 500 void
 501 TimeAxisView::name_entry_changed ()
 502 {
 503 }
 504
 505 bool
 506 TimeAxisView::name_entry_button_press (GdkEventButton *ev)
 507 {
 508         if (ev->button == 3) {
 509                 return true;
 510         }
 511         return false;
 512 }
 513
 514 bool
 515 TimeAxisView::name_entry_button_release (GdkEventButton *ev)
 516 {
 517         if (ev->button == 3) {
 518                 popup_display_menu (ev->time);
 519                 return true;
 520         }
 521         return false;
 522 }
 523
 524 void
 525 TimeAxisView::conditionally_add_to_selection ()
 526 {
 527         Selection& s (editor.get_selection());
 528
 529         if (!s.selected (this)) {
 530                 editor.set_selected_track (*this, Selection::Set);
 531         }
 532 }
 533
 534
 535 void
 536 TimeAxisView::popup_display_menu (guint32 when)
 537 {
 538         if (display_menu == 0) {
 539                 build_display_menu ();
 540         }
 541
 542         conditionally_add_to_selection ();
 543         display_menu->popup (1, when);
 544 }
 545
 546 gint
 547 TimeAxisView::size_click (GdkEventButton *ev)
 548 {
 549         conditionally_add_to_selection ();
 550         popup_size_menu (ev->time);
 551         return TRUE;
 552 }
 553
 554 void
 555 TimeAxisView::popup_size_menu (guint32 when)
 556 {
 557         if (size_menu == 0) {
 558                 build_size_menu ();
 559         }
 560         size_menu->popup (1, when);
 561 }
 562
 563 void
 564 TimeAxisView::set_selected (bool yn)
 565 {
 566         if (yn == _selected) {
 567                 return;
 568         }
 569
 570         Selectable::set_selected (yn);
 571
 572         if (_selected) {
 573                 controls_ebox.set_name (controls_base_selected_name);
 574                 controls_frame.set_name (controls_base_selected_name);
 575                 controls_vbox.set_name (controls_base_selected_name);
 576                 /* propagate any existing selection, if the mode is right */
 577
 578                 if (editor.current_mouse_mode() == Editing::MouseRange && !editor.get_selection().time.empty()) {
 579                         show_selection (editor.get_selection().time);
 580                 }
 581
 582         } else {
 583                 controls_ebox.set_name (controls_base_unselected_name);
 584                 controls_frame.set_name (controls_base_unselected_name);
 585                 controls_vbox.set_name (controls_base_unselected_name);
 586                 hide_selection ();
 587
 588                 /* children will be set for the yn=true case. but when deselecting
 589                    the editor only has a list of top-level trackviews, so we
 590                    have to do this here.
 591                 */
 592
 593                 for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 594                         (*i)->set_selected (false);
 595                 }
 596         }
 597 }
 598
 599 void
 600 TimeAxisView::build_size_menu ()
 601 {
 602         using namespace Menu_Helpers;
 603
 604         size_menu = new Menu;
 605         size_menu->set_name ("ArdourContextMenu");
 606         MenuList& items = size_menu->items();
 607
 608         items.push_back (MenuElem (_("Largest"), bind (mem_fun (*this, &TimeAxisView::set_heights), hLargest)));
 609         items.push_back (MenuElem (_("Large"), bind (mem_fun (*this, &TimeAxisView::set_heights), hLarge)));
 610         items.push_back (MenuElem (_("Larger"), bind (mem_fun (*this, &TimeAxisView::set_heights), hLarger)));
 611         items.push_back (MenuElem (_("Normal"), bind (mem_fun (*this, &TimeAxisView::set_heights), hNormal)));
 612         items.push_back (MenuElem (_("Smaller"), bind (mem_fun (*this, &TimeAxisView::set_heights),hSmaller)));
 613         items.push_back (MenuElem (_("Small"), bind (mem_fun (*this, &TimeAxisView::set_heights), hSmall)));
 614 }
 615
 616 void
 617 TimeAxisView::build_display_menu ()
 618 {
 619         using namespace Menu_Helpers;
 620
 621         display_menu = new Menu;
 622         display_menu->set_name ("ArdourContextMenu");
 623
 624         // Just let implementing classes define what goes into the manu
 625 }
 626
 627 void
 628 TimeAxisView::set_samples_per_unit (double spu)
 629 {
 630         AnalysisFeatureList::const_iterator i;
 631         list<ArdourCanvas::SimpleLine*>::iterator l;
 632
 633         for (i = analysis_features.begin(), l = feature_lines.begin(); i != analysis_features.end() && l != feature_lines.end(); ++i, ++l) {
 634                 (*l)->property_x1() = editor.frame_to_pixel (*i);
 635                 (*l)->property_x2() = editor.frame_to_pixel (*i);
 636         }
 637
 638         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 639                 (*i)->set_samples_per_unit (spu);
 640         }
 641 }
 642
 643 void
 644 TimeAxisView::show_timestretch (nframes_t start, nframes_t end)
 645 {
 646         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 647                 (*i)->show_timestretch (start, end);
 648         }
 649 }
 650
 651 void
 652 TimeAxisView::hide_timestretch ()
 653 {
 654         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 655                 (*i)->hide_timestretch ();
 656         }
 657 }
 658
 659 void
 660 TimeAxisView::show_selection (TimeSelection& ts)
 661 {
 662         double x1;
 663         double x2;
 664         double y2;
 665         SelectionRect *rect;
 666
 667         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 668                 (*i)->show_selection (ts);
 669         }
 670
 671         if (canvas_item_visible (selection_group)) {
 672                 while (!used_selection_rects.empty()) {
 673                         free_selection_rects.push_front (used_selection_rects.front());
 674                         used_selection_rects.pop_front();
 675                         free_selection_rects.front()->rect->hide();
 676                         free_selection_rects.front()->start_trim->hide();
 677                         free_selection_rects.front()->end_trim->hide();
 678                 }
 679                 selection_group->hide();
 680         }
 681
 682         selection_group->show();
 683         selection_group->raise_to_top();
 684
 685         for (list<AudioRange>::iterator i = ts.begin(); i != ts.end(); ++i) {
 686                 nframes_t start, end, cnt;
 687
 688                 start = (*i).start;
 689                 end = (*i).end;
 690                 cnt = end - start + 1;
 691
 692                 rect = get_selection_rect ((*i).id);
 693
 694                 x1 = editor.frame_to_unit (start);
 695                 x2 = editor.frame_to_unit (start + cnt - 1);
 696                 y2 = current_height();
 697
 698                 rect->rect->property_x1() = x1;
 699                 rect->rect->property_y1() = 1.0;
 700                 rect->rect->property_x2() = x2;
 701                 rect->rect->property_y2() = y2;
 702
 703                 // trim boxes are at the top for selections
 704
 705                 if (x2 > x1) {
 706                         rect->start_trim->property_x1() = x1;
 707                         rect->start_trim->property_y1() = 1.0;
 708                         rect->start_trim->property_x2() = x1 + trim_handle_size;
 709                         rect->start_trim->property_y2() = 1.0 + trim_handle_size;
 710
 711                         rect->end_trim->property_x1() = x2 - trim_handle_size;
 712                         rect->end_trim->property_y1() = 1.0;
 713                         rect->end_trim->property_x2() = x2;
 714                         rect->end_trim->property_y2() = 1.0 + trim_handle_size;
 715
 716                         rect->start_trim->show();
 717                         rect->end_trim->show();
 718                 } else {
 719                         rect->start_trim->hide();
 720                         rect->end_trim->hide();
 721                 }
 722
 723                 rect->rect->show ();
 724                 used_selection_rects.push_back (rect);
 725         }
 726 }
 727
 728 void
 729 TimeAxisView::reshow_selection (TimeSelection& ts)
 730 {
 731         show_selection (ts);
 732
 733         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 734                 (*i)->show_selection (ts);
 735         }
 736 }
 737
 738 void
 739 TimeAxisView::hide_selection ()
 740 {
 741         if (canvas_item_visible (selection_group)) {
 742                 while (!used_selection_rects.empty()) {
 743                         free_selection_rects.push_front (used_selection_rects.front());
 744                         used_selection_rects.pop_front();
 745                         free_selection_rects.front()->rect->hide();
 746                         free_selection_rects.front()->start_trim->hide();
 747                         free_selection_rects.front()->end_trim->hide();
 748                 }
 749                 selection_group->hide();
 750         }
 751
 752         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 753                 (*i)->hide_selection ();
 754         }
 755 }
 756
 757 void
 758 TimeAxisView::order_selection_trims (ArdourCanvas::Item *item, bool put_start_on_top)
 759 {
 760         /* find the selection rect this is for. we have the item corresponding to one
 761            of the trim handles.
 762          */
 763
 764         for (list<SelectionRect*>::iterator i = used_selection_rects.begin(); i != used_selection_rects.end(); ++i) {
 765                 if ((*i)->start_trim == item || (*i)->end_trim == item) {
 766
 767                         /* make one trim handle be "above" the other so that if they overlap,
 768                            the top one is the one last used.
 769                         */
 770
 771                         (*i)->rect->raise_to_top ();
 772                         (put_start_on_top ? (*i)->start_trim : (*i)->end_trim)->raise_to_top ();
 773                         (put_start_on_top ? (*i)->end_trim : (*i)->start_trim)->raise_to_top ();
 774
 775                         break;
 776                 }
 777         }
 778 }
 779
 780 SelectionRect *
 781 TimeAxisView::get_selection_rect (uint32_t id)
 782 {
 783         SelectionRect *rect;
 784
 785         /* check to see if we already have a visible rect for this particular selection ID */
 786
 787         for (list<SelectionRect*>::iterator i = used_selection_rects.begin(); i != used_selection_rects.end(); ++i) {
 788                 if ((*i)->id == id) {
 789                         return (*i);
 790                 }
 791         }
 792
 793         /* ditto for the free rect list */
 794
 795         for (list<SelectionRect*>::iterator i = free_selection_rects.begin(); i != free_selection_rects.end(); ++i) {
 796                 if ((*i)->id == id) {
 797                         SelectionRect* ret = (*i);
 798                         free_selection_rects.erase (i);
 799                         return ret;
 800                 }
 801         }
 802
 803         /* no existing matching rect, so go get a new one from the free list, or create one if there are none */
 804
 805         if (free_selection_rects.empty()) {
 806
 807                 rect = new SelectionRect;
 808
 809                 rect->rect = new SimpleRect (*selection_group);
 810                 rect->rect->property_x1() = 0.0;
 811                 rect->rect->property_y1() = 0.0;
 812                 rect->rect->property_x2() = 0.0;
 813                 rect->rect->property_y2() = 0.0;
 814                 rect->rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_SelectionRect.get();
 815                 rect->rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_SelectionRect.get();
 816
 817                 rect->start_trim = new SimpleRect (*selection_group);
 818                 rect->start_trim->property_x1() = 0.0;
 819                 rect->start_trim->property_x2() = 0.0;
 820                 rect->start_trim->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
 821                 rect->start_trim->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
 822
 823                 rect->end_trim = new SimpleRect (*selection_group);
 824                 rect->end_trim->property_x1() = 0.0;
 825                 rect->end_trim->property_x2() = 0.0;
 826                 rect->end_trim->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
 827                 rect->end_trim->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
 828
 829                 free_selection_rects.push_front (rect);
 830
 831                 rect->rect->signal_event().connect (bind (mem_fun (editor, &PublicEditor::canvas_selection_rect_event), rect->rect, rect));
 832                 rect->start_trim->signal_event().connect (bind (mem_fun (editor, &PublicEditor::canvas_selection_start_trim_event), rect->rect, rect));
 833                 rect->end_trim->signal_event().connect (bind (mem_fun (editor, &PublicEditor::canvas_selection_end_trim_event), rect->rect, rect));
 834         }
 835
 836         rect = free_selection_rects.front();
 837         rect->id = id;
 838         free_selection_rects.pop_front();
 839         return rect;
 840 }
 841
 842 bool
 843 TimeAxisView::is_child (TimeAxisView* tav)
 844 {
 845         return find (children.begin(), children.end(), tav) != children.end();
 846 }
 847
 848 void
 849 TimeAxisView::add_child (TimeAxisView* child)
 850 {
 851         children.push_back (child);
 852 }
 853
 854 void
 855 TimeAxisView::remove_child (TimeAxisView* child)
 856 {
 857         vector<TimeAxisView*>::iterator i;
 858
 859         if ((i = find (children.begin(), children.end(), child)) != children.end()) {
 860                 children.erase (i);
 861         }
 862 }
 863
 864 void
 865 TimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& result)
 866 {
 867         return;
 868 }
 869
 870 void
 871 TimeAxisView::get_inverted_selectables (Selection& sel, list<Selectable*>& result)
 872 {
 873         return;
 874 }
 875
 876 bool
 877 TimeAxisView::touched (double top, double bot)
 878 {
 879         /* remember: this is X Window - coordinate space starts in upper left and moves down.
 880            y_position is the "origin" or "top" of the track.
 881          */
 882
 883         double mybot = y_position + current_height();
 884
 885         return ((y_position <= bot && y_position >= top) ||
 886                 ((mybot <= bot) && (top < mybot)) ||
 887                 (mybot >= bot && y_position < top));
 888 }
 889
 890 void
 891 TimeAxisView::set_parent (TimeAxisView& p)
 892 {
 893         parent = &p;
 894 }
 895
 896 bool
 897 TimeAxisView::has_state () const
 898 {
 899         return _has_state;
 900 }
 901
 902 TimeAxisView*
 903 TimeAxisView::get_parent_with_state ()
 904 {
 905         if (parent == 0) {
 906                 return 0;
 907         }
 908
 909         if (parent->has_state()) {
 910                 return parent;
 911         }
 912
 913         return parent->get_parent_with_state ();
 914 }
 915
 916
 917 XMLNode&
 918 TimeAxisView::get_state ()
 919 {
 920         XMLNode* node = new XMLNode ("TAV-" + name());
 921         char buf[32];
 922
 923         snprintf (buf, sizeof(buf), "%u", height);
 924         node->add_property ("height", buf);
 925         node->add_property ("marked_for_display", (_marked_for_display ? "1" : "0"));
 926         return *node;
 927 }
 928
 929 int
 930 TimeAxisView::set_state (const XMLNode& node)
 931 {
 932         const XMLProperty *prop;
 933
 934         if ((prop = node.property ("marked_for_display")) != 0) {
 935                 _marked_for_display = (prop->value() == "1");
 936         }
 937
 938         if ((prop = node.property ("track_height")) != 0) {
 939
 940                 if (prop->value() == "largest") {
 941                         set_height (hLargest);
 942                 } else if (prop->value() == "large") {
 943                         set_height (hLarge);
 944                 } else if (prop->value() == "larger") {
 945                         set_height (hLarger);
 946                 } else if (prop->value() == "normal") {
 947                         set_height (hNormal);
 948                 } else if (prop->value() == "smaller") {
 949                         set_height (hSmaller);
 950                 } else if (prop->value() == "small") {
 951                         set_height (hSmall);
 952                 } else {
 953                         error << string_compose(_("unknown track height name \"%1\" in XML GUI information"), prop->value()) << endmsg;
 954                         set_height (Normal);
 955                 }
 956
 957         } else if ((prop = node.property ("height")) != 0) {
 958
 959                 set_height (atoi (prop->value()));
 960
 961         } else {
 962
 963                 set_height (hNormal);
 964         }
 965
 966         return 0;
 967 }
 968
 969 void
 970 TimeAxisView::reset_height()
 971 {
 972         set_height (height);
 973
 974         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
 975                 (*i)->set_height ((*i)->height);
 976         }
 977 }
 978
 979 void
 980 TimeAxisView::compute_controls_size_info ()
 981 {
 982         Gtk::Window window (Gtk::WINDOW_TOPLEVEL);
 983         Gtk::Table two_row_table (2, 8);
 984         Gtk::Table one_row_table (1, 8);
 985         Button* buttons[5];
 986         const int border_width = 2;
 987         const int extra_height = (2 * border_width) + 2 // 2 pixels for the controls frame
 988                 + 10; // resizer button
 989
 990         window.add (one_row_table);
 991
 992         one_row_table.set_border_width (border_width);
 993         one_row_table.set_row_spacings (0);
 994         one_row_table.set_col_spacings (0);
 995         one_row_table.set_homogeneous (true);
 996
 997         two_row_table.set_border_width (border_width);
 998         two_row_table.set_row_spacings (0);
 999         two_row_table.set_col_spacings (0);
1000         two_row_table.set_homogeneous (true);
1001
1002         for (int i = 0; i < 5; ++i) {
1003                 buttons[i] = manage (new Button (X_("f")));
1004                 buttons[i]->set_name ("TrackMuteButton");
1005         }
1006
1007         one_row_table.attach (*buttons[0], 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
1008
1009         one_row_table.show_all ();
1010         Gtk::Requisition req(one_row_table.size_request ());
1011
1012
1013         // height required to show 1 row of buttons
1014
1015         hSmaller = req.height + extra_height;
1016
1017         window.remove ();
1018         window.add (two_row_table);
1019
1020         two_row_table.attach (*buttons[1], 5, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
1021         two_row_table.attach (*buttons[2], 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
1022         two_row_table.attach (*buttons[3], 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
1023         two_row_table.attach (*buttons[4], 8, 9, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
1024
1025         two_row_table.show_all ();
1026         req = two_row_table.size_request ();
1027
1028         // height required to show all normal buttons
1029
1030         hNormal = req.height + extra_height;
1031
1032         // these heights are all just larger than normal. no more
1033         // elements are visible (yet).
1034
1035         hLarger = hNormal + 50;
1036         hLarge = hNormal + 150;
1037         hLargest = hNormal + 250;
1038
1039         // height required to show track name
1040
1041         hSmall = 27;
1042 }
1043
1044 void
1045 TimeAxisView::show_name_label ()
1046 {
1047         if (!(name_packing & NameLabelPacked)) {
1048                 name_hbox.pack_start (name_label, true, true);
1049                 name_packing = NamePackingBits (name_packing | NameLabelPacked);
1050                 name_hbox.show ();
1051                 name_label.show ();
1052         }
1053 }
1054
1055 void
1056 TimeAxisView::show_name_entry ()
1057 {
1058         if (!(name_packing & NameEntryPacked)) {
1059                 name_hbox.pack_start (name_entry, true, true);
1060                 name_packing = NamePackingBits (name_packing | NameEntryPacked);
1061                 name_hbox.show ();
1062                 name_entry.show ();
1063         }
1064 }
1065
1066 void
1067 TimeAxisView::hide_name_label ()
1068 {
1069         if (name_packing & NameLabelPacked) {
1070                 name_hbox.remove (name_label);
1071                 name_packing = NamePackingBits (name_packing & ~NameLabelPacked);
1072         }
1073 }
1074
1075 void
1076 TimeAxisView::hide_name_entry ()
1077 {
1078         if (name_packing & NameEntryPacked) {
1079                 name_hbox.remove (name_entry);
1080                 name_packing = NamePackingBits (name_packing & ~NameEntryPacked);
1081         }
1082 }
1083
1084 void
1085 TimeAxisView::color_handler ()
1086 {
1087         for (list<SelectionRect*>::iterator i = used_selection_rects.begin(); i != used_selection_rects.end(); ++i) {
1088
1089                 (*i)->rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_SelectionRect.get();
1090                 (*i)->rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1091
1092                 (*i)->start_trim->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1093                 (*i)->start_trim->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1094
1095                 (*i)->end_trim->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1096                 (*i)->end_trim->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1097         }
1098
1099         for (list<SelectionRect*>::iterator i = free_selection_rects.begin(); i != free_selection_rects.end(); ++i) {
1100
1101                 (*i)->rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_SelectionRect.get();
1102                 (*i)->rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1103
1104                 (*i)->start_trim->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1105                 (*i)->start_trim->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1106
1107                 (*i)->end_trim->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1108                 (*i)->end_trim->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_Selection.get();
1109         }
1110 }
1111
1112 TimeAxisView*
1113 TimeAxisView::covers_y_position (double y)
1114 {
1115         if (hidden()) {
1116                 return 0;
1117         }
1118
1119         if (y_position <= y && y < (y_position + height)) {
1120                 return this;
1121         }
1122
1123         for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
1124                 TimeAxisView* tv;
1125
1126                 if ((tv = (*i)->covers_y_position (y)) != 0) {
1127                         return tv;
1128                 }
1129         }
1130
1131         return 0;
1132 }
1133
1134 void
1135 TimeAxisView::show_feature_lines (const AnalysisFeatureList& pos)
1136 {
1137         analysis_features = pos;
1138         reshow_feature_lines ();
1139 }
1140
1141
1142 void
1143 TimeAxisView::hide_feature_lines ()
1144 {
1145         list<ArdourCanvas::SimpleLine*>::iterator l;
1146
1147         for (l = feature_lines.begin(); l != feature_lines.end(); ++l) {
1148                 (*l)->hide();
1149         }
1150 }
1151
1152 void
1153 TimeAxisView::reshow_feature_lines ()
1154 {
1155         while (feature_lines.size()< analysis_features.size()) {
1156                 ArdourCanvas::SimpleLine* l = new ArdourCanvas::SimpleLine (*canvas_display);
1157                 l->property_color_rgba() = (guint) ARDOUR_UI::config()->canvasvar_ZeroLine.get();
1158                 l->property_y1() = 0;
1159                 l->property_y2() = current_height();
1160                 feature_lines.push_back (l);
1161         }
1162
1163         while (feature_lines.size() > analysis_features.size()) {
1164                 ArdourCanvas::SimpleLine *line = feature_lines.back();
1165                 feature_lines.pop_back ();
1166                 delete line;
1167         }
1168
1169         AnalysisFeatureList::const_iterator i;
1170         list<ArdourCanvas::SimpleLine*>::iterator l;
1171
1172         for (i = analysis_features.begin(), l = feature_lines.begin(); i != analysis_features.end() && l != feature_lines.end(); ++i, ++l) {
1173                 (*l)->property_x1() = editor.frame_to_pixel (*i);
1174                 (*l)->property_x2() = editor.frame_to_pixel (*i);
1175                 (*l)->show ();
1176         }
1177 }
1178
1179 bool
1180 TimeAxisView::resizer_button_press (GdkEventButton* event)
1181 {
1182         resize_drag_start = event->y_root;
1183         resize_idle_target = current_height();
1184         editor.start_resize_line_ops ();
1185         return true;
1186 }
1187
1188 bool
1189 TimeAxisView::resizer_button_release (GdkEventButton* ev)
1190 {
1191         resize_drag_start = -1;
1192         editor.end_resize_line_ops ();
1193         return true;
1194 }
1195
1196 static gboolean
1197 _idle_resizer (gpointer arg)
1198 {
1199         return ((TimeAxisView*)arg)->idle_resize ();
1200 }
1201
1202 bool
1203 TimeAxisView::idle_resize ()
1204 {
1205         set_height (resize_idle_target);
1206         resize_idle_id = -1;
1207         return false;
1208 }
1209
1210 bool
1211 TimeAxisView::resizer_motion (GdkEventMotion* ev)
1212 {
1213         if (resize_drag_start < 0) {
1214                 return true;
1215         }
1216
1217         int32_t delta = (int32_t) floor (resize_drag_start - ev->y_root);
1218         int xroot, yroot;
1219         Glib::RefPtr<Gdk::Window> win (resizer.get_window());
1220
1221         if (win) {
1222                 win->get_origin (xroot, yroot);
1223                 editor.queue_draw_resize_line (yroot + ev->y);
1224         }
1225
1226         resize_idle_target = std::max (resize_idle_target - delta, (int) hSmall);
1227
1228         if (resize_idle_id < 0) {
1229                 // resize_idle_id = g_idle_add (_idle_resizer, this);
1230         }
1231
1232         resize_drag_start = ev->y_root;
1233
1234         return true;
1235 }
1236
1237 bool
1238 TimeAxisView::resizer_expose (GdkEventExpose* event)
1239 {
1240         resizer.get_window()->draw_rectangle (resizer.get_style()->get_fg_gc(STATE_ACTIVE),
1241                                               true,
1242                                               event->area.x,
1243                                               event->area.y,
1244                                               event->area.width,
1245                                               event->area.height);
1246         return true;
1247 }
1248