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::unset_inoutpoint()
 644 {
 645         vwindow->unset_inoutpoint();
 646 }
 647
 648
 649 void VWindowEditing::to_clip()
 650 {
 651         EDL *edl = vwindow->get_edl();
 652         if( !edl ) return;
 653         mwindow->to_clip(edl, _("viewer window: "));
 654 }
 655
 656 VWindowSource::VWindowSource(MWindow *mwindow, VWindowGUI *vwindow, int x, int y)
 657  : BC_PopupTextBox(vwindow,
 658         &vwindow->sources,
 659         "",
 660         x,
 661         y,
 662         200,
 663         200)
 664 {
 665         this->mwindow = mwindow;
 666         this->vwindow = vwindow;
 667 }
 668
 669 VWindowSource::~VWindowSource()
 670 {
 671 }
 672
 673 int VWindowSource::handle_event()
 674 {
 675         return 1;
 676 }
 677
 678
 679 VWindowTransport::VWindowTransport(MWindow *mwindow,
 680         VWindowGUI *gui,
 681         int x,
 682         int y)
 683  : PlayTransport(mwindow,
 684         gui,
 685         x,
 686         y)
 687 {
 688         this->gui = gui;
 689 }
 690
 691 EDL* VWindowTransport::get_edl()
 692 {
 693         return gui->vwindow->get_edl();
 694 }
 695
 696
 697 void VWindowTransport::goto_start()
 698 {
 699         gui->unlock_window();
 700         handle_transport(REWIND, 1);
 701         gui->lock_window("VWindowTransport::goto_start");
 702         gui->vwindow->goto_start();
 703 }
 704
 705 void VWindowTransport::goto_end()
 706 {
 707         gui->unlock_window();
 708         handle_transport(GOTO_END, 1);
 709         gui->lock_window("VWindowTransport::goto_end");
 710         gui->vwindow->goto_end();
 711 }
 712
 713
 714
 715
 716 VWindowCanvas::VWindowCanvas(MWindow *mwindow, VWindowGUI *gui)
 717  : Canvas(mwindow,
 718         gui,
 719         mwindow->theme->vcanvas_x,
 720         mwindow->theme->vcanvas_y,
 721         mwindow->theme->vcanvas_w,
 722         mwindow->theme->vcanvas_h,
 723         0, 0, 0)
 724 {
 725 //printf("VWindowCanvas::VWindowCanvas %d %d\n", __LINE__, mwindow->theme->vcanvas_x);
 726         this->mwindow = mwindow;
 727         this->gui = gui;
 728 }
 729
 730 void VWindowCanvas::zoom_resize_window(float percentage)
 731 {
 732         EDL *edl = gui->vwindow->get_edl();
 733         if(!edl) edl = mwindow->edl;
 734
 735         int canvas_w, canvas_h;
 736         int new_w, new_h;
 737
 738 // Get required canvas size
 739         calculate_sizes(edl->get_aspect_ratio(),
 740                 edl->session->output_w,
 741                 edl->session->output_h,
 742                 percentage,
 743                 canvas_w,
 744                 canvas_h);
 745
 746 // Estimate window size from current borders
 747         new_w = canvas_w + (gui->get_w() - mwindow->theme->vcanvas_w);
 748         new_h = canvas_h + (gui->get_h() - mwindow->theme->vcanvas_h);
 749
 750         mwindow->session->vwindow_w = new_w;
 751         mwindow->session->vwindow_h = new_h;
 752
 753         mwindow->theme->get_vwindow_sizes(gui);
 754
 755 // Estimate again from new borders
 756         new_w = canvas_w + (mwindow->session->vwindow_w - mwindow->theme->vcanvas_w);
 757         new_h = canvas_h + (mwindow->session->vwindow_h - mwindow->theme->vcanvas_h);
 758
 759
 760         gui->resize_window(new_w, new_h);
 761         gui->resize_event(new_w, new_h);
 762 }
 763
 764 void VWindowCanvas::close_source()
 765 {
 766         gui->unlock_window();
 767         gui->vwindow->playback_engine->interrupt_playback(1);
 768         gui->lock_window("VWindowCanvas::close_source");
 769         gui->vwindow->delete_source(1, 1);
 770 }
 771
 772
 773 void VWindowCanvas::draw_refresh(int flush)
 774 {
 775         EDL *edl = gui->vwindow->get_edl();
 776
 777         if(!get_canvas()->get_video_on()) get_canvas()->clear_box(0, 0, get_canvas()->get_w(), get_canvas()->get_h());
 778         if(!get_canvas()->get_video_on() && refresh_frame && edl)
 779         {
 780                 float in_x1, in_y1, in_x2, in_y2;
 781                 float out_x1, out_y1, out_x2, out_y2;
 782                 get_transfers(edl,
 783                         in_x1,
 784                         in_y1,
 785                         in_x2,
 786                         in_y2,
 787                         out_x1,
 788                         out_y1,
 789                         out_x2,
 790                         out_y2);
 791                 get_canvas()->draw_vframe(refresh_frame,
 792                                 (int)out_x1,
 793                                 (int)out_y1,
 794                                 (int)(out_x2 - out_x1),
 795                                 (int)(out_y2 - out_y1),
 796                                 (int)in_x1,
 797                                 (int)in_y1,
 798                                 (int)(in_x2 - in_x1),
 799                                 (int)(in_y2 - in_y1),
 800                                 0);
 801         }
 802
 803         if(!get_canvas()->get_video_on())
 804         {
 805                 draw_overlays();
 806                 get_canvas()->flash(flush);
 807         }
 808 }
 809
 810 void VWindowCanvas::draw_overlays()
 811 {
 812         if( gui->highlighted )
 813         {
 814                 get_canvas()->set_color(WHITE);
 815                 get_canvas()->set_inverse();
 816                 get_canvas()->draw_rectangle(0, 0, get_canvas()->get_w(), get_canvas()->get_h());
 817                 get_canvas()->draw_rectangle(1, 1, get_canvas()->get_w() - 2, get_canvas()->get_h() - 2);
 818                 get_canvas()->set_opaque();
 819         }
 820 }
 821
 822 int VWindowCanvas::get_fullscreen()
 823 {
 824         return mwindow->session->vwindow_fullscreen;
 825 }
 826
 827 void VWindowCanvas::set_fullscreen(int value)
 828 {
 829         mwindow->session->vwindow_fullscreen = value;
 830 }
 831
 832
 833
 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 #if 0
 869 void VWindowGUI::update_points()
 870 {
 871         EDL *edl = vwindow->get_edl();
 872
 873 //printf("VWindowGUI::update_points 1\n");
 874         if(!edl) return;
 875
 876 //printf("VWindowGUI::update_points 2\n");
 877         long pixel = (long)((double)edl->local_session->in_point /
 878                 edl->tracks->total_length() *
 879                 (mwindow->theme->vtimebar_w -
 880                         2 *
 881                         mwindow->theme->in_point[0]->get_w())) +
 882                 mwindow->theme->in_point[0]->get_w();
 883
 884 //printf("VWindowGUI::update_points 3 %d\n", edl->local_session->in_point);
 885         if(in_point)
 886         {
 887 //printf("VWindowGUI::update_points 3.1\n");
 888                 if(edl->local_session->in_point >= 0)
 889                 {
 890 //printf("VWindowGUI::update_points 4\n");
 891                         if(edl->local_session->in_point != in_point->position ||
 892                                 in_point->pixel != pixel)
 893                         {
 894                                 in_point->pixel = pixel;
 895                                 in_point->reposition();
 896                         }
 897
 898 //printf("VWindowGUI::update_points 5\n");
 899                         in_point->position = edl->local_session->in_point;
 900
 901 //printf("VWindowGUI::update_points 6\n");
 902                         if(edl->equivalent(in_point->position, edl->local_session->get_selectionstart(1)) ||
 903                                 edl->equivalent(in_point->position, edl->local_session->get_selectionend(1)))
 904                                 in_point->update(1);
 905                         else
 906                                 in_point->update(0);
 907 //printf("VWindowGUI::update_points 7\n");
 908                 }
 909                 else
 910                 {
 911                         delete in_point;
 912                         in_point = 0;
 913                 }
 914         }
 915         else
 916         if(edl->local_session->in_point >= 0)
 917         {
 918 //printf("VWindowGUI::update_points 8 %p\n", mwindow->theme->in_point);
 919                 add_subwindow(in_point =
 920                         new VWindowInPoint(mwindow,
 921                                 0,
 922                                 this,
 923                                 pixel,
 924                                 edl->local_session->in_point));
 925 //printf("VWindowGUI::update_points 9\n");
 926         }
 927 //printf("VWindowGUI::update_points 10\n");
 928
 929         pixel = (long)((double)edl->local_session->out_point /
 930                 (edl->tracks->total_length() + 0.5) *
 931                 (mwindow->theme->vtimebar_w -
 932                         2 *
 933                         mwindow->theme->in_point[0]->get_w())) +
 934                 mwindow->theme->in_point[0]->get_w() *
 935                 2;
 936
 937         if(out_point)
 938         {
 939                 if(edl->local_session->out_point >= 0 && pixel >= 0 && pixel <= mwindow->theme->vtimebar_w)
 940                 {
 941                         if(edl->local_session->out_point != out_point->position ||
 942                                 out_point->pixel != pixel)
 943                         {
 944                                 out_point->pixel = pixel;
 945                                 out_point->reposition();
 946                         }
 947                         out_point->position = edl->local_session->out_point;
 948
 949                         if(edl->equivalent(out_point->position, edl->local_session->get_selectionstart(1)) ||
 950                                 edl->equivalent(out_point->position, edl->local_session->get_selectionend(1)))
 951                                 out_point->update(1);
 952                         else
 953                                 out_point->update(0);
 954                 }
 955                 else
 956                 {
 957                         delete out_point;
 958                         out_point = 0;
 959                 }
 960         }
 961         else
 962         if(edl->local_session->out_point >= 0 && pixel >= 0 && pixel <= mwindow->theme->vtimebar_w)
 963         {
 964                 add_subwindow(out_point =
 965                         new VWindowOutPoint(mwindow,
 966                                 0,
 967                                 this,
 968                                 pixel,
 969                                 edl->local_session->out_point));
 970         }
 971 }
 972
 973
 974 void VWindowGUI::update_labels()
 975 {
 976         EDL *edl = vwindow->get_edl();
 977         int output = 0;
 978
 979         for(Label *current = edl->labels->first;
 980                 current;
 981                 current = NEXT)
 982         {
 983                 long pixel = (long)((current->position - edl->local_session->view_start) / edl->local_session->zoom_sample);
 984
 985                 if(pixel >= 0 && pixel < mwindow->theme->vtimebar_w)
 986                 {
 987 // Create new label
 988                         if(output >= labels.total)
 989                         {
 990                                 LabelGUI *new_label;
 991                                 add_subwindow(new_label = new LabelGUI(mwindow, this, pixel, 0, current->position));
 992                                 labels.append(new_label);
 993                         }
 994                         else
 995 // Reposition old label
 996                         if(labels.values[output]->pixel != pixel)
 997                         {
 998                                 labels.values[output]->pixel = pixel;
 999                                 labels.values[output]->position = current->position;
1000                                 labels.values[output]->reposition();
1001                         }
1002
1003                         if(mwindow->edl->local_session->get_selectionstart(1) <= current->position &&
1004                                 mwindow->edl->local_session->get_selectionend(1) >= current->position)
1005                                 labels.values[output]->update(1);
1006                         else
1007                         if(labels.values[output]->get_value())
1008                                 labels.values[output]->update(0);
1009                         output++;
1010                 }
1011         }
1012
1013 // Delete excess labels
1014         while(labels.total > output)
1015         {
1016                 labels.remove_object();
1017         }
1018 }
1019
1020
1021
1022 VWindowInPoint::VWindowInPoint(MWindow *mwindow,
1023                 TimeBar *timebar,
1024                 VWindowGUI *gui,
1025                 long pixel,
1026                 double position)
1027  : InPointGUI(mwindow,
1028                 timebar,
1029                 pixel,
1030                 position)
1031 {
1032         this->gui = gui;
1033 }
1034
1035 int VWindowInPoint::handle_event()
1036 {
1037         EDL *edl = gui->vwindow->get_edl();
1038
1039         if(edl)
1040         {
1041                 double position = edl->align_to_frame(this->position, 0);
1042
1043                 edl->local_session->set_selectionstart(position);
1044                 edl->local_session->set_selectionend(position);
1045                 gui->timebar->update(1);
1046
1047 // Que the VWindow
1048                 mwindow->vwindow->update_position(CHANGE_NONE, 0, 1, 0);
1049         }
1050         return 1;
1051 }
1052
1053
1054
1055 VWindowOutPoint::VWindowOutPoint(MWindow *mwindow,
1056                 TimeBar *timebar,
1057                 VWindowGUI *gui,
1058                 long pixel,
1059                 double position)
1060  : OutPointGUI(mwindow,
1061                 timebar,
1062                 pixel,
1063                 position)
1064 {
1065         this->gui = gui;
1066 }
1067
1068 int VWindowOutPoint::handle_event()
1069 {
1070         EDL *edl = gui->vwindow->get_edl();
1071
1072         if(edl)
1073         {
1074                 double position = edl->align_to_frame(this->position, 0);
1075
1076                 edl->local_session->set_selectionstart(position);
1077                 edl->local_session->set_selectionend(position);
1078                 gui->timebar->update(1);
1079
1080 // Que the VWindow
1081                 mwindow->vwindow->update_position(CHANGE_NONE, 0, 1, 0);
1082         }
1083
1084         return 1;
1085 }
1086
1087
1088
1089 #endif
1090