cinelerra-5.1/cinelerra/vwindowgui.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 1997-2011 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 "asset.h"
  23 #include "assets.h"
  24 #include "awindowgui.h"
  25 #include "awindow.h"
  26 #include "canvas.h"
  27 #include "clip.h"
  28 #include "clipedit.h"
  29 #include "edl.h"
  30 #include "edlsession.h"
  31 #include "filesystem.h"
  32 #include "filexml.h"
  33 #include "fonts.h"
  34 #include "keys.h"
  35 #include "labels.h"
  36 #include "language.h"
  37 #include "localsession.h"
  38 #include "mainclock.h"
  39 #include "mainmenu.h"
  40 #include "mainsession.h"
  41 #include "mainundo.h"
  42 #include "meterpanel.h"
  43 #include "mwindowgui.h"
  44 #include "mwindow.h"
  45 #include "playtransport.h"
  46 #include "preferences.h"
  47 #include "theme.h"
  48 #include "timebar.h"
  49 #include "tracks.h"
  50 #include "vframe.h"
  51 #include "vplayback.h"
  52 #include "vtimebar.h"
  53 #include "vwindowgui.h"
  54 #include "vwindow.h"
  55
  56
  57
  58
  59 VWindowGUI::VWindowGUI(MWindow *mwindow, VWindow *vwindow)
  60  : BC_Window(_(PROGRAM_NAME ": Viewer"),
  61         mwindow->session->vwindow_x,
  62         mwindow->session->vwindow_y,
  63         mwindow->session->vwindow_w,
  64         mwindow->session->vwindow_h,
  65         100,
  66         100,
  67         1,
  68         1,
  69         0) // Hide it
  70 {
  71         this->mwindow = mwindow;
  72         this->vwindow = vwindow;
  73         canvas = 0;
  74         transport = 0;
  75         edit_panel = 0;
  76         meters = 0;
  77 //      source = 0;
  78         strcpy(loaded_title, "");
  79         highlighted = 0;
  80 }
  81
  82 VWindowGUI::~VWindowGUI()
  83 {
  84         vwindow->playback_engine->interrupt_playback(1);
  85         sources.remove_all_objects();
  86         labels.remove_all_objects();
  87         delete canvas;
  88         delete transport;
  89         delete edit_panel;
  90         delete meters;
  91 //      delete source;
  92 }
  93
  94 void VWindowGUI::change_source(EDL *edl, const char *title)
  95 {
  96 //printf("VWindowGUI::change_source %d\n", __LINE__);
  97
  98         update_sources(title);
  99         strcpy(loaded_title, title);
 100         char string[BCTEXTLEN];
 101         if(title[0])
 102                 sprintf(string, _(PROGRAM_NAME ": %s"), title);
 103         else
 104                 sprintf(string, _(PROGRAM_NAME ": Viewer"));
 105
 106         lock_window("VWindowGUI::change_source");
 107         canvas->clear();
 108         timebar->update(0);
 109         set_title(string);
 110         unlock_window();
 111 }
 112
 113
 114 // Get source list from master EDL
 115 void VWindowGUI::update_sources(const char *title)
 116 {
 117         lock_window("VWindowGUI::update_sources");
 118
 119 //printf("VWindowGUI::update_sources 1\n");
 120         sources.remove_all_objects();
 121 //printf("VWindowGUI::update_sources 2\n");
 122
 123
 124
 125         for(int i = 0;
 126                 i < mwindow->edl->clips.total;
 127                 i++)
 128         {
 129                 char *clip_title = mwindow->edl->clips.values[i]->local_session->clip_title;
 130                 int exists = 0;
 131
 132                 for(int j = 0; j < sources.total; j++)
 133                 {
 134                         if(!strcasecmp(sources.values[j]->get_text(), clip_title))
 135                         {
 136                                 exists = 1;
 137                         }
 138                 }
 139
 140                 if(!exists)
 141                 {
 142                         sources.append(new BC_ListBoxItem(clip_title));
 143                 }
 144         }
 145 //printf("VWindowGUI::update_sources 3\n");
 146
 147         FileSystem fs;
 148         for(Asset *current = mwindow->edl->assets->first;
 149                 current;
 150                 current = NEXT)
 151         {
 152                 char clip_title[BCTEXTLEN];
 153                 fs.extract_name(clip_title, current->path);
 154                 int exists = 0;
 155
 156                 for(int j = 0; j < sources.total; j++)
 157                 {
 158                         if(!strcasecmp(sources.values[j]->get_text(), clip_title))
 159                         {
 160                                 exists = 1;
 161                         }
 162                 }
 163
 164                 if(!exists)
 165                 {
 166                         sources.append(new BC_ListBoxItem(clip_title));
 167                 }
 168         }
 169
 170 //printf("VWindowGUI::update_sources 4\n");
 171
 172 //      source->update_list(&sources);
 173 //      source->update(title);
 174         unlock_window();
 175 }
 176
 177 void VWindowGUI::create_objects()
 178 {
 179         in_point = 0;
 180         out_point = 0;
 181         lock_window("VWindowGUI::create_objects");
 182         set_icon(mwindow->theme->get_image("vwindow_icon"));
 183
 184 //printf("VWindowGUI::create_objects 1\n");
 185         mwindow->theme->get_vwindow_sizes(this);
 186         mwindow->theme->draw_vwindow_bg(this);
 187         flash(0);
 188
 189         meters = new VWindowMeters(mwindow,
 190                 this,
 191                 mwindow->theme->vmeter_x,
 192                 mwindow->theme->vmeter_y,
 193                 mwindow->theme->vmeter_h);
 194         meters->create_objects();
 195
 196 //printf("VWindowGUI::create_objects 1\n");
 197 // Requires meters to build
 198         edit_panel = new VWindowEditing(mwindow, vwindow);
 199         edit_panel->set_meters(meters);
 200         edit_panel->create_objects();
 201
 202 //printf("VWindowGUI::create_objects 1\n");
 203         transport = new VWindowTransport(mwindow,
 204                 this,
 205                 mwindow->theme->vtransport_x,
 206                 mwindow->theme->vtransport_y);
 207         transport->create_objects();
 208
 209 //printf("VWindowGUI::create_objects 1\n");
 210 //      add_subwindow(fps_title = new BC_Title(mwindow->theme->vedit_x, y, ""));
 211     add_subwindow(clock = new MainClock(mwindow,
 212                 mwindow->theme->vtime_x,
 213                 mwindow->theme->vtime_y,
 214                 mwindow->theme->vtime_w));
 215
 216         canvas = new VWindowCanvas(mwindow, this);
 217         canvas->create_objects(mwindow->edl);
 218         canvas->use_vwindow();
 219
 220
 221 //printf("VWindowGUI::create_objects 1\n");
 222         add_subwindow(timebar = new VTimeBar(mwindow,
 223                 this,
 224                 mwindow->theme->vtimebar_x,
 225                 mwindow->theme->vtimebar_y,
 226                 mwindow->theme->vtimebar_w,
 227                 mwindow->theme->vtimebar_h));
 228         timebar->create_objects();
 229 //printf("VWindowGUI::create_objects 2\n");
 230
 231
 232 //printf("VWindowGUI::create_objects 1\n");
 233 //      source = new VWindowSource(mwindow,
 234 //              this,
 235 //              mwindow->theme->vsource_x,
 236 //              mwindow->theme->vsource_y);
 237 //      source->create_objects();
 238         update_sources(_("None"));
 239
 240 //printf("VWindowGUI::create_objects 2\n");
 241         deactivate();
 242
 243         show_window();
 244         unlock_window();
 245 }
 246
 247 int VWindowGUI::resize_event(int w, int h)
 248 {
 249         mwindow->session->vwindow_x = get_x();
 250         mwindow->session->vwindow_y = get_y();
 251         mwindow->session->vwindow_w = w;
 252         mwindow->session->vwindow_h = h;
 253
 254         mwindow->theme->get_vwindow_sizes(this);
 255         mwindow->theme->draw_vwindow_bg(this);
 256         flash(0);
 257
 258 //printf("VWindowGUI::resize_event %d %d\n", __LINE__, mwindow->theme->vedit_y);
 259         edit_panel->reposition_buttons(mwindow->theme->vedit_x,
 260                 mwindow->theme->vedit_y);
 261
 262         timebar->resize_event();
 263         transport->reposition_buttons(mwindow->theme->vtransport_x,
 264                 mwindow->theme->vtransport_y);
 265         clock->reposition_window(mwindow->theme->vtime_x,
 266                 mwindow->theme->vtime_y,
 267                 mwindow->theme->vtime_w,
 268                 clock->get_h());
 269         canvas->reposition_window(0,
 270                 mwindow->theme->vcanvas_x,
 271                 mwindow->theme->vcanvas_y,
 272                 mwindow->theme->vcanvas_w,
 273                 mwindow->theme->vcanvas_h);
 274 //printf("VWindowGUI::resize_event %d %d\n", __LINE__, mwindow->theme->vcanvas_x);
 275 //      source->reposition_window(mwindow->theme->vsource_x,
 276 //              mwindow->theme->vsource_y);
 277         meters->reposition_window(mwindow->theme->vmeter_x,
 278                 mwindow->theme->vmeter_y,
 279                 -1,
 280                 mwindow->theme->vmeter_h);
 281
 282         BC_WindowBase::resize_event(w, h);
 283         return 1;
 284 }
 285
 286
 287
 288
 289
 290 int VWindowGUI::translation_event()
 291 {
 292         mwindow->session->vwindow_x = get_x();
 293         mwindow->session->vwindow_y = get_y();
 294         return 0;
 295 }
 296
 297 int VWindowGUI::close_event()
 298 {
 299         hide_window();
 300         int i = mwindow->vwindows.size();
 301         while( --i >= 0 && mwindow->vwindows.get(i)->gui != this );
 302         if( i > 0 ) {
 303                 set_done(0);
 304                 return 1;
 305         }
 306
 307         mwindow->session->show_vwindow = 0;
 308         unlock_window();
 309
 310         mwindow->gui->lock_window("VWindowGUI::close_event");
 311         mwindow->gui->mainmenu->show_vwindow->set_checked(0);
 312         mwindow->gui->unlock_window();
 313
 314         lock_window("VWindowGUI::close_event");
 315         mwindow->save_defaults();
 316         return 1;
 317 }
 318
 319 int VWindowGUI::keypress_event()
 320 {
 321         int result = 0;
 322         switch(get_keypress())
 323         {
 324                 case 'w':
 325                 case 'W':
 326                         close_event();
 327                         result = 1;
 328                         break;
 329                 case 'z':
 330                         mwindow->undo_entry(this);
 331                         break;
 332                 case 'Z':
 333                         mwindow->redo_entry(this);
 334                         break;
 335                 case 'f':
 336                         unlock_window();
 337                         if(mwindow->session->vwindow_fullscreen)
 338                                 canvas->stop_fullscreen();
 339                         else
 340                                 canvas->start_fullscreen();
 341                         lock_window("VWindowGUI::keypress_event 1");
 342                         break;
 343                 case ESC:
 344                         unlock_window();
 345                         if(mwindow->session->vwindow_fullscreen)
 346                                 canvas->stop_fullscreen();
 347                         lock_window("VWindowGUI::keypress_event 2");
 348                         break;
 349         }
 350         if(!result) result = transport->keypress_event();
 351         return result;
 352 }
 353
 354 void VWindowGUI::stop_transport(const char *lock_msg)
 355 {
 356         if( !transport->is_stopped() ) {
 357                 if( lock_msg ) unlock_window();
 358                 transport->handle_transport(STOP, 1, 0, 0);
 359                 if( lock_msg ) lock_window(lock_msg);
 360         }
 361 }
 362
 363 int VWindowGUI::button_press_event()
 364 {
 365         if( vwindow->get_edl() != 0 && canvas->get_canvas() &&
 366             canvas->get_canvas()->get_cursor_over_window() ) {
 367                 switch( get_buttonpress() ) {
 368                 case LEFT_BUTTON:
 369                         if( !vwindow->playback_engine->is_playing_back ) {
 370                                 double length = vwindow->get_edl()->tracks->total_playable_length();
 371                                 double position = vwindow->playback_engine->get_tracking_position();
 372                                 if( position >= length ) transport->goto_start();
 373                         }
 374                         return transport->forward_play->handle_event();
 375                 case MIDDLE_BUTTON:
 376                         if( !vwindow->playback_engine->is_playing_back ) {
 377                                 double position = vwindow->playback_engine->get_tracking_position();
 378                                 if( position <= 0 ) transport->goto_end();
 379                         }
 380                         return transport->reverse_play->handle_event();
 381                 case RIGHT_BUTTON:  // activates popup
 382                         break;
 383                 case WHEEL_UP:
 384                         return transport->frame_forward_play->handle_event();
 385                 case WHEEL_DOWN:
 386                         return transport->frame_reverse_play->handle_event();
 387                 }
 388         }
 389         if(canvas->get_canvas())
 390                 return canvas->button_press_event_base(canvas->get_canvas());
 391         return 0;
 392 }
 393
 394 int VWindowGUI::cursor_leave_event()
 395 {
 396         if(canvas->get_canvas())
 397                 return canvas->cursor_leave_event_base(canvas->get_canvas());
 398         return 0;
 399 }
 400
 401 int VWindowGUI::cursor_enter_event()
 402 {
 403         if(canvas->get_canvas())
 404                 return canvas->cursor_enter_event_base(canvas->get_canvas());
 405         return 0;
 406 }
 407
 408 int VWindowGUI::button_release_event()
 409 {
 410         if(canvas->get_canvas())
 411                 return canvas->button_release_event();
 412         return 0;
 413 }
 414
 415 int VWindowGUI::cursor_motion_event()
 416 {
 417         if(canvas->get_canvas())
 418         {
 419                 canvas->get_canvas()->unhide_cursor();
 420                 return canvas->cursor_motion_event();
 421         }
 422         return 0;
 423 }
 424
 425
 426 void VWindowGUI::drag_motion()
 427 {
 428 // Window hidden
 429         if(get_hidden()) return;
 430         if(mwindow->session->current_operation != DRAG_ASSET) return;
 431         int need_highlight = cursor_above() && get_cursor_over_window() ? 1 : 0;
 432         if( highlighted == need_highlight ) return;
 433         highlighted = need_highlight;
 434         canvas->draw_refresh();
 435 }
 436
 437 int VWindowGUI::drag_stop()
 438 {
 439         if(get_hidden()) return 0;
 440
 441         if(highlighted &&
 442                 mwindow->session->current_operation == DRAG_ASSET)
 443         {
 444                 highlighted = 0;
 445                 canvas->draw_refresh();
 446                 unlock_window();
 447
 448                 Indexable *indexable = mwindow->session->drag_assets->size() ?
 449                         mwindow->session->drag_assets->get(0) :
 450                         0;
 451                 EDL *edl = mwindow->session->drag_clips->size() ?
 452                         mwindow->session->drag_clips->get(0) :
 453                         0;
 454                 if(indexable)
 455                         vwindow->change_source(indexable);
 456                 else
 457                 if(edl)
 458                         vwindow->change_source(edl);
 459                 lock_window("VWindowGUI::drag_stop");
 460                 return 1;
 461         }
 462
 463         return 0;
 464 }
 465
 466
 467 void VWindowGUI::update_meters()
 468 {
 469         if(mwindow->edl->session->vwindow_meter != meters->visible)
 470         {
 471                 meters->set_meters(meters->meter_count,
 472                         mwindow->edl->session->vwindow_meter);
 473                 mwindow->theme->get_vwindow_sizes(this);
 474                 resize_event(get_w(), get_h());
 475         }
 476 }
 477
 478
 479
 480 VWindowMeters::VWindowMeters(MWindow *mwindow,
 481         VWindowGUI *gui,
 482         int x,
 483         int y,
 484         int h)
 485  : MeterPanel(mwindow,
 486                 gui,
 487                 x,
 488                 y,
 489                 -1,
 490                 h,
 491                 mwindow->edl->session->audio_channels,
 492                 mwindow->edl->session->vwindow_meter,
 493                 0,
 494                 0)
 495 {
 496         this->mwindow = mwindow;
 497         this->gui = gui;
 498 }
 499
 500 VWindowMeters::~VWindowMeters()
 501 {
 502 }
 503
 504 int VWindowMeters::change_status_event(int new_status)
 505 {
 506         mwindow->edl->session->vwindow_meter = new_status;
 507         gui->update_meters();
 508         return 1;
 509 }
 510
 511
 512
 513
 514
 515
 516
 517 VWindowEditing::VWindowEditing(MWindow *mwindow, VWindow *vwindow)
 518  : EditPanel(mwindow,
 519                 vwindow->gui,
 520                 mwindow->theme->vedit_x,
 521                 mwindow->theme->vedit_y,
 522                 EDITING_ARROW,
 523                 0,
 524                 0,
 525                 1,
 526                 1,
 527                 0,
 528                 0,
 529                 1,
 530                 0,
 531                 0,
 532                 0,
 533                 0, // locklabels
 534                 1,
 535                 1,
 536                 1,
 537                 0,
 538                 0,
 539                 0)
 540 {
 541         this->mwindow = mwindow;
 542         this->vwindow = vwindow;
 543 }
 544
 545 VWindowEditing::~VWindowEditing()
 546 {
 547 }
 548
 549 void VWindowEditing::copy_selection()
 550 {
 551         vwindow->copy();
 552 }
 553
 554 void VWindowEditing::splice_selection()
 555 {
 556         if(vwindow->get_edl())
 557         {
 558                 mwindow->gui->lock_window("VWindowEditing::splice_selection");
 559                 mwindow->splice(vwindow->get_edl());
 560                 mwindow->gui->unlock_window();
 561         }
 562 }
 563
 564 void VWindowEditing::overwrite_selection()
 565 {
 566         if(vwindow->get_edl())
 567         {
 568                 mwindow->gui->lock_window("VWindowEditing::overwrite_selection");
 569                 mwindow->overwrite(vwindow->get_edl());
 570                 mwindow->gui->unlock_window();
 571         }
 572 }
 573
 574 void VWindowEditing::toggle_label()
 575 {
 576         if(vwindow->get_edl())
 577         {
 578                 EDL *edl = vwindow->get_edl();
 579                 edl->labels->toggle_label(edl->local_session->get_selectionstart(1),
 580                         edl->local_session->get_selectionend(1));
 581                 vwindow->gui->timebar->update(1);
 582         }
 583 }
 584
 585 void VWindowEditing::prev_label()
 586 {
 587         if(vwindow->get_edl())
 588         {
 589                 EDL *edl = vwindow->get_edl();
 590                 vwindow->gui->unlock_window();
 591                 vwindow->playback_engine->interrupt_playback(1);
 592                 vwindow->gui->lock_window("VWindowEditing::prev_label");
 593
 594                 Label *current = edl->labels->prev_label(
 595                         edl->local_session->get_selectionstart(1));
 596
 597
 598                 if(!current)
 599                 {
 600                         edl->local_session->set_selectionstart(0);
 601                         edl->local_session->set_selectionend(0);
 602                         vwindow->update_position(CHANGE_NONE, 0, 1, 0);
 603                         vwindow->gui->timebar->update(1);
 604                 }
 605                 else
 606                 {
 607                         edl->local_session->set_selectionstart(current->position);
 608                         edl->local_session->set_selectionend(current->position);
 609                         vwindow->update_position(CHANGE_NONE, 0, 1, 0);
 610                         vwindow->gui->timebar->update(1);
 611                 }
 612         }
 613 }
 614
 615 void VWindowEditing::next_label()
 616 {
 617         if(vwindow->get_edl())
 618         {
 619                 EDL *edl = vwindow->get_edl();
 620                 Label *current = edl->labels->next_label(
 621                         edl->local_session->get_selectionstart(1));
 622                 if(!current)
 623                 {
 624                         vwindow->gui->unlock_window();
 625                         vwindow->playback_engine->interrupt_playback(1);
 626                         vwindow->gui->lock_window("VWindowEditing::next_label 1");
 627
 628                         double position = edl->tracks->total_length();
 629                         edl->local_session->set_selectionstart(position);
 630                         edl->local_session->set_selectionend(position);
 631                         vwindow->update_position(CHANGE_NONE, 0, 1, 0);
 632                         vwindow->gui->timebar->update(1);
 633                 }
 634                 else
 635                 {
 636                         vwindow->gui->unlock_window();
 637                         vwindow->playback_engine->interrupt_playback(1);
 638                         vwindow->gui->lock_window("VWindowEditing::next_label 2");
 639
 640                         edl->local_session->set_selectionstart(current->position);
 641                         edl->local_session->set_selectionend(current->position);
 642                         vwindow->update_position(CHANGE_NONE, 0, 1, 0);
 643                         vwindow->gui->timebar->update(1);
 644                 }
 645         }
 646 }
 647
 648 double VWindowEditing::get_position()
 649 {
 650         EDL *edl = vwindow->get_edl();
 651         double position = !edl ? 0 : edl->local_session->get_selectionstart(1);
 652         return position;
 653 }
 654
 655 void VWindowEditing::set_position(double position)
 656 {
 657         EDL *edl = vwindow->get_edl();
 658         if( !edl ) return;
 659         if( get_position() != position ) {
 660                 if( position < 0 ) position = 0;
 661                 edl->local_session->set_selectionstart(position);
 662                 edl->local_session->set_selectionend(position);
 663                 vwindow->update_position(CHANGE_NONE, 0, 1);
 664         }
 665 }
 666
 667 void VWindowEditing::set_inpoint()
 668 {
 669         vwindow->set_inpoint();
 670 }
 671
 672 void VWindowEditing::set_outpoint()
 673 {
 674         vwindow->set_outpoint();
 675 }
 676
 677 void VWindowEditing::unset_inoutpoint()
 678 {
 679         vwindow->unset_inoutpoint();
 680 }
 681
 682
 683 void VWindowEditing::to_clip()
 684 {
 685         EDL *edl = vwindow->get_edl();
 686         if( !edl ) return;
 687         mwindow->to_clip(edl, _("viewer window: "));
 688 }
 689
 690 VWindowSource::VWindowSource(MWindow *mwindow, VWindowGUI *vwindow, int x, int y)
 691  : BC_PopupTextBox(vwindow,
 692         &vwindow->sources,
 693         "",
 694         x,
 695         y,
 696         200,
 697         200)
 698 {
 699         this->mwindow = mwindow;
 700         this->vwindow = vwindow;
 701 }
 702
 703 VWindowSource::~VWindowSource()
 704 {
 705 }
 706
 707 int VWindowSource::handle_event()
 708 {
 709         return 1;
 710 }
 711
 712
 713 VWindowTransport::VWindowTransport(MWindow *mwindow,
 714         VWindowGUI *gui,
 715         int x,
 716         int y)
 717  : PlayTransport(mwindow,
 718         gui,
 719         x,
 720         y)
 721 {
 722         this->gui = gui;
 723 }
 724
 725 EDL* VWindowTransport::get_edl()
 726 {
 727         return gui->vwindow->get_edl();
 728 }
 729
 730
 731 void VWindowTransport::goto_start()
 732 {
 733         gui->unlock_window();
 734         handle_transport(REWIND, 1);
 735         gui->lock_window("VWindowTransport::goto_start");
 736         gui->vwindow->goto_start();
 737 }
 738
 739 void VWindowTransport::goto_end()
 740 {
 741         gui->unlock_window();
 742         handle_transport(GOTO_END, 1);
 743         gui->lock_window("VWindowTransport::goto_end");
 744         gui->vwindow->goto_end();
 745 }
 746
 747
 748
 749
 750 VWindowCanvas::VWindowCanvas(MWindow *mwindow, VWindowGUI *gui)
 751  : Canvas(mwindow,
 752         gui,
 753         mwindow->theme->vcanvas_x,
 754         mwindow->theme->vcanvas_y,
 755         mwindow->theme->vcanvas_w,
 756         mwindow->theme->vcanvas_h,
 757         0, 0, 0)
 758 {
 759 //printf("VWindowCanvas::VWindowCanvas %d %d\n", __LINE__, mwindow->theme->vcanvas_x);
 760         this->mwindow = mwindow;
 761         this->gui = gui;
 762 }
 763
 764 void VWindowCanvas::zoom_resize_window(float percentage)
 765 {
 766         EDL *edl = gui->vwindow->get_edl();
 767         if(!edl) edl = mwindow->edl;
 768
 769         int canvas_w, canvas_h;
 770         int new_w, new_h;
 771
 772 // Get required canvas size
 773         calculate_sizes(edl->get_aspect_ratio(),
 774                 edl->session->output_w,
 775                 edl->session->output_h,
 776                 percentage,
 777                 canvas_w,
 778                 canvas_h);
 779
 780 // Estimate window size from current borders
 781         new_w = canvas_w + (gui->get_w() - mwindow->theme->vcanvas_w);
 782         new_h = canvas_h + (gui->get_h() - mwindow->theme->vcanvas_h);
 783
 784         mwindow->session->vwindow_w = new_w;
 785         mwindow->session->vwindow_h = new_h;
 786
 787         mwindow->theme->get_vwindow_sizes(gui);
 788
 789 // Estimate again from new borders
 790         new_w = canvas_w + (mwindow->session->vwindow_w - mwindow->theme->vcanvas_w);
 791         new_h = canvas_h + (mwindow->session->vwindow_h - mwindow->theme->vcanvas_h);
 792
 793
 794         gui->resize_window(new_w, new_h);
 795         gui->resize_event(new_w, new_h);
 796 }
 797
 798 void VWindowCanvas::close_source()
 799 {
 800         gui->unlock_window();
 801         gui->vwindow->playback_engine->interrupt_playback(1);
 802         gui->lock_window("VWindowCanvas::close_source");
 803         gui->vwindow->delete_source(1, 1);
 804 }
 805
 806
 807 void VWindowCanvas::draw_refresh(int flush)
 808 {
 809         EDL *edl = gui->vwindow->get_edl();
 810
 811         if(!get_canvas()->get_video_on()) get_canvas()->clear_box(0, 0, get_canvas()->get_w(), get_canvas()->get_h());
 812         if(!get_canvas()->get_video_on() && refresh_frame && edl)
 813         {
 814                 float in_x1, in_y1, in_x2, in_y2;
 815                 float out_x1, out_y1, out_x2, out_y2;
 816                 get_transfers(edl,
 817                         in_x1,
 818                         in_y1,
 819                         in_x2,
 820                         in_y2,
 821                         out_x1,
 822                         out_y1,
 823                         out_x2,
 824                         out_y2);
 825                 get_canvas()->draw_vframe(refresh_frame,
 826                                 (int)out_x1,
 827                                 (int)out_y1,
 828                                 (int)(out_x2 - out_x1),
 829                                 (int)(out_y2 - out_y1),
 830                                 (int)in_x1,
 831                                 (int)in_y1,
 832                                 (int)(in_x2 - in_x1),
 833                                 (int)(in_y2 - in_y1),
 834                                 0);
 835         }
 836
 837         if(!get_canvas()->get_video_on())
 838         {
 839                 draw_overlays();
 840                 get_canvas()->flash(flush);
 841         }
 842 }
 843
 844 void VWindowCanvas::draw_overlays()
 845 {
 846         if( gui->highlighted )
 847         {
 848                 get_canvas()->set_color(WHITE);
 849                 get_canvas()->set_inverse();
 850                 get_canvas()->draw_rectangle(0, 0, get_canvas()->get_w(), get_canvas()->get_h());
 851                 get_canvas()->draw_rectangle(1, 1, get_canvas()->get_w() - 2, get_canvas()->get_h() - 2);
 852                 get_canvas()->set_opaque();
 853         }
 854 }
 855
 856 int VWindowCanvas::get_fullscreen()
 857 {
 858         return mwindow->session->vwindow_fullscreen;
 859 }
 860
 861 void VWindowCanvas::set_fullscreen(int value)
 862 {
 863         mwindow->session->vwindow_fullscreen = value;
 864 }
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902 #if 0
 903 void VWindowGUI::update_points()
 904 {
 905         EDL *edl = vwindow->get_edl();
 906
 907 //printf("VWindowGUI::update_points 1\n");
 908         if(!edl) return;
 909
 910 //printf("VWindowGUI::update_points 2\n");
 911         long pixel = (long)((double)edl->local_session->in_point /
 912                 edl->tracks->total_length() *
 913                 (mwindow->theme->vtimebar_w -
 914                         2 *
 915                         mwindow->theme->in_point[0]->get_w())) +
 916                 mwindow->theme->in_point[0]->get_w();
 917
 918 //printf("VWindowGUI::update_points 3 %d\n", edl->local_session->in_point);
 919         if(in_point)
 920         {
 921 //printf("VWindowGUI::update_points 3.1\n");
 922                 if(edl->local_session->in_point >= 0)
 923                 {
 924 //printf("VWindowGUI::update_points 4\n");
 925                         if(edl->local_session->in_point != in_point->position ||
 926                                 in_point->pixel != pixel)
 927                         {
 928                                 in_point->pixel = pixel;
 929                                 in_point->reposition();
 930                         }
 931
 932 //printf("VWindowGUI::update_points 5\n");
 933                         in_point->position = edl->local_session->in_point;
 934
 935 //printf("VWindowGUI::update_points 6\n");
 936                         if(edl->equivalent(in_point->position, edl->local_session->get_selectionstart(1)) ||
 937                                 edl->equivalent(in_point->position, edl->local_session->get_selectionend(1)))
 938                                 in_point->update(1);
 939                         else
 940                                 in_point->update(0);
 941 //printf("VWindowGUI::update_points 7\n");
 942                 }
 943                 else
 944                 {
 945                         delete in_point;
 946                         in_point = 0;
 947                 }
 948         }
 949         else
 950         if(edl->local_session->in_point >= 0)
 951         {
 952 //printf("VWindowGUI::update_points 8 %p\n", mwindow->theme->in_point);
 953                 add_subwindow(in_point =
 954                         new VWindowInPoint(mwindow,
 955                                 0,
 956                                 this,
 957                                 pixel,
 958                                 edl->local_session->in_point));
 959 //printf("VWindowGUI::update_points 9\n");
 960         }
 961 //printf("VWindowGUI::update_points 10\n");
 962
 963         pixel = (long)((double)edl->local_session->out_point /
 964                 (edl->tracks->total_length() + 0.5) *
 965                 (mwindow->theme->vtimebar_w -
 966                         2 *
 967                         mwindow->theme->in_point[0]->get_w())) +
 968                 mwindow->theme->in_point[0]->get_w() *
 969                 2;
 970
 971         if(out_point)
 972         {
 973                 if(edl->local_session->out_point >= 0 && pixel >= 0 && pixel <= mwindow->theme->vtimebar_w)
 974                 {
 975                         if(edl->local_session->out_point != out_point->position ||
 976                                 out_point->pixel != pixel)
 977                         {
 978                                 out_point->pixel = pixel;
 979                                 out_point->reposition();
 980                         }
 981                         out_point->position = edl->local_session->out_point;
 982
 983                         if(edl->equivalent(out_point->position, edl->local_session->get_selectionstart(1)) ||
 984                                 edl->equivalent(out_point->position, edl->local_session->get_selectionend(1)))
 985                                 out_point->update(1);
 986                         else
 987                                 out_point->update(0);
 988                 }
 989                 else
 990                 {
 991                         delete out_point;
 992                         out_point = 0;
 993                 }
 994         }
 995         else
 996         if(edl->local_session->out_point >= 0 && pixel >= 0 && pixel <= mwindow->theme->vtimebar_w)
 997         {
 998                 add_subwindow(out_point =
 999                         new VWindowOutPoint(mwindow,
1000                                 0,
1001                                 this,
1002                                 pixel,
1003                                 edl->local_session->out_point));
1004         }
1005 }
1006
1007
1008 void VWindowGUI::update_labels()
1009 {
1010         EDL *edl = vwindow->get_edl();
1011         int output = 0;
1012
1013         for(Label *current = edl->labels->first;
1014                 current;
1015                 current = NEXT)
1016         {
1017                 long pixel = (long)((current->position - edl->local_session->view_start) / edl->local_session->zoom_sample);
1018
1019                 if(pixel >= 0 && pixel < mwindow->theme->vtimebar_w)
1020                 {
1021 // Create new label
1022                         if(output >= labels.total)
1023                         {
1024                                 LabelGUI *new_label;
1025                                 add_subwindow(new_label = new LabelGUI(mwindow, this, pixel, 0, current->position));
1026                                 labels.append(new_label);
1027                         }
1028                         else
1029 // Reposition old label
1030                         if(labels.values[output]->pixel != pixel)
1031                         {
1032                                 labels.values[output]->pixel = pixel;
1033                                 labels.values[output]->position = current->position;
1034                                 labels.values[output]->reposition();
1035                         }
1036
1037                         if(mwindow->edl->local_session->get_selectionstart(1) <= current->position &&
1038                                 mwindow->edl->local_session->get_selectionend(1) >= current->position)
1039                                 labels.values[output]->update(1);
1040                         else
1041                         if(labels.values[output]->get_value())
1042                                 labels.values[output]->update(0);
1043                         output++;
1044                 }
1045         }
1046
1047 // Delete excess labels
1048         while(labels.total > output)
1049         {
1050                 labels.remove_object();
1051         }
1052 }
1053
1054
1055
1056 VWindowInPoint::VWindowInPoint(MWindow *mwindow,
1057                 TimeBar *timebar,
1058                 VWindowGUI *gui,
1059                 long pixel,
1060                 double position)
1061  : InPointGUI(mwindow,
1062                 timebar,
1063                 pixel,
1064                 position)
1065 {
1066         this->gui = gui;
1067 }
1068
1069 int VWindowInPoint::handle_event()
1070 {
1071         EDL *edl = gui->vwindow->get_edl();
1072
1073         if(edl)
1074         {
1075                 double position = edl->align_to_frame(this->position, 0);
1076
1077                 edl->local_session->set_selectionstart(position);
1078                 edl->local_session->set_selectionend(position);
1079                 gui->timebar->update(1);
1080
1081 // Que the VWindow
1082                 mwindow->vwindow->update_position(CHANGE_NONE, 0, 1, 0);
1083         }
1084         return 1;
1085 }
1086
1087
1088
1089 VWindowOutPoint::VWindowOutPoint(MWindow *mwindow,
1090                 TimeBar *timebar,
1091                 VWindowGUI *gui,
1092                 long pixel,
1093                 double position)
1094  : OutPointGUI(mwindow,
1095                 timebar,
1096                 pixel,
1097                 position)
1098 {
1099         this->gui = gui;
1100 }
1101
1102 int VWindowOutPoint::handle_event()
1103 {
1104         EDL *edl = gui->vwindow->get_edl();
1105
1106         if(edl)
1107         {
1108                 double position = edl->align_to_frame(this->position, 0);
1109
1110                 edl->local_session->set_selectionstart(position);
1111                 edl->local_session->set_selectionend(position);
1112                 gui->timebar->update(1);
1113
1114 // Que the VWindow
1115                 mwindow->vwindow->update_position(CHANGE_NONE, 0, 1, 0);
1116         }
1117
1118         return 1;
1119 }
1120
1121
1122
1123 #endif
1124