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() / 10;
 541         edl->local_session->view_start[pane->number] -= distance;
 542         samplemovement(edl->local_session->view_start[pane->number],
 543                 pane->number);
 544         return 0;
 545 }
 546
 547 int MWindow::move_right(int64_t distance)
 548 {
 549         TimelinePane *pane = gui->get_focused_pane();
 550         if(!distance)
 551                 distance = pane->canvas->get_w() / 10;
 552         edl->local_session->view_start[pane->number] += distance;
 553         samplemovement(edl->local_session->view_start[pane->number],
 554                 pane->number);
 555         return 0;
 556 }
 557
 558 void MWindow::select_all()
 559 {
 560         if( edl->local_session->get_selectionstart(1) == 0 &&
 561             edl->local_session->get_selectionend(1) == edl->tracks->total_length() )
 562                 edl->local_session->set_selectionend(0);
 563         else {
 564                 edl->local_session->set_selectionstart(0);
 565                 edl->local_session->set_selectionend(edl->tracks->total_length());
 566         }
 567         gui->update(0, NORMAL_DRAW, 1, 1, 0, 1, 0);
 568         gui->activate_timeline();
 569         cwindow->update(1, 0, 0, 0, 1);
 570         update_plugin_guis();
 571 }
 572
 573 int MWindow::next_label(int shift_down)
 574 {
 575         double position = edl->local_session->get_selectionend(1);
 576         double total_length = edl->tracks->total_length();
 577         Label *current = edl->labels->next_label(position);
 578         double new_position = current ? current->position : total_length;
 579 // last playback endpoints as fake label positions
 580         double playback_start = edl->local_session->playback_start;
 581         double playback_end = edl->local_session->playback_end;
 582         if( playback_start > position && playback_start < new_position )
 583                 new_position = playback_start;
 584         else if( playback_end > position && playback_end < new_position )
 585                 new_position = playback_end;
 586         if( new_position > total_length )
 587                 new_position = total_length;
 588         edl->local_session->set_selectionend(new_position);
 589 //printf("MWindow::next_edit_handle %d\n", shift_down);
 590         if( !shift_down )
 591                 edl->local_session->set_selectionstart(new_position);
 592         return find_selection(new_position);
 593 }
 594
 595 int MWindow::prev_label(int shift_down)
 596 {
 597         double position = edl->local_session->get_selectionstart(1);
 598         Label *current = edl->labels->prev_label(position);
 599         double new_position = current ? current->position : 0;
 600 // last playback endpoints as fake label positions
 601         double playback_start = edl->local_session->playback_start;
 602         double playback_end = edl->local_session->playback_end;
 603         if( playback_end < position && playback_end > new_position )
 604                 new_position = playback_end;
 605         else if( playback_start < position && playback_start > new_position )
 606                 new_position = playback_start;
 607         if( new_position < 0 )
 608                 new_position = 0;
 609         edl->local_session->set_selectionstart(new_position);
 610 //printf("MWindow::next_edit_handle %d\n", shift_down);
 611         if( !shift_down )
 612                 edl->local_session->set_selectionend(new_position);
 613         return find_selection(new_position);
 614 }
 615
 616 int MWindow::next_edit_handle(int shift_down)
 617 {
 618         double position = edl->local_session->get_selectionend(1);
 619         double new_position = edl->next_edit(position);
 620         double total_length = edl->tracks->total_length();
 621         if( new_position >= total_length )
 622                 new_position = total_length;
 623         edl->local_session->set_selectionend(new_position);
 624 //printf("MWindow::next_edit_handle %d\n", shift_down);
 625         if( !shift_down )
 626                 edl->local_session->set_selectionstart(new_position);
 627         return find_selection(new_position);
 628 }
 629
 630 int MWindow::prev_edit_handle(int shift_down)
 631 {
 632         double position = edl->local_session->get_selectionstart(1);
 633         double new_position = edl->prev_edit(position);
 634         if( new_position < 0 )
 635                 new_position = 0;
 636         edl->local_session->set_selectionstart(new_position);
 637         if( !shift_down )
 638                 edl->local_session->set_selectionend(new_position);
 639         return find_selection(new_position);
 640 }
 641
 642 int MWindow::nearest_plugin_keyframe(int shift_down, int dir)
 643 {
 644         KeyFrame *keyframe = 0;
 645         double start = edl->local_session->get_selectionstart(1);
 646         double end = edl->local_session->get_selectionend(1);
 647         double position = dir == PLAY_FORWARD ? end : start, new_position = 0;
 648         for( Track *track=edl->tracks->first; track; track=track->next ) {
 649                 if( !track->record ) continue;
 650                 for( int i=0; i<track->plugin_set.size(); ++i ) {
 651                         PluginSet *plugin_set = track->plugin_set[i];
 652                         int64_t pos = track->to_units(position, 0);
 653                         KeyFrame *key = plugin_set->nearest_keyframe(pos, dir);
 654                         if( !key ) continue;
 655                         double key_position = track->from_units(key->position);
 656                         if( keyframe && (dir == PLAY_FORWARD ?
 657                                 key_position >= new_position :
 658                                 new_position >= key_position ) ) continue;
 659                         keyframe = key;  new_position = key_position;
 660                 }
 661         }
 662
 663         new_position = keyframe ?
 664                 keyframe->autos->track->from_units(keyframe->position) :
 665                 dir == PLAY_FORWARD ? edl->tracks->total_length() : 0;
 666
 667         if( !shift_down )
 668                 start = end = new_position;
 669         else if( dir == PLAY_FORWARD )
 670                 end = new_position;
 671         else
 672                 start = new_position;
 673
 674         edl->local_session->set_selectionstart(start);
 675         edl->local_session->set_selectionend(end);
 676         return find_selection(new_position);
 677 }
 678
 679 int MWindow::find_selection(double position, int scroll_display)
 680 {
 681         update_plugin_guis();
 682         TimelinePane *pane = gui->get_focused_pane();
 683         double pixel_zoom = (double)edl->session->sample_rate / edl->local_session->zoom_sample;
 684         if( !scroll_display ) {
 685                 double timeline_start = edl->local_session->view_start[pane->number] / pixel_zoom;
 686                 double timeline_end = timeline_start + pane->canvas->time_visible();
 687                 if( position >= timeline_end || position < timeline_start )
 688                         scroll_display = 1;
 689         }
 690         if( scroll_display ) {
 691                 samplemovement((int64_t)(position * pixel_zoom - pane->canvas->get_w() / 2), pane->number);
 692                 cwindow->update(1, 0, 0, 0, 0);
 693         }
 694         else {
 695                 gui->update_patchbay();
 696                 gui->update_timebar(0);
 697                 gui->hide_cursor(0);
 698                 gui->draw_cursor(0);
 699                 gui->zoombar->update();
 700                 gui->flash_canvas(1);
 701                 cwindow->update(1, 0, 0, 0, 1);
 702         }
 703         return 0;
 704 }
 705
 706 double MWindow::get_position()
 707 {
 708         return edl->local_session->get_selectionstart(1);
 709 }
 710
 711 void MWindow::set_position(double position)
 712 {
 713         if( position != get_position() ) {
 714                 if( position < 0 ) position = 0;
 715                 edl->local_session->set_selectionstart(position);
 716                 edl->local_session->set_selectionend(position);
 717                 gui->lock_window();
 718                 find_cursor();
 719                 gui->update(1, NORMAL_DRAW, 1, 1, 1, 1, 0);
 720                 gui->unlock_window();
 721                 cwindow->update(1, 0, 0, 0, 0);
 722         }
 723 }
 724
 725
 726 int MWindow::expand_y()
 727 {
 728         int result = edl->local_session->zoom_y * 2;
 729         result = MIN(result, MAX_AMP_ZOOM);
 730         zoom_amp(result);
 731         gui->zoombar->update();
 732         return 0;
 733 }
 734
 735 int MWindow::zoom_in_y()
 736 {
 737         int result = edl->local_session->zoom_y / 2;
 738         result = MAX(result, MIN_AMP_ZOOM);
 739         zoom_amp(result);
 740         gui->zoombar->update();
 741         return 0;
 742 }
 743
 744 int MWindow::expand_t()
 745 {
 746         int result = edl->local_session->zoom_track * 2;
 747         result = MIN(result, MAX_TRACK_ZOOM);
 748         zoom_track(result);
 749         gui->zoombar->update();
 750         return 0;
 751 }
 752
 753 int MWindow::zoom_in_t()
 754 {
 755         int result = edl->local_session->zoom_track / 2;
 756         result = MAX(result, MIN_TRACK_ZOOM);
 757         zoom_track(result);
 758         gui->zoombar->update();
 759         return 0;
 760 }
 761
 762 void MWindow::split_x()
 763 {
 764         gui->resource_thread->stop_draw(1);
 765
 766         if(gui->pane[TOP_RIGHT_PANE])
 767         {
 768                 gui->delete_x_pane(theme->mcanvas_w);
 769                 edl->local_session->x_pane = -1;
 770         }
 771         else
 772         {
 773                 gui->create_x_pane(theme->mcanvas_w / 2);
 774                 edl->local_session->x_pane = theme->mcanvas_w / 2;
 775         }
 776
 777         gui->mainmenu->update_toggles(0);
 778         gui->update_pane_dividers();
 779         gui->update_cursor();
 780         gui->draw_samplemovement();
 781 // required to get new widgets to appear
 782         gui->show_window();
 783
 784         gui->resource_thread->start_draw();
 785 }
 786
 787 void MWindow::split_y()
 788 {
 789         gui->resource_thread->stop_draw(1);
 790         if(gui->pane[BOTTOM_LEFT_PANE])
 791         {
 792                 gui->delete_y_pane(theme->mcanvas_h);
 793                 edl->local_session->y_pane = -1;
 794         }
 795         else
 796         {
 797                 gui->create_y_pane(theme->mcanvas_h / 2);
 798                 edl->local_session->y_pane = theme->mcanvas_h / 2;
 799         }
 800
 801         gui->mainmenu->update_toggles(0);
 802         gui->update_pane_dividers();
 803         gui->update_cursor();
 804         gui->draw_trackmovement();
 805 // required to get new widgets to appear
 806         gui->show_window();
 807         gui->resource_thread->start_draw();
 808 }
 809