cinelerra-5.1/cinelerra/canvas.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008-2017 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 "bcsignals.h"
  23 #include "canvas.h"
  24 #include "clip.h"
  25 #include "edl.h"
  26 #include "edlsession.h"
  27 #include "keys.h"
  28 #include "language.h"
  29 #include "mainsession.h"
  30 #include "mwindowgui.h"
  31 #include "mutex.h"
  32 #include "mwindow.h"
  33 #include "playback3d.h"
  34 #include "videodevice.h"
  35 #include "vframe.h"
  36
  37
  38
  39 Canvas::Canvas(MWindow *mwindow,
  40         BC_WindowBase *subwindow,
  41         int x,
  42         int y,
  43         int w,
  44         int h,
  45         int output_w,
  46         int output_h,
  47         int use_scrollbars)
  48 {
  49         reset();
  50
  51         if(w < 10) w = 10;
  52         if(h < 10) h = 10;
  53         this->mwindow = mwindow;
  54         this->subwindow = subwindow;
  55         this->x = x;
  56         this->y = y;
  57         this->w = w;
  58         this->h = h;
  59         this->output_w = output_w;
  60         this->output_h = output_h;
  61         this->use_scrollbars = use_scrollbars;
  62         this->canvas_auxwindow = 0;
  63         this->scr_w0 = subwindow->get_screen_w(0, 0);
  64         this->root_w = subwindow->get_root_w(0);
  65         this->root_h = subwindow->get_root_h(0);
  66         canvas_lock = new Mutex("Canvas::canvas_lock", 1);
  67 }
  68
  69 Canvas::~Canvas()
  70 {
  71         if(refresh_frame) delete refresh_frame;
  72         delete canvas_menu;
  73         if(yscroll) delete yscroll;
  74         if(xscroll) delete xscroll;
  75         delete canvas_subwindow;
  76         delete canvas_fullscreen;
  77         delete canvas_lock;
  78 }
  79
  80 void Canvas::reset()
  81 {
  82         use_scrollbars = 0;
  83         output_w = 0;
  84         output_h = 0;
  85         xscroll = 0;
  86         yscroll = 0;
  87         refresh_frame = 0;
  88         canvas_subwindow = 0;
  89         canvas_fullscreen = 0;
  90         is_processing = 0;
  91         cursor_inside = 0;
  92 }
  93
  94 void Canvas::lock_canvas(const char *location)
  95 {
  96         canvas_lock->lock(location);
  97 }
  98
  99 void Canvas::unlock_canvas()
 100 {
 101         canvas_lock->unlock();
 102 }
 103
 104 int Canvas::is_locked()
 105 {
 106         return canvas_lock->is_locked();
 107 }
 108
 109
 110 BC_WindowBase* Canvas::get_canvas()
 111 {
 112         if(get_fullscreen() && canvas_fullscreen)
 113                 return canvas_fullscreen;
 114         return canvas_auxwindow ? canvas_auxwindow : canvas_subwindow;
 115 }
 116
 117 void Canvas::use_auxwindow(BC_WindowBase *aux)
 118 {
 119         canvas_auxwindow = aux;
 120 }
 121
 122 void Canvas::use_cwindow()
 123 {
 124         canvas_menu->use_cwindow();
 125         fullscreen_menu->use_cwindow();
 126 }
 127
 128 void Canvas::use_rwindow()
 129 {
 130         canvas_menu->use_rwindow();
 131 }
 132
 133 void Canvas::use_vwindow()
 134 {
 135         canvas_menu->use_vwindow();
 136 }
 137
 138 // Get dimensions given a zoom
 139 void Canvas::calculate_sizes(float aspect_ratio,
 140         int output_w,
 141         int output_h,
 142         float zoom,
 143         int &w,
 144         int &h)
 145 {
 146 // Horizontal stretch
 147         if((float)output_w / output_h <= aspect_ratio)
 148         {
 149                 w = (int)((float)output_h * aspect_ratio * zoom);
 150                 h = (int)((float)output_h * zoom);
 151         }
 152         else
 153 // Vertical stretch
 154         {
 155                 h = (int)((float)output_w / aspect_ratio * zoom);
 156                 w = (int)((float)output_w * zoom);
 157         }
 158 }
 159
 160 float Canvas::get_x_offset(EDL *edl,
 161         int single_channel,
 162         float zoom_x,
 163         float conformed_w,
 164         float conformed_h)
 165 {
 166         if(use_scrollbars)
 167         {
 168                 if(xscroll)
 169                 {
 170 // If the projection is smaller than the canvas, this forces it in the center.
 171 //                      if(conformed_w < w_visible)
 172 //                              return -(float)(w_visible - conformed_w) / 2;
 173
 174                         return (float)get_xscroll();
 175                 }
 176                 else
 177                         return ((float)-get_canvas()->get_w() / zoom_x +
 178                                 edl->session->output_w) / 2;
 179         }
 180         else
 181         {
 182                 int out_w, out_h;
 183                 int canvas_w = get_canvas()->get_w();
 184                 int canvas_h = get_canvas()->get_h();
 185                 out_w = canvas_w;
 186                 out_h = canvas_h;
 187
 188                 if((float)out_w / out_h > conformed_w / conformed_h)
 189                 {
 190                         out_w = (int)(out_h * conformed_w / conformed_h + 0.5);
 191                 }
 192
 193                 if(out_w < canvas_w)
 194                         return -(canvas_w - out_w) / 2 / zoom_x;
 195         }
 196
 197         return 0;
 198 }
 199
 200 float Canvas::get_y_offset(EDL *edl,
 201         int single_channel,
 202         float zoom_y,
 203         float conformed_w,
 204         float conformed_h)
 205 {
 206         if(use_scrollbars)
 207         {
 208                 if(yscroll)
 209                 {
 210 // If the projection is smaller than the canvas, this forces it in the center.
 211 //                      if(conformed_h < h_visible)
 212 //                              return -(float)(h_visible - conformed_h) / 2;
 213
 214                         return (float)get_yscroll();
 215                 }
 216                 else
 217                         return ((float)-get_canvas()->get_h() / zoom_y +
 218                                 edl->session->output_h) / 2;
 219         }
 220         else
 221         {
 222                 int out_w, out_h;
 223                 int canvas_w = get_canvas()->get_w();
 224                 int canvas_h = get_canvas()->get_h();
 225                 out_w = canvas_w;
 226                 out_h = canvas_h;
 227
 228                 if((float)out_w / out_h <= conformed_w / conformed_h)
 229                 {
 230                         out_h = (int)((float)out_w / (conformed_w / conformed_h) + 0.5);
 231                 }
 232
 233 //printf("Canvas::get_y_offset 1 %d %d %f\n", out_h, canvas_h, -((float)canvas_h - out_h) / 2);
 234                 if(out_h < canvas_h)
 235                         return -((float)canvas_h - out_h) / 2 / zoom_y;
 236         }
 237
 238         return 0;
 239 }
 240
 241 // This may not be used anymore
 242 void Canvas::check_boundaries(EDL *edl, int &x, int &y, float &zoom)
 243 {
 244         if(x + w_visible > w_needed) x = w_needed - w_visible;
 245         if(y + h_visible > h_needed) y = h_needed - h_visible;
 246
 247         if(x < 0) x = 0;
 248         if(y < 0) y = 0;
 249 }
 250
 251 void Canvas::update_scrollbars(int flush)
 252 {
 253         if(use_scrollbars)
 254         {
 255                 if(xscroll) xscroll->update_length(w_needed, get_xscroll(), w_visible, flush);
 256                 if(yscroll) yscroll->update_length(h_needed, get_yscroll(), h_visible, flush);
 257         }
 258 }
 259
 260 void Canvas::get_zooms(EDL *edl,
 261         int single_channel,
 262         float &zoom_x,
 263         float &zoom_y,
 264         float &conformed_w,
 265         float &conformed_h)
 266 {
 267         edl->calculate_conformed_dimensions(single_channel,
 268                 conformed_w,
 269                 conformed_h);
 270
 271         if(use_scrollbars)
 272         {
 273                 zoom_x = get_zoom() *
 274                         conformed_w /
 275                         edl->session->output_w;
 276                 zoom_y = get_zoom() *
 277                         conformed_h /
 278                         edl->session->output_h;
 279         }
 280         else
 281         {
 282                 int out_w, out_h;
 283                 int canvas_w = get_canvas()->get_w();
 284                 int canvas_h = get_canvas()->get_h();
 285
 286                 out_w = canvas_w;
 287                 out_h = canvas_h;
 288
 289                 if((float)out_w / out_h > conformed_w / conformed_h)
 290                 {
 291                         out_w = (int)((float)out_h * conformed_w / conformed_h + 0.5);
 292                 }
 293                 else
 294                 {
 295                         out_h = (int)((float)out_w / (conformed_w / conformed_h) + 0.5);
 296                 }
 297
 298                 zoom_x = (float)out_w / edl->session->output_w;
 299                 zoom_y = (float)out_h / edl->session->output_h;
 300 //printf("get zooms 2 %d %d %f %f\n", canvas_w, canvas_h, conformed_w, conformed_h);
 301         }
 302 }
 303
 304 // Convert a coordinate on the canvas to a coordinate on the output
 305 void Canvas::canvas_to_output(EDL *edl, int single_channel, float &x, float &y)
 306 {
 307         float zoom_x, zoom_y, conformed_w, conformed_h;
 308         get_zooms(edl, single_channel, zoom_x, zoom_y, conformed_w, conformed_h);
 309
 310 //printf("Canvas::canvas_to_output y=%f zoom_y=%f y_offset=%f\n",
 311 //      y, zoom_y, get_y_offset(edl, single_channel, zoom_y, conformed_w, conformed_h));
 312
 313         x = (float)x / zoom_x + get_x_offset(edl, single_channel, zoom_x, conformed_w, conformed_h);
 314         y = (float)y / zoom_y + get_y_offset(edl, single_channel, zoom_y, conformed_w, conformed_h);
 315 }
 316
 317 void Canvas::output_to_canvas(EDL *edl, int single_channel, float &x, float &y)
 318 {
 319         float zoom_x, zoom_y, conformed_w, conformed_h;
 320         get_zooms(edl, single_channel, zoom_x, zoom_y, conformed_w, conformed_h);
 321
 322 //printf("Canvas::output_to_canvas x=%f zoom_x=%f x_offset=%f\n", x, zoom_x, get_x_offset(edl, single_channel, zoom_x, conformed_w));
 323
 324         x = (float)zoom_x * (x - get_x_offset(edl, single_channel, zoom_x, conformed_w, conformed_h));
 325         y = (float)zoom_y * (y - get_y_offset(edl, single_channel, zoom_y, conformed_w, conformed_h));
 326 }
 327
 328
 329
 330 void Canvas::get_transfers(EDL *edl,
 331         float &output_x1, float &output_y1, float &output_x2, float &output_y2,
 332         float &canvas_x1, float &canvas_y1, float &canvas_x2, float &canvas_y2,
 333         int canvas_w, int canvas_h)
 334 {
 335 //printf("Canvas::get_transfers %d canvas_w=%d canvas_h=%d\n",
 336 // __LINE__,  canvas_w, canvas_h);
 337 // automatic canvas size detection
 338         if(canvas_w < 0) canvas_w = get_canvas()->get_w();
 339         if(canvas_h < 0) canvas_h = get_canvas()->get_h();
 340
 341 // Canvas is zoomed to a portion of the output frame
 342         if(use_scrollbars)
 343         {
 344                 float in_x1, in_y1, in_x2, in_y2;
 345                 float out_x1, out_y1, out_x2, out_y2;
 346                 float zoom_x, zoom_y, conformed_w, conformed_h;
 347
 348                 get_zooms(edl, 0, zoom_x, zoom_y, conformed_w, conformed_h);
 349                 out_x1 = 0;
 350                 out_y1 = 0;
 351                 out_x2 = canvas_w;
 352                 out_y2 = canvas_h;
 353                 in_x1 = 0;
 354                 in_y1 = 0;
 355                 in_x2 = canvas_w;
 356                 in_y2 = canvas_h;
 357
 358                 canvas_to_output(edl, 0, in_x1, in_y1);
 359                 canvas_to_output(edl, 0, in_x2, in_y2);
 360
 361 //printf("Canvas::get_transfers 1 %.0f %.0f %.0f %.0f -> %.0f %.0f %.0f %.0f\n",
 362 //in_x1, in_y1, in_x2, in_y2, out_x1, out_y1, out_x2, out_y2);
 363
 364                 if(in_x1 < 0)
 365                 {
 366                         out_x1 += -in_x1 * zoom_x;
 367                         in_x1 = 0;
 368                 }
 369
 370                 if(in_y1 < 0)
 371                 {
 372                         out_y1 += -in_y1 * zoom_y;
 373                         in_y1 = 0;
 374                 }
 375
 376                 int output_w = get_output_w(edl);
 377                 int output_h = get_output_h(edl);
 378
 379                 if(in_x2 > output_w)
 380                 {
 381                         out_x2 -= (in_x2 - output_w) * zoom_x;
 382                         in_x2 = output_w;
 383                 }
 384
 385                 if(in_y2 > output_h)
 386                 {
 387                         out_y2 -= (in_y2 - output_h) * zoom_y;
 388                         in_y2 = output_h;
 389                 }
 390 // printf("Canvas::get_transfers 2 %.0f %.0f %.0f %.0f -> %.0f %.0f %.0f %.0f\n",
 391 //                      in_x1, in_y1, in_x2, in_y2, out_x1, out_y1, out_x2, out_y2);
 392
 393                 output_x1 = in_x1;
 394                 output_y1 = in_y1;
 395                 output_x2 = in_x2;
 396                 output_y2 = in_y2;
 397                 canvas_x1 = out_x1;
 398                 canvas_y1 = out_y1;
 399                 canvas_x2 = out_x2;
 400                 canvas_y2 = out_y2;
 401
 402 // Center on canvas
 403 //              if(!scrollbars_exist())
 404 //              {
 405 //                      out_x = canvas_w / 2 - out_w / 2;
 406 //                      out_y = canvas_h / 2 - out_h / 2;
 407 //              }
 408
 409         }
 410         else
 411 // The output frame is normalized to the canvas
 412         {
 413 // Default canvas coords fill the entire canvas
 414                 canvas_x1 = 0;
 415                 canvas_y1 = 0;
 416                 canvas_x2 = canvas_w;
 417                 canvas_y2 = canvas_h;
 418
 419                 if(edl)
 420                 {
 421 // Use EDL aspect ratio to shrink one of the canvas dimensions
 422                         float out_w = canvas_x2 - canvas_x1;
 423                         float out_h = canvas_y2 - canvas_y1;
 424                         if(out_w / out_h > edl->get_aspect_ratio())
 425                         {
 426                                 out_w = (int)(out_h * edl->get_aspect_ratio() + 0.5);
 427                                 canvas_x1 = canvas_w / 2 - out_w / 2;
 428                         }
 429                         else
 430                         {
 431                                 out_h = (int)(out_w / edl->get_aspect_ratio() + 0.5);
 432                                 canvas_y1 = canvas_h / 2 - out_h / 2;
 433 // printf("Canvas::get_transfers %d canvas_h=%d out_h=%f canvas_y1=%f\n",
 434 // __LINE__,
 435 // canvas_h,
 436 // out_h,
 437 // canvas_y1);
 438                         }
 439                         canvas_x2 = canvas_x1 + out_w;
 440                         canvas_y2 = canvas_y1 + out_h;
 441
 442 // Get output frame coords from EDL
 443                         output_x1 = 0;
 444                         output_y1 = 0;
 445                         output_x2 = get_output_w(edl);
 446                         output_y2 = get_output_h(edl);
 447                 }
 448                 else
 449 // No EDL to get aspect ratio or output frame coords from
 450                 {
 451                         output_x1 = 0;
 452                         output_y1 = 0;
 453                         output_x2 = this->output_w;
 454                         output_y2 = this->output_h;
 455                 }
 456         }
 457
 458 // Clamp to minimum value
 459         output_x1 = MAX(0, output_x1);
 460         output_y1 = MAX(0, output_y1);
 461         output_x2 = MAX(output_x1, output_x2);
 462         output_y2 = MAX(output_y1, output_y2);
 463         canvas_x1 = MAX(0, canvas_x1);
 464         canvas_y1 = MAX(0, canvas_y1);
 465         canvas_x2 = MAX(canvas_x1, canvas_x2);
 466         canvas_y2 = MAX(canvas_y1, canvas_y2);
 467 // printf("Canvas::get_transfers %d %f,%f %f,%f -> %f,%f %f,%f\n",
 468 // __LINE__,
 469 // output_x1,
 470 // output_y1,
 471 // output_x2,
 472 // output_y2,
 473 // canvas_x1,
 474 // canvas_y1,
 475 // canvas_x2,
 476 // canvas_y2);
 477 }
 478
 479 int Canvas::scrollbars_exist()
 480 {
 481         return(use_scrollbars && (xscroll || yscroll));
 482 }
 483
 484 int Canvas::get_output_w(EDL *edl)
 485 {
 486         return !edl ? 0 : edl->session->output_w;
 487 }
 488
 489 int Canvas::get_output_h(EDL *edl)
 490 {
 491         return !edl ? 0 : edl->session->output_h;
 492 }
 493
 494
 495
 496 void Canvas::get_scrollbars(EDL *edl,
 497         int &canvas_x,
 498         int &canvas_y,
 499         int &canvas_w,
 500         int &canvas_h)
 501 {
 502         int need_xscroll = 0;
 503         int need_yscroll = 0;
 504 //      int done = 0;
 505         float zoom_x, zoom_y, conformed_w, conformed_h;
 506
 507         if(edl)
 508         {
 509                 w_needed = edl->session->output_w;
 510                 h_needed = edl->session->output_h;
 511                 w_visible = w_needed;
 512                 h_visible = h_needed;
 513         }
 514 //printf("Canvas::get_scrollbars 1 %d %d\n", get_xscroll(), get_yscroll());
 515
 516         if( use_scrollbars ) {
 517                 w_needed = edl->session->output_w;
 518                 h_needed = edl->session->output_h;
 519                 get_zooms(edl, 0, zoom_x, zoom_y, conformed_w, conformed_h);
 520 //printf("Canvas::get_scrollbars 2 %d %d\n", get_xscroll(), get_yscroll());
 521
 522                 w_visible = (int)(canvas_w / zoom_x);
 523                 h_visible = (int)(canvas_h / zoom_y);
 524                 if( w_needed > w_visible ) {
 525                         need_xscroll = 1;
 526                         canvas_h -= BC_ScrollBar::get_span(SCROLL_HORIZ);
 527                 }
 528
 529                 if( h_needed > h_visible ) {
 530                         need_yscroll = 1;
 531                         canvas_w -= BC_ScrollBar::get_span(SCROLL_VERT);
 532                 }
 533 //printf("Canvas::get_scrollbars %d %d %d %d %d %d\n", canvas_w, canvas_h, w_needed, h_needed, w_visible, h_visible);
 534 //printf("Canvas::get_scrollbars 3 %d %d\n", get_xscroll(), get_yscroll());
 535
 536                 w_visible = (int)(canvas_w / zoom_x);
 537                 h_visible = (int)(canvas_h / zoom_y);
 538         }
 539
 540         if( need_xscroll ) {
 541                 if( !xscroll ) {
 542                         xscroll = new CanvasXScroll(edl, this, canvas_x, canvas_y + canvas_h,
 543                                         w_needed, get_xscroll(), w_visible, canvas_w);
 544                         subwindow->add_subwindow(xscroll);
 545                         xscroll->show_window(0);
 546                 }
 547                 else
 548                         xscroll->reposition_window(canvas_x, canvas_y + canvas_h, canvas_w);
 549
 550                 if( xscroll->get_length() != w_needed ||
 551                     xscroll->get_handlelength() != w_visible )
 552                         xscroll->update_length(w_needed, get_xscroll(), w_visible, 0);
 553         }
 554         else if( xscroll ) {
 555                 delete xscroll;  xscroll = 0;
 556         }
 557 //printf("Canvas::get_scrollbars 4 %d %d\n", get_xscroll(), get_yscroll());
 558
 559         if( need_yscroll ) {
 560                 if( !yscroll ) {
 561                         yscroll = new CanvasYScroll(edl, this, canvas_x + canvas_w, canvas_y,
 562                                         h_needed, get_yscroll(), h_visible, canvas_h);
 563                         subwindow->add_subwindow(yscroll);
 564                         yscroll->show_window(0);
 565                 }
 566                 else
 567                         yscroll->reposition_window(canvas_x + canvas_w, canvas_y, canvas_h);
 568
 569                 if( yscroll->get_length() != edl->session->output_h ||
 570                     yscroll->get_handlelength() != h_visible )
 571                         yscroll->update_length(h_needed, get_yscroll(), h_visible, 0);
 572         }
 573         else if( yscroll ) {
 574                 delete yscroll;  yscroll = 0;
 575         }
 576 //printf("Canvas::get_scrollbars 5 %d %d\n", get_xscroll(), get_yscroll());
 577 }
 578
 579 void Canvas::reposition_window(EDL *edl, int x, int y, int w, int h)
 580 {
 581         this->x = view_x = x;  this->y = view_y = y;
 582         this->w = view_w = w;  this->h = view_h = h;
 583 //printf("Canvas::reposition_window 1\n");
 584         get_scrollbars(edl, view_x, view_y, view_w, view_h);
 585 //printf("Canvas::reposition_window %d %d %d %d\n", view_x, view_y, view_w, view_h);
 586         if(canvas_subwindow)
 587         {
 588                 canvas_subwindow->reposition_window(view_x, view_y, view_w, view_h);
 589
 590 // Need to clear out the garbage in the back
 591                 if(canvas_subwindow->get_video_on())
 592                 {
 593                         canvas_subwindow->set_color(BLACK);
 594                         canvas_subwindow->draw_box(0, 0,
 595                                 get_canvas()->get_w(), get_canvas()->get_h());
 596                         canvas_subwindow->flash(0);
 597                 }
 598         }
 599
 600
 601         draw_refresh(0);
 602 }
 603
 604 void Canvas::set_cursor(int cursor)
 605 {
 606         get_canvas()->set_cursor(cursor, 0, 1);
 607 }
 608
 609 int Canvas::get_cursor_x()
 610 {
 611         return get_canvas()->get_cursor_x();
 612 }
 613
 614 int Canvas::get_cursor_y()
 615 {
 616         return get_canvas()->get_cursor_y();
 617 }
 618
 619 int Canvas::get_buttonpress()
 620 {
 621         return get_canvas()->get_buttonpress();
 622 }
 623
 624
 625 void Canvas::create_objects(EDL *edl)
 626 {
 627         view_x = x;
 628         view_y = y;
 629         view_w = w;
 630         view_h = h;
 631         get_scrollbars(edl, view_x, view_y, view_w, view_h);
 632
 633         subwindow->unlock_window();
 634         create_canvas();
 635         subwindow->lock_window("Canvas::create_objects");
 636
 637         subwindow->add_subwindow(canvas_menu = new CanvasPopup(this));
 638         canvas_menu->create_objects();
 639
 640         subwindow->add_subwindow(fullscreen_menu = new CanvasFullScreenPopup(this));
 641         fullscreen_menu->create_objects();
 642
 643 }
 644
 645 int Canvas::button_press_event()
 646 {
 647         int result = 0;
 648
 649         if(get_canvas()->get_buttonpress() == 3)
 650         {
 651                 if(get_fullscreen())
 652                         fullscreen_menu->activate_menu();
 653                 else
 654                         canvas_menu->activate_menu();
 655                 result = 1;
 656         }
 657
 658         return result;
 659 }
 660
 661 void Canvas::start_single()
 662 {
 663         is_processing = 1;
 664         status_event();
 665 }
 666
 667 void Canvas::stop_single()
 668 {
 669         is_processing = 0;
 670         status_event();
 671 }
 672
 673 void Canvas::start_video()
 674 {
 675         if(get_canvas())
 676         {
 677                 get_canvas()->start_video();
 678                 status_event();
 679         }
 680 }
 681
 682 void Canvas::stop_video()
 683 {
 684         if(get_canvas())
 685         {
 686                 get_canvas()->stop_video();
 687                 status_event();
 688         }
 689 }
 690
 691
 692 void Canvas::start_fullscreen()
 693 {
 694         set_fullscreen(1);
 695         create_canvas();
 696 }
 697
 698 void Canvas::stop_fullscreen()
 699 {
 700         set_fullscreen(0);
 701         create_canvas();
 702 }
 703
 704 void Canvas::create_canvas()
 705 {
 706         int video_on = 0;
 707         lock_canvas("Canvas::create_canvas");
 708
 709
 710         if(!get_fullscreen())
 711 // Enter windowed
 712         {
 713                 if(canvas_fullscreen)
 714                 {
 715                         video_on = canvas_fullscreen->get_video_on();
 716                         canvas_fullscreen->stop_video();
 717                         canvas_fullscreen->lock_window("Canvas::create_canvas 2");
 718                         canvas_fullscreen->hide_window();
 719                         canvas_fullscreen->unlock_window();
 720                 }
 721
 722                 if(!canvas_auxwindow && !canvas_subwindow)
 723                 {
 724                         subwindow->add_subwindow(canvas_subwindow = new CanvasOutput(this,
 725                                 view_x,
 726                                 view_y,
 727                                 view_w,
 728                                 view_h));
 729                 }
 730         }
 731         else
 732 // Enter fullscreen
 733         {
 734                 BC_WindowBase *wdw = canvas_auxwindow ?
 735                         canvas_auxwindow : canvas_subwindow;
 736                 if(wdw)
 737                 {
 738                         video_on = wdw->get_video_on();
 739                         wdw->stop_video();
 740                 }
 741
 742                 int x = subwindow->get_screen_x(0, -1);
 743                 int y = subwindow->get_screen_y(0, -1);
 744                 int w = root_w;
 745                 int h = root_h;
 746                 if( mwindow->screens == 1 && root_w > scr_w0 ) {
 747                         // Xinerama
 748                         if( subwindow->get_x() >= scr_w0 ) {
 749                                 // assumes right side is the big one
 750                                 w = root_w - scr_w0;
 751                                 h = root_h;
 752                         }
 753                         else {
 754                                 // use same aspect ratio to compute left height
 755                                 w = scr_w0;
 756                                 h = (w*root_h) / (root_w-scr_w0);
 757                         }
 758                 }
 759
 760                 if( canvas_fullscreen )
 761                 {
 762                         if( x != canvas_fullscreen->get_x() ||
 763                             y != canvas_fullscreen->get_y() ||
 764                             w != canvas_fullscreen->get_w() ||
 765                             h != canvas_fullscreen->get_h() ) {
 766                                 delete canvas_fullscreen;
 767                                 canvas_fullscreen = 0;
 768                         }
 769                 }
 770                 if(!canvas_fullscreen)
 771                 {
 772                         canvas_fullscreen = new CanvasFullScreen(this, w, h);
 773                 }
 774                 else
 775                 {
 776                         canvas_fullscreen->reposition_window(x, y);
 777                         canvas_fullscreen->show_window();
 778                 }
 779         }
 780
 781
 782         if(!video_on)
 783         {
 784                 get_canvas()->lock_window("Canvas::create_canvas 1");
 785                 draw_refresh();
 786                 get_canvas()->unlock_window();
 787         }
 788
 789         if(video_on) get_canvas()->start_video();
 790
 791         unlock_canvas();
 792 }
 793
 794
 795
 796 int Canvas::cursor_leave_event_base(BC_WindowBase *caller)
 797 {
 798         int result = 0;
 799         if(cursor_inside) result = cursor_leave_event();
 800         cursor_inside = 0;
 801         return result;
 802 }
 803
 804 int Canvas::cursor_enter_event_base(BC_WindowBase *caller)
 805 {
 806         int result = 0;
 807         if(caller->is_event_win() && caller->cursor_inside())
 808         {
 809                 cursor_inside = 1;
 810                 result = cursor_enter_event();
 811         }
 812         return result;
 813 }
 814
 815 int Canvas::button_press_event_base(BC_WindowBase *caller)
 816 {
 817         if(caller->is_event_win() && caller->cursor_inside())
 818         {
 819                 return button_press_event();
 820         }
 821         return 0;
 822 }
 823
 824 int Canvas::keypress_event(BC_WindowBase *caller)
 825 {
 826         int caller_is_canvas = (caller == get_canvas());
 827         int key = caller->get_keypress();
 828         switch( key ) {
 829         case 'f':
 830                 caller->unlock_window();
 831                 if(get_fullscreen())
 832                         stop_fullscreen();
 833                 else
 834                         start_fullscreen();
 835                 if(!caller_is_canvas) caller->lock_window("Canvas::keypress_event 1");
 836                 break;
 837         case ESC:
 838                 caller->unlock_window();
 839                 if(get_fullscreen())
 840                         stop_fullscreen();
 841                 if(!caller_is_canvas) caller->lock_window("Canvas::keypress_event 2");
 842                 break;
 843         default:
 844                 return 0;
 845         }
 846         return 1;
 847 }
 848
 849 void Canvas::update_refresh(VideoDevice *device, VFrame *output_frame)
 850 {
 851         int best_color_model = output_frame->get_color_model();
 852         int use_opengl =
 853                 device->out_config->driver == PLAYBACK_X11_GL &&
 854                 output_frame->get_opengl_state() != VFrame::RAM;
 855
 856 // OpenGL does YUV->RGB in the compositing step
 857         if( use_opengl )
 858                 best_color_model = BC_RGB888;
 859
 860         int out_w = output_frame->get_w();
 861         int out_h = output_frame->get_h();
 862         if( refresh_frame &&
 863            (refresh_frame->get_w() != out_w ||
 864             refresh_frame->get_h() != out_h ||
 865             refresh_frame->get_color_model() != best_color_model ) ) {
 866 // x11 direct render uses BC_BGR8888, use tranfer_from to remap
 867                 delete refresh_frame;  refresh_frame = 0;
 868         }
 869
 870         if( !refresh_frame ) {
 871                 refresh_frame =
 872                         new VFrame(out_w, out_h, best_color_model);
 873         }
 874
 875         if( use_opengl ) {
 876                 get_canvas()->unlock_window();
 877                 unlock_canvas();
 878
 879                 mwindow->playback_3d->copy_from(this, refresh_frame, output_frame, 0);
 880                 lock_canvas(" Canvas::output_refresh");
 881                 get_canvas()->lock_window(" Canvas::output_refresh");
 882         }
 883         else
 884                 refresh_frame->copy_from(output_frame);
 885 }
 886
 887
 888 void Canvas::clear(int flush)
 889 {
 890         if( refresh_frame )
 891                 refresh_frame->clear_frame();
 892         BC_WindowBase *wdw = get_canvas();
 893         if( !wdw ) return;
 894         wdw->set_bg_color(BLACK);
 895         wdw->clear_box(0,0, wdw->get_w(), wdw->get_h());
 896         wdw->flash(flush);
 897 }
 898
 899
 900
 901 CanvasOutput::CanvasOutput(Canvas *canvas,
 902     int x,
 903     int y,
 904     int w,
 905     int h)
 906  : BC_SubWindow(x, y, w, h, BLACK)
 907 {
 908         this->canvas = canvas;
 909 }
 910
 911 CanvasOutput::~CanvasOutput()
 912 {
 913 }
 914
 915 int CanvasOutput::cursor_leave_event()
 916 {
 917         return canvas->cursor_leave_event_base(this);
 918 }
 919
 920 int CanvasOutput::cursor_enter_event()
 921 {
 922         return canvas->cursor_enter_event_base(this);
 923 }
 924
 925 int CanvasOutput::button_press_event()
 926 {
 927         return canvas->button_press_event_base(this);
 928 }
 929
 930 int CanvasOutput::button_release_event()
 931 {
 932         return canvas->button_release_event();
 933 }
 934
 935 int CanvasOutput::cursor_motion_event()
 936 {
 937         return canvas->cursor_motion_event();
 938 }
 939
 940 int CanvasOutput::keypress_event()
 941 {
 942         return canvas->keypress_event(this);
 943 }
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957 CanvasFullScreen::CanvasFullScreen(Canvas *canvas,
 958     int w,
 959     int h)
 960  : BC_FullScreen(canvas->subwindow,
 961         w,
 962         h,
 963         BLACK,
 964         0,
 965         0,
 966         0)
 967 {
 968         this->canvas = canvas;
 969 }
 970
 971 CanvasFullScreen::~CanvasFullScreen()
 972 {
 973 }
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987 CanvasXScroll::CanvasXScroll(EDL *edl,
 988         Canvas *canvas,
 989     int x,
 990     int y,
 991         int length,
 992         int position,
 993         int handle_length,
 994     int pixels)
 995  : BC_ScrollBar(x,
 996                 y,
 997                 SCROLL_HORIZ,
 998                 pixels,
 999                 length,
1000                 position,
1001                 handle_length)
1002 {
1003         this->canvas = canvas;
1004 }
1005
1006 CanvasXScroll::~CanvasXScroll()
1007 {
1008 }
1009
1010 int CanvasXScroll::handle_event()
1011 {
1012 //printf("CanvasXScroll::handle_event %d %d %d\n", get_length(), get_value(), get_handlelength());
1013         canvas->update_zoom(get_value(), canvas->get_yscroll(), canvas->get_zoom());
1014         canvas->draw_refresh();
1015         return 1;
1016 }
1017
1018
1019
1020
1021
1022
1023 CanvasYScroll::CanvasYScroll(EDL *edl,
1024         Canvas *canvas,
1025     int x,
1026     int y,
1027         int length,
1028         int position,
1029         int handle_length,
1030     int pixels)
1031  : BC_ScrollBar(x,
1032                 y,
1033                 SCROLL_VERT,
1034                 pixels,
1035                 length,
1036                 position,
1037                 handle_length)
1038 {
1039         this->canvas = canvas;
1040 }
1041
1042 CanvasYScroll::~CanvasYScroll()
1043 {
1044 }
1045
1046 int CanvasYScroll::handle_event()
1047 {
1048 //printf("CanvasYScroll::handle_event %d %d\n", get_value(), get_length());
1049         canvas->update_zoom(canvas->get_xscroll(), get_value(), canvas->get_zoom());
1050         canvas->draw_refresh();
1051         return 1;
1052 }
1053
1054
1055
1056
1057
1058
1059 CanvasFullScreenPopup::CanvasFullScreenPopup(Canvas *canvas)
1060  : BC_PopupMenu(0, 0, 0, "", 0)
1061 {
1062         this->canvas = canvas;
1063 }
1064
1065
1066 void CanvasFullScreenPopup::create_objects()
1067 {
1068         add_item(new CanvasSubWindowItem(canvas));
1069 }
1070
1071 void CanvasFullScreenPopup::use_cwindow()
1072 {
1073         add_item(new CanvasPopupAuto(canvas));
1074 }
1075
1076 CanvasSubWindowItem::CanvasSubWindowItem(Canvas *canvas)
1077  : BC_MenuItem(_("Windowed"), "f", 'f')
1078 {
1079         this->canvas = canvas;
1080 }
1081
1082 int CanvasSubWindowItem::handle_event()
1083 {
1084 // It isn't a problem to delete the canvas from in here because the event
1085 // dispatcher is the canvas subwindow.
1086         canvas->subwindow->unlock_window();
1087         canvas->stop_fullscreen();
1088         canvas->subwindow->lock_window("CanvasSubWindowItem::handle_event");
1089         return 1;
1090 }
1091
1092
1093
1094
1095
1096
1097
1098
1099 CanvasPopup::CanvasPopup(Canvas *canvas)
1100  : BC_PopupMenu(0, 0, 0, "", 0)
1101 {
1102         this->canvas = canvas;
1103 }
1104
1105 CanvasPopup::~CanvasPopup()
1106 {
1107 }
1108
1109 void CanvasPopup::create_objects()
1110 {
1111         add_item(new BC_MenuItem("-"));
1112         add_item(new CanvasFullScreenItem(canvas));
1113         add_item(new CanvasPopupSize(canvas, _("Zoom 25%"), 0.25));
1114         add_item(new CanvasPopupSize(canvas, _("Zoom 33%"), 0.33));
1115         add_item(new CanvasPopupSize(canvas, _("Zoom 50%"), 0.5));
1116         add_item(new CanvasPopupSize(canvas, _("Zoom 75%"), 0.75));
1117         add_item(new CanvasPopupSize(canvas, _("Zoom 100%"), 1.0));
1118         add_item(new CanvasPopupSize(canvas, _("Zoom 150%"), 1.5));
1119         add_item(new CanvasPopupSize(canvas, _("Zoom 200%"), 2.0));
1120         add_item(new CanvasPopupSize(canvas, _("Zoom 300%"), 3.0));
1121         add_item(new CanvasPopupSize(canvas, _("Zoom 400%"), 4.0));
1122 }
1123
1124 void CanvasPopup::use_cwindow()
1125 {
1126         add_item(new CanvasPopupAuto(canvas));
1127         add_item(new CanvasPopupResetCamera(canvas));
1128         add_item(new CanvasPopupResetProjector(canvas));
1129         add_item(toggle_controls = new CanvasToggleControls(canvas));
1130 }
1131
1132 void CanvasPopup::use_rwindow()
1133 {
1134         add_item(new CanvasPopupResetTranslation(canvas));
1135 }
1136
1137 void CanvasPopup::use_vwindow()
1138 {
1139         add_item(new CanvasPopupRemoveSource(canvas));
1140 }
1141
1142
1143 CanvasPopupAuto::CanvasPopupAuto(Canvas *canvas)
1144  : BC_MenuItem(_("Zoom Auto"))
1145 {
1146         this->canvas = canvas;
1147 }
1148
1149 int CanvasPopupAuto::handle_event()
1150 {
1151         canvas->zoom_auto();
1152         return 1;
1153 }
1154
1155
1156 CanvasPopupSize::CanvasPopupSize(Canvas *canvas, char *text, float percentage)
1157  : BC_MenuItem(text)
1158 {
1159         this->canvas = canvas;
1160         this->percentage = percentage;
1161 }
1162 CanvasPopupSize::~CanvasPopupSize()
1163 {
1164 }
1165 int CanvasPopupSize::handle_event()
1166 {
1167         canvas->zoom_resize_window(percentage);
1168         return 1;
1169 }
1170
1171
1172
1173 CanvasPopupResetCamera::CanvasPopupResetCamera(Canvas *canvas)
1174  : BC_MenuItem(_("Reset camera"), "F11", KEY_F11)
1175 {
1176         this->canvas = canvas;
1177 }
1178 int CanvasPopupResetCamera::handle_event()
1179 {
1180         canvas->reset_camera();
1181         return 1;
1182 }
1183
1184
1185
1186 CanvasPopupResetProjector::CanvasPopupResetProjector(Canvas *canvas)
1187  : BC_MenuItem(_("Reset projector"), "F12", KEY_F12)
1188 {
1189         this->canvas = canvas;
1190 }
1191 int CanvasPopupResetProjector::handle_event()
1192 {
1193         canvas->reset_projector();
1194         return 1;
1195 }
1196
1197
1198
1199 CanvasPopupResetTranslation::CanvasPopupResetTranslation(Canvas *canvas)
1200  : BC_MenuItem(_("Reset translation"))
1201 {
1202         this->canvas = canvas;
1203 }
1204 int CanvasPopupResetTranslation::handle_event()
1205 {
1206         canvas->reset_translation();
1207         return 1;
1208 }
1209
1210
1211
1212 CanvasToggleControls::CanvasToggleControls(Canvas *canvas)
1213  : BC_MenuItem(calculate_text(canvas->get_cwindow_controls()))
1214 {
1215         this->canvas = canvas;
1216 }
1217 int CanvasToggleControls::handle_event()
1218 {
1219         canvas->toggle_controls();
1220         set_text(calculate_text(canvas->get_cwindow_controls()));
1221         return 1;
1222 }
1223
1224 char* CanvasToggleControls::calculate_text(int cwindow_controls)
1225 {
1226         if(!cwindow_controls)
1227                 return _("Show controls");
1228         else
1229                 return _("Hide controls");
1230 }
1231
1232
1233
1234
1235
1236
1237
1238 CanvasFullScreenItem::CanvasFullScreenItem(Canvas *canvas)
1239  : BC_MenuItem(_("Fullscreen"), "f", 'f')
1240 {
1241         this->canvas = canvas;
1242 }
1243 int CanvasFullScreenItem::handle_event()
1244 {
1245         canvas->subwindow->unlock_window();
1246         canvas->start_fullscreen();
1247         canvas->subwindow->lock_window("CanvasFullScreenItem::handle_event");
1248         return 1;
1249 }
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259 CanvasPopupRemoveSource::CanvasPopupRemoveSource(Canvas *canvas)
1260  : BC_MenuItem(_("Close source"))
1261 {
1262         this->canvas = canvas;
1263 }
1264 int CanvasPopupRemoveSource::handle_event()
1265 {
1266         canvas->close_source();
1267         return 1;
1268 }
1269
1270