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