cinelerra-5.1/cinelerra/mwindowmove.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 1997-2014 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "automation.h"
  23 #include "autos.h"
  24 #include "clip.h"
  25 #include "cplayback.h"
  26 #include "cwindow.h"
  27 #include "cwindowgui.h"
  28 #include "edits.h"
  29 #include "edl.h"
  30 #include "edlsession.h"
  31 #include "keyframe.h"
  32 #include "labels.h"
  33 #include "localsession.h"
  34 #include "maincursor.h"
  35 #include "mainmenu.h"
  36 #include "mainsession.h"
  37 #include "mtimebar.h"
  38 #include "mwindow.h"
  39 #include "mwindowgui.h"
  40 #include "patchbay.h"
  41 #include "playbackengine.h"
  42 #include "plugin.h"
  43 #include "pluginset.h"
  44 #include "resourcethread.h"
  45 #include "samplescroll.h"
  46 #include "theme.h"
  47 #include "trackcanvas.h"
  48 #include "tracks.h"
  49 #include "track.h"
  50 #include "transportque.h"
  51 #include "zoombar.h"
  52
  53
  54 void MWindow::update_plugins()
  55 {
  56 // Show plugins which are visible and hide plugins which aren't
  57 // Update plugin pointers in plugin servers
  58 }
  59
  60
  61 int MWindow::expand_sample()
  62 {
  63         if(gui)
  64         {
  65                 if(edl->local_session->zoom_sample < 0x100000)
  66                 {
  67                         edl->local_session->zoom_sample *= 2;
  68                         gui->zoombar->sample_zoom->update(edl->local_session->zoom_sample);
  69                         zoom_sample(edl->local_session->zoom_sample);
  70                 }
  71         }
  72         return 0;
  73 }
  74
  75 int MWindow::zoom_in_sample()
  76 {
  77         if(gui)
  78         {
  79                 if(edl->local_session->zoom_sample > 1)
  80                 {
  81                         edl->local_session->zoom_sample /= 2;
  82                         gui->zoombar->sample_zoom->update(edl->local_session->zoom_sample);
  83                         zoom_sample(edl->local_session->zoom_sample);
  84                 }
  85         }
  86         return 0;
  87 }
  88
  89 int MWindow::zoom_sample(int64_t zoom_sample)
  90 {
  91         CLAMP(zoom_sample, 1, 0x100000);
  92         edl->local_session->zoom_sample = zoom_sample;
  93         find_cursor();
  94
  95         TimelinePane *pane = gui->get_focused_pane();
  96         samplemovement(edl->local_session->view_start[pane->number], pane->number);
  97         return 0;
  98 }
  99
 100 void MWindow::find_cursor()
 101 {
 102         TimelinePane *pane = gui->get_focused_pane();
 103         edl->local_session->view_start[pane->number] =
 104                 Units::round((edl->local_session->get_selectionend(1) +
 105                 edl->local_session->get_selectionstart(1)) /
 106                 2 *
 107                 edl->session->sample_rate /
 108                 edl->local_session->zoom_sample -
 109                 (double)pane->canvas->get_w() /
 110                 2);
 111
 112         if(edl->local_session->view_start[pane->number] < 0)
 113                 edl->local_session->view_start[pane->number] = 0;
 114 }
 115
 116
 117 void MWindow::fit_selection()
 118 {
 119         if(EQUIV(edl->local_session->get_selectionstart(1),
 120                 edl->local_session->get_selectionend(1)))
 121         {
 122                 double total_samples = edl->tracks->total_length() *
 123                         edl->session->sample_rate;
 124                 TimelinePane *pane = gui->get_focused_pane();
 125                 for(edl->local_session->zoom_sample = 1;
 126                         pane->canvas->get_w() * edl->local_session->zoom_sample < total_samples;
 127                         edl->local_session->zoom_sample *= 2)
 128                         ;
 129         }
 130         else
 131         {
 132                 double total_samples = (edl->local_session->get_selectionend(1) -
 133                         edl->local_session->get_selectionstart(1)) *
 134                         edl->session->sample_rate;
 135                 TimelinePane *pane = gui->get_focused_pane();
 136                 for(edl->local_session->zoom_sample = 1;
 137                         pane->canvas->get_w() * edl->local_session->zoom_sample < total_samples;
 138                         edl->local_session->zoom_sample *= 2)
 139                         ;
 140         }
 141
 142         edl->local_session->zoom_sample = MIN(0x100000,
 143                 edl->local_session->zoom_sample);
 144         zoom_sample(edl->local_session->zoom_sample);
 145 }
 146
 147
 148 void MWindow::fit_autos(int all)
 149 {
 150         float min = 0, max = 0;
 151         double start, end;
 152
 153 // Test all autos
 154         if(EQUIV(edl->local_session->get_selectionstart(1),
 155                 edl->local_session->get_selectionend(1)))
 156         {
 157                 start = 0;
 158                 end = edl->tracks->total_length();
 159         }
 160         else
 161 // Test autos in highlighting only
 162         {
 163                 start = edl->local_session->get_selectionstart(1);
 164                 end = edl->local_session->get_selectionend(1);
 165         }
 166
 167         int forstart = edl->local_session->zoombar_showautotype;
 168         int forend   = edl->local_session->zoombar_showautotype + 1;
 169
 170         if( all ) {
 171                 forstart = 0;
 172                 forend   = AUTOGROUPTYPE_COUNT;
 173         }
 174
 175         for (int i = forstart; i < forend; i++)
 176         {
 177 // Adjust min and max
 178                 edl->tracks->get_automation_extents(&min, &max, start, end, i);
 179 //printf("MWindow::fit_autos %d %f %f results in ", i, min, max);
 180
 181                 float range = max - min;
 182                 switch (i)
 183                 {
 184                 case AUTOGROUPTYPE_AUDIO_FADE:
 185                         if (range < 1) {
 186                                 min = MIN(min, edl->local_session->automation_mins[i]);
 187                                 max = MAX(max, edl->local_session->automation_maxs[i]);
 188                                 if( min >= max-0.1 ) { min = -80.0; min = 6.0; }
 189                         }
 190                         break;
 191                 case AUTOGROUPTYPE_VIDEO_FADE:
 192                         if (range < 1) {
 193                                 min = MIN(min, edl->local_session->automation_mins[i]);
 194                                 max = MAX(max, edl->local_session->automation_maxs[i]);
 195                                 if( min >= max-0.1 ) { min = 0.0; min = 100.0; }
 196                         }
 197                         break;
 198                 case AUTOGROUPTYPE_ZOOM:
 199                         if (range < 0.001) {
 200                                 min = floor(min*50)/100;
 201                                 max = floor(max*200)/100;
 202                         }
 203                         break;
 204                 case AUTOGROUPTYPE_SPEED:
 205                         if (range < 0.001) {
 206                                 min = floor(min*5)/100;
 207                                 max = floor(max*300)/100;
 208                         }
 209                         break;
 210                 case AUTOGROUPTYPE_X:
 211                 case AUTOGROUPTYPE_Y:
 212                         if (range < 1) {
 213                                 float scale = bmin(edl->session->output_w, edl->session->output_h);
 214                                 min = floor((min+max)/2) - 0.5*scale;
 215                                 max = floor((min+max)/2) + 0.5*scale;
 216                         }
 217                         break;
 218                 }
 219 //printf("%f %f\n", min, max);
 220                 if (!Automation::autogrouptypes_fixedrange[i])
 221                 {
 222                         edl->local_session->automation_mins[i] = min;
 223                         edl->local_session->automation_maxs[i] = max;
 224                 }
 225         }
 226
 227 // Show range in zoombar
 228         gui->zoombar->update();
 229
 230 // Draw
 231         gui->draw_overlays(1);
 232 }
 233
 234
 235 void MWindow::change_currentautorange(int autogrouptype, int increment, int changemax)
 236 {
 237         float val;
 238         if (changemax) {
 239                 val = edl->local_session->automation_maxs[autogrouptype];
 240         } else {
 241                 val = edl->local_session->automation_mins[autogrouptype];
 242         }
 243
 244         if (increment)
 245         {
 246                 switch (autogrouptype) {
 247                 case AUTOGROUPTYPE_AUDIO_FADE:
 248                         val += 2;
 249                         break;
 250                 case AUTOGROUPTYPE_VIDEO_FADE:
 251                         val += 1;
 252                         break;
 253                 case AUTOGROUPTYPE_ZOOM:
 254                 case AUTOGROUPTYPE_SPEED:
 255                         if (val == 0)
 256                                 val = 0.001;
 257                         else
 258                                 val = val*2;
 259                         break;
 260                 case AUTOGROUPTYPE_X:
 261                 case AUTOGROUPTYPE_Y:
 262                         val = floor(val + 5);
 263                         break;
 264                 }
 265         }
 266         else
 267         { // decrement
 268                 switch (autogrouptype) {
 269                 case AUTOGROUPTYPE_AUDIO_FADE:
 270                         val -= 2;
 271                         break;
 272                 case AUTOGROUPTYPE_VIDEO_FADE:
 273                         val -= 1;
 274                         break;
 275                 case AUTOGROUPTYPE_ZOOM:
 276                 case AUTOGROUPTYPE_SPEED:
 277                         if (val > 0) val = val/2;
 278                         break;
 279                 case AUTOGROUPTYPE_X:
 280                 case AUTOGROUPTYPE_Y:
 281                         val = floor(val-5);
 282                         break;
 283                 }
 284         }
 285
 286         AUTOMATIONVIEWCLAMPS(val, autogrouptype);
 287
 288         if (changemax) {
 289                 if (val > edl->local_session->automation_mins[autogrouptype])
 290                         edl->local_session->automation_maxs[autogrouptype] = val;
 291         }
 292         else
 293         {
 294                 if (val < edl->local_session->automation_maxs[autogrouptype])
 295                         edl->local_session->automation_mins[autogrouptype] = val;
 296         }
 297 }
 298
 299
 300 void MWindow::expand_autos(int changeall, int domin, int domax)
 301 {
 302         if (changeall)
 303                 for (int i = 0; i < AUTOGROUPTYPE_COUNT; i++) {
 304                         if (domin) change_currentautorange(i, 1, 0);
 305                         if (domax) change_currentautorange(i, 1, 1);
 306                 }
 307         else
 308         {
 309                 if (domin) change_currentautorange(edl->local_session->zoombar_showautotype, 1, 0);
 310                 if (domax) change_currentautorange(edl->local_session->zoombar_showautotype, 1, 1);
 311         }
 312         gui->zoombar->update_autozoom();
 313         gui->draw_overlays(0);
 314         gui->update_patchbay();
 315         gui->flash_canvas(1);
 316 }
 317
 318 void MWindow::shrink_autos(int changeall, int domin, int domax)
 319 {
 320         if (changeall)
 321                 for (int i = 0; i < AUTOGROUPTYPE_COUNT; i++) {
 322                         if (domin) change_currentautorange(i, 0, 0);
 323                         if (domax) change_currentautorange(i, 0, 1);
 324                 }
 325         else
 326         {
 327                 if (domin) change_currentautorange(edl->local_session->zoombar_showautotype, 0, 0);
 328                 if (domax) change_currentautorange(edl->local_session->zoombar_showautotype, 0, 1);
 329         }
 330         gui->zoombar->update_autozoom();
 331         gui->draw_overlays(0);
 332         gui->update_patchbay();
 333         gui->flash_canvas(1);
 334 }
 335
 336
 337 void MWindow::zoom_autos(float min, float max)
 338 {
 339         int i = edl->local_session->zoombar_showautotype;
 340         edl->local_session->automation_mins[i] = min;
 341         edl->local_session->automation_maxs[i] = max;
 342         gui->zoombar->update_autozoom();
 343         gui->draw_overlays(1);
 344 }
 345
 346
 347 void MWindow::zoom_amp(int64_t zoom_amp)
 348 {
 349         edl->local_session->zoom_y = zoom_amp;
 350         gui->draw_canvas(0, 0);
 351         gui->flash_canvas(0);
 352         gui->update_patchbay();
 353         gui->flush();
 354 }
 355
 356 void MWindow::zoom_track(int64_t zoom_track)
 357 {
 358 // scale waveforms
 359         edl->local_session->zoom_y = (int64_t)((float)edl->local_session->zoom_y *
 360                 zoom_track /
 361                 edl->local_session->zoom_track);
 362         CLAMP(edl->local_session->zoom_y, MIN_AMP_ZOOM, MAX_AMP_ZOOM);
 363
 364 // scale tracks
 365         double scale = (double)zoom_track / edl->local_session->zoom_track;
 366         edl->local_session->zoom_track = zoom_track;
 367
 368 // shift row position
 369         for(int i = 0; i < TOTAL_PANES; i++)
 370         {
 371                 edl->local_session->track_start[i] *= scale;
 372         }
 373         edl->tracks->update_y_pixels(theme);
 374         gui->draw_trackmovement();
 375 //printf("MWindow::zoom_track %d %d\n", edl->local_session->zoom_y, edl->local_session->zoom_track);
 376 }
 377
 378 void MWindow::trackmovement(int offset, int pane_number)
 379 {
 380         edl->local_session->track_start[pane_number] += offset;
 381         if(edl->local_session->track_start[pane_number] < 0)
 382                 edl->local_session->track_start[pane_number] = 0;
 383
 384         if(pane_number == TOP_RIGHT_PANE ||
 385                 pane_number == TOP_LEFT_PANE)
 386         {
 387                 edl->local_session->track_start[TOP_LEFT_PANE] =
 388                         edl->local_session->track_start[TOP_RIGHT_PANE] =
 389                         edl->local_session->track_start[pane_number];
 390         }
 391         else
 392         if(pane_number == BOTTOM_RIGHT_PANE ||
 393                 pane_number == BOTTOM_LEFT_PANE)
 394         {
 395                 edl->local_session->track_start[BOTTOM_LEFT_PANE] =
 396                         edl->local_session->track_start[BOTTOM_RIGHT_PANE] =
 397                         edl->local_session->track_start[pane_number];
 398         }
 399
 400
 401         edl->tracks->update_y_pixels(theme);
 402         gui->draw_trackmovement();
 403 }
 404
 405 void MWindow::move_up(int64_t distance)
 406 {
 407         TimelinePane *pane = gui->get_focused_pane();
 408         if(distance == 0) distance = edl->local_session->zoom_track;
 409
 410         trackmovement(-distance, pane->number);
 411 }
 412
 413 void MWindow::move_down(int64_t distance)
 414 {
 415         TimelinePane *pane = gui->get_focused_pane();
 416         if(distance == 0) distance = edl->local_session->zoom_track;
 417
 418         trackmovement(distance, pane->number);
 419 }
 420
 421 int MWindow::goto_end()
 422 {
 423         TimelinePane *pane = gui->get_focused_pane();
 424         int64_t old_view_start = edl->local_session->view_start[pane->number];
 425
 426         if(edl->tracks->total_length() > (double)pane->canvas->get_w() *
 427                 edl->local_session->zoom_sample /
 428                 edl->session->sample_rate)
 429         {
 430                 edl->local_session->view_start[pane->number] =
 431                         Units::round(edl->tracks->total_length() *
 432                                 edl->session->sample_rate /
 433                                 edl->local_session->zoom_sample -
 434                                 pane->canvas->get_w() /
 435                                 2);
 436         }
 437         else
 438         {
 439                 edl->local_session->view_start[pane->number] = 0;
 440         }
 441
 442         if(gui->shift_down())
 443         {
 444                 edl->local_session->set_selectionend(edl->tracks->total_length());
 445         }
 446         else
 447         {
 448                 edl->local_session->set_selectionstart(edl->tracks->total_length());
 449                 edl->local_session->set_selectionend(edl->tracks->total_length());
 450         }
 451
 452         if(edl->local_session->view_start[pane->number] != old_view_start)
 453         {
 454                 samplemovement(edl->local_session->view_start[pane->number], pane->number);
 455                 gui->draw_samplemovement();
 456         }
 457
 458         update_plugin_guis();
 459
 460         gui->update_patchbay();
 461         gui->update_cursor();
 462         gui->activate_timeline();
 463         gui->zoombar->update();
 464         gui->update_timebar(1);
 465         cwindow->update(1, 0, 0, 0, 1);
 466         return 0;
 467 }
 468
 469 int MWindow::goto_start()
 470 {
 471         TimelinePane *pane = gui->get_focused_pane();
 472         int64_t old_view_start = edl->local_session->view_start[pane->number];
 473
 474         edl->local_session->view_start[pane->number] = 0;
 475         if(gui->shift_down())
 476         {
 477                 edl->local_session->set_selectionstart(0);
 478         }
 479         else
 480         {
 481                 edl->local_session->set_selectionstart(0);
 482                 edl->local_session->set_selectionend(0);
 483         }
 484
 485         if(edl->local_session->view_start[pane->number] != old_view_start)
 486         {
 487                 samplemovement(edl->local_session->view_start[pane->number], pane->number);
 488                 gui->draw_samplemovement();
 489         }
 490
 491         update_plugin_guis();
 492         gui->update_patchbay();
 493         gui->update_cursor();
 494         gui->activate_timeline();
 495         gui->zoombar->update();
 496         gui->update_timebar(1);
 497         cwindow->update(1, 0, 0, 0, 1);
 498         return 0;
 499 }
 500
 501 int MWindow::goto_position(double position)
 502 {
 503         position = edl->align_to_frame(position, 0);
 504         if( position < 0 ) position = 0;
 505         select_point(position);
 506         gui->activate_timeline();
 507         return 0;
 508 }
 509
 510 int MWindow::samplemovement(int64_t view_start, int pane_number)
 511 {
 512         if( view_start < 0 ) view_start = 0;
 513         edl->local_session->view_start[pane_number] = view_start;
 514         if(edl->local_session->view_start[pane_number] < 0)
 515                 edl->local_session->view_start[pane_number] = 0;
 516
 517         if(pane_number == TOP_LEFT_PANE ||
 518                 pane_number == BOTTOM_LEFT_PANE)
 519         {
 520                 edl->local_session->view_start[TOP_LEFT_PANE] =
 521                         edl->local_session->view_start[BOTTOM_LEFT_PANE] =
 522                         edl->local_session->view_start[pane_number];
 523         }
 524         else
 525         {
 526                 edl->local_session->view_start[TOP_RIGHT_PANE] =
 527                         edl->local_session->view_start[BOTTOM_RIGHT_PANE] =
 528                         edl->local_session->view_start[pane_number];
 529         }
 530
 531         gui->draw_samplemovement();
 532
 533         return 0;
 534 }
 535
 536 int MWindow::move_left(int64_t distance)
 537 {
 538         TimelinePane *pane = gui->get_focused_pane();
 539         if(!distance)
 540                 distance = pane->canvas->get_w() /
 541                         10;
 542         edl->local_session->view_start[pane->number] -= distance;
 543         samplemovement(edl->local_session->view_start[pane->number],
 544                 pane->number);
 545         return 0;
 546 }
 547
 548 int MWindow::move_right(int64_t distance)
 549 {
 550         TimelinePane *pane = gui->get_focused_pane();
 551         if(!distance)
 552                 distance = pane->canvas->get_w() /
 553                         10;
 554         edl->local_session->view_start[pane->number] += distance;
 555         samplemovement(edl->local_session->view_start[pane->number],
 556                 pane->number);
 557         return 0;
 558 }
 559
 560 void MWindow::select_all()
 561 {
 562         if( edl->local_session->get_selectionstart(1) == 0 &&
 563             edl->local_session->get_selectionend(1) == edl->tracks->total_length() )
 564                 edl->local_session->set_selectionend(0);
 565         else {
 566                 edl->local_session->set_selectionstart(0);
 567                 edl->local_session->set_selectionend(edl->tracks->total_length());
 568         }
 569         gui->update(0, NORMAL_DRAW, 1, 1, 0, 1, 0);
 570         gui->activate_timeline();
 571         cwindow->update(1, 0, 0, 0, 1);
 572         update_plugin_guis();
 573 }
 574
 575 int MWindow::next_label(int shift_down)
 576 {
 577         double position = edl->local_session->get_selectionend(1);
 578         double total_length = edl->tracks->total_length();
 579         Label *current = edl->labels->next_label(position);
 580         double new_position = current ? current->position : total_length;
 581 // last playback endpoints as fake label positions
 582         double playback_start = edl->local_session->playback_start;
 583         double playback_end = edl->local_session->playback_end;
 584         if( playback_start > position && playback_start < new_position )
 585                 new_position = playback_start;
 586         else if( playback_end > position && playback_end < new_position )
 587                 new_position = playback_end;
 588         if( new_position > total_length )
 589                 new_position = total_length;
 590         edl->local_session->set_selectionend(new_position);
 591 //printf("MWindow::next_edit_handle %d\n", shift_down);
 592         if( !shift_down )
 593                 edl->local_session->set_selectionstart(new_position);
 594         return find_selection(new_position);
 595 }
 596
 597 int MWindow::prev_label(int shift_down)
 598 {
 599         double position = edl->local_session->get_selectionstart(1);
 600         Label *current = edl->labels->prev_label(position);
 601         double new_position = current ? current->position : 0;
 602 // last playback endpoints as fake label positions
 603         double playback_start = edl->local_session->playback_start;
 604         double playback_end = edl->local_session->playback_end;
 605         if( playback_end < position && playback_end > new_position )
 606                 new_position = playback_end;
 607         else if( playback_start < position && playback_start > new_position )
 608                 new_position = playback_start;
 609         if( new_position < 0 )
 610                 new_position = 0;
 611         edl->local_session->set_selectionstart(new_position);
 612 //printf("MWindow::next_edit_handle %d\n", shift_down);
 613         if( !shift_down )
 614                 edl->local_session->set_selectionend(new_position);
 615         return find_selection(new_position);
 616 }
 617
 618 int MWindow::next_edit_handle(int shift_down)
 619 {
 620         double position = edl->local_session->get_selectionend(1);
 621         double new_position = edl->next_edit(position);
 622         double total_length = edl->tracks->total_length();
 623         if( new_position >= total_length )
 624                 new_position = total_length;
 625         edl->local_session->set_selectionend(new_position);
 626 //printf("MWindow::next_edit_handle %d\n", shift_down);
 627         if( !shift_down )
 628                 edl->local_session->set_selectionstart(new_position);
 629         return find_selection(new_position);
 630 }
 631
 632 int MWindow::prev_edit_handle(int shift_down)
 633 {
 634         double position = edl->local_session->get_selectionstart(1);
 635         double new_position = edl->prev_edit(position);
 636         if( new_position < 0 )
 637                 new_position = 0;
 638         edl->local_session->set_selectionstart(new_position);
 639         if( !shift_down )
 640                 edl->local_session->set_selectionend(new_position);
 641         return find_selection(new_position);
 642 }
 643
 644 int MWindow::nearest_plugin_keyframe(int shift_down, int dir)
 645 {
 646         KeyFrame *keyframe = 0;
 647         double start = edl->local_session->get_selectionstart(1);
 648         double end = edl->local_session->get_selectionend(1);
 649         double position = dir == PLAY_FORWARD ? end : start, new_position = 0;
 650         for( Track *track=edl->tracks->first; track; track=track->next ) {
 651                 if( !track->record ) continue;
 652                 for( int i=0; i<track->plugin_set.size(); ++i ) {
 653                         PluginSet *plugin_set = track->plugin_set[i];
 654                         int64_t pos = track->to_units(position, 0);
 655                         KeyFrame *key = plugin_set->nearest_keyframe(pos, dir);
 656                         if( !key ) continue;
 657                         double key_position = track->from_units(key->position);
 658                         if( keyframe && (dir == PLAY_FORWARD ?
 659                                 key_position >= new_position :
 660                                 new_position >= key_position ) ) continue;
 661                         keyframe = key;  new_position = key_position;
 662                 }
 663         }
 664
 665         new_position = keyframe ?
 666                 keyframe->autos->track->from_units(keyframe->position) :
 667                 dir == PLAY_FORWARD ? edl->tracks->total_length() : 0;
 668
 669         if( !shift_down )
 670                 start = end = new_position;
 671         else if( dir == PLAY_FORWARD )
 672                 end = new_position;
 673         else
 674                 start = new_position;
 675
 676         edl->local_session->set_selectionstart(start);
 677         edl->local_session->set_selectionend(end);
 678         return find_selection(new_position);
 679 }
 680
 681 int MWindow::find_selection(double position, int scroll_display)
 682 {
 683         update_plugin_guis();
 684         TimelinePane *pane = gui->get_focused_pane();
 685         double pixel_zoom = (double)edl->session->sample_rate / edl->local_session->zoom_sample;
 686         if( !scroll_display ) {
 687                 double timeline_start = edl->local_session->view_start[pane->number] / pixel_zoom;
 688                 double timeline_end = timeline_start + pane->canvas->time_visible();
 689                 if( position >= timeline_end || position < timeline_start )
 690                         scroll_display = 1;
 691         }
 692         if( scroll_display ) {
 693                 samplemovement((int64_t)(position * pixel_zoom - pane->canvas->get_w() / 2), pane->number);
 694                 cwindow->update(1, 0, 0, 0, 0);
 695         }
 696         else {
 697                 gui->update_patchbay();
 698                 gui->update_timebar(0);
 699                 gui->hide_cursor(0);
 700                 gui->draw_cursor(0);
 701                 gui->zoombar->update();
 702                 gui->flash_canvas(1);
 703                 cwindow->update(1, 0, 0, 0, 1);
 704         }
 705         return 0;
 706 }
 707
 708 double MWindow::get_position()
 709 {
 710         return edl->local_session->get_selectionstart(1);
 711 }
 712
 713 void MWindow::set_position(double position)
 714 {
 715         if( position != get_position() ) {
 716                 if( position < 0 ) position = 0;
 717                 edl->local_session->set_selectionstart(position);
 718                 edl->local_session->set_selectionend(position);
 719                 gui->lock_window();
 720                 find_cursor();
 721                 gui->update(1, NORMAL_DRAW, 1, 1, 1, 1, 0);
 722                 gui->unlock_window();
 723                 cwindow->update(1, 0, 0, 0, 0);
 724         }
 725 }
 726
 727
 728 int MWindow::expand_y()
 729 {
 730         int result = edl->local_session->zoom_y * 2;
 731         result = MIN(result, MAX_AMP_ZOOM);
 732         zoom_amp(result);
 733         gui->zoombar->update();
 734         return 0;
 735 }
 736
 737 int MWindow::zoom_in_y()
 738 {
 739         int result = edl->local_session->zoom_y / 2;
 740         result = MAX(result, MIN_AMP_ZOOM);
 741         zoom_amp(result);
 742         gui->zoombar->update();
 743         return 0;
 744 }
 745
 746 int MWindow::expand_t()
 747 {
 748         int result = edl->local_session->zoom_track * 2;
 749         result = MIN(result, MAX_TRACK_ZOOM);
 750         zoom_track(result);
 751         gui->zoombar->update();
 752         return 0;
 753 }
 754
 755 int MWindow::zoom_in_t()
 756 {
 757         int result = edl->local_session->zoom_track / 2;
 758         result = MAX(result, MIN_TRACK_ZOOM);
 759         zoom_track(result);
 760         gui->zoombar->update();
 761         return 0;
 762 }
 763
 764 void MWindow::split_x()
 765 {
 766         gui->resource_thread->stop_draw(1);
 767
 768         if(gui->pane[TOP_RIGHT_PANE])
 769         {
 770                 gui->delete_x_pane(theme->mcanvas_w);
 771                 edl->local_session->x_pane = -1;
 772         }
 773         else
 774         {
 775                 gui->create_x_pane(theme->mcanvas_w / 2);
 776                 edl->local_session->x_pane = theme->mcanvas_w / 2;
 777         }
 778
 779         gui->mainmenu->update_toggles(0);
 780         gui->update_pane_dividers();
 781         gui->update_cursor();
 782         gui->draw_samplemovement();
 783 // required to get new widgets to appear
 784         gui->show_window();
 785
 786         gui->resource_thread->start_draw();
 787 }
 788
 789 void MWindow::split_y()
 790 {
 791         gui->resource_thread->stop_draw(1);
 792         if(gui->pane[BOTTOM_LEFT_PANE])
 793         {
 794                 gui->delete_y_pane(theme->mcanvas_h);
 795                 edl->local_session->y_pane = -1;
 796         }
 797         else
 798         {
 799                 gui->create_y_pane(theme->mcanvas_h / 2);
 800                 edl->local_session->y_pane = theme->mcanvas_h / 2;
 801         }
 802
 803         gui->mainmenu->update_toggles(0);
 804         gui->update_pane_dividers();
 805         gui->update_cursor();
 806         gui->draw_trackmovement();
 807 // required to get new widgets to appear
 808         gui->show_window();
 809         gui->resource_thread->start_draw();
 810 }
 811