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
 352         return result;
 353 }
 354
 355 int VWindowGUI::button_press_event()
 356 {
 357         if(canvas->get_canvas())
 358                 return canvas->button_press_event_base(canvas->get_canvas());
 359         return 0;
 360 }
 361
 362 int VWindowGUI::cursor_leave_event()
 363 {
 364         if(canvas->get_canvas())
 365                 return canvas->cursor_leave_event_base(canvas->get_canvas());
 366         return 0;
 367 }
 368
 369 int VWindowGUI::cursor_enter_event()
 370 {
 371         if(canvas->get_canvas())
 372                 return canvas->cursor_enter_event_base(canvas->get_canvas());
 373         return 0;
 374 }
 375
 376 int VWindowGUI::button_release_event()
 377 {
 378         if(canvas->get_canvas())
 379                 return canvas->button_release_event();
 380         return 0;
 381 }
 382
 383 int VWindowGUI::cursor_motion_event()
 384 {
 385         if(canvas->get_canvas())
 386         {
 387                 canvas->get_canvas()->unhide_cursor();
 388                 return canvas->cursor_motion_event();
 389         }
 390         return 0;
 391 }
 392
 393
 394 void VWindowGUI::drag_motion()
 395 {
 396 // Window hidden
 397         if(get_hidden()) return;
 398         if(mwindow->session->current_operation != DRAG_ASSET) return;
 399         int need_highlight = cursor_above() && get_cursor_over_window() ? 1 : 0;
 400         if( highlighted == need_highlight ) return;
 401         highlighted = need_highlight;
 402         canvas->draw_refresh();
 403 }
 404
 405 int VWindowGUI::drag_stop()
 406 {
 407         if(get_hidden()) return 0;
 408
 409         if(highlighted &&
 410                 mwindow->session->current_operation == DRAG_ASSET)
 411         {
 412                 highlighted = 0;
 413                 canvas->draw_refresh();
 414
 415                 Indexable *indexable = mwindow->session->drag_assets->size() ?
 416                         mwindow->session->drag_assets->get(0) :
 417                         0;
 418                 EDL *edl = mwindow->session->drag_clips->size() ?
 419                         mwindow->session->drag_clips->get(0) :
 420                         0;
 421
 422                 if(indexable)
 423                         vwindow->change_source(indexable);
 424                 else
 425                 if(edl)
 426                         vwindow->change_source(edl);
 427                 return 1;
 428         }
 429
 430         return 0;
 431 }
 432
 433
 434 void VWindowGUI::update_meters()
 435 {
 436         if(mwindow->edl->session->vwindow_meter != meters->visible)
 437         {
 438                 meters->set_meters(meters->meter_count,
 439                         mwindow->edl->session->vwindow_meter);
 440                 mwindow->theme->get_vwindow_sizes(this);
 441                 resize_event(get_w(), get_h());
 442         }
 443 }
 444
 445
 446
 447 VWindowMeters::VWindowMeters(MWindow *mwindow,
 448         VWindowGUI *gui,
 449         int x,
 450         int y,
 451         int h)
 452  : MeterPanel(mwindow,
 453                 gui,
 454                 x,
 455                 y,
 456                 -1,
 457                 h,
 458                 mwindow->edl->session->audio_channels,
 459                 mwindow->edl->session->vwindow_meter,
 460                 0,
 461                 0)
 462 {
 463         this->mwindow = mwindow;
 464         this->gui = gui;
 465 }
 466
 467 VWindowMeters::~VWindowMeters()
 468 {
 469 }
 470
 471 int VWindowMeters::change_status_event(int new_status)
 472 {
 473         mwindow->edl->session->vwindow_meter = new_status;
 474         gui->update_meters();
 475         return 1;
 476 }
 477
 478
 479
 480
 481
 482
 483
 484 VWindowEditing::VWindowEditing(MWindow *mwindow, VWindow *vwindow)
 485  : EditPanel(mwindow,
 486                 vwindow->gui,
 487                 mwindow->theme->vedit_x,
 488                 mwindow->theme->vedit_y,
 489                 EDITING_ARROW,
 490                 0,
 491                 0,
 492                 1,
 493                 1,
 494                 0,
 495                 0,
 496                 1,
 497                 0,
 498                 0,
 499                 0,
 500                 0, // locklabels
 501                 1,
 502                 1,
 503                 1,
 504                 0,
 505                 0,
 506                 0)
 507 {
 508         this->mwindow = mwindow;
 509         this->vwindow = vwindow;
 510 }
 511
 512 VWindowEditing::~VWindowEditing()
 513 {
 514 }
 515
 516 void VWindowEditing::copy_selection()
 517 {
 518         vwindow->copy();
 519 }
 520
 521 void VWindowEditing::splice_selection()
 522 {
 523         if(vwindow->get_edl())
 524         {
 525                 mwindow->gui->lock_window("VWindowEditing::splice_selection");
 526                 mwindow->splice(vwindow->get_edl());
 527                 mwindow->gui->unlock_window();
 528         }
 529 }
 530
 531 void VWindowEditing::overwrite_selection()
 532 {
 533         if(vwindow->get_edl())
 534         {
 535                 mwindow->gui->lock_window("VWindowEditing::overwrite_selection");
 536                 mwindow->overwrite(vwindow->get_edl());
 537                 mwindow->gui->unlock_window();
 538         }
 539 }
 540
 541 void VWindowEditing::toggle_label()
 542 {
 543         if(vwindow->get_edl())
 544         {
 545                 EDL *edl = vwindow->get_edl();
 546                 edl->labels->toggle_label(edl->local_session->get_selectionstart(1),
 547                         edl->local_session->get_selectionend(1));
 548                 vwindow->gui->timebar->update(1);
 549         }
 550 }
 551
 552 void VWindowEditing::prev_label()
 553 {
 554         if(vwindow->get_edl())
 555         {
 556                 EDL *edl = vwindow->get_edl();
 557                 vwindow->gui->unlock_window();
 558                 vwindow->playback_engine->interrupt_playback(1);
 559                 vwindow->gui->lock_window("VWindowEditing::prev_label");
 560
 561                 Label *current = edl->labels->prev_label(
 562                         edl->local_session->get_selectionstart(1));
 563
 564
 565                 if(!current)
 566                 {
 567                         edl->local_session->set_selectionstart(0);
 568                         edl->local_session->set_selectionend(0);
 569                         vwindow->update_position(CHANGE_NONE, 0, 1, 0);
 570                         vwindow->gui->timebar->update(1);
 571                 }
 572                 else
 573                 {
 574                         edl->local_session->set_selectionstart(current->position);
 575                         edl->local_session->set_selectionend(current->position);
 576                         vwindow->update_position(CHANGE_NONE, 0, 1, 0);
 577                         vwindow->gui->timebar->update(1);
 578                 }
 579         }
 580 }
 581
 582 void VWindowEditing::next_label()
 583 {
 584         if(vwindow->get_edl())
 585         {
 586                 EDL *edl = vwindow->get_edl();
 587                 Label *current = edl->labels->next_label(
 588                         edl->local_session->get_selectionstart(1));
 589                 if(!current)
 590                 {
 591                         vwindow->gui->unlock_window();
 592                         vwindow->playback_engine->interrupt_playback(1);
 593                         vwindow->gui->lock_window("VWindowEditing::next_label 1");
 594
 595                         double position = edl->tracks->total_length();
 596                         edl->local_session->set_selectionstart(position);
 597                         edl->local_session->set_selectionend(position);
 598                         vwindow->update_position(CHANGE_NONE, 0, 1, 0);
 599                         vwindow->gui->timebar->update(1);
 600                 }
 601                 else
 602                 {
 603                         vwindow->gui->unlock_window();
 604                         vwindow->playback_engine->interrupt_playback(1);
 605                         vwindow->gui->lock_window("VWindowEditing::next_label 2");
 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 double VWindowEditing::get_position()
 616 {
 617         EDL *edl = vwindow->get_edl();
 618         double position = !edl ? 0 : edl->local_session->get_selectionstart(1);
 619         return position;
 620 }
 621
 622 void VWindowEditing::set_position(double position)
 623 {
 624         EDL *edl = vwindow->get_edl();
 625         if( !edl ) return;
 626         if( get_position() != position ) {
 627                 if( position < 0 ) position = 0;
 628                 edl->local_session->set_selectionstart(position);
 629                 edl->local_session->set_selectionend(position);
 630                 vwindow->update_position(CHANGE_NONE, 0, 1);
 631         }
 632 }
 633
 634 void VWindowEditing::set_inpoint()
 635 {
 636         vwindow->set_inpoint();
 637 }
 638
 639 void VWindowEditing::set_outpoint()
 640 {
 641         vwindow->set_outpoint();
 642 }
 643
 644 void VWindowEditing::unset_inoutpoint()
 645 {
 646         vwindow->unset_inoutpoint();
 647 }
 648
 649
 650 void VWindowEditing::to_clip()
 651 {
 652         EDL *edl = vwindow->get_edl();
 653         if( !edl ) return;
 654         mwindow->to_clip(edl, _("viewer window: "));
 655 }
 656
 657 VWindowSource::VWindowSource(MWindow *mwindow, VWindowGUI *vwindow, int x, int y)
 658  : BC_PopupTextBox(vwindow,
 659         &vwindow->sources,
 660         "",
 661         x,
 662         y,
 663         200,
 664         200)
 665 {
 666         this->mwindow = mwindow;
 667         this->vwindow = vwindow;
 668 }
 669
 670 VWindowSource::~VWindowSource()
 671 {
 672 }
 673
 674 int VWindowSource::handle_event()
 675 {
 676         return 1;
 677 }
 678
 679
 680 VWindowTransport::VWindowTransport(MWindow *mwindow,
 681         VWindowGUI *gui,
 682         int x,
 683         int y)
 684  : PlayTransport(mwindow,
 685         gui,
 686         x,
 687         y)
 688 {
 689         this->gui = gui;
 690 }
 691
 692 EDL* VWindowTransport::get_edl()
 693 {
 694         return gui->vwindow->get_edl();
 695 }
 696
 697
 698 void VWindowTransport::goto_start()
 699 {
 700         gui->unlock_window();
 701         handle_transport(REWIND, 1);
 702         gui->lock_window("VWindowTransport::goto_start");
 703         gui->vwindow->goto_start();
 704 }
 705
 706 void VWindowTransport::goto_end()
 707 {
 708         gui->unlock_window();
 709         handle_transport(GOTO_END, 1);
 710         gui->lock_window("VWindowTransport::goto_end");
 711         gui->vwindow->goto_end();
 712 }
 713
 714
 715
 716
 717 VWindowCanvas::VWindowCanvas(MWindow *mwindow, VWindowGUI *gui)
 718  : Canvas(mwindow,
 719         gui,
 720         mwindow->theme->vcanvas_x,
 721         mwindow->theme->vcanvas_y,
 722         mwindow->theme->vcanvas_w,
 723         mwindow->theme->vcanvas_h,
 724         0, 0, 0)
 725 {
 726 //printf("VWindowCanvas::VWindowCanvas %d %d\n", __LINE__, mwindow->theme->vcanvas_x);
 727         this->mwindow = mwindow;
 728         this->gui = gui;
 729 }
 730
 731 void VWindowCanvas::zoom_resize_window(float percentage)
 732 {
 733         EDL *edl = gui->vwindow->get_edl();
 734         if(!edl) edl = mwindow->edl;
 735
 736         int canvas_w, canvas_h;
 737         int new_w, new_h;
 738
 739 // Get required canvas size
 740         calculate_sizes(edl->get_aspect_ratio(),
 741                 edl->session->output_w,
 742                 edl->session->output_h,
 743                 percentage,
 744                 canvas_w,
 745                 canvas_h);
 746
 747 // Estimate window size from current borders
 748         new_w = canvas_w + (gui->get_w() - mwindow->theme->vcanvas_w);
 749         new_h = canvas_h + (gui->get_h() - mwindow->theme->vcanvas_h);
 750
 751         mwindow->session->vwindow_w = new_w;
 752         mwindow->session->vwindow_h = new_h;
 753
 754         mwindow->theme->get_vwindow_sizes(gui);
 755
 756 // Estimate again from new borders
 757         new_w = canvas_w + (mwindow->session->vwindow_w - mwindow->theme->vcanvas_w);
 758         new_h = canvas_h + (mwindow->session->vwindow_h - mwindow->theme->vcanvas_h);
 759
 760
 761         gui->resize_window(new_w, new_h);
 762         gui->resize_event(new_w, new_h);
 763 }
 764
 765 void VWindowCanvas::close_source()
 766 {
 767         gui->unlock_window();
 768         gui->vwindow->playback_engine->interrupt_playback(1);
 769         gui->lock_window("VWindowCanvas::close_source");
 770         gui->vwindow->delete_source(1, 1);
 771 }
 772
 773
 774 void VWindowCanvas::draw_refresh(int flush)
 775 {
 776         EDL *edl = gui->vwindow->get_edl();
 777
 778         if(!get_canvas()->get_video_on()) get_canvas()->clear_box(0, 0, get_canvas()->get_w(), get_canvas()->get_h());
 779         if(!get_canvas()->get_video_on() && refresh_frame && edl)
 780         {
 781                 float in_x1, in_y1, in_x2, in_y2;
 782                 float out_x1, out_y1, out_x2, out_y2;
 783                 get_transfers(edl,
 784                         in_x1,
 785                         in_y1,
 786                         in_x2,
 787                         in_y2,
 788                         out_x1,
 789                         out_y1,
 790                         out_x2,
 791                         out_y2);
 792                 get_canvas()->draw_vframe(refresh_frame,
 793                                 (int)out_x1,
 794                                 (int)out_y1,
 795                                 (int)(out_x2 - out_x1),
 796                                 (int)(out_y2 - out_y1),
 797                                 (int)in_x1,
 798                                 (int)in_y1,
 799                                 (int)(in_x2 - in_x1),
 800                                 (int)(in_y2 - in_y1),
 801                                 0);
 802         }
 803
 804         if(!get_canvas()->get_video_on())
 805         {
 806                 draw_overlays();
 807                 get_canvas()->flash(flush);
 808         }
 809 }
 810
 811 void VWindowCanvas::draw_overlays()
 812 {
 813         if( gui->highlighted )
 814         {
 815                 get_canvas()->set_color(WHITE);
 816                 get_canvas()->set_inverse();
 817                 get_canvas()->draw_rectangle(0, 0, get_canvas()->get_w(), get_canvas()->get_h());
 818                 get_canvas()->draw_rectangle(1, 1, get_canvas()->get_w() - 2, get_canvas()->get_h() - 2);
 819                 get_canvas()->set_opaque();
 820         }
 821 }
 822
 823 int VWindowCanvas::get_fullscreen()
 824 {
 825         return mwindow->session->vwindow_fullscreen;
 826 }
 827
 828 void VWindowCanvas::set_fullscreen(int value)
 829 {
 830         mwindow->session->vwindow_fullscreen = value;
 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
 869 #if 0
 870 void VWindowGUI::update_points()
 871 {
 872         EDL *edl = vwindow->get_edl();
 873
 874 //printf("VWindowGUI::update_points 1\n");
 875         if(!edl) return;
 876
 877 //printf("VWindowGUI::update_points 2\n");
 878         long pixel = (long)((double)edl->local_session->in_point /
 879                 edl->tracks->total_length() *
 880                 (mwindow->theme->vtimebar_w -
 881                         2 *
 882                         mwindow->theme->in_point[0]->get_w())) +
 883                 mwindow->theme->in_point[0]->get_w();
 884
 885 //printf("VWindowGUI::update_points 3 %d\n", edl->local_session->in_point);
 886         if(in_point)
 887         {
 888 //printf("VWindowGUI::update_points 3.1\n");
 889                 if(edl->local_session->in_point >= 0)
 890                 {
 891 //printf("VWindowGUI::update_points 4\n");
 892                         if(edl->local_session->in_point != in_point->position ||
 893                                 in_point->pixel != pixel)
 894                         {
 895                                 in_point->pixel = pixel;
 896                                 in_point->reposition();
 897                         }
 898
 899 //printf("VWindowGUI::update_points 5\n");
 900                         in_point->position = edl->local_session->in_point;
 901
 902 //printf("VWindowGUI::update_points 6\n");
 903                         if(edl->equivalent(in_point->position, edl->local_session->get_selectionstart(1)) ||
 904                                 edl->equivalent(in_point->position, edl->local_session->get_selectionend(1)))
 905                                 in_point->update(1);
 906                         else
 907                                 in_point->update(0);
 908 //printf("VWindowGUI::update_points 7\n");
 909                 }
 910                 else
 911                 {
 912                         delete in_point;
 913                         in_point = 0;
 914                 }
 915         }
 916         else
 917         if(edl->local_session->in_point >= 0)
 918         {
 919 //printf("VWindowGUI::update_points 8 %p\n", mwindow->theme->in_point);
 920                 add_subwindow(in_point =
 921                         new VWindowInPoint(mwindow,
 922                                 0,
 923                                 this,
 924                                 pixel,
 925                                 edl->local_session->in_point));
 926 //printf("VWindowGUI::update_points 9\n");
 927         }
 928 //printf("VWindowGUI::update_points 10\n");
 929
 930         pixel = (long)((double)edl->local_session->out_point /
 931                 (edl->tracks->total_length() + 0.5) *
 932                 (mwindow->theme->vtimebar_w -
 933                         2 *
 934                         mwindow->theme->in_point[0]->get_w())) +
 935                 mwindow->theme->in_point[0]->get_w() *
 936                 2;
 937
 938         if(out_point)
 939         {
 940                 if(edl->local_session->out_point >= 0 && pixel >= 0 && pixel <= mwindow->theme->vtimebar_w)
 941                 {
 942                         if(edl->local_session->out_point != out_point->position ||
 943                                 out_point->pixel != pixel)
 944                         {
 945                                 out_point->pixel = pixel;
 946                                 out_point->reposition();
 947                         }
 948                         out_point->position = edl->local_session->out_point;
 949
 950                         if(edl->equivalent(out_point->position, edl->local_session->get_selectionstart(1)) ||
 951                                 edl->equivalent(out_point->position, edl->local_session->get_selectionend(1)))
 952                                 out_point->update(1);
 953                         else
 954                                 out_point->update(0);
 955                 }
 956                 else
 957                 {
 958                         delete out_point;
 959                         out_point = 0;
 960                 }
 961         }
 962         else
 963         if(edl->local_session->out_point >= 0 && pixel >= 0 && pixel <= mwindow->theme->vtimebar_w)
 964         {
 965                 add_subwindow(out_point =
 966                         new VWindowOutPoint(mwindow,
 967                                 0,
 968                                 this,
 969                                 pixel,
 970                                 edl->local_session->out_point));
 971         }
 972 }
 973
 974
 975 void VWindowGUI::update_labels()
 976 {
 977         EDL *edl = vwindow->get_edl();
 978         int output = 0;
 979
 980         for(Label *current = edl->labels->first;
 981                 current;
 982                 current = NEXT)
 983         {
 984                 long pixel = (long)((current->position - edl->local_session->view_start) / edl->local_session->zoom_sample);
 985
 986                 if(pixel >= 0 && pixel < mwindow->theme->vtimebar_w)
 987                 {
 988 // Create new label
 989                         if(output >= labels.total)
 990                         {
 991                                 LabelGUI *new_label;
 992                                 add_subwindow(new_label = new LabelGUI(mwindow, this, pixel, 0, current->position));
 993                                 labels.append(new_label);
 994                         }
 995                         else
 996 // Reposition old label
 997                         if(labels.values[output]->pixel != pixel)
 998                         {
 999                                 labels.values[output]->pixel = pixel;
1000                                 labels.values[output]->position = current->position;
1001                                 labels.values[output]->reposition();
1002                         }
1003
1004                         if(mwindow->edl->local_session->get_selectionstart(1) <= current->position &&
1005                                 mwindow->edl->local_session->get_selectionend(1) >= current->position)
1006                                 labels.values[output]->update(1);
1007                         else
1008                         if(labels.values[output]->get_value())
1009                                 labels.values[output]->update(0);
1010                         output++;
1011                 }
1012         }
1013
1014 // Delete excess labels
1015         while(labels.total > output)
1016         {
1017                 labels.remove_object();
1018         }
1019 }
1020
1021
1022
1023 VWindowInPoint::VWindowInPoint(MWindow *mwindow,
1024                 TimeBar *timebar,
1025                 VWindowGUI *gui,
1026                 long pixel,
1027                 double position)
1028  : InPointGUI(mwindow,
1029                 timebar,
1030                 pixel,
1031                 position)
1032 {
1033         this->gui = gui;
1034 }
1035
1036 int VWindowInPoint::handle_event()
1037 {
1038         EDL *edl = gui->vwindow->get_edl();
1039
1040         if(edl)
1041         {
1042                 double position = edl->align_to_frame(this->position, 0);
1043
1044                 edl->local_session->set_selectionstart(position);
1045                 edl->local_session->set_selectionend(position);
1046                 gui->timebar->update(1);
1047
1048 // Que the VWindow
1049                 mwindow->vwindow->update_position(CHANGE_NONE, 0, 1, 0);
1050         }
1051         return 1;
1052 }
1053
1054
1055
1056 VWindowOutPoint::VWindowOutPoint(MWindow *mwindow,
1057                 TimeBar *timebar,
1058                 VWindowGUI *gui,
1059                 long pixel,
1060                 double position)
1061  : OutPointGUI(mwindow,
1062                 timebar,
1063                 pixel,
1064                 position)
1065 {
1066         this->gui = gui;
1067 }
1068
1069 int VWindowOutPoint::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
1085         return 1;
1086 }
1087
1088
1089
1090 #endif
1091