cinelerra-5.1/cinelerra/mwindowgui.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 "androidcontrol.h"
  23 #include "awindowgui.h"
  24 #include "awindow.h"
  25 #include "bcdisplayinfo.h"
  26 #include "bchash.h"
  27 #include "bcsignals.h"
  28 #include "clip.h"
  29 #include "cwindowgui.h"
  30 #include "cwindow.h"
  31 #include "channelinfo.h"
  32 #include "dbwindow.h"
  33 #include "edit.h"
  34 #include "editpopup.h"
  35 #include "edits.h"
  36 #include "edl.h"
  37 #include "edlsession.h"
  38 #include "filesystem.h"
  39 #include "keyframepopup.h"
  40 #include "keys.h"
  41 #include "language.h"
  42 #include "localsession.h"
  43 #include "mainclock.h"
  44 #include "maincursor.h"
  45 #include "mainmenu.h"
  46 #include "mainsession.h"
  47 #include "mainundo.h"
  48 #include "mbuttons.h"
  49 #include "mtimebar.h"
  50 #include "mwindowgui.h"
  51 #include "mwindow.h"
  52 #include "panedividers.h"
  53 #include "patchbay.h"
  54 #include "plugin.h"
  55 #include "pluginpopup.h"
  56 #include "pluginset.h"
  57 #include "preferences.h"
  58 #include "record.h"
  59 #include "recordgui.h"
  60 #include "renderengine.h"
  61 #include "resourcethread.h"
  62 #include "samplescroll.h"
  63 #include "shbtnprefs.h"
  64 #include "statusbar.h"
  65 #include "swindow.h"
  66 #include "theme.h"
  67 #include "trackcanvas.h"
  68 #include "trackpopup.h"
  69 #include "trackscroll.h"
  70 #include "tracks.h"
  71 #include "transitionpopup.h"
  72 #include "vwindowgui.h"
  73 #include "vwindow.h"
  74 #include "zoombar.h"
  75
  76 #define PANE_DRAG_MARGIN MAX(mwindow->theme->pane_w, mwindow->theme->pane_h)
  77
  78
  79 // the main window uses its own private colormap for video
  80 MWindowGUI::MWindowGUI(MWindow *mwindow)
  81  : BC_Window(_(PROGRAM_NAME ": Program"),
  82                 mwindow->session->mwindow_x,
  83                 mwindow->session->mwindow_y,
  84                 mwindow->session->mwindow_w,
  85                 mwindow->session->mwindow_h,
  86                 100,
  87                 100,
  88                 1,
  89                 1,
  90                 1)
  91 {
  92         this->mwindow = mwindow;
  93 //      samplescroll = 0;
  94 //      trackscroll = 0;
  95 //      cursor = 0;
  96 //      patchbay = 0;
  97 //      timebar = 0;
  98 //      canvas = 0;
  99         focused_pane = TOP_LEFT_PANE;
 100         x_divider = 0;
 101         y_divider = 0;
 102         x_pane_drag = 0;
 103         y_pane_drag = 0;
 104         dragging_pane = 0;
 105         drag_popup = 0;
 106
 107         render_engine = 0;
 108         for(int i = 0; i < TOTAL_PANES; i++)
 109                 pane[i] = 0;
 110
 111         record = 0;
 112         channel_info = 0;
 113         swindow = 0;
 114         db_window = 0;
 115 // subwindows
 116         mbuttons = 0;
 117         statusbar = 0;
 118         zoombar = 0;
 119         mainclock = 0;
 120         track_menu = 0;
 121         edit_menu = 0;
 122         plugin_menu = 0;
 123         keyframe_menu = 0;
 124         keyframe_hide = 0;
 125         keyvalue_popup = 0;
 126         transition_menu = 0;
 127         remote_control = 0;
 128         cwindow_remote_handler = 0;
 129         record_remote_handler = 0;
 130         android_control = 0;
 131 }
 132
 133
 134 MWindowGUI::~MWindowGUI()
 135 {
 136         delete android_control;
 137         delete cwindow_remote_handler;
 138         delete record_remote_handler;
 139         delete remote_control;
 140         delete keyvalue_popup;
 141 //      delete samplescroll;
 142 //      delete trackscroll;
 143         for(int i = 0; i < TOTAL_PANES; i++)
 144                 if(pane[i]) delete pane[i];
 145 //      delete cursor;
 146         delete render_engine;
 147         delete resource_thread;
 148         resource_pixmaps.remove_all_objects();
 149         delete swindow;
 150 #ifdef HAVE_DVB
 151         delete channel_info;
 152 #endif
 153         delete db_window;
 154         delete x_divider;
 155         delete y_divider;
 156 }
 157
 158 #if 0
 159 void MWindowGUI::get_scrollbars(int flush)
 160 {
 161         //int64_t h_needed = mwindow->edl->get_tracks_height(mwindow->theme);
 162         //int64_t w_needed = mwindow->edl->get_tracks_width();
 163         int need_xscroll = 0;
 164         int need_yscroll = 0;
 165         view_w = mwindow->theme->mcanvas_w;
 166         view_h = mwindow->theme->mcanvas_h;
 167
 168 // Scrollbars are constitutive
 169         need_xscroll = need_yscroll = 1;
 170         view_h = mwindow->theme->mcanvas_h;
 171         view_w = mwindow->theme->mcanvas_w;
 172
 173 //      for(int i = 0; i < 2; i++)
 174 //      {
 175 //              if(w_needed > view_w)
 176 //              {
 177 //                      need_xscroll = 1;
 178 //                      view_h = mwindow->theme->mcanvas_h - SCROLL_SPAN;
 179 //              }
 180 //              else
 181 //                      need_xscroll = 0;
 182 //
 183 //              if(h_needed > view_h)
 184 //              {
 185 //                      need_yscroll = 1;
 186 //                      view_w = mwindow->theme->mcanvas_w - SCROLL_SPAN;
 187 //              }
 188 //              else
 189 //                      need_yscroll = 0;
 190 //      }
 191 //printf("MWindowGUI::get_scrollbars 1\n");
 192
 193         if(canvas && (view_w != canvas->get_w() || view_h != canvas->get_h()))
 194         {
 195                 canvas->reposition_window(mwindow->theme->mcanvas_x,
 196                         mwindow->theme->mcanvas_y,
 197                         view_w,
 198                         view_h);
 199         }
 200
 201         if(need_xscroll)
 202         {
 203                 if(!samplescroll)
 204                         add_subwindow(samplescroll = new SampleScroll(mwindow,
 205                                 this,
 206                                 mwindow->theme->mhscroll_x,
 207                                 mwindow->theme->mhscroll_y,
 208                                 mwindow->theme->mhscroll_w));
 209                 else
 210                         samplescroll->resize_event();
 211
 212                 samplescroll->set_position(0);
 213         }
 214         else
 215         {
 216                 if(samplescroll) delete samplescroll;
 217                 samplescroll = 0;
 218                 mwindow->edl->local_session->view_start = 0;
 219         }
 220
 221
 222         if(need_yscroll)
 223         {
 224 //printf("MWindowGUI::get_scrollbars 1.1 %p %p\n", this, canvas);
 225                 if(!trackscroll)
 226                         add_subwindow(trackscroll = new TrackScroll(mwindow,
 227                                 this,
 228                                 mwindow->theme->mvscroll_x,
 229                                 mwindow->theme->mvscroll_y,
 230                                 mwindow->theme->mvscroll_h));
 231                 else
 232                         trackscroll->resize_event();
 233
 234
 235 //printf("MWindowGUI::get_scrollbars 1.2\n");
 236                 trackscroll->update_length(mwindow->edl->get_tracks_height(mwindow->theme),
 237                         mwindow->edl->local_session->track_start,
 238                         view_h,
 239                         0);
 240 //printf("MWindowGUI::get_scrollbars 1.3\n");
 241         }
 242         else
 243         {
 244                 if(trackscroll) delete trackscroll;
 245                 trackscroll = 0;
 246                 mwindow->edl->local_session->track_start = 0;
 247         }
 248
 249         if(flush) this->flush();
 250
 251 }
 252 #endif // 0
 253
 254 void MWindowGUI::create_objects()
 255 {
 256         lock_window("MWindowGUI::create_objects");
 257         const int debug = 0;
 258
 259         resource_thread = new ResourceThread(mwindow, this);
 260         resource_thread->create_objects();
 261
 262
 263         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 264         set_icon(mwindow->theme->get_image("mwindow_icon"));
 265         remote_control = new RemoteControl(this);
 266         cwindow_remote_handler = new CWindowRemoteHandler(remote_control);
 267         record_remote_handler = new RecordRemoteHandler(remote_control);
 268         mwindow->reset_android_remote();
 269
 270         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 271
 272         int x = get_w() - MainShBtns::calculate_w(0);
 273         add_subwindow(mainmenu = new MainMenu(mwindow, this, x));
 274         mainmenu->create_objects();
 275         add_subwindow(mainshbtns = new MainShBtns(mwindow, x, -1));
 276         mainshbtns->load(mwindow->preferences);
 277         mwindow->theme->get_mwindow_sizes(this, get_w(), get_h());
 278         mwindow->theme->draw_mwindow_bg(this);
 279         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 280
 281         add_subwindow(mbuttons = new MButtons(mwindow, this));
 282         mbuttons->create_objects();
 283         int x1 = mbuttons->get_x() + mbuttons->get_w(), y1 = mbuttons->get_y()+2;
 284         add_subwindow(proxy_toggle = new ProxyToggle(mwindow, mbuttons, x1, y1));
 285         x1 += proxy_toggle->get_w() + 3;
 286         add_subwindow(ffmpeg_toggle = new FFMpegToggle(mwindow, mbuttons, x1, y1));
 287
 288         pane[TOP_LEFT_PANE] = new TimelinePane(mwindow,
 289                 TOP_LEFT_PANE,
 290                 mwindow->theme->mcanvas_x,
 291                 mwindow->theme->mcanvas_y,
 292                 mwindow->theme->mcanvas_w,
 293                 mwindow->theme->mcanvas_h);
 294         pane[TOP_LEFT_PANE]->create_objects();
 295
 296 //      add_subwindow(timebar = new MTimeBar(mwindow,
 297 //              this,
 298 //              mwindow->theme->mtimebar_x,
 299 //              mwindow->theme->mtimebar_y,
 300 //              mwindow->theme->mtimebar_w,
 301 //              mwindow->theme->mtimebar_h));
 302 //      timebar->create_objects();
 303
 304 //      if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 305 //      add_subwindow(patchbay = new PatchBay(mwindow, this));
 306 //      patchbay->create_objects();
 307
 308 //      if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 309 //      get_scrollbars(0);
 310
 311 //      if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 312 //      mwindow->gui->add_subwindow(canvas = new TrackCanvas(mwindow, this));
 313 //      canvas->create_objects();
 314
 315
 316         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 317         add_subwindow(zoombar = new ZoomBar(mwindow, this));
 318         zoombar->create_objects();
 319
 320
 321         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 322         add_subwindow(statusbar = new StatusBar(mwindow, this));
 323         statusbar->create_objects();
 324
 325
 326
 327         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 328         add_subwindow(mainclock = new MainClock(mwindow,
 329                 mwindow->theme->mclock_x, mwindow->theme->mclock_y,
 330                 mwindow->theme->mclock_w));
 331         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 332         mainclock->update(0);
 333
 334
 335
 336 //      if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 337 //      cursor = new MainCursor(mwindow, this);
 338 //      cursor->create_objects();
 339
 340
 341         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 342         add_subwindow(track_menu = new TrackPopup(mwindow, this));
 343         track_menu->create_objects();
 344         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 345         add_subwindow(edit_menu = new EditPopup(mwindow, this));
 346         edit_menu->create_objects();
 347
 348
 349         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 350         add_subwindow(plugin_menu = new PluginPopup(mwindow, this));
 351         plugin_menu->create_objects();
 352
 353
 354         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 355         add_subwindow(keyframe_menu = new KeyframePopup(mwindow, this));
 356         keyframe_menu->create_objects();
 357         add_subwindow(keyframe_hide = new KeyframeHidePopup(mwindow, this));
 358         keyframe_hide->create_objects();
 359
 360
 361         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 362         add_subwindow(transition_menu = new TransitionPopup(mwindow, this));
 363         transition_menu->create_objects();
 364
 365 #ifdef HAVE_DVB
 366         channel_info = new ChannelInfo(mwindow);
 367 #endif
 368 #ifdef HAVE_COMMERCIAL
 369         db_window = new DbWindow(mwindow);
 370 #endif
 371         swindow = new SWindow(mwindow);
 372
 373         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 374
 375         add_subwindow(pane_button = new PaneButton(mwindow,
 376                 get_w() - mwindow->theme->get_image_set("pane")[0]->get_w(),
 377                 mwindow->theme->mzoom_y + 1 - mwindow->theme->get_image_set("pane")[0]->get_h()));
 378
 379         pane[TOP_LEFT_PANE]->canvas->activate();
 380
 381         if(debug) printf("MWindowGUI::create_objects %d\n", __LINE__);
 382         unlock_window();
 383 }
 384
 385 void MWindowGUI::redraw_time_dependancies()
 386 {
 387         zoombar->redraw_time_dependancies();
 388         for(int i = 0; i < TOTAL_PANES; i++)
 389                 if(pane[i] && pane[i]->timebar) pane[i]->timebar->update(0);
 390         mainclock->update(mwindow->edl->local_session->get_selectionstart(1));
 391 }
 392
 393 int MWindowGUI::focus_in_event()
 394 {
 395         for(int i = 0; i < TOTAL_PANES; i++)
 396                 if(pane[i]) pane[i]->cursor->focus_in_event();
 397         return 1;
 398 }
 399
 400 int MWindowGUI::focus_out_event()
 401 {
 402         for(int i = 0; i < TOTAL_PANES; i++)
 403                 if(pane[i]) pane[i]->cursor->focus_out_event();
 404         return 1;
 405 }
 406
 407
 408 int MWindowGUI::resize_event(int w, int h)
 409 {
 410 //printf("MWindowGUI::resize_event %d\n", __LINE__);
 411         mwindow->session->mwindow_w = w;
 412         mwindow->session->mwindow_h = h;
 413         int x = w - MainShBtns::calculate_w(0);
 414         mainmenu->resize_event(x, mainmenu->get_h());
 415         mainshbtns->reposition_window(x, -1);
 416         mwindow->theme->get_mwindow_sizes(this, w, h);
 417         mwindow->theme->draw_mwindow_bg(this);
 418         mbuttons->resize_event();
 419         int x1 = mbuttons->get_x() + mbuttons->get_w(), y1 = mbuttons->get_y()+2;
 420         proxy_toggle->reposition_window(x1, y1);
 421         x1 += proxy_toggle->get_w() + 3;
 422         ffmpeg_toggle->reposition_window(x1, y1);
 423         statusbar->resize_event();
 424         zoombar->resize_event();
 425
 426         resource_thread->stop_draw(1);
 427
 428         if(total_panes() > 1)
 429         {
 430                 if(horizontal_panes())
 431                 {
 432 //                      printf("MWindowGUI::resize_event %d %d %d\n",
 433 //                              __LINE__,
 434 //                              pane[TOP_RIGHT_PANE]->x,
 435 //                              mwindow->theme->mcanvas_w -
 436 //                                      BC_ScrollBar::get_span(SCROLL_VERT) -
 437 //                                      PANE_DRAG_MARGIN);
 438                         if(pane[TOP_RIGHT_PANE]->x >= mwindow->theme->mcanvas_w -
 439                                 BC_ScrollBar::get_span(SCROLL_VERT) -
 440                                 PANE_DRAG_MARGIN)
 441                         {
 442                                 delete_x_pane(pane[TOP_RIGHT_PANE]->x);
 443                                 mwindow->edl->local_session->x_pane = -1;
 444                         }
 445                 }
 446                 else
 447                 if(vertical_panes())
 448                 {
 449                         if(pane[BOTTOM_LEFT_PANE]->y >= mwindow->theme->mzoom_y -
 450                                 BC_ScrollBar::get_span(SCROLL_HORIZ) -
 451                                 PANE_DRAG_MARGIN)
 452                         {
 453                                 delete_y_pane(pane[BOTTOM_LEFT_PANE]->y);
 454                                 mwindow->edl->local_session->y_pane = -1;
 455                         }
 456                 }
 457                 else
 458                 {
 459                         if(pane[TOP_RIGHT_PANE]->x >= mwindow->theme->mcanvas_w -
 460                                         BC_ScrollBar::get_span(SCROLL_VERT) -
 461                                         PANE_DRAG_MARGIN)
 462                         {
 463                                 delete_x_pane(pane[TOP_RIGHT_PANE]->x);
 464                                 mwindow->edl->local_session->x_pane = -1;
 465                         }
 466
 467                         if(pane[BOTTOM_LEFT_PANE]->y >= mwindow->theme->mzoom_y -
 468                                 BC_ScrollBar::get_span(SCROLL_HORIZ) -
 469                                 PANE_DRAG_MARGIN)
 470                         {
 471                                 delete_y_pane(pane[BOTTOM_LEFT_PANE]->y);
 472                                 mwindow->edl->local_session->y_pane = -1;
 473                         }
 474                 }
 475         }
 476
 477         if(total_panes() == 1)
 478         {
 479                 pane[TOP_LEFT_PANE]->resize_event(
 480                         mwindow->theme->mcanvas_x,
 481                         mwindow->theme->mcanvas_y,
 482                         mwindow->theme->mcanvas_w,
 483                         mwindow->theme->mcanvas_h);
 484         }
 485         else
 486         if(horizontal_panes())
 487         {
 488                 pane[TOP_LEFT_PANE]->resize_event(
 489                         pane[TOP_LEFT_PANE]->x,
 490                         pane[TOP_LEFT_PANE]->y,
 491                         pane[TOP_LEFT_PANE]->w,
 492                         mwindow->theme->mcanvas_h);
 493                 pane[TOP_RIGHT_PANE]->resize_event(
 494                         pane[TOP_RIGHT_PANE]->x,
 495                         pane[TOP_RIGHT_PANE]->y,
 496                         mwindow->theme->mcanvas_w - pane[TOP_RIGHT_PANE]->x,
 497                         mwindow->theme->mcanvas_h);
 498         }
 499         else
 500         if(vertical_panes())
 501         {
 502                 pane[TOP_LEFT_PANE]->resize_event(
 503                         pane[TOP_LEFT_PANE]->x,
 504                         pane[TOP_LEFT_PANE]->y,
 505                         mwindow->theme->mcanvas_w,
 506                         pane[TOP_LEFT_PANE]->h);
 507                 pane[BOTTOM_LEFT_PANE]->resize_event(
 508                         pane[BOTTOM_LEFT_PANE]->x,
 509                         pane[BOTTOM_LEFT_PANE]->y,
 510                         mwindow->theme->mcanvas_w,
 511                         mwindow->theme->mcanvas_y +
 512                                 mwindow->theme->mcanvas_h -
 513                                 pane[BOTTOM_LEFT_PANE]->y);
 514         }
 515         else
 516         {
 517                 pane[TOP_LEFT_PANE]->resize_event(
 518                         pane[TOP_LEFT_PANE]->x,
 519                         pane[TOP_LEFT_PANE]->y,
 520                         pane[TOP_LEFT_PANE]->w,
 521                         pane[TOP_LEFT_PANE]->h);
 522                 pane[TOP_RIGHT_PANE]->resize_event(
 523                         pane[TOP_RIGHT_PANE]->x,
 524                         pane[TOP_RIGHT_PANE]->y,
 525                         mwindow->theme->mcanvas_w - pane[TOP_RIGHT_PANE]->x,
 526                         pane[TOP_RIGHT_PANE]->h);
 527                 pane[BOTTOM_LEFT_PANE]->resize_event(
 528                         pane[BOTTOM_LEFT_PANE]->x,
 529                         pane[BOTTOM_LEFT_PANE]->y,
 530                         pane[BOTTOM_LEFT_PANE]->w,
 531                         mwindow->theme->mcanvas_y +
 532                                 mwindow->theme->mcanvas_h -
 533                                 pane[BOTTOM_LEFT_PANE]->y);
 534                 pane[BOTTOM_RIGHT_PANE]->resize_event(
 535                         pane[BOTTOM_RIGHT_PANE]->x,
 536                         pane[BOTTOM_RIGHT_PANE]->y,
 537                         mwindow->theme->mcanvas_w -
 538                                 pane[BOTTOM_RIGHT_PANE]->x,
 539                         mwindow->theme->mcanvas_y +
 540                                 mwindow->theme->mcanvas_h -
 541                                 pane[BOTTOM_RIGHT_PANE]->y);
 542         }
 543
 544         update_pane_dividers();
 545         pane_button->reposition_window(w - mwindow->theme->get_image_set("pane")[0]->get_w(),
 546                 mwindow->theme->mzoom_y + 1 - mwindow->theme->get_image_set("pane")[0]->get_h());
 547         resource_thread->start_draw();
 548
 549         flash(1);
 550         return 0;
 551 }
 552
 553 int MWindowGUI::total_panes()
 554 {
 555         int total = 0;
 556         for(int i = 0; i < TOTAL_PANES; i++)
 557                 if(pane[i]) total++;
 558         return total;
 559 }
 560
 561 int MWindowGUI::vertical_panes()
 562 {
 563         return total_panes() == 2 &&
 564                 pane[TOP_LEFT_PANE] &&
 565                 pane[BOTTOM_LEFT_PANE];
 566 }
 567
 568 int MWindowGUI::horizontal_panes()
 569 {
 570         return total_panes() == 2 &&
 571                 pane[TOP_LEFT_PANE] &&
 572                 pane[TOP_RIGHT_PANE];
 573 }
 574
 575 TimelinePane* MWindowGUI::get_focused_pane()
 576 {
 577         if(pane[focused_pane]) return pane[focused_pane];
 578         for(int i = 0; i < TOTAL_PANES; i++)
 579         {
 580                 if(pane[i]) return pane[i];
 581         }
 582         return 0;
 583 }
 584
 585 void MWindowGUI::activate_timeline()
 586 {
 587         if(pane[focused_pane])
 588         {
 589                 pane[focused_pane]->activate();
 590         }
 591         else
 592         {
 593                 for(int i = 0; i < TOTAL_PANES; i++)
 594                 {
 595                         if(pane[i])
 596                         {
 597                                 pane[i]->activate();
 598                                 return;
 599                         }
 600                 }
 601         }
 602 }
 603
 604 void MWindowGUI::deactivate_timeline()
 605 {
 606         for(int i = 0; i < TOTAL_PANES; i++)
 607         {
 608                 if(pane[i])
 609                 {
 610                         pane[i]->canvas->deactivate();
 611                 }
 612         }
 613 }
 614
 615 void MWindowGUI::update_title(char *path)
 616 {
 617         FileSystem fs;
 618         char filename[BCTEXTLEN], string[BCTEXTLEN];
 619         fs.extract_name(filename, path);
 620         sprintf(string, _(PROGRAM_NAME ": %s"), filename);
 621         set_title(string);
 622 //printf("MWindowGUI::update_title %s\n", string);
 623         flush();
 624 }
 625
 626 void MWindowGUI::draw_overlays(int flash_it)
 627 {
 628         for(int i = 0; i < TOTAL_PANES; i++)
 629         {
 630                 if(pane[i])
 631                 {
 632                         pane[i]->canvas->draw_overlays();
 633                         if(flash_it) pane[i]->canvas->flash();
 634                 }
 635         }
 636 }
 637
 638 void MWindowGUI::update_timebar(int flush_it)
 639 {
 640         for(int i = 0; i < TOTAL_PANES; i++)
 641         {
 642                 if(pane[i] && pane[i]->timebar)
 643                 {
 644                         pane[i]->timebar->update(flush_it);
 645                 }
 646         }
 647 }
 648
 649 void MWindowGUI::update_timebar_highlights()
 650 {
 651         for(int i = 0; i < TOTAL_PANES; i++)
 652         {
 653                 if(pane[i] && pane[i]->timebar)
 654                 {
 655                         pane[i]->timebar->update_highlights();
 656                 }
 657         }
 658 }
 659
 660
 661 void MWindowGUI::update_patchbay()
 662 {
 663         for(int i = 0; i < TOTAL_PANES; i++)
 664         {
 665                 if(pane[i] && pane[i]->patchbay)
 666                 {
 667                         pane[i]->patchbay->update();
 668                 }
 669         }
 670 }
 671
 672 void MWindowGUI::update_proxy_toggle()
 673 {
 674         int value = mwindow->edl->session->proxy_scale == 1 ? 1 : 0;
 675         proxy_toggle->set_value(value);
 676         if( mwindow->edl->session->proxy_scale == 1 &&
 677             mwindow->edl->session->proxy_disabled_scale == 1 )
 678                 proxy_toggle->hide();
 679         else
 680                 proxy_toggle->show();
 681 }
 682
 683 void MWindowGUI::update_plugintoggles()
 684 {
 685         for(int i = 0; i < TOTAL_PANES; i++)
 686         {
 687                 if(pane[i])
 688                 {
 689                         pane[i]->canvas->refresh_plugintoggles();
 690                 }
 691         }
 692
 693 }
 694
 695 void MWindowGUI::draw_indexes(Indexable *indexable)
 696 {
 697         for(int i = 0; i < TOTAL_PANES; i++)
 698         {
 699                 if(pane[i])
 700                 {
 701                         pane[i]->canvas->draw_indexes(indexable);
 702                 }
 703         }
 704 }
 705
 706 void MWindowGUI::draw_canvas(int redraw, int hide_cursor)
 707 {
 708         resource_thread->stop_draw(0);
 709
 710         int mode = redraw ? FORCE_REDRAW : NORMAL_DRAW;
 711         for(int i = 0; i < TOTAL_PANES; i++) {
 712                 if( pane[i] )
 713                         pane[i]->canvas->draw(mode, hide_cursor);
 714         }
 715
 716         resource_thread->start_draw();
 717 }
 718
 719 void MWindowGUI::flash_canvas(int flush)
 720 {
 721         for(int i = 0; i < TOTAL_PANES; i++)
 722         {
 723                 if(pane[i])
 724                 {
 725                         pane[i]->canvas->flash(flush);
 726                 }
 727         }
 728 }
 729
 730 int MWindowGUI::show_window(int flush)
 731 {
 732         int ret = BC_WindowBase::show_window(flush);
 733         update_proxy_toggle();
 734         return ret;
 735 }
 736
 737 void MWindowGUI::draw_cursor(int do_plugintoggles)
 738 {
 739         for(int i = 0; i < TOTAL_PANES; i++)
 740         {
 741                 if(pane[i])
 742                 {
 743                         pane[i]->cursor->draw(do_plugintoggles);
 744                 }
 745         }
 746 }
 747
 748 void MWindowGUI::show_cursor(int do_plugintoggles)
 749 {
 750         for(int i = 0; i < TOTAL_PANES; i++)
 751         {
 752                 if(pane[i])
 753                 {
 754                         pane[i]->cursor->show(do_plugintoggles);
 755                 }
 756         }
 757 }
 758
 759 void MWindowGUI::hide_cursor(int do_plugintoggles)
 760 {
 761         for(int i = 0; i < TOTAL_PANES; i++)
 762         {
 763                 if(pane[i])
 764                 {
 765                         pane[i]->cursor->hide(do_plugintoggles);
 766                 }
 767         }
 768 }
 769
 770 void MWindowGUI::update_cursor()
 771 {
 772         for(int i = 0; i < TOTAL_PANES; i++)
 773         {
 774                 if(pane[i])
 775                 {
 776                         pane[i]->cursor->update();
 777                 }
 778         }
 779 }
 780
 781 void MWindowGUI::set_playing_back(int value)
 782 {
 783         for(int i = 0; i < TOTAL_PANES; i++)
 784         {
 785                 if(pane[i])
 786                 {
 787                         pane[i]->cursor->playing_back = value;
 788                 }
 789         }
 790 }
 791
 792 void MWindowGUI::update_scrollbars(int flush)
 793 {
 794         for(int i = 0; i < TOTAL_PANES; i++)
 795         {
 796                 if(pane[i])
 797                 {
 798                         pane[i]->update(1, NO_DRAW, 0, 0);
 799                 }
 800         }
 801         if(flush) this->flush();
 802 }
 803
 804 void MWindowGUI::reset_meters()
 805 {
 806         for(int i = 0; i < TOTAL_PANES; i++)
 807         {
 808                 if(pane[i] && pane[i]->patchbay)
 809                 {
 810                         pane[i]->patchbay->reset_meters();
 811                 }
 812         }
 813 }
 814
 815 void MWindowGUI::stop_meters()
 816 {
 817         for(int i = 0; i < TOTAL_PANES; i++)
 818         {
 819                 if(pane[i] && pane[i]->patchbay)
 820                 {
 821                         pane[i]->patchbay->stop_meters();
 822                 }
 823         }
 824 }
 825
 826 void MWindowGUI::update_meters(ArrayList<double> *module_levels)
 827 {
 828         for(int i = 0; i < TOTAL_PANES; i++)
 829         {
 830                 if(pane[i] && pane[i]->patchbay)
 831                 {
 832                         pane[i]->patchbay->update_meters(module_levels);
 833                 }
 834         }
 835 }
 836
 837 void MWindowGUI::set_editing_mode(int flush)
 838 {
 839         for(int i = 0; i < TOTAL_PANES; i++)
 840         {
 841                 if(pane[i])
 842                 {
 843                         pane[i]->canvas->update_cursor(flush);
 844                 }
 845         }
 846 }
 847
 848 void MWindowGUI::set_meter_format(int mode, int min, int max)
 849 {
 850         for(int i = 0; i < TOTAL_PANES; i++)
 851         {
 852                 if(pane[i] && pane[i]->patchbay)
 853                 {
 854                         pane[i]->patchbay->set_meter_format(mode, min, max);
 855                 }
 856         }
 857 }
 858
 859 void MWindowGUI::update(int scrollbars,
 860         int do_canvas,
 861         int timebar,
 862         int zoombar,
 863         int patchbay,
 864         int clock,
 865         int buttonbar)
 866 {
 867         const int debug = 0;
 868         if(debug) PRINT_TRACE
 869
 870
 871
 872         mwindow->edl->tracks->update_y_pixels(mwindow->theme);
 873
 874         if( do_canvas != NO_DRAW && do_canvas != IGNORE_THREAD )
 875                 resource_thread->stop_draw(1);
 876
 877         for(int i = 0; i < TOTAL_PANES; i++)
 878         {
 879                 if(pane[i]) pane[i]->update(scrollbars,
 880                         do_canvas,
 881                         timebar,
 882                         patchbay);
 883         }
 884
 885         if( do_canvas != NO_DRAW && do_canvas != IGNORE_THREAD )
 886                 resource_thread->start_draw();
 887
 888 //      if(scrollbars) this->get_scrollbars(0);
 889 //      if(timebar) this->timebar->update(0);
 890         if(zoombar) this->zoombar->update();
 891 //      if(patchbay) this->patchbay->update();
 892         if(clock) this->mainclock->update(
 893                 mwindow->edl->local_session->get_selectionstart(1));
 894         if(debug) PRINT_TRACE
 895
 896
 897
 898 //      if(do_canvas)
 899 //      {
 900 //              this->canvas->draw(do_canvas);
 901 //              this->cursor->show();
 902 //              this->canvas->flash(0);
 903 // Activate causes the menubar to deactivate.  Don't want this for
 904 // picon thread.
 905 //              if(canvas != IGNORE_THREAD) this->canvas->activate();
 906 //      }
 907         if(debug) PRINT_TRACE
 908
 909
 910
 911         if(buttonbar) mbuttons->update();
 912         if(debug) PRINT_TRACE
 913
 914 // Can't age if the cache called this to draw missing picons
 915 // or the GUI is updating the status of the draw toggle.
 916         if( do_canvas != FORCE_REDRAW && do_canvas != IGNORE_THREAD ) {
 917                 unlock_window();
 918                 mwindow->age_caches();
 919                 lock_window("MWindowGUI::update");
 920         }
 921
 922         flush();
 923         if(debug) PRINT_TRACE
 924 }
 925
 926 int MWindowGUI::visible(int64_t x1, int64_t x2, int64_t view_x1, int64_t view_x2)
 927 {
 928         return (x1 >= view_x1 && x1 < view_x2) ||
 929                 (x2 > view_x1 && x2 <= view_x2) ||
 930                 (x1 <= view_x1 && x2 >= view_x2);
 931 }
 932
 933
 934 void MWindowGUI::show_message(const char *message, int color)
 935 {
 936         statusbar->show_message(message, color);
 937 }
 938
 939 void MWindowGUI::update_default_message()
 940 {
 941         statusbar->update_default_message();
 942 }
 943
 944 void MWindowGUI::reset_default_message()
 945 {
 946         statusbar->reset_default_message();
 947 }
 948
 949 void MWindowGUI::default_message()
 950 {
 951         statusbar->default_message();
 952 }
 953
 954 // Drag motion called from other window
 955 int MWindowGUI::drag_motion()
 956 {
 957         if(get_hidden()) return 0;
 958
 959         Track *over_track = 0;
 960         Edit *over_edit = 0;
 961         PluginSet *over_pluginset = 0;
 962         Plugin *over_plugin = 0;
 963         int redraw = 0;
 964
 965         if(drag_popup)
 966         {
 967                 drag_popup->cursor_motion_event();
 968         }
 969
 970
 971 // there's no point in drawing highlights has until drag operation has been set
 972         if (!mwindow->session->current_operation)
 973                 return 0;
 974
 975         for(int i = 0; i < TOTAL_PANES; i++)
 976         {
 977                 if(pane[i]) pane[i]->canvas->drag_motion(
 978                         &over_track,
 979                         &over_edit,
 980                         &over_pluginset,
 981                         &over_plugin);
 982         }
 983
 984         if(mwindow->session->track_highlighted != over_track)
 985         {
 986                 mwindow->session->track_highlighted = over_track;
 987                 redraw = 1;
 988         }
 989
 990         if(mwindow->session->edit_highlighted != over_edit)
 991         {
 992                 mwindow->session->edit_highlighted = over_edit;
 993                 redraw = 1;
 994         }
 995
 996         if(mwindow->session->pluginset_highlighted != over_pluginset)
 997         {
 998                 mwindow->session->pluginset_highlighted = over_pluginset;
 999                 redraw = 1;
1000         }
1001
1002         if(mwindow->session->plugin_highlighted != over_plugin)
1003         {
1004                 mwindow->session->plugin_highlighted = over_plugin;
1005                 redraw = 1;
1006         }
1007
1008         if( mwindow->session->current_operation == DRAG_ASSET ||
1009             mwindow->session->current_operation == DRAG_EDIT ||
1010             mwindow->session->current_operation == DRAG_AEFFECT_COPY ||
1011             mwindow->session->current_operation == DRAG_VEFFECT_COPY )
1012         {
1013                 redraw = 1;
1014         }
1015
1016
1017 // printf("drag_motion %d %d over_track=%p over_edit=%p\n",
1018 // __LINE__,
1019 // redraw,
1020 // over_track,
1021 // over_edit);
1022         if(redraw)
1023         {
1024                 lock_window("MWindowGUI::drag_motion");
1025                 draw_overlays(1);
1026                 unlock_window();
1027         }
1028         return 0;
1029 }
1030
1031 int MWindowGUI::drag_stop()
1032 {
1033         if(get_hidden()) return 0;
1034         int result = 0, redraw = 0;
1035
1036         for(int i = 0; i < TOTAL_PANES; i++)
1037         {
1038                 if(pane[i]) result |= pane[i]->canvas->drag_stop(
1039                         &redraw);
1040         }
1041         mwindow->edl->optimize();
1042
1043 // since we don't have subwindows we have to terminate any drag operation
1044         if(result)
1045         {
1046                 if (mwindow->session->track_highlighted
1047                         || mwindow->session->edit_highlighted
1048                         || mwindow->session->plugin_highlighted
1049                         || mwindow->session->pluginset_highlighted)
1050                         redraw = 1;
1051                 mwindow->session->track_highlighted = 0;
1052                 mwindow->session->edit_highlighted = 0;
1053                 mwindow->session->plugin_highlighted = 0;
1054                 mwindow->session->pluginset_highlighted = 0;
1055                 mwindow->session->current_operation = NO_OPERATION;
1056         }
1057
1058
1059 //printf("MWindowGUI::drag_stop %d %d\n", redraw, mwindow->session->current_operation);
1060         if(redraw)
1061         {
1062                 mwindow->edl->tracks->update_y_pixels(mwindow->theme);
1063                 update_scrollbars(0);
1064                 update_patchbay();
1065                 draw_canvas(1, 1);
1066                 update_cursor();
1067                 flash_canvas(1);
1068         }
1069
1070         if(drag_popup)
1071         {
1072                 delete drag_popup;
1073                 drag_popup = 0;
1074         }
1075         return result;
1076 }
1077
1078 void MWindowGUI::default_positions()
1079 {
1080 //printf("MWindowGUI::default_positions 1\n");
1081         VWindow *vwindow = mwindow->vwindows.size() > DEFAULT_VWINDOW ?
1082                 mwindow->vwindows.get(DEFAULT_VWINDOW) : 0;
1083         if( vwindow && !vwindow->is_running() ) vwindow = 0;
1084         if( vwindow ) vwindow->gui->lock_window("MWindowGUI::default_positions");
1085         mwindow->cwindow->gui->lock_window("MWindowGUI::default_positions");
1086         mwindow->awindow->gui->lock_window("MWindowGUI::default_positions");
1087
1088 // printf("MWindowGUI::default_positions 1 %d %d %d %d\n", mwindow->session->vwindow_x,
1089 // mwindow->session->vwindow_y,
1090 // mwindow->session->vwindow_w,
1091 // mwindow->session->vwindow_h);
1092         reposition_window(mwindow->session->mwindow_x,
1093                 mwindow->session->mwindow_y,
1094                 mwindow->session->mwindow_w,
1095                 mwindow->session->mwindow_h);
1096         if( vwindow ) vwindow->gui->reposition_window(mwindow->session->vwindow_x,
1097                 mwindow->session->vwindow_y,
1098                 mwindow->session->vwindow_w,
1099                 mwindow->session->vwindow_h);
1100         mwindow->cwindow->gui->reposition_window(mwindow->session->cwindow_x,
1101                 mwindow->session->cwindow_y,
1102                 mwindow->session->cwindow_w,
1103                 mwindow->session->cwindow_h);
1104         mwindow->awindow->gui->reposition_window(mwindow->session->awindow_x,
1105                 mwindow->session->awindow_y,
1106                 mwindow->session->awindow_w,
1107                 mwindow->session->awindow_h);
1108 //printf("MWindowGUI::default_positions 1\n");
1109
1110         resize_event(mwindow->session->mwindow_w,
1111                 mwindow->session->mwindow_h);
1112 //printf("MWindowGUI::default_positions 1\n");
1113         if( vwindow ) vwindow->gui->resize_event(mwindow->session->vwindow_w,
1114                 mwindow->session->vwindow_h);
1115 //printf("MWindowGUI::default_positions 1\n");
1116         mwindow->cwindow->gui->resize_event(mwindow->session->cwindow_w,
1117                 mwindow->session->cwindow_h);
1118 //printf("MWindowGUI::default_positions 1\n");
1119         mwindow->awindow->gui->resize_event(mwindow->session->awindow_w,
1120                 mwindow->session->awindow_h);
1121
1122 //printf("MWindowGUI::default_positions 1\n");
1123
1124         flush();
1125         if( vwindow ) vwindow->gui->flush();
1126         mwindow->cwindow->gui->flush();
1127         mwindow->awindow->gui->flush();
1128
1129         if( vwindow ) vwindow->gui->unlock_window();
1130         mwindow->cwindow->gui->unlock_window();
1131         mwindow->awindow->gui->unlock_window();
1132 //printf("MWindowGUI::default_positions 2\n");
1133 }
1134
1135
1136 int MWindowGUI::repeat_event(int64_t duration)
1137 {
1138 // if(duration == 100)
1139 // mwindow->sync_parameters(CHANGE_ALL);
1140         int result = 0;
1141         for(int i = 0; i < TOTAL_PANES; i++)
1142         {
1143                 if(pane[i]) result = pane[i]->cursor->repeat_event(duration);
1144         }
1145         return result;
1146 }
1147
1148
1149 int MWindowGUI::translation_event()
1150 {
1151 //printf("MWindowGUI::translation_event 1 %d %d\n", get_x(), get_y());
1152         mwindow->session->mwindow_x = get_x();
1153         mwindow->session->mwindow_y = get_y();
1154         return 0;
1155 }
1156
1157
1158 int MWindowGUI::save_defaults(BC_Hash *defaults)
1159 {
1160         defaults->update("MWINDOWWIDTH", get_w());
1161         defaults->update("MWINDOWHEIGHT", get_h());
1162         mainmenu->save_defaults(defaults);
1163         BC_WindowBase::save_defaults(defaults);
1164         return 0;
1165 }
1166
1167 int MWindowGUI::keypress_event()
1168 {
1169 //printf("MWindowGUI::keypress_event 1 %d\n", get_keypress());
1170         int result = mbuttons->keypress_event();
1171         if( result ) return result;
1172
1173         Track *this_track = 0;
1174
1175         switch(get_keypress()) {
1176         case 'e':
1177                 mwindow->toggle_editing_mode();
1178                 result = 1;
1179                 break;
1180
1181         case 'k': case 'K':
1182                 if( alt_down() ) break;
1183                 stop_transport("MWindowGUI::keypress_event 1");
1184                 mwindow->nearest_plugin_keyframe(shift_down(),
1185                         !ctrl_down() ? PLAY_FORWARD : PLAY_REVERSE);
1186                 result = 1;
1187                 break;
1188
1189         case 'c':
1190                 if( !ctrl_down() || alt_down() ) break;
1191                 mwindow->selected_to_clipboard();
1192                 break;
1193         case 'v':
1194                 if( !ctrl_down() || alt_down() ) break;
1195                 mwindow->paste();
1196                 break;
1197         case 'z':
1198         case 'x':
1199                 if( !ctrl_down() || alt_down() ) break;
1200                 mwindow->cut_selected_edits(get_keypress()=='x' ? 1 : 0);
1201                 break;
1202         case 'm':
1203         case DELETE:
1204                 if( !ctrl_down() || alt_down() ) break;
1205                 mwindow->delete_edits(get_keypress()==DELETE ? 1 : 0);
1206                 break;
1207
1208         case '1': case '2': case '3': case '4':
1209         case '5': case '6': case '7': case '8':
1210                 if( !alt_down() || shift_down() ) break;
1211                 if( !mwindow->select_asset(get_keypress()-'1',1) )
1212                         result = 1;
1213                 break;
1214
1215         case LEFT:
1216                 if( !ctrl_down() ) {
1217                         if( alt_down() ) {
1218                                 stop_transport("MWindowGUI::keypress_event 1");
1219                                 mwindow->prev_edit_handle(shift_down());
1220                         }
1221                         else
1222                                 mwindow->move_left();
1223                         result = 1;
1224                 }
1225                 break;
1226
1227         case ',':
1228                 if( !ctrl_down() && !alt_down() ) {
1229                         mwindow->move_left();
1230                         result = 1;
1231                 }
1232                 break;
1233
1234         case RIGHT:
1235                 if( !ctrl_down() ) {
1236                         if( alt_down() ) {
1237                                 stop_transport("MWindowGUI::keypress_event 2");
1238                                 mwindow->next_edit_handle(shift_down());
1239                         }
1240                         else
1241                                 mwindow->move_right();
1242                         result = 1;
1243                 }
1244                 break;
1245
1246         case '.':
1247                 if( !ctrl_down() && !alt_down() ) {
1248                         mwindow->move_right();
1249                         result = 1;
1250                 }
1251                 break;
1252
1253         case UP:
1254                 if( ctrl_down() && !alt_down() )
1255                         mwindow->expand_y();
1256                 else if( !ctrl_down() && alt_down() )
1257                         mwindow->expand_autos(0,1,1);
1258                 else if( ctrl_down() && alt_down() )
1259                         mwindow->expand_autos(1,1,1);
1260                 else
1261                         mwindow->expand_sample();
1262                 result = 1;
1263                 break;
1264
1265         case DOWN:
1266                 if( ctrl_down() && !alt_down() )
1267                         mwindow->zoom_in_y();
1268                 else if( !ctrl_down() && alt_down() )
1269                         mwindow->shrink_autos(0,1,1);
1270                 else if( ctrl_down() && alt_down() )
1271                         mwindow->shrink_autos(1,1,1);
1272                 else
1273                         mwindow->zoom_in_sample();
1274                 result = 1;
1275                 break;
1276
1277         case PGUP:
1278                 if( !ctrl_down() )
1279                         mwindow->move_up();
1280                 else
1281                         mwindow->expand_t();
1282                 result = 1;
1283                 break;
1284
1285         case PGDN:
1286                 if( !ctrl_down() )
1287                         mwindow->move_down();
1288                 else
1289                         mwindow->zoom_in_t();
1290                 result = 1;
1291                 break;
1292
1293         case TAB:
1294         case LEFTTAB:
1295                 for( int i=0; i<TOTAL_PANES; ++i ) {
1296                         if( !pane[i] ) continue;
1297                         if( (this_track = pane[i]->over_track()) != 0 ) break;
1298                         if( (this_track = pane[i]->over_patchbay()) != 0 ) break;
1299                 }
1300
1301                 if( get_keypress() == TAB ) { // Switch the record button
1302                         if( this_track )
1303                                 this_track->record = !this_track->record ? 1 : 0;
1304                 }
1305                 else {
1306                         int total_selected = mwindow->edl->tracks->total_of(Tracks::RECORD);
1307                         // all selected if nothing previously selected or
1308                         // if this patch was previously the only one selected and armed
1309                         int selected = !total_selected || (total_selected == 1 &&
1310                                 this_track && this_track->record ) ? 1 : 0;
1311                         mwindow->edl->tracks->select_all(Tracks::RECORD, selected);
1312                         if( !selected && this_track ) this_track->record = 1;
1313                 }
1314
1315                 update(0, NORMAL_DRAW, 0, 0, 1, 0, 1);
1316                 unlock_window();
1317                 mwindow->cwindow->update(0, 1, 1);
1318                 lock_window("MWindowGUI::keypress_event 3");
1319
1320                 result = 1;
1321                 break;
1322
1323         case KEY_F1:
1324         case KEY_F2:
1325         case KEY_F3:
1326         case KEY_F4:
1327         case KEY_F5:
1328         case KEY_F6:
1329         case KEY_F7:
1330         case KEY_F8:
1331         case KEY_F9:
1332         case KEY_F10:
1333         case KEY_F11:
1334         case KEY_F12:
1335                 resend_event(mwindow->cwindow->gui);
1336                 return 1;
1337         }
1338
1339 // since things under cursor have changed...
1340         if(result)
1341                 cursor_motion_event();
1342
1343         return result;
1344 }
1345
1346 int MWindowGUI::keyboard_listener(BC_WindowBase *wp)
1347 {
1348         return key_listener(wp->get_keypress());
1349 }
1350
1351 int MWindowGUI::key_listener(int key)
1352 {
1353         int result = 1;
1354         switch( key ) {
1355         case KPTV:
1356                 if( !record->running() )
1357                         record->start();
1358                 else
1359                         record->record_gui->interrupt_thread->start(0);
1360                 break;
1361         case KPHAND:
1362                 mwindow->quit();
1363                 break;
1364 #ifdef HAVE_DVB
1365         case KPBOOK:
1366                 channel_info->toggle_scan();
1367                 break;
1368 #endif
1369         case KPMENU:
1370                 if( !remote_control->deactivate() )
1371                         remote_control->activate();
1372                 break;
1373         default:
1374                 result = 0;
1375                 break;
1376         }
1377         return result;
1378 }
1379
1380
1381 void MWindowGUI::use_android_remote(int on)
1382 {
1383         if( !on ) {
1384                 delete android_control;
1385                 android_control = 0;
1386                 return;
1387         }
1388         if( android_control ) return;
1389         android_control = new AndroidControl(this);
1390 }
1391
1392 int MWindowGUI::close_event()
1393 {
1394         mainmenu->quit();
1395         return 0;
1396 }
1397
1398 void MWindowGUI::stop_drawing()
1399 {
1400         resource_thread->stop_draw(1);
1401 }
1402
1403 int MWindowGUI::menu_w()
1404 {
1405         return mainmenu->get_w();
1406 }
1407
1408 int MWindowGUI::menu_h()
1409 {
1410         return mainmenu->get_h();
1411 }
1412
1413 void MWindowGUI::start_x_pane_drag()
1414 {
1415         if(!x_pane_drag)
1416         {
1417                 x_pane_drag = new BC_Popup(this,
1418                         get_abs_cursor_x(0) - mwindow->theme->pane_w,
1419                         BC_DisplayInfo::get_top_border() +
1420                                 get_y() +
1421                                 mwindow->theme->mcanvas_y,
1422                         mwindow->theme->pane_w,
1423                         mwindow->theme->mcanvas_h,
1424                         mwindow->theme->drag_pane_color);
1425                 x_pane_drag->draw_3segmentv(0,
1426                         0,
1427                         x_pane_drag->get_h(),
1428                         mwindow->theme->get_image_set("xpane")[BUTTON_DOWNHI]);
1429                 x_pane_drag->flash(1);
1430         }
1431         dragging_pane = 1;
1432 }
1433
1434 void MWindowGUI::start_y_pane_drag()
1435 {
1436         if(!y_pane_drag)
1437         {
1438 //printf("MWindowGUI::start_y_pane_drag %d %d %d\n", __LINE__, get_x(), get_y());
1439                 y_pane_drag = new BC_Popup(this,
1440                         BC_DisplayInfo::get_left_border() +
1441                                 get_x() +
1442                                 mwindow->theme->mcanvas_x,
1443                         get_abs_cursor_y(0) - mwindow->theme->pane_h,
1444                         mwindow->theme->mcanvas_w,
1445                         mwindow->theme->pane_h,
1446                         mwindow->theme->drag_pane_color);
1447                 y_pane_drag->draw_3segmenth(0,
1448                         0,
1449                         y_pane_drag->get_w(),
1450                         mwindow->theme->get_image_set("ypane")[BUTTON_DOWNHI]);
1451                 y_pane_drag->flash(1);
1452         }
1453         dragging_pane = 1;
1454 }
1455
1456 void MWindowGUI::handle_pane_drag()
1457 {
1458         if(dragging_pane)
1459         {
1460                 if(x_pane_drag)
1461                 {
1462                         x_pane_drag->reposition_window(
1463                                 get_abs_cursor_x(0) - mwindow->theme->pane_w,
1464                                 x_pane_drag->get_y());
1465                 }
1466
1467                 if(y_pane_drag)
1468                 {
1469                         y_pane_drag->reposition_window(
1470                                 y_pane_drag->get_x(),
1471                                 get_abs_cursor_y(0) - mwindow->theme->pane_h);
1472                 }
1473         }
1474 }
1475
1476
1477 void MWindowGUI::create_x_pane(int cursor_x)
1478 {
1479         if(total_panes() == 1)
1480         {
1481 // create a horizontal pane
1482 // do this 1st so the resize_event knows there are 2 panes
1483                 mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] =
1484                         mwindow->edl->local_session->view_start[TOP_LEFT_PANE] +
1485                         cursor_x -
1486                         mwindow->theme->patchbay_w;
1487                 pane[TOP_RIGHT_PANE] = new TimelinePane(mwindow,
1488                         TOP_RIGHT_PANE,
1489                         mwindow->theme->mcanvas_x +
1490                                 cursor_x,
1491                         mwindow->theme->mcanvas_y,
1492                         mwindow->theme->mcanvas_x +
1493                                 mwindow->theme->mcanvas_w -
1494                                 cursor_x,
1495                         mwindow->theme->mcanvas_h);
1496                 pane[TOP_LEFT_PANE]->resize_event(
1497                         mwindow->theme->mcanvas_x,
1498                         mwindow->theme->mcanvas_y,
1499                         cursor_x - mwindow->theme->pane_w,
1500                         mwindow->theme->mcanvas_h);
1501                 pane[TOP_RIGHT_PANE]->create_objects();
1502         }
1503         else
1504         if(vertical_panes())
1505         {
1506 // create 2 horizontal panes
1507                 mwindow->edl->local_session->track_start[TOP_RIGHT_PANE] =
1508                         mwindow->edl->local_session->track_start[TOP_LEFT_PANE];
1509                 mwindow->edl->local_session->track_start[BOTTOM_RIGHT_PANE] =
1510                         mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE];
1511                 mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] =
1512                         mwindow->edl->local_session->view_start[BOTTOM_RIGHT_PANE] =
1513                         mwindow->edl->local_session->view_start[TOP_LEFT_PANE] +
1514                         cursor_x -
1515                         mwindow->theme->patchbay_w;
1516                 pane[TOP_RIGHT_PANE] = new TimelinePane(mwindow,
1517                         TOP_RIGHT_PANE,
1518                         mwindow->theme->mcanvas_x +
1519                                 cursor_x,
1520                         pane[TOP_LEFT_PANE]->y,
1521                         mwindow->theme->mcanvas_x +
1522                                 mwindow->theme->mcanvas_w -
1523                                 cursor_x,
1524                         pane[TOP_LEFT_PANE]->h);
1525                 pane[BOTTOM_RIGHT_PANE] = new TimelinePane(mwindow,
1526                         BOTTOM_RIGHT_PANE,
1527                         mwindow->theme->mcanvas_x +
1528                                 cursor_x,
1529                         pane[BOTTOM_LEFT_PANE]->y,
1530                         mwindow->theme->mcanvas_x +
1531                                 mwindow->theme->mcanvas_w -
1532                                 cursor_x,
1533                         pane[BOTTOM_LEFT_PANE]->h);
1534                 pane[TOP_LEFT_PANE]->resize_event(
1535                         pane[TOP_LEFT_PANE]->x,
1536                         pane[TOP_LEFT_PANE]->y,
1537                         cursor_x - mwindow->theme->pane_w,
1538                         pane[TOP_LEFT_PANE]->h);
1539                 pane[BOTTOM_LEFT_PANE]->resize_event(
1540                         pane[BOTTOM_LEFT_PANE]->x,
1541                         pane[BOTTOM_LEFT_PANE]->y,
1542                         cursor_x - mwindow->theme->pane_w,
1543                         pane[BOTTOM_LEFT_PANE]->h);
1544                 pane[TOP_RIGHT_PANE]->create_objects();
1545                 pane[BOTTOM_RIGHT_PANE]->create_objects();
1546         }
1547         else
1548         if(horizontal_panes())
1549         {
1550 // resize a horizontal pane
1551                 mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] +=
1552                         cursor_x -
1553                         pane[TOP_RIGHT_PANE]->x;
1554                 if(mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] < 0)
1555                         mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] = 0;
1556                 pane[TOP_LEFT_PANE]->resize_event(
1557                         mwindow->theme->mcanvas_x,
1558                         mwindow->theme->mcanvas_y,
1559                         cursor_x - mwindow->theme->pane_w,
1560                         mwindow->theme->mcanvas_h);
1561                 pane[TOP_RIGHT_PANE]->resize_event(
1562                         mwindow->theme->mcanvas_x +
1563                                 cursor_x,
1564                         pane[TOP_RIGHT_PANE]->y,
1565                         mwindow->theme->mcanvas_x +
1566                                 mwindow->theme->mcanvas_w -
1567                                 cursor_x,
1568                         mwindow->theme->mcanvas_h);
1569         }
1570         else
1571         {
1572 // resize 2 horizontal panes
1573                 mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] +=
1574                         cursor_x -
1575                         pane[TOP_RIGHT_PANE]->x;
1576                 if(mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] < 0)
1577                         mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] = 0;
1578                 mwindow->edl->local_session->view_start[BOTTOM_RIGHT_PANE] =
1579                         mwindow->edl->local_session->view_start[TOP_RIGHT_PANE];
1580
1581                 pane[TOP_LEFT_PANE]->resize_event(
1582                         mwindow->theme->mcanvas_x,
1583                         pane[TOP_LEFT_PANE]->y,
1584                         cursor_x - mwindow->theme->pane_w,
1585                         pane[TOP_LEFT_PANE]->h);
1586                 pane[TOP_RIGHT_PANE]->resize_event(
1587                         mwindow->theme->mcanvas_x +
1588                                 cursor_x,
1589                         pane[TOP_RIGHT_PANE]->y,
1590                         mwindow->theme->mcanvas_x +
1591                                 mwindow->theme->mcanvas_w -
1592                                 cursor_x,
1593                         pane[TOP_RIGHT_PANE]->h);
1594                 pane[BOTTOM_LEFT_PANE]->resize_event(
1595                         mwindow->theme->mcanvas_x,
1596                         pane[BOTTOM_LEFT_PANE]->y,
1597                         cursor_x - mwindow->theme->pane_w,
1598                         pane[BOTTOM_LEFT_PANE]->h);
1599                 pane[BOTTOM_RIGHT_PANE]->resize_event(
1600                         mwindow->theme->mcanvas_x +
1601                                 cursor_x,
1602                         pane[BOTTOM_RIGHT_PANE]->y,
1603                         mwindow->theme->mcanvas_x +
1604                                 mwindow->theme->mcanvas_w -
1605                                 cursor_x,
1606                         pane[BOTTOM_RIGHT_PANE]->h);
1607
1608         }
1609 }
1610
1611
1612 void MWindowGUI::delete_x_pane(int cursor_x)
1613 {
1614 // give left panes coordinates of right pane
1615         if(cursor_x < mwindow->theme->patchbay_w + PANE_DRAG_MARGIN &&
1616                 pane[TOP_RIGHT_PANE])
1617         {
1618                 mwindow->edl->local_session->view_start[TOP_LEFT_PANE] =
1619                         mwindow->edl->local_session->view_start[TOP_RIGHT_PANE] -
1620                         pane[TOP_RIGHT_PANE]->x + mwindow->theme->patchbay_w;
1621                 if(mwindow->edl->local_session->view_start[TOP_LEFT_PANE] < 0)
1622                         mwindow->edl->local_session->view_start[TOP_LEFT_PANE] = 0;
1623                 mwindow->edl->local_session->view_start[BOTTOM_LEFT_PANE] =
1624                         mwindow->edl->local_session->view_start[TOP_LEFT_PANE];
1625         }
1626
1627         switch(total_panes())
1628         {
1629                 case 2:
1630                         if(pane[TOP_LEFT_PANE] && pane[TOP_RIGHT_PANE])
1631                         {
1632 // delete right pane
1633                                 delete pane[TOP_RIGHT_PANE];
1634                                 pane[TOP_RIGHT_PANE] = 0;
1635                                 pane[TOP_LEFT_PANE]->resize_event(
1636                                         mwindow->theme->mcanvas_x,
1637                                         mwindow->theme->mcanvas_y,
1638                                         mwindow->theme->mcanvas_w,
1639                                         mwindow->theme->mcanvas_h);
1640
1641                         }
1642                         break;
1643
1644                 case 4:
1645 // delete right panes
1646                         delete pane[TOP_RIGHT_PANE];
1647                         pane[TOP_RIGHT_PANE] = 0;
1648                         delete pane[BOTTOM_RIGHT_PANE];
1649                         pane[BOTTOM_RIGHT_PANE] = 0;
1650                         pane[TOP_LEFT_PANE]->resize_event(
1651                                 mwindow->theme->mcanvas_x,
1652                                 pane[TOP_LEFT_PANE]->y,
1653                                 mwindow->theme->mcanvas_w,
1654                                 pane[TOP_LEFT_PANE]->h);
1655                         pane[BOTTOM_LEFT_PANE]->resize_event(
1656                                 mwindow->theme->mcanvas_x,
1657                                 pane[BOTTOM_LEFT_PANE]->y,
1658                                 mwindow->theme->mcanvas_w,
1659                                 pane[BOTTOM_LEFT_PANE]->h);
1660                         break;
1661         }
1662 }
1663
1664 void MWindowGUI::create_y_pane(int cursor_y)
1665 {
1666         if(total_panes() == 1)
1667         {
1668                 mwindow->edl->local_session->view_start[BOTTOM_LEFT_PANE] =
1669                         mwindow->edl->local_session->view_start[TOP_LEFT_PANE];
1670                 mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] =
1671                         mwindow->edl->local_session->track_start[TOP_LEFT_PANE] +
1672                         cursor_y -
1673                         mwindow->theme->mtimebar_h;
1674 // do this 1st so the resize_event knows there are 2 panes
1675                 pane[BOTTOM_LEFT_PANE] = new TimelinePane(mwindow,
1676                         BOTTOM_LEFT_PANE,
1677                         mwindow->theme->mcanvas_x,
1678                         mwindow->theme->mcanvas_y +
1679                                 cursor_y,
1680                         mwindow->theme->mcanvas_w,
1681                         mwindow->theme->mcanvas_h -
1682                                 cursor_y);
1683                 pane[TOP_LEFT_PANE]->resize_event(
1684                         mwindow->theme->mcanvas_x,
1685                         mwindow->theme->mcanvas_y,
1686                         mwindow->theme->mcanvas_w,
1687                         pane[BOTTOM_LEFT_PANE]->y -
1688                                 mwindow->theme->mcanvas_y -
1689                                 mwindow->theme->pane_h);
1690                 pane[BOTTOM_LEFT_PANE]->create_objects();
1691         }
1692         else
1693         if(horizontal_panes())
1694         {
1695 // create 2 panes
1696                 mwindow->edl->local_session->view_start[BOTTOM_LEFT_PANE] =
1697                         mwindow->edl->local_session->view_start[TOP_LEFT_PANE];
1698                 mwindow->edl->local_session->view_start[BOTTOM_RIGHT_PANE] =
1699                         mwindow->edl->local_session->view_start[TOP_RIGHT_PANE];
1700                 mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] =
1701                 mwindow->edl->local_session->track_start[BOTTOM_RIGHT_PANE] =
1702                         mwindow->edl->local_session->track_start[TOP_LEFT_PANE] +
1703                         cursor_y -
1704                         mwindow->theme->mtimebar_h;
1705
1706                 pane[BOTTOM_LEFT_PANE] = new TimelinePane(mwindow,
1707                         BOTTOM_LEFT_PANE,
1708                         pane[TOP_LEFT_PANE]->x,
1709                         mwindow->theme->mcanvas_y +
1710                                 cursor_y,
1711                         pane[TOP_LEFT_PANE]->w,
1712                         mwindow->theme->mcanvas_h -
1713                                 cursor_y);
1714                 pane[BOTTOM_RIGHT_PANE] = new TimelinePane(mwindow,
1715                         BOTTOM_RIGHT_PANE,
1716                         pane[TOP_RIGHT_PANE]->x,
1717                         mwindow->theme->mcanvas_y +
1718                                 cursor_y,
1719                         pane[TOP_RIGHT_PANE]->w,
1720                         mwindow->theme->mcanvas_h -
1721                                 cursor_y);
1722
1723                 pane[TOP_LEFT_PANE]->resize_event(
1724                         pane[TOP_LEFT_PANE]->x,
1725                         pane[TOP_LEFT_PANE]->y,
1726                         pane[TOP_LEFT_PANE]->w,
1727                         pane[BOTTOM_LEFT_PANE]->y -
1728                                 mwindow->theme->mcanvas_y -
1729                                 mwindow->theme->pane_h);
1730                 pane[TOP_RIGHT_PANE]->resize_event(
1731                         pane[TOP_RIGHT_PANE]->x,
1732                         pane[TOP_RIGHT_PANE]->y,
1733                         pane[TOP_RIGHT_PANE]->w,
1734                         pane[BOTTOM_RIGHT_PANE]->y -
1735                                 mwindow->theme->mcanvas_y -
1736                                 mwindow->theme->pane_h);
1737
1738                 pane[BOTTOM_LEFT_PANE]->create_objects();
1739                 pane[BOTTOM_RIGHT_PANE]->create_objects();
1740         }
1741         else
1742         if(vertical_panes())
1743         {
1744 // resize a pane
1745                 mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] +=
1746                         cursor_y -
1747                         (pane[BOTTOM_LEFT_PANE]->y - mwindow->theme->mcanvas_y);
1748                 if(mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] < 0)
1749                         mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] = 0;
1750                 pane[TOP_LEFT_PANE]->resize_event(
1751                         mwindow->theme->mcanvas_x,
1752                         mwindow->theme->mcanvas_y,
1753                         mwindow->theme->mcanvas_w,
1754                         cursor_y - mwindow->theme->pane_h);
1755                 pane[BOTTOM_LEFT_PANE]->resize_event(
1756                         pane[BOTTOM_LEFT_PANE]->x,
1757                         cursor_y +
1758                                 mwindow->theme->mcanvas_y,
1759                         mwindow->theme->mcanvas_w,
1760                         mwindow->theme->mcanvas_h -
1761                                 cursor_y);
1762         }
1763         else
1764         {
1765 // resize 2 panes
1766                 mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] +=
1767                         cursor_y -
1768                         (pane[BOTTOM_LEFT_PANE]->y - mwindow->theme->mcanvas_y);
1769                 if(mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] < 0)
1770                         mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] = 0;
1771                 mwindow->edl->local_session->track_start[BOTTOM_RIGHT_PANE] =
1772                         mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE];
1773                 pane[TOP_LEFT_PANE]->resize_event(
1774                         pane[TOP_LEFT_PANE]->x,
1775                         pane[TOP_LEFT_PANE]->y,
1776                         pane[TOP_LEFT_PANE]->w,
1777                         cursor_y - mwindow->theme->pane_h);
1778                 pane[BOTTOM_LEFT_PANE]->resize_event(
1779                         pane[BOTTOM_LEFT_PANE]->x,
1780                         cursor_y +
1781                                 mwindow->theme->mcanvas_y,
1782                         pane[BOTTOM_LEFT_PANE]->w,
1783                         mwindow->theme->mcanvas_h -
1784                                         cursor_y);
1785                 pane[TOP_RIGHT_PANE]->resize_event(
1786                         pane[TOP_RIGHT_PANE]->x,
1787                         pane[TOP_RIGHT_PANE]->y,
1788                         pane[TOP_RIGHT_PANE]->w,
1789                         cursor_y - mwindow->theme->pane_h);
1790                 pane[BOTTOM_RIGHT_PANE]->resize_event(
1791                         pane[BOTTOM_RIGHT_PANE]->x,
1792                         cursor_y +
1793                                 mwindow->theme->mcanvas_y,
1794                         pane[BOTTOM_RIGHT_PANE]->w,
1795                         mwindow->theme->mcanvas_h -
1796                                         cursor_y);
1797         }
1798 }
1799
1800 void MWindowGUI::delete_y_pane(int cursor_y)
1801 {
1802         if(cursor_y < mwindow->theme->mtimebar_h +
1803                 PANE_DRAG_MARGIN &&
1804                 pane[BOTTOM_LEFT_PANE])
1805         {
1806 // give top pane coordinates of bottom pane
1807                 mwindow->edl->local_session->track_start[TOP_LEFT_PANE] =
1808                         mwindow->edl->local_session->track_start[BOTTOM_LEFT_PANE] -
1809                         pane[BOTTOM_LEFT_PANE]->y;
1810                 if(mwindow->edl->local_session->track_start[TOP_LEFT_PANE] < 0)
1811                         mwindow->edl->local_session->track_start[TOP_LEFT_PANE] = 0;
1812                 mwindow->edl->local_session->track_start[TOP_RIGHT_PANE] =
1813                         mwindow->edl->local_session->track_start[TOP_LEFT_PANE];
1814         }
1815
1816 // delete a pane
1817         switch(total_panes())
1818         {
1819                 case 2:
1820                         delete pane[BOTTOM_LEFT_PANE];
1821                         pane[BOTTOM_LEFT_PANE] = 0;
1822                         pane[TOP_LEFT_PANE]->resize_event(
1823                                 mwindow->theme->mcanvas_x,
1824                                 mwindow->theme->mcanvas_y,
1825                                 mwindow->theme->mcanvas_w,
1826                                 mwindow->theme->mcanvas_h);
1827                         break;
1828
1829                 case 4:
1830 // delete bottom 2 panes
1831
1832                         delete pane[BOTTOM_LEFT_PANE];
1833                         pane[BOTTOM_LEFT_PANE] = 0;
1834                         delete pane[BOTTOM_RIGHT_PANE];
1835                         pane[BOTTOM_RIGHT_PANE] = 0;
1836                         pane[TOP_LEFT_PANE]->resize_event(
1837                                 pane[TOP_LEFT_PANE]->x,
1838                                 mwindow->theme->mcanvas_y,
1839                                 pane[TOP_LEFT_PANE]->w,
1840                                 mwindow->theme->mcanvas_h);
1841                         pane[TOP_RIGHT_PANE]->resize_event(
1842                                 pane[TOP_RIGHT_PANE]->x,
1843                                 mwindow->theme->mcanvas_y,
1844                                 pane[TOP_RIGHT_PANE]->w,
1845                                 mwindow->theme->mcanvas_h);
1846                         break;
1847         }
1848 }
1849
1850 void MWindowGUI::stop_pane_drag()
1851 {
1852         dragging_pane = 0;
1853         resource_thread->stop_draw(0);
1854
1855         if(x_pane_drag)
1856         {
1857 // cursor position relative to canvas
1858                 int cursor_x = x_pane_drag->get_x() -
1859                         get_x() -
1860                         BC_DisplayInfo::get_left_border() -
1861                         mwindow->theme->mcanvas_x +
1862                         mwindow->theme->pane_w;
1863                 delete x_pane_drag;
1864                 x_pane_drag = 0;
1865
1866
1867                 if(cursor_x >= mwindow->theme->patchbay_w + PANE_DRAG_MARGIN &&
1868                         cursor_x < mwindow->theme->mcanvas_w -
1869                                 BC_ScrollBar::get_span(SCROLL_VERT) -
1870                                 PANE_DRAG_MARGIN)
1871                 {
1872                         create_x_pane(cursor_x);
1873                         mwindow->edl->local_session->x_pane = cursor_x;
1874                 }
1875                 else
1876 // deleted a pane
1877                 {
1878                         delete_x_pane(cursor_x);
1879                         mwindow->edl->local_session->x_pane = -1;
1880                 }
1881
1882
1883         }
1884
1885         if(y_pane_drag)
1886         {
1887 // cursor position relative to canvas
1888                 int cursor_y = y_pane_drag->get_y() -
1889                         get_y() -
1890                         BC_DisplayInfo::get_top_border() -
1891                         mwindow->theme->mcanvas_y +
1892                         mwindow->theme->pane_h;
1893                 delete y_pane_drag;
1894                 y_pane_drag = 0;
1895
1896
1897
1898                 if(cursor_y >= mwindow->theme->mtimebar_h +
1899                                 PANE_DRAG_MARGIN &&
1900                         cursor_y < mwindow->theme->mcanvas_h -
1901                                 BC_ScrollBar::get_span(SCROLL_HORIZ) -
1902                                 PANE_DRAG_MARGIN)
1903                 {
1904                         create_y_pane(cursor_y);
1905                         mwindow->edl->local_session->y_pane = cursor_y;
1906                 }
1907                 else
1908                 {
1909                         delete_y_pane(cursor_y);
1910                         mwindow->edl->local_session->y_pane = -1;
1911                 }
1912         }
1913
1914         update_pane_dividers();
1915         update_cursor();
1916 // required to get new widgets to appear
1917         show_window();
1918         resource_thread->start_draw();
1919 }
1920
1921 // create panes from EDL
1922 void MWindowGUI::load_panes()
1923 {
1924         int need_x_panes = 0;
1925         int need_y_panes = 0;
1926 // use names from create functions
1927         int cursor_x = mwindow->edl->local_session->x_pane;
1928         int cursor_y = mwindow->edl->local_session->y_pane;
1929
1930         resource_thread->stop_draw(1);
1931         if(cursor_x >=
1932                 mwindow->theme->patchbay_w + PANE_DRAG_MARGIN &&
1933                 cursor_x <
1934                 mwindow->theme->mcanvas_w -
1935                                 BC_ScrollBar::get_span(SCROLL_VERT) -
1936                                 PANE_DRAG_MARGIN)
1937         {
1938                 need_x_panes = 1;
1939         }
1940
1941         if(cursor_y >=
1942                 mwindow->theme->mtimebar_h + PANE_DRAG_MARGIN &&
1943                 cursor_y <
1944                 mwindow->theme->mcanvas_h -
1945                                 BC_ScrollBar::get_span(SCROLL_HORIZ) -
1946                                 PANE_DRAG_MARGIN)
1947         {
1948                 need_y_panes = 1;
1949         }
1950
1951 //printf("MWindowGUI::load_panes %d %d %d\n", __LINE__, need_x_panes, need_y_panes);
1952
1953
1954         if(need_x_panes)
1955         {
1956                 if(need_y_panes)
1957                 {
1958 // 4 panes
1959                         if(total_panes() == 1)
1960                         {
1961 // create 4 panes
1962 //printf("MWindowGUI::load_panes %d\n", __LINE__);
1963                                 pane[TOP_RIGHT_PANE] = new TimelinePane(mwindow,
1964                                         TOP_RIGHT_PANE,
1965                                         mwindow->theme->mcanvas_x +
1966                                                 cursor_x,
1967                                         mwindow->theme->mcanvas_y,
1968                                         mwindow->theme->mcanvas_x +
1969                                                 mwindow->theme->mcanvas_w -
1970                                                 cursor_x,
1971                                         cursor_y - mwindow->theme->pane_h);
1972                                 pane[BOTTOM_LEFT_PANE] = new TimelinePane(mwindow,
1973                                         BOTTOM_LEFT_PANE,
1974                                         mwindow->theme->mcanvas_x,
1975                                         mwindow->theme->mcanvas_y +
1976                                                 cursor_y,
1977                                         cursor_x - mwindow->theme->pane_w,
1978                                         mwindow->theme->mcanvas_h -
1979                                                 cursor_y);
1980                                 pane[BOTTOM_RIGHT_PANE] = new TimelinePane(mwindow,
1981                                         BOTTOM_RIGHT_PANE,
1982                                         pane[TOP_RIGHT_PANE]->x,
1983                                         mwindow->theme->mcanvas_y +
1984                                                 cursor_y,
1985                                         pane[TOP_RIGHT_PANE]->w,
1986                                         mwindow->theme->mcanvas_h -
1987                                                 cursor_y);
1988                                 pane[TOP_LEFT_PANE]->resize_event(
1989                                         pane[TOP_LEFT_PANE]->x,
1990                                         pane[TOP_LEFT_PANE]->y,
1991                                         cursor_x - mwindow->theme->pane_w,
1992                                         cursor_y - mwindow->theme->pane_h);
1993                                 pane[TOP_RIGHT_PANE]->create_objects();
1994                                 pane[BOTTOM_LEFT_PANE]->create_objects();
1995                                 pane[BOTTOM_RIGHT_PANE]->create_objects();
1996                         }
1997                         else
1998                         if(horizontal_panes())
1999                         {
2000 // create vertical panes
2001 //printf("MWindowGUI::load_panes %d\n", __LINE__);
2002                                 pane[BOTTOM_LEFT_PANE] = new TimelinePane(mwindow,
2003                                         BOTTOM_LEFT_PANE,
2004                                         mwindow->theme->mcanvas_x,
2005                                         mwindow->theme->mcanvas_y +
2006                                                 cursor_y,
2007                                         cursor_x - mwindow->theme->pane_w,
2008                                         mwindow->theme->mcanvas_h -
2009                                                 cursor_y);
2010                                 pane[BOTTOM_RIGHT_PANE] = new TimelinePane(mwindow,
2011                                         BOTTOM_RIGHT_PANE,
2012                                         pane[TOP_RIGHT_PANE]->x,
2013                                         mwindow->theme->mcanvas_y +
2014                                                 cursor_y,
2015                                         pane[TOP_RIGHT_PANE]->w,
2016                                         mwindow->theme->mcanvas_h -
2017                                                 cursor_y);
2018                                 pane[TOP_LEFT_PANE]->resize_event(
2019                                         pane[TOP_LEFT_PANE]->x,
2020                                         pane[TOP_LEFT_PANE]->y,
2021                                         cursor_x - mwindow->theme->pane_w,
2022                                         cursor_y - mwindow->theme->pane_h);
2023                                 pane[TOP_RIGHT_PANE]->resize_event(
2024                                         mwindow->theme->mcanvas_x +
2025                                                 cursor_x,
2026                                         mwindow->theme->mcanvas_y,
2027                                         mwindow->theme->mcanvas_x +
2028                                                 mwindow->theme->mcanvas_w -
2029                                                 cursor_x,
2030                                         cursor_y - mwindow->theme->pane_h);
2031                                 pane[BOTTOM_LEFT_PANE]->create_objects();
2032                                 pane[BOTTOM_RIGHT_PANE]->create_objects();
2033                         }
2034                         else
2035                         if(vertical_panes())
2036                         {
2037 // create horizontal panes
2038 //printf("MWindowGUI::load_panes %d\n", __LINE__);
2039                                 pane[TOP_RIGHT_PANE] = new TimelinePane(mwindow,
2040                                         TOP_RIGHT_PANE,
2041                                         mwindow->theme->mcanvas_x +
2042                                                 cursor_x,
2043                                         mwindow->theme->mcanvas_y,
2044                                         mwindow->theme->mcanvas_x +
2045                                                 mwindow->theme->mcanvas_w -
2046                                                 cursor_x,
2047                                         cursor_y - mwindow->theme->pane_h);
2048                                 pane[BOTTOM_RIGHT_PANE] = new TimelinePane(mwindow,
2049                                         BOTTOM_RIGHT_PANE,
2050                                         pane[TOP_RIGHT_PANE]->x,
2051                                         mwindow->theme->mcanvas_y +
2052                                                 cursor_y,
2053                                         pane[TOP_RIGHT_PANE]->w,
2054                                         mwindow->theme->mcanvas_h -
2055                                                 cursor_y);
2056                                 pane[TOP_LEFT_PANE]->resize_event(
2057                                         pane[TOP_LEFT_PANE]->x,
2058                                         pane[TOP_LEFT_PANE]->y,
2059                                         cursor_x - mwindow->theme->pane_w,
2060                                         cursor_y - mwindow->theme->pane_h);
2061                                 pane[BOTTOM_LEFT_PANE]->resize_event(
2062                                         pane[TOP_LEFT_PANE]->x,
2063                                         mwindow->theme->mcanvas_y +
2064                                                 cursor_y,
2065                                         mwindow->theme->mcanvas_x +
2066                                                 mwindow->theme->mcanvas_w -
2067                                                 cursor_x -  mwindow->theme->pane_w,
2068                                         mwindow->theme->mcanvas_h -
2069                                                 cursor_y);
2070                                 pane[TOP_RIGHT_PANE]->create_objects();
2071                                 pane[BOTTOM_RIGHT_PANE]->create_objects();
2072
2073
2074                         }
2075                         else
2076                         {
2077 // resize all panes
2078 //printf("MWindowGUI::load_panes %d\n", __LINE__);
2079                                 pane[TOP_LEFT_PANE]->resize_event(
2080                                         pane[TOP_LEFT_PANE]->x,
2081                                         pane[TOP_LEFT_PANE]->y,
2082                                         cursor_x - mwindow->theme->pane_w,
2083                                         cursor_y - mwindow->theme->pane_h);
2084                                 pane[TOP_RIGHT_PANE]->resize_event(
2085                                         mwindow->theme->mcanvas_x +
2086                                                 cursor_x,
2087                                         mwindow->theme->mcanvas_y,
2088                                         mwindow->theme->mcanvas_x +
2089                                                 mwindow->theme->mcanvas_w -
2090                                                 cursor_x,
2091                                         cursor_y - mwindow->theme->pane_h);
2092                                 pane[BOTTOM_LEFT_PANE]->resize_event(
2093                                         pane[TOP_LEFT_PANE]->x,
2094                                         mwindow->theme->mcanvas_y +
2095                                                 cursor_y,
2096                                         mwindow->theme->mcanvas_x +
2097                                                 mwindow->theme->mcanvas_w -
2098                                                 cursor_x - mwindow->theme->pane_w,
2099                                         mwindow->theme->mcanvas_h -
2100                                                 cursor_y);
2101                                 pane[BOTTOM_RIGHT_PANE]->resize_event(
2102                                         pane[TOP_RIGHT_PANE]->x,
2103                                         mwindow->theme->mcanvas_y +
2104                                                 cursor_y,
2105                                         pane[TOP_RIGHT_PANE]->w,
2106                                         mwindow->theme->mcanvas_h -
2107                                                 cursor_y);
2108
2109
2110                         }
2111                 }
2112                 else
2113                 {
2114 // 2 X panes
2115                         if(pane[BOTTOM_LEFT_PANE]) delete pane[BOTTOM_LEFT_PANE];
2116                         if(pane[BOTTOM_RIGHT_PANE]) delete pane[BOTTOM_RIGHT_PANE];
2117                         pane[BOTTOM_LEFT_PANE] = 0;
2118                         pane[BOTTOM_RIGHT_PANE] = 0;
2119
2120                         if(!pane[TOP_RIGHT_PANE])
2121                         {
2122                                 pane[TOP_RIGHT_PANE] = new TimelinePane(mwindow,
2123                                         TOP_RIGHT_PANE,
2124                                         mwindow->theme->mcanvas_x +
2125                                                 cursor_x,
2126                                         mwindow->theme->mcanvas_y,
2127                                         mwindow->theme->mcanvas_x +
2128                                                 mwindow->theme->mcanvas_w -
2129                                                 cursor_x,
2130                                         mwindow->theme->mcanvas_h);
2131                                 pane[TOP_LEFT_PANE]->resize_event(
2132                                         mwindow->theme->mcanvas_x,
2133                                         mwindow->theme->mcanvas_y,
2134                                         cursor_x - mwindow->theme->pane_w,
2135                                         mwindow->theme->mcanvas_h);
2136                                 pane[TOP_RIGHT_PANE]->create_objects();
2137                         }
2138                         else
2139                         {
2140                                 pane[TOP_LEFT_PANE]->resize_event(
2141                                         mwindow->theme->mcanvas_x,
2142                                         mwindow->theme->mcanvas_y,
2143                                         cursor_x - mwindow->theme->pane_w,
2144                                         mwindow->theme->mcanvas_h);
2145                                 pane[TOP_RIGHT_PANE]->resize_event(
2146                                         mwindow->theme->mcanvas_x +
2147                                                 cursor_x,
2148                                         pane[TOP_RIGHT_PANE]->y,
2149                                         mwindow->theme->mcanvas_x +
2150                                                 mwindow->theme->mcanvas_w -
2151                                                 cursor_x,
2152                                         mwindow->theme->mcanvas_h);
2153                         }
2154                 }
2155         }
2156         else
2157         if(need_y_panes)
2158         {
2159 // 2 Y panes
2160                 if(pane[TOP_RIGHT_PANE]) delete pane[TOP_RIGHT_PANE];
2161                 if(pane[BOTTOM_RIGHT_PANE]) delete pane[BOTTOM_RIGHT_PANE];
2162                 pane[TOP_RIGHT_PANE] = 0;
2163                 pane[BOTTOM_RIGHT_PANE] = 0;
2164
2165                 if(!pane[BOTTOM_LEFT_PANE])
2166                 {
2167 //printf("MWindowGUI::load_panes %d\n", __LINE__);
2168                         pane[BOTTOM_LEFT_PANE] = new TimelinePane(mwindow,
2169                                 BOTTOM_LEFT_PANE,
2170                                 mwindow->theme->mcanvas_x,
2171                                 mwindow->theme->mcanvas_y +
2172                                         cursor_y,
2173                                 mwindow->theme->mcanvas_w,
2174                                 mwindow->theme->mcanvas_h -
2175                                         cursor_y);
2176                         pane[TOP_LEFT_PANE]->resize_event(
2177                                 mwindow->theme->mcanvas_x,
2178                                 mwindow->theme->mcanvas_y,
2179                                 mwindow->theme->mcanvas_w,
2180                                 pane[BOTTOM_LEFT_PANE]->y -
2181                                         mwindow->theme->mcanvas_y -
2182                                         mwindow->theme->pane_h);
2183                         pane[BOTTOM_LEFT_PANE]->create_objects();
2184                 }
2185                 else
2186                 {
2187                         pane[TOP_LEFT_PANE]->resize_event(
2188                                 mwindow->theme->mcanvas_x,
2189                                 mwindow->theme->mcanvas_y,
2190                                 mwindow->theme->mcanvas_w,
2191                                 cursor_y - mwindow->theme->pane_h);
2192                         pane[BOTTOM_LEFT_PANE]->resize_event(
2193                                 pane[BOTTOM_LEFT_PANE]->x,
2194                                 cursor_y +
2195                                         mwindow->theme->mcanvas_y,
2196                                 mwindow->theme->mcanvas_w,
2197                                 mwindow->theme->mcanvas_h -
2198                                         cursor_y);
2199                 }
2200         }
2201         else
2202         {
2203 // 1 pane
2204                 if(pane[TOP_RIGHT_PANE]) delete pane[TOP_RIGHT_PANE];
2205                 if(pane[BOTTOM_RIGHT_PANE]) delete pane[BOTTOM_RIGHT_PANE];
2206                 if(pane[BOTTOM_LEFT_PANE]) delete pane[BOTTOM_LEFT_PANE];
2207                 pane[TOP_RIGHT_PANE] = 0;
2208                 pane[BOTTOM_RIGHT_PANE] = 0;
2209                 pane[BOTTOM_LEFT_PANE] = 0;
2210                 pane[TOP_LEFT_PANE]->resize_event(
2211                         mwindow->theme->mcanvas_x,
2212                         mwindow->theme->mcanvas_y,
2213                         mwindow->theme->mcanvas_w,
2214                         mwindow->theme->mcanvas_h);
2215         }
2216
2217         update_pane_dividers();
2218         show_window();
2219
2220         resource_thread->start_draw();
2221 }
2222
2223 void MWindowGUI::update_pane_dividers()
2224 {
2225
2226         if(horizontal_panes() || total_panes() == 4)
2227         {
2228                 int x = pane[TOP_RIGHT_PANE]->x - mwindow->theme->pane_w;
2229                 int y = mwindow->theme->mcanvas_y;
2230                 int h = mwindow->theme->mcanvas_h;
2231
2232                 if(!x_divider)
2233                 {
2234                         add_subwindow(x_divider = new PaneDivider(
2235                                 mwindow, x, y, h, 1));
2236                         x_divider->create_objects();
2237                 }
2238                 else
2239                 {
2240                         x_divider->reposition_window(x, y, h);
2241                         x_divider->draw(0);
2242                 }
2243         }
2244         else
2245         {
2246                 if(x_divider)
2247                 {
2248                         delete x_divider;
2249                         x_divider = 0;
2250                 }
2251         }
2252
2253         if(vertical_panes() || total_panes() == 4)
2254         {
2255                 int x = mwindow->theme->mcanvas_x;
2256                 int y = pane[BOTTOM_LEFT_PANE]->y -
2257                         mwindow->theme->pane_h;
2258                 int w = mwindow->theme->mcanvas_w;
2259                 if(!y_divider)
2260                 {
2261                         add_subwindow(y_divider = new PaneDivider(
2262                                 mwindow, x, y, w, 0));
2263                         y_divider->create_objects();
2264                 }
2265                 else
2266                 {
2267                         y_divider->reposition_window(x, y, w);
2268                         y_divider->draw(0);
2269                 }
2270         }
2271         else
2272         {
2273                 if(y_divider)
2274                 {
2275                         delete y_divider;
2276                         y_divider = 0;
2277                 }
2278         }
2279 }
2280
2281 void MWindowGUI::draw_samplemovement()
2282 {
2283         draw_canvas(0, 1);
2284         show_cursor(1);
2285         flash_canvas(0);
2286         update_timebar(0);
2287         zoombar->update();
2288         update_scrollbars(1);
2289 }
2290
2291 void MWindowGUI::draw_trackmovement()
2292 {
2293         update_scrollbars(0);
2294         draw_canvas(0, 0);
2295         update_patchbay();
2296         flash_canvas(1);
2297 }
2298
2299
2300 void MWindowGUI::update_mixers(Track *track, int v)
2301 {
2302         for( int i=0; i<TOTAL_PANES;  ++i ) {
2303                 if( !pane[i] ) continue;
2304                 PatchBay *patchbay = pane[i]->patchbay;
2305                 if( !patchbay ) continue;
2306                 for( int j=0; j<patchbay->patches.total; ++j ) {
2307                         PatchGUI *patchgui = patchbay->patches.values[j];
2308                         if( !patchgui->mix ) continue;
2309                         if( !track || patchgui->track == track ) {
2310                                 patchgui->mix->update(v>=0 ? v :
2311                                         mwindow->mixer_track_active(patchgui->track));
2312                         }
2313                 }
2314         }
2315 }
2316
2317 void MWindowGUI::stop_transport(const char *lock_msg)
2318 {
2319         if( !mbuttons->transport->is_stopped() ) {
2320                 if( lock_msg ) unlock_window();
2321                 mbuttons->transport->handle_transport(STOP, 1, 0, 0);
2322                 if( lock_msg ) lock_window(lock_msg);
2323         }
2324 }
2325
2326 PaneButton::PaneButton(MWindow *mwindow, int x, int y)
2327  : BC_Button(x, y, mwindow->theme->get_image_set("pane"))
2328 {
2329         this->mwindow = mwindow;
2330 }
2331
2332 int PaneButton::cursor_motion_event()
2333 {
2334         if(get_top_level()->get_button_down() &&
2335                 is_event_win() &&
2336                 get_status() == BUTTON_DOWNHI &&
2337                 !cursor_inside())
2338         {
2339 //              printf("PaneButton::cursor_motion_event %d\n", __LINE__);
2340 // create drag bar
2341                 if(get_cursor_x() < 0 && !mwindow->gui->dragging_pane)
2342                 {
2343                         mwindow->gui->start_x_pane_drag();
2344                 }
2345                 else
2346                 if(get_cursor_y() < 0 && !mwindow->gui->dragging_pane)
2347                 {
2348                         mwindow->gui->start_y_pane_drag();
2349                 }
2350         }
2351
2352         mwindow->gui->handle_pane_drag();
2353
2354         int result = BC_Button::cursor_motion_event();
2355         return result;
2356 }
2357
2358 int PaneButton::button_release_event()
2359 {
2360         if( get_buttonpress() != WHEEL_DOWN && get_buttonpress() != WHEEL_UP )
2361                 mwindow->gui->stop_pane_drag();
2362         int result = BC_Button::button_release_event();
2363         return result;
2364 }
2365
2366
2367 FFMpegToggle::FFMpegToggle(MWindow *mwindow, MButtons *mbuttons, int x, int y)
2368  : BC_Toggle(x, y, mwindow->theme->ffmpeg_toggle,
2369          mwindow->preferences->get_file_probe_armed("FFMPEG_Early") > 0 ? 1 : 0)
2370 {
2371         this->mwindow = mwindow;
2372         this->mbuttons = mbuttons;
2373         set_tooltip(get_value() ? FFMPEG_EARLY_TIP : FFMPEG_LATE_TIP);
2374 }
2375
2376 FFMpegToggle::~FFMpegToggle()
2377 {
2378 }
2379
2380 int FFMpegToggle::handle_event()
2381 {
2382         int ffmpeg_early_probe = get_value();
2383         set_tooltip(ffmpeg_early_probe ? FFMPEG_EARLY_TIP : FFMPEG_LATE_TIP);
2384         mwindow->preferences->set_file_probe_armed("FFMPEG_Early", ffmpeg_early_probe);
2385         mwindow->preferences->set_file_probe_armed("FFMPEG_Late", !ffmpeg_early_probe);
2386
2387         mwindow->show_warning(&mwindow->preferences->warn_indexes,
2388                 _("Changing the base codecs may require rebuilding indexes."));
2389         return 1;
2390 }
2391
2392
2393 ProxyToggle::ProxyToggle(MWindow *mwindow, MButtons *mbuttons, int x, int y)
2394  : BC_Toggle(x, y, ( !mwindow->edl->session->proxy_use_scaler ?
2395                         mwindow->theme->proxy_p_toggle :
2396                         mwindow->theme->proxy_s_toggle ),
2397                 mwindow->edl->session->proxy_disabled_scale != 1)
2398 {
2399         this->mwindow = mwindow;
2400         this->mbuttons = mbuttons;
2401         scaler_images = mwindow->edl->session->proxy_use_scaler;
2402         set_tooltip(mwindow->edl->session->proxy_disabled_scale==1 ?
2403                 _("Disable proxy") : _("Enable proxy"));
2404 }
2405
2406 void ProxyToggle::show()
2407 {
2408         int use_scaler = mwindow->edl->session->proxy_use_scaler;
2409         if( scaler_images != use_scaler )
2410                 set_images(!(scaler_images=use_scaler) ?
2411                         mwindow->theme->proxy_p_toggle :
2412                         mwindow->theme->proxy_s_toggle );
2413         draw_face(1, 0);
2414         if( is_hidden() )
2415                 show_window();
2416 }
2417
2418 void ProxyToggle::hide()
2419 {
2420         if( !is_hidden() )
2421                 hide_window();
2422 }
2423
2424 ProxyToggle::~ProxyToggle()
2425 {
2426 }
2427
2428 int ProxyToggle::handle_event()
2429 {
2430         int disabled = get_value();
2431         mwindow->gui->unlock_window();
2432         if( disabled )
2433                 mwindow->disable_proxy();
2434         else
2435                 mwindow->enable_proxy();
2436         mwindow->gui->lock_window("ProxyToggle::handle_event");
2437         set_tooltip(!disabled ? _("Disable proxy") : _("Enable proxy"));
2438         return 1;
2439 }
2440
2441 int ProxyToggle::keypress_event()
2442 {
2443         if( ctrl_down() && !shift_down() && !alt_down() ) {
2444                 int key = get_keypress();
2445                 if( key == 'r' ) {
2446                         int value = get_value() ? 0 : 1;
2447                         set_value(value);
2448                         return handle_event();
2449                 }
2450         }
2451         return 0;
2452 }
2453