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