gtk2_ardour/region_view.cc

   1 /*
   2     Copyright (C) 2001-2006 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 <cmath>
  21 #include <cassert>
  22 #include <algorithm>
  23
  24 #include <gtkmm.h>
  25
  26 #include <gtkmm2ext/gtk_ui.h>
  27 #include <pbd/stacktrace.h>
  28
  29 #include <ardour/playlist.h>
  30 #include <ardour/audioregion.h>
  31 #include <ardour/audiosource.h>
  32 #include <ardour/audio_diskstream.h>
  33
  34 #include "ardour_ui.h"
  35 #include "streamview.h"
  36 #include "region_view.h"
  37 #include "automation_region_view.h"
  38 #include "route_time_axis.h"
  39 #include "simplerect.h"
  40 #include "simpleline.h"
  41 #include "waveview.h"
  42 #include "public_editor.h"
  43 #include "region_editor.h"
  44 #include "ghostregion.h"
  45 #include "route_time_axis.h"
  46 #include "utils.h"
  47 #include "rgb_macros.h"
  48 #include "gui_thread.h"
  49
  50 #include "i18n.h"
  51
  52 using namespace sigc;
  53 using namespace ARDOUR;
  54 using namespace PBD;
  55 using namespace Editing;
  56 using namespace ArdourCanvas;
  57
  58 static const int32_t sync_mark_width = 9;
  59
  60 sigc::signal<void,RegionView*> RegionView::RegionViewGoingAway;
  61
  62 RegionView::RegionView (ArdourCanvas::Group*              parent,
  63                         TimeAxisView&                     tv,
  64                         boost::shared_ptr<ARDOUR::Region> r,
  65                         double                            spu,
  66                         Gdk::Color&                       basic_color)
  67         : TimeAxisViewItem (r->name(), *parent, tv, spu, basic_color, r->position(), r->length(),
  68                             TimeAxisViewItem::Visibility (TimeAxisViewItem::ShowNameText|
  69                                                           TimeAxisViewItem::ShowNameHighlight|
  70                                                           TimeAxisViewItem::ShowFrame))
  71           , _region (r)
  72           , sync_mark(0)
  73           , editor(0)
  74           , current_visible_sync_position(0.0)
  75           , valid(false)
  76           , _enable_display(false)
  77           , _pixel_width(1.0)
  78           , in_destructor(false)
  79           , wait_for_data(false)
  80 {
  81 }
  82
  83 RegionView::RegionView (const RegionView& other)
  84         : TimeAxisViewItem (other)
  85 {
  86         /* derived concrete type will call init () */
  87
  88         _region = other._region;
  89         editor = 0;
  90         current_visible_sync_position = other.current_visible_sync_position;
  91         valid = false;
  92         _enable_display = false;
  93         _pixel_width = other._pixel_width;
  94 }
  95
  96 RegionView::RegionView (ArdourCanvas::Group*         parent,
  97                         TimeAxisView&                tv,
  98                         boost::shared_ptr<ARDOUR::Region> r,
  99                         double                       spu,
 100                         Gdk::Color&                  basic_color,
 101                         TimeAxisViewItem::Visibility visibility)
 102         : TimeAxisViewItem (r->name(), *parent, tv, spu, basic_color, r->position(), r->length(), visibility)
 103         , _region (r)
 104         , sync_mark(0)
 105         , editor(0)
 106         , current_visible_sync_position(0.0)
 107         , valid(false)
 108         , _enable_display(false)
 109         , _pixel_width(1.0)
 110         , in_destructor(false)
 111         , wait_for_data(false)
 112 {
 113 }
 114
 115 void
 116 RegionView::init (Gdk::Color& basic_color, bool wfd)
 117 {
 118         valid           = true;
 119         _enable_display = false;
 120         in_destructor   = false;
 121         wait_for_data   = wfd;
 122
 123         compute_colors (basic_color);
 124
 125         name_highlight->set_data ("regionview", this);
 126
 127         if (name_text) {
 128                 name_text->set_data ("regionview", this);
 129         }
 130
 131         /* an equilateral triangle */
 132
 133         ArdourCanvas::Points shape;
 134         shape.push_back (Gnome::Art::Point (-((sync_mark_width-1)/2), 1));
 135         shape.push_back (Gnome::Art::Point ((sync_mark_width - 1)/2, 1));
 136         shape.push_back (Gnome::Art::Point (0, sync_mark_width - 1));
 137         shape.push_back (Gnome::Art::Point (-((sync_mark_width-1)/2), 1));
 138
 139         sync_mark =  new ArdourCanvas::Polygon (*group);
 140         sync_mark->property_points() = shape;
 141         sync_mark->property_fill_color_rgba() = fill_color;
 142         sync_mark->hide();
 143
 144         //reset_width_dependent_items ((double) _region->length() / samples_per_unit);
 145
 146         if (wfd)
 147                 _enable_display = true;
 148
 149         set_y_position_and_height (0, trackview.height - 2);
 150
 151         _region->StateChanged.connect (mem_fun(*this, &RegionView::region_changed));
 152
 153         group->signal_event().connect (bind (mem_fun (PublicEditor::instance(), &PublicEditor::canvas_region_view_event), group, this));
 154         name_highlight->signal_event().connect (bind (mem_fun (PublicEditor::instance(), &PublicEditor::canvas_region_view_name_highlight_event), name_highlight, this));
 155
 156         set_colors ();
 157
 158         ColorsChanged.connect (mem_fun (*this, &RegionView::color_handler));
 159
 160         /* XXX sync mark drag? */
 161 }
 162
 163 RegionView::~RegionView ()
 164 {
 165         in_destructor = true;
 166
 167         for (vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
 168                 delete *g;
 169         }
 170
 171         if (editor) {
 172                 delete editor;
 173         }
 174 }
 175
 176 gint
 177 RegionView::_lock_toggle (ArdourCanvas::Item* item, GdkEvent* ev, void* arg)
 178 {
 179         switch (ev->type) {
 180         case GDK_BUTTON_RELEASE:
 181                 static_cast<RegionView*>(arg)->lock_toggle ();
 182                 return TRUE;
 183                 break;
 184         default:
 185                 break;
 186         }
 187         return FALSE;
 188 }
 189
 190 void
 191 RegionView::lock_toggle ()
 192 {
 193         _region->set_locked (!_region->locked());
 194 }
 195
 196 void
 197 RegionView::region_changed (Change what_changed)
 198 {
 199         ENSURE_GUI_THREAD (bind (mem_fun(*this, &RegionView::region_changed), what_changed));
 200
 201         if (what_changed & BoundsChanged) {
 202                 region_resized (what_changed);
 203                 region_sync_changed ();
 204         }
 205         if (what_changed & Region::MuteChanged) {
 206                 region_muted ();
 207         }
 208         if (what_changed & Region::OpacityChanged) {
 209                 region_opacity ();
 210         }
 211         if (what_changed & ARDOUR::NameChanged) {
 212                 region_renamed ();
 213         }
 214         if (what_changed & Region::SyncOffsetChanged) {
 215                 region_sync_changed ();
 216         }
 217         /*
 218            this should not be needed now that only playlist can change layering
 219         */
 220         /*
 221         if (what_changed & Region::LayerChanged) {
 222                 region_layered ();
 223         }
 224         */
 225         if (what_changed & Region::LockChanged) {
 226                 region_locked ();
 227         }
 228 }
 229
 230 void
 231 RegionView::region_locked ()
 232 {
 233         /* name will show locked status */
 234         region_renamed ();
 235 }
 236
 237 void
 238 RegionView::region_resized (Change what_changed)
 239 {
 240         double unit_length;
 241
 242         if (what_changed & ARDOUR::PositionChanged) {
 243                 set_position (_region->position(), 0);
 244         }
 245
 246         if (what_changed & Change (StartChanged|LengthChanged)) {
 247
 248                 set_duration (_region->length(), 0);
 249
 250                 unit_length = _region->length() / samples_per_unit;
 251
 252                 for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
 253
 254                         (*i)->set_duration (unit_length);
 255
 256                 }
 257         }
 258 }
 259
 260 void
 261 RegionView::reset_width_dependent_items (double pixel_width)
 262 {
 263         TimeAxisViewItem::reset_width_dependent_items (pixel_width);
 264         _pixel_width = pixel_width;
 265
 266         /*for (AutomationChildren::iterator i = _automation_children.begin();
 267                         i != _automation_children.end(); ++i) {
 268                 i->second->reset_width_dependent_items(pixel_width);
 269         }*/
 270 }
 271
 272 void
 273 RegionView::region_layered ()
 274 {
 275         RouteTimeAxisView *rtv = dynamic_cast<RouteTimeAxisView*>(&get_time_axis_view());
 276         assert(rtv);
 277         rtv->view()->region_layered (this);
 278 }
 279
 280 void
 281 RegionView::region_muted ()
 282 {
 283         set_frame_color ();
 284         region_renamed ();
 285 }
 286
 287 void
 288 RegionView::region_opacity ()
 289 {
 290         set_frame_color ();
 291 }
 292
 293 void
 294 RegionView::raise_to_top ()
 295 {
 296         _region->raise_to_top ();
 297 }
 298
 299 void
 300 RegionView::lower_to_bottom ()
 301 {
 302         _region->lower_to_bottom ();
 303 }
 304
 305 bool
 306 RegionView::set_position (nframes_t pos, void* src, double* ignored)
 307 {
 308         double delta;
 309         bool ret;
 310
 311         if (!(ret = TimeAxisViewItem::set_position (pos, this, &delta))) {
 312                 return false;
 313         }
 314
 315         if (ignored) {
 316                 *ignored = delta;
 317         }
 318
 319         if (delta) {
 320                 for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
 321                         (*i)->group->move (delta, 0.0);
 322                 }
 323
 324                 for (AutomationChildren::iterator i = _automation_children.begin();
 325                                 i != _automation_children.end(); ++i) {
 326                         i->second->get_canvas_group()->move(delta, 0.0);
 327                 }
 328         }
 329
 330         return ret;
 331 }
 332
 333 void
 334 RegionView::set_samples_per_unit (gdouble spu)
 335 {
 336         TimeAxisViewItem::set_samples_per_unit (spu);
 337
 338         for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
 339                 (*i)->set_samples_per_unit (spu);
 340                 (*i)->set_duration (_region->length() / samples_per_unit);
 341         }
 342
 343         region_sync_changed ();
 344 }
 345
 346 bool
 347 RegionView::set_duration (nframes_t frames, void *src)
 348 {
 349         if (!TimeAxisViewItem::set_duration (frames, src)) {
 350                 return false;
 351         }
 352
 353         for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
 354                 (*i)->set_duration (_region->length() / samples_per_unit);
 355         }
 356
 357         return true;
 358 }
 359
 360 void
 361 RegionView::compute_colors (Gdk::Color& basic_color)
 362 {
 363         TimeAxisViewItem::compute_colors (basic_color);
 364 }
 365
 366 void
 367 RegionView::set_colors ()
 368 {
 369         TimeAxisViewItem::set_colors ();
 370
 371         if (sync_mark) {
 372                 sync_mark->property_fill_color_rgba() = fill_color;
 373         }
 374 }
 375
 376 void
 377 RegionView::set_frame_color ()
 378 {
 379         if (_region->opaque()) {
 380                 fill_opacity = 130;
 381         } else {
 382                 fill_opacity = 60;
 383         }
 384
 385         TimeAxisViewItem::set_frame_color ();
 386 }
 387
 388 void
 389 RegionView::fake_set_opaque (bool yn)
 390 {
 391        if (yn) {
 392                fill_opacity = 130;
 393        } else {
 394                fill_opacity = 60;
 395        }
 396
 397        TimeAxisViewItem::set_frame_color ();
 398 }
 399
 400 void
 401 RegionView::hide_region_editor()
 402 {
 403         if (editor) {
 404                 editor->hide_all ();
 405         }
 406 }
 407
 408 Glib::ustring
 409 RegionView::make_name () const
 410 {
 411         Glib::ustring str;
 412
 413         // XXX nice to have some good icons for this
 414
 415         if (_region->locked()) {
 416                 str += '>';
 417                 str += _region->name();
 418                 str += '<';
 419         } else if (_region->position_locked()) {
 420                 str += '{';
 421                 str += _region->name();
 422                 str += '}';
 423         } else {
 424                 str = _region->name();
 425         }
 426
 427         if (_region->muted()) {
 428                 str = string ("!") + str;
 429         }
 430
 431         return str;
 432 }
 433
 434 void
 435 RegionView::region_renamed ()
 436 {
 437         Glib::ustring str = make_name ();
 438
 439         set_item_name (str, this);
 440         set_name_text (str);
 441         reset_width_dependent_items (_pixel_width);
 442 }
 443
 444 void
 445 RegionView::region_sync_changed ()
 446 {
 447         if (sync_mark == 0) {
 448                 return;
 449         }
 450
 451         int sync_dir;
 452         nframes_t sync_offset;
 453
 454         sync_offset = _region->sync_offset (sync_dir);
 455
 456         /* this has to handle both a genuine change of position, a change of samples_per_unit,
 457            and a change in the bounds of the _region->
 458          */
 459
 460         if (sync_offset == 0) {
 461
 462                 /* no sync mark - its the start of the region */
 463
 464                 sync_mark->hide();
 465
 466         } else {
 467
 468                 if ((sync_dir < 0) || ((sync_dir > 0) && (sync_offset > _region->length()))) {
 469
 470                         /* no sync mark - its out of the bounds of the region */
 471
 472                         sync_mark->hide();
 473
 474                 } else {
 475
 476                         /* lets do it */
 477
 478                         Points points;
 479
 480                         //points = sync_mark->property_points().get_value();
 481
 482                         double offset = sync_offset / samples_per_unit;
 483                         points.push_back (Gnome::Art::Point (offset - ((sync_mark_width-1)/2), 1));
 484                         points.push_back (Gnome::Art::Point (offset + ((sync_mark_width-1)/2), 1));
 485                         points.push_back (Gnome::Art::Point (offset, sync_mark_width - 1));
 486                         points.push_back (Gnome::Art::Point (offset - ((sync_mark_width-1)/2), 1));
 487                         sync_mark->property_points().set_value (points);
 488                         sync_mark->show();
 489
 490                 }
 491         }
 492 }
 493
 494 void
 495 RegionView::move (double x_delta, double y_delta)
 496 {
 497         if (!_region->can_move() || (x_delta == 0 && y_delta == 0)) {
 498                 return;
 499         }
 500
 501         get_canvas_group()->move (x_delta, y_delta);
 502
 503         /* note: ghosts never leave their tracks so y_delta for them is always zero */
 504
 505         for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
 506                 (*i)->group->move (x_delta, 0.0);
 507         }
 508
 509         for (AutomationChildren::iterator i = _automation_children.begin();
 510                         i != _automation_children.end(); ++i) {
 511                 i->second->get_canvas_group()->move(x_delta, 0.0);
 512         }
 513 }
 514
 515 void
 516 RegionView::remove_ghost (GhostRegion* ghost)
 517 {
 518         if (in_destructor) {
 519                 return;
 520         }
 521
 522         for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
 523                 if (*i == ghost) {
 524                         ghosts.erase (i);
 525                         break;
 526                 }
 527         }
 528 }
 529
 530 uint32_t
 531 RegionView::get_fill_color ()
 532 {
 533         return fill_color;
 534 }
 535