gtk2_ardour/time_axis_view_item.cc

   1 /*
   2     Copyright (C) 2003 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 <utility>
  21
  22 #include "pbd/error.h"
  23 #include "pbd/stacktrace.h"
  24
  25 #include "ardour/types.h"
  26 #include "ardour/ardour.h"
  27
  28 #include "gtkmm2ext/utils.h"
  29 #include "gtkmm2ext/gui_thread.h"
  30
  31 #include "canvas/group.h"
  32 #include "canvas/rectangle.h"
  33 #include "canvas/debug.h"
  34 #include "canvas/drag_handle.h"
  35 #include "canvas/text.h"
  36 #include "canvas/utils.h"
  37
  38 #include "ardour/profile.h"
  39
  40 #include "ardour_ui.h"
  41 /*
  42  * ardour_ui.h was moved up in the include list
  43  * due to a conflicting definition of 'Rect' between
  44  * Apple's MacTypes.h file and GTK
  45  */
  46
  47 #include "public_editor.h"
  48 #include "time_axis_view_item.h"
  49 #include "time_axis_view.h"
  50 #include "utils.h"
  51 #include "rgb_macros.h"
  52
  53 #include "i18n.h"
  54
  55 using namespace std;
  56 using namespace Editing;
  57 using namespace Glib;
  58 using namespace PBD;
  59 using namespace ARDOUR;
  60 using namespace Gtkmm2ext;
  61
  62 Pango::FontDescription TimeAxisViewItem::NAME_FONT;
  63 const double TimeAxisViewItem::NAME_X_OFFSET = 15.0;
  64 const double TimeAxisViewItem::GRAB_HANDLE_TOP = 0.0;
  65 const double TimeAxisViewItem::GRAB_HANDLE_WIDTH = 10.0;
  66 const double TimeAxisViewItem::RIGHT_EDGE_SHIFT = 1.0;
  67
  68 int    TimeAxisViewItem::NAME_HEIGHT;
  69 double TimeAxisViewItem::NAME_Y_OFFSET;
  70 double TimeAxisViewItem::NAME_HIGHLIGHT_SIZE;
  71 double TimeAxisViewItem::NAME_HIGHLIGHT_THRESH;
  72
  73 void
  74 TimeAxisViewItem::set_constant_heights ()
  75 {
  76         NAME_FONT = get_font_for_style (X_("TimeAxisViewItemName"));
  77
  78         Gtk::Window win;
  79         Gtk::Label foo;
  80         win.add (foo);
  81
  82         Glib::RefPtr<Pango::Layout> layout = foo.create_pango_layout (X_("Hg")); /* ascender + descender */
  83         int width = 0;
  84         int height = 0;
  85
  86         layout->set_font_description (NAME_FONT);
  87         get_pixel_size (layout, width, height);
  88
  89         layout = foo.create_pango_layout (X_("H")); /* just the ascender */
  90
  91         NAME_HEIGHT = height;
  92
  93         /* Config->get_show_name_highlight) == true:
  94                 Y_OFFSET is measured from bottom of the time axis view item.
  95            Config->get_show_name_highlight) == false:
  96                 Y_OFFSET is measured from the top of the time axis view item.
  97         */
  98
  99         if (Config->get_show_name_highlight()) {
 100                 NAME_Y_OFFSET = height + 1;
 101                 NAME_HIGHLIGHT_SIZE = height + 2;
 102         } else {
 103                 NAME_Y_OFFSET = 3;
 104                 NAME_HIGHLIGHT_SIZE = 0;
 105         }
 106         NAME_HIGHLIGHT_THRESH = NAME_HIGHLIGHT_SIZE * 3;
 107 }
 108
 109 /**
 110  * Construct a new TimeAxisViewItem.
 111  *
 112  * @param it_name the unique name of this item
 113  * @param parent the parent canvas group
 114  * @param tv the TimeAxisView we are going to be added to
 115  * @param spu samples per unit
 116  * @param base_color
 117  * @param start the start point of this item
 118  * @param duration the duration of this item
 119  * @param recording true if this is a recording region view
 120  * @param automation true if this is an automation region view
 121  */
 122 TimeAxisViewItem::TimeAxisViewItem(
 123         const string & it_name, ArdourCanvas::Group& parent, TimeAxisView& tv, double spu, Gdk::Color const & base_color,
 124         framepos_t start, framecnt_t duration, bool recording, bool automation, Visibility vis
 125         )
 126         : trackview (tv)
 127         , frame_position (-1)
 128         , item_name (it_name)
 129         , _height (1.0)
 130         , _recregion (recording)
 131         , _automation (automation)
 132         , _dragging (false)
 133         , _width (0.0)
 134 {
 135         init (&parent, spu, base_color, start, duration, vis, true, true);
 136 }
 137
 138 TimeAxisViewItem::TimeAxisViewItem (const TimeAxisViewItem& other)
 139         : trackable (other)
 140         , Selectable (other)
 141         , PBD::ScopedConnectionList()
 142         , trackview (other.trackview)
 143         , frame_position (-1)
 144         , item_name (other.item_name)
 145         , _height (1.0)
 146         , _recregion (other._recregion)
 147         , _automation (other._automation)
 148         , _dragging (other._dragging)
 149         , _width (0.0)
 150 {
 151
 152         Gdk::Color c;
 153         int r,g,b,a;
 154
 155         UINT_TO_RGBA (other.fill_color, &r, &g, &b, &a);
 156         c.set_rgb_p (r/255.0, g/255.0, b/255.0);
 157
 158         /* share the other's parent, but still create a new group */
 159
 160         ArdourCanvas::Group* parent = other.group->parent();
 161
 162         _selected = other._selected;
 163
 164         init (parent, other.samples_per_pixel, c, other.frame_position,
 165               other.item_duration, other.visibility, other.wide_enough_for_name, other.high_enough_for_name);
 166 }
 167
 168 void
 169 TimeAxisViewItem::init (ArdourCanvas::Group* parent, double fpp, Gdk::Color const & base_color,
 170                         framepos_t start, framepos_t duration, Visibility vis,
 171                         bool wide, bool high)
 172 {
 173         group = new ArdourCanvas::Group (parent);
 174         CANVAS_DEBUG_NAME (group, string_compose ("TAVI group for %1", get_item_name()));
 175         group->Event.connect (sigc::mem_fun (*this, &TimeAxisViewItem::canvas_group_event));
 176
 177         samples_per_pixel = fpp;
 178         frame_position = start;
 179         item_duration = duration;
 180         name_connected = false;
 181         fill_opacity = 60;
 182         position_locked = false;
 183         max_item_duration = ARDOUR::max_framepos;
 184         min_item_duration = 0;
 185         show_vestigial = true;
 186         visibility = vis;
 187         _sensitive = true;
 188         name_text_width = 0;
 189         last_item_width = 0;
 190         wide_enough_for_name = wide;
 191         high_enough_for_name = high;
 192         rect_visible = true;
 193
 194         if (duration == 0) {
 195                 warning << "Time Axis Item Duration == 0" << endl;
 196         }
 197
 198         vestigial_frame = new ArdourCanvas::Rectangle (group, ArdourCanvas::Rect (0.0, 1.0, 2.0, trackview.current_height()));
 199         CANVAS_DEBUG_NAME (vestigial_frame, string_compose ("vestigial frame for %1", get_item_name()));
 200         vestigial_frame->hide ();
 201         vestigial_frame->set_outline_color (ARDOUR_UI::config()->get_canvasvar_VestigialFrame());
 202         vestigial_frame->set_fill_color (ARDOUR_UI::config()->get_canvasvar_VestigialFrame());
 203
 204         if (visibility & ShowFrame) {
 205                 frame = new ArdourCanvas::Rectangle (group,
 206                                                      ArdourCanvas::Rect (0.0, 0.0,
 207                                                                          trackview.editor().sample_to_pixel(duration) + RIGHT_EDGE_SHIFT,
 208                                                                          trackview.current_height() - 1.0));
 209
 210                 CANVAS_DEBUG_NAME (frame, string_compose ("frame for %1", get_item_name()));
 211
 212                 if (Config->get_show_name_highlight()) {
 213                         frame->set_outline_what (ArdourCanvas::Rectangle::What (ArdourCanvas::Rectangle::LEFT|ArdourCanvas::Rectangle::RIGHT));
 214                 } else {
 215                         frame->set_outline_what (ArdourCanvas::Rectangle::What (ArdourCanvas::Rectangle::LEFT|ArdourCanvas::Rectangle::RIGHT|ArdourCanvas::Rectangle::BOTTOM));
 216                 }
 217
 218                 if (_recregion) {
 219                         frame->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RecordingRect());
 220                 } else {
 221                         frame->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TimeAxisFrame());
 222                 }
 223
 224         } else {
 225
 226                 frame = 0;
 227         }
 228
 229         if (Config->get_show_name_highlight() && (visibility & ShowNameHighlight)) {
 230
 231                 double width;
 232                 double start;
 233
 234                 if (visibility & FullWidthNameHighlight) {
 235                         start = 0.0;
 236                         width = trackview.editor().sample_to_pixel(item_duration) + RIGHT_EDGE_SHIFT;
 237                 } else {
 238                         start = 1.0;
 239                         width = trackview.editor().sample_to_pixel(item_duration) - 2.0 + RIGHT_EDGE_SHIFT;
 240                 }
 241
 242                 name_highlight = new ArdourCanvas::Rectangle (group,
 243                                                               ArdourCanvas::Rect (start,
 244                                                                                   trackview.current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE,
 245                                                                                   width - 2.0 + RIGHT_EDGE_SHIFT,
 246                                                                                   trackview.current_height() - 1.0));
 247                 CANVAS_DEBUG_NAME (name_highlight, string_compose ("name highlight for %1", get_item_name()));
 248                 name_highlight->set_data ("timeaxisviewitem", this);
 249                 name_highlight->set_outline_what (ArdourCanvas::Rectangle::TOP);
 250                 name_highlight->set_outline_color (RGBA_TO_UINT (0,0,0,255));
 251
 252         } else {
 253                 name_highlight = 0;
 254         }
 255
 256         if (visibility & ShowNameText) {
 257                 name_text = new ArdourCanvas::Text (group);
 258                 CANVAS_DEBUG_NAME (name_text, string_compose ("name text for %1", get_item_name()));
 259                 if (Config->get_show_name_highlight()) {
 260                         name_text->set_position (ArdourCanvas::Duple (NAME_X_OFFSET, trackview.current_height() - NAME_Y_OFFSET));
 261                 } else {
 262                         name_text->set_position (ArdourCanvas::Duple (NAME_X_OFFSET, NAME_Y_OFFSET));
 263                 }
 264                 name_text->set_font_description (NAME_FONT);
 265         } else {
 266                 name_text = 0;
 267         }
 268
 269         /* create our grab handles used for trimming/duration etc */
 270         if (!_recregion && !_automation) {
 271                 double top   = TimeAxisViewItem::GRAB_HANDLE_TOP;
 272                 double width = TimeAxisViewItem::GRAB_HANDLE_WIDTH;
 273
 274                 frame_handle_start = new ArdourCanvas::DragHandle (group, ArdourCanvas::Rect (0.0, top, width, trackview.current_height()), true);
 275                 CANVAS_DEBUG_NAME (frame_handle_start, "TAVI frame handle start");
 276                 frame_handle_start->set_outline (false);
 277                 frame_handle_start->set_fill (false);
 278                 frame_handle_start->Event.connect (sigc::bind (sigc::mem_fun (*this, &TimeAxisViewItem::frame_handle_crossing), frame_handle_start));
 279
 280                 frame_handle_end = new ArdourCanvas::DragHandle (group, ArdourCanvas::Rect (0.0, top, width, trackview.current_height()), false);
 281                 CANVAS_DEBUG_NAME (frame_handle_end, "TAVI frame handle end");
 282                 frame_handle_end->set_outline (false);
 283                 frame_handle_end->set_fill (false);
 284                 frame_handle_end->Event.connect (sigc::bind (sigc::mem_fun (*this, &TimeAxisViewItem::frame_handle_crossing), frame_handle_end));
 285         } else {
 286                 frame_handle_start = frame_handle_end = 0;
 287         }
 288
 289         set_color (base_color);
 290
 291         set_duration (item_duration, this);
 292         set_position (start, this);
 293
 294         Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&TimeAxisViewItem::parameter_changed, this, _1), gui_context ());
 295         ARDOUR_UI::config()->ParameterChanged.connect (sigc::mem_fun (*this, &TimeAxisViewItem::parameter_changed));
 296 }
 297
 298 TimeAxisViewItem::~TimeAxisViewItem()
 299 {
 300         delete group;
 301 }
 302
 303 bool
 304 TimeAxisViewItem::canvas_group_event (GdkEvent* /*ev*/)
 305 {
 306         return false;
 307 }
 308
 309 void
 310 TimeAxisViewItem::hide_rect ()
 311 {
 312         rect_visible = false;
 313         set_frame_color ();
 314
 315         if (name_highlight) {
 316                 name_highlight->set_outline_what (ArdourCanvas::Rectangle::What (0));
 317                 name_highlight->set_fill_color (UINT_RGBA_CHANGE_A (fill_color, 64));
 318         }
 319 }
 320
 321 void
 322 TimeAxisViewItem::show_rect ()
 323 {
 324         rect_visible = true;
 325         set_frame_color ();
 326
 327         if (name_highlight) {
 328                 name_highlight->set_outline_what (ArdourCanvas::Rectangle::TOP);
 329                 name_highlight->set_fill_color (fill_color);
 330         }
 331 }
 332
 333 /**
 334  * Set the position of this item on the timeline.
 335  *
 336  * @param pos the new position
 337  * @param src the identity of the object that initiated the change
 338  * @return true on success
 339  */
 340
 341 bool
 342 TimeAxisViewItem::set_position(framepos_t pos, void* src, double* delta)
 343 {
 344         if (position_locked) {
 345                 return false;
 346         }
 347
 348         frame_position = pos;
 349
 350         double new_unit_pos = trackview.editor().sample_to_pixel (pos);
 351
 352         if (delta) {
 353                 (*delta) = new_unit_pos - group->position().x;
 354                 if (*delta == 0.0) {
 355                         return true;
 356                 }
 357         } else {
 358                 if (new_unit_pos == group->position().x) {
 359                         return true;
 360                 }
 361         }
 362
 363         group->set_x_position (new_unit_pos);
 364
 365         PositionChanged (frame_position, src); /* EMIT_SIGNAL */
 366
 367         return true;
 368 }
 369
 370 /** @return position of this item on the timeline */
 371 framepos_t
 372 TimeAxisViewItem::get_position() const
 373 {
 374         return frame_position;
 375 }
 376
 377 /**
 378  * Set the duration of this item.
 379  *
 380  * @param dur the new duration of this item
 381  * @param src the identity of the object that initiated the change
 382  * @return true on success
 383  */
 384
 385 bool
 386 TimeAxisViewItem::set_duration (framecnt_t dur, void* src)
 387 {
 388         if ((dur > max_item_duration) || (dur < min_item_duration)) {
 389                 warning << string_compose (
 390                                 P_("new duration %1 frame is out of bounds for %2", "new duration of %1 frames is out of bounds for %2", dur),
 391                                 get_item_name(), dur)
 392                         << endmsg;
 393                 return false;
 394         }
 395
 396         if (dur == 0) {
 397                 group->hide();
 398         }
 399
 400         item_duration = dur;
 401
 402         reset_width_dependent_items (trackview.editor().sample_to_pixel (dur));
 403
 404         DurationChanged (dur, src); /* EMIT_SIGNAL */
 405         return true;
 406 }
 407
 408 /** @return duration of this item */
 409 framepos_t
 410 TimeAxisViewItem::get_duration() const
 411 {
 412         return item_duration;
 413 }
 414
 415 /**
 416  * Set the maximum duration that this item can have.
 417  *
 418  * @param dur the new maximum duration
 419  * @param src the identity of the object that initiated the change
 420  */
 421 void
 422 TimeAxisViewItem::set_max_duration(framecnt_t dur, void* src)
 423 {
 424         max_item_duration = dur;
 425         MaxDurationChanged(max_item_duration, src); /* EMIT_SIGNAL */
 426 }
 427
 428 /** @return the maximum duration that this item may have */
 429 framecnt_t
 430 TimeAxisViewItem::get_max_duration() const
 431 {
 432         return max_item_duration;
 433 }
 434
 435 /**
 436  * Set the minimum duration that this item may have.
 437  *
 438  * @param the minimum duration that this item may be set to
 439  * @param src the identity of the object that initiated the change
 440  */
 441 void
 442 TimeAxisViewItem::set_min_duration(framecnt_t dur, void* src)
 443 {
 444         min_item_duration = dur;
 445         MinDurationChanged(max_item_duration, src); /* EMIT_SIGNAL */
 446 }
 447
 448 /** @return the minimum duration that this item mey have */
 449 framecnt_t
 450 TimeAxisViewItem::get_min_duration() const
 451 {
 452         return min_item_duration;
 453 }
 454
 455 /**
 456  * Set whether this item is locked to its current position.
 457  * Locked items cannot be moved until the item is unlocked again.
 458  *
 459  * @param yn true to lock this item to its current position
 460  * @param src the identity of the object that initiated the change
 461  */
 462 void
 463 TimeAxisViewItem::set_position_locked(bool yn, void* src)
 464 {
 465         position_locked = yn;
 466         set_trim_handle_colors();
 467         PositionLockChanged (position_locked, src); /* EMIT_SIGNAL */
 468 }
 469
 470 /** @return true if this item is locked to its current position */
 471 bool
 472 TimeAxisViewItem::get_position_locked() const
 473 {
 474         return position_locked;
 475 }
 476
 477 /**
 478  * Set whether the maximum duration constraint is active.
 479  *
 480  * @param active set true to enforce the max duration constraint
 481  * @param src the identity of the object that initiated the change
 482  */
 483 void
 484 TimeAxisViewItem::set_max_duration_active (bool active, void* /*src*/)
 485 {
 486         max_duration_active = active;
 487 }
 488
 489 /** @return true if the maximum duration constraint is active */
 490 bool
 491 TimeAxisViewItem::get_max_duration_active() const
 492 {
 493         return max_duration_active;
 494 }
 495
 496 /**
 497  * Set whether the minimum duration constraint is active.
 498  *
 499  * @param active set true to enforce the min duration constraint
 500  * @param src the identity of the object that initiated the change
 501  */
 502
 503 void
 504 TimeAxisViewItem::set_min_duration_active (bool active, void* /*src*/)
 505 {
 506         min_duration_active = active;
 507 }
 508
 509 /** @return true if the maximum duration constraint is active */
 510 bool
 511 TimeAxisViewItem::get_min_duration_active() const
 512 {
 513         return min_duration_active;
 514 }
 515
 516 /**
 517  * Set the name of this item.
 518  *
 519  * @param new_name the new name of this item
 520  * @param src the identity of the object that initiated the change
 521  */
 522
 523 void
 524 TimeAxisViewItem::set_item_name(std::string new_name, void* src)
 525 {
 526         if (new_name != item_name) {
 527                 std::string temp_name = item_name;
 528                 item_name = new_name;
 529                 NameChanged (item_name, temp_name, src); /* EMIT_SIGNAL */
 530         }
 531 }
 532
 533 /** @return the name of this item */
 534 std::string
 535 TimeAxisViewItem::get_item_name() const
 536 {
 537         return item_name;
 538 }
 539
 540 /**
 541  * Set selection status.
 542  *
 543  * @param yn true if this item is currently selected
 544  */
 545 void
 546 TimeAxisViewItem::set_selected(bool yn)
 547 {
 548         if (_selected != yn) {
 549                 Selectable::set_selected (yn);
 550                 set_frame_color ();
 551         }
 552 }
 553
 554 /** @return the TimeAxisView that this item is on */
 555 TimeAxisView&
 556 TimeAxisViewItem::get_time_axis_view () const
 557 {
 558         return trackview;
 559 }
 560
 561 /**
 562  * Set the displayed item text.
 563  * This item is the visual text name displayed on the canvas item, this can be different to the name of the item.
 564  *
 565  * @param new_name the new name text to display
 566  */
 567
 568 void
 569 TimeAxisViewItem::set_name_text(const string& new_name)
 570 {
 571         if (!name_text) {
 572                 return;
 573         }
 574
 575         name_text_width = pixel_width (new_name, NAME_FONT) + 2;
 576         name_text->set (new_name);
 577
 578 }
 579
 580 /**
 581  * Set the height of this item.
 582  *
 583  * @param h new height
 584  */
 585 void
 586 TimeAxisViewItem::set_height (double height)
 587 {
 588         _height = height;
 589
 590         manage_name_highlight ();
 591
 592         if (visibility & ShowNameText) {
 593                 if (Config->get_show_name_highlight()) {
 594                         name_text->set_y_position (height - NAME_Y_OFFSET);
 595                 } else {
 596                         name_text->set_y_position (NAME_Y_OFFSET);
 597                 }
 598         }
 599
 600         if (frame) {
 601                 frame->set_y1 (height);
 602                 if (frame_handle_start) {
 603                         frame_handle_start->set_y1 (height);
 604                         frame_handle_end->set_y1 (height);
 605                 }
 606         }
 607
 608         vestigial_frame->set_y1 (height - 1.0);
 609
 610         set_colors ();
 611 }
 612
 613 void
 614 TimeAxisViewItem::manage_name_highlight ()
 615 {
 616         if (!name_highlight) {
 617                 return;
 618         }
 619
 620         if (_height < NAME_HIGHLIGHT_THRESH) {
 621                 high_enough_for_name = false;
 622         } else {
 623                 high_enough_for_name = true;
 624         }
 625
 626         if (_width < 2.0) {
 627                 wide_enough_for_name = false;
 628         } else {
 629                 wide_enough_for_name = true;
 630         }
 631
 632         if (name_highlight && wide_enough_for_name && high_enough_for_name) {
 633
 634                 name_highlight->show();
 635                 name_highlight->set (ArdourCanvas::Rect (0.0, (double) _height - NAME_HIGHLIGHT_SIZE,  _width+RIGHT_EDGE_SHIFT, (double) _height - 1.0));
 636
 637         } else {
 638                 name_highlight->hide();
 639         }
 640
 641         manage_name_text ();
 642 }
 643
 644 void
 645 TimeAxisViewItem::set_color (Gdk::Color const & base_color)
 646 {
 647         compute_colors (base_color);
 648         set_colors ();
 649 }
 650
 651 ArdourCanvas::Item*
 652 TimeAxisViewItem::get_canvas_frame()
 653 {
 654         return frame;
 655 }
 656
 657 ArdourCanvas::Group*
 658 TimeAxisViewItem::get_canvas_group()
 659 {
 660         return group;
 661 }
 662
 663 ArdourCanvas::Item*
 664 TimeAxisViewItem::get_name_highlight()
 665 {
 666         return name_highlight;
 667 }
 668
 669 /**
 670  * Calculate some contrasting color for displaying various parts of this item, based upon the base color.
 671  *
 672  * @param color the base color of the item
 673  */
 674 void
 675 TimeAxisViewItem::compute_colors (Gdk::Color const & base_color)
 676 {
 677         unsigned char r,g,b;
 678
 679         /* FILL: change opacity to a fixed value */
 680
 681         r = base_color.get_red()/256;
 682         g = base_color.get_green()/256;
 683         b = base_color.get_blue()/256;
 684         fill_color = RGBA_TO_UINT(r,g,b,160);
 685 }
 686
 687 /**
 688  * Convenience method to set the various canvas item colors
 689  */
 690 void
 691 TimeAxisViewItem::set_colors()
 692 {
 693         set_frame_color();
 694
 695         if (name_highlight) {
 696                 name_highlight->set_fill_color (fill_color);
 697         }
 698
 699         set_name_text_color ();
 700         set_trim_handle_colors();
 701 }
 702
 703 void
 704 TimeAxisViewItem::set_name_text_color ()
 705 {
 706         if (!name_text) {
 707                 return;
 708         }
 709
 710         double r, g, b, a;
 711
 712         const double black_r = 0.0;
 713         const double black_g = 0.0;
 714         const double black_b = 0.0;
 715
 716         const double white_r = 1.0;
 717         const double white_g = 1.0;
 718         const double white_b = 1.0;
 719
 720         uint32_t f;
 721
 722         if (Config->get_show_name_highlight()) {
 723                 /* name text will always be on top of name highlight, which
 724                    will always use our fill color.
 725                 */
 726                 f = fill_color;
 727         } else {
 728                 /* name text will be on top of the item, whose color
 729                    may vary depending on various conditions.
 730                 */
 731                 f = get_fill_color ();
 732         }
 733
 734         ArdourCanvas::color_to_rgba (f, r, g, b, a);
 735
 736         /* Use W3C contrast guideline calculation */
 737
 738         double white_contrast = (max (r, white_r) - min (r, white_r)) +
 739                 (max (g, white_g) - min (g, white_g)) +
 740                 (max (b, white_b) - min (b, white_b));
 741
 742         double black_contrast = (max (r, black_r) - min (r, black_r)) +
 743                 (max (g, black_g) - min (g, black_g)) +
 744                 (max (b, black_b) - min (b, black_b));
 745
 746         if (white_contrast > black_contrast) {
 747                 /* use white */
 748                 name_text->set_color (ArdourCanvas::rgba_to_color (1.0, 1.0, 1.0, 1.0));
 749         } else {
 750                 /* use black */
 751                 name_text->set_color (ArdourCanvas::rgba_to_color (0.0, 0.0, 0.0, 1.0));
 752         }
 753 }
 754
 755 uint32_t
 756 TimeAxisViewItem::get_fill_color () const
 757 {
 758         uint32_t f = 0;
 759
 760         if (_selected) {
 761
 762                 f = ARDOUR_UI::config()->get_canvasvar_SelectedFrameBase();
 763
 764         } else {
 765
 766                 if (_recregion) {
 767                         f = ARDOUR_UI::config()->get_canvasvar_RecordingRect();
 768                 } else {
 769
 770                         if (high_enough_for_name && !ARDOUR_UI::config()->get_color_regions_using_track_color()) {
 771                                 f = ARDOUR_UI::config()->get_canvasvar_FrameBase();
 772                         } else {
 773                                 f = fill_color;
 774                         }
 775                 }
 776         }
 777
 778         return f;
 779 }
 780
 781 /**
 782  * Sets the frame color depending on whether this item is selected
 783  */
 784 void
 785 TimeAxisViewItem::set_frame_color()
 786 {
 787         uint32_t f = 0;
 788
 789         if (!frame) {
 790                 return;
 791         }
 792
 793         f = get_fill_color ();
 794
 795         if (fill_opacity) {
 796                 f = UINT_RGBA_CHANGE_A (f, fill_opacity);
 797         }
 798
 799         if (!rect_visible) {
 800                 f = UINT_RGBA_CHANGE_A (f, 0);
 801         }
 802
 803         frame->set_fill_color (f);
 804         set_frame_gradient ();
 805
 806         if (!_recregion) {
 807                 if (_selected) {
 808                         f = ARDOUR_UI::config()->get_canvasvar_SelectedTimeAxisFrame();
 809                 } else {
 810                         f = ARDOUR_UI::config()->get_canvasvar_TimeAxisFrame();
 811                 }
 812
 813                 if (!rect_visible) {
 814                         f = UINT_RGBA_CHANGE_A (f, 64);
 815                 }
 816
 817                 frame->set_outline_color (f);
 818         }
 819 }
 820
 821 void
 822 TimeAxisViewItem::set_frame_gradient ()
 823 {
 824         if (ARDOUR_UI::config()->get_timeline_item_gradient_depth() == 0.0) {
 825                 frame->set_gradient (ArdourCanvas::Fill::StopList (), 0);
 826                 return;
 827         }
 828
 829         ArdourCanvas::Fill::StopList stops;
 830         double r, g, b, a;
 831         double h, s, v;
 832         ArdourCanvas::Color f (get_fill_color());
 833
 834         /* need to get alpha value */
 835         ArdourCanvas::color_to_rgba (f, r, g, b, a);
 836
 837         stops.push_back (std::make_pair (0.0, f));
 838
 839         /* now a darker version */
 840
 841         ArdourCanvas::color_to_hsv (f, h, s, v);
 842
 843         v = min (1.0, v * (1.0 - ARDOUR_UI::config()->get_timeline_item_gradient_depth()));
 844
 845         ArdourCanvas::Color darker = ArdourCanvas::hsv_to_color (h, s, v, a);
 846         stops.push_back (std::make_pair (1.0, darker));
 847
 848         frame->set_gradient (stops, true);
 849 }
 850
 851 /**
 852  * Set the colors of the start and end trim handle depending on object state
 853  */
 854 void
 855 TimeAxisViewItem::set_trim_handle_colors()
 856 {
 857 #if 1
 858         /* Leave them transparent for now */
 859         if (frame_handle_start) {
 860                 frame_handle_start->set_fill_color (0x00000000);
 861                 frame_handle_end->set_fill_color (0x00000000);
 862         }
 863 #else
 864         if (frame_handle_start) {
 865                 if (position_locked) {
 866                         frame_handle_start->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TrimHandleLocked());
 867                         frame_handle_end->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TrimHandleLocked());
 868                 } else {
 869                         frame_handle_start->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TrimHandle());
 870                         frame_handle_end->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TrimHandle());
 871                 }
 872         }
 873 #endif
 874 }
 875
 876 bool
 877 TimeAxisViewItem::frame_handle_crossing (GdkEvent* ev, ArdourCanvas::Rectangle* item)
 878 {
 879         switch (ev->type) {
 880         case GDK_LEAVE_NOTIFY:
 881                 /* always hide the handle whenever we leave, no matter what mode */
 882                 item->set_fill (false);
 883                 break;
 884         case GDK_ENTER_NOTIFY:
 885                 if (trackview.editor().effective_mouse_mode() == Editing::MouseObject &&
 886                     !trackview.editor().internal_editing()) {
 887                         /* never set this to be visible in internal
 888                            edit mode. Note, however, that we do need to
 889                            undo visibility (LEAVE_NOTIFY case above) no
 890                            matter what the mode is.
 891                         */
 892                         item->set_fill (true);
 893                 }
 894                 break;
 895         default:
 896                 break;
 897         }
 898         return false;
 899 }
 900
 901 /** @return the frames per pixel */
 902 double
 903 TimeAxisViewItem::get_samples_per_pixel () const
 904 {
 905         return samples_per_pixel;
 906 }
 907
 908 /** Set the frames per pixel of this item.
 909  *  This item is used to determine the relative visual size and position of this item
 910  *  based upon its duration and start value.
 911  *
 912  *  @param fpp the new frames per pixel
 913  */
 914 void
 915 TimeAxisViewItem::set_samples_per_pixel (double fpp)
 916 {
 917         samples_per_pixel = fpp;
 918         set_position (this->get_position(), this);
 919         reset_width_dependent_items ((double) get_duration() / samples_per_pixel);
 920 }
 921
 922 void
 923 TimeAxisViewItem::reset_width_dependent_items (double pixel_width)
 924 {
 925         _width = pixel_width;
 926
 927         manage_name_highlight ();
 928
 929         if (pixel_width < 2.0) {
 930
 931                 if (show_vestigial) {
 932                         vestigial_frame->show();
 933                 }
 934
 935                 if (frame) {
 936                         frame->hide();
 937                 }
 938
 939                 if (frame_handle_start) {
 940                         frame_handle_start->hide();
 941                         frame_handle_end->hide();
 942                 }
 943
 944         } else {
 945                 vestigial_frame->hide();
 946
 947                 if (frame) {
 948                         frame->show();
 949                         frame->set_x1 (pixel_width + RIGHT_EDGE_SHIFT);
 950                 }
 951
 952                 if (frame_handle_start) {
 953                         if (pixel_width < (3 * TimeAxisViewItem::GRAB_HANDLE_WIDTH)) {
 954                                 /*
 955                                  * there's less than GRAB_HANDLE_WIDTH of the region between
 956                                  * the right-hand end of frame_handle_start and the left-hand
 957                                  * end of frame_handle_end, so disable the handles
 958                                  */
 959
 960                                 frame_handle_start->hide();
 961                                 frame_handle_end->hide();
 962                         } else {
 963                                 frame_handle_start->show();
 964                                 frame_handle_end->set_x0 (pixel_width + RIGHT_EDGE_SHIFT - (TimeAxisViewItem::GRAB_HANDLE_WIDTH));
 965                                 frame_handle_end->set_x1 (pixel_width + RIGHT_EDGE_SHIFT);
 966                                 frame_handle_end->show();
 967                         }
 968                 }
 969         }
 970 }
 971
 972 void
 973 TimeAxisViewItem::manage_name_text ()
 974 {
 975         int visible_name_width;
 976
 977         if (!name_text) {
 978                 return;
 979         }
 980
 981         if (!wide_enough_for_name || !high_enough_for_name) {
 982                 name_text->hide ();
 983                 return;
 984         }
 985
 986         if (name_text->text().empty()) {
 987                 name_text->hide ();
 988         }
 989
 990         visible_name_width = name_text_width;
 991
 992         if (visible_name_width > _width - NAME_X_OFFSET) {
 993                 visible_name_width = _width - NAME_X_OFFSET;
 994         }
 995
 996         if (visible_name_width < 1) {
 997                 name_text->hide ();
 998         } else {
 999                 name_text->clamp_width (visible_name_width);
1000                 name_text->show ();
1001         }
1002 }
1003
1004 /**
1005  * Callback used to remove this time axis item during the gtk idle loop.
1006  * This is used to avoid deleting the obejct while inside the remove_this_item
1007  * method.
1008  *
1009  * @param item the TimeAxisViewItem to remove.
1010  * @param src the identity of the object that initiated the change.
1011  */
1012 gint
1013 TimeAxisViewItem::idle_remove_this_item(TimeAxisViewItem* item, void* src)
1014 {
1015         item->ItemRemoved (item->get_item_name(), src); /* EMIT_SIGNAL */
1016         delete item;
1017         item = 0;
1018         return false;
1019 }
1020
1021 void
1022 TimeAxisViewItem::set_y (double y)
1023 {
1024         group->set_y_position (y);
1025 }
1026
1027 void
1028 TimeAxisViewItem::parameter_changed (string p)
1029 {
1030         if (p == "color-regions-using-track-color") {
1031                 set_colors ();
1032         } else if (p == "timeline-item-gradient-depth") {
1033                 set_frame_gradient ();
1034         }
1035 }