cinelerra-5.1/cinelerra/cwindowtool.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008-2014 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 <stdio.h>
  23 #include <stdint.h>
  24
  25 #include "automation.h"
  26 #include "cicolors.h"
  27 #include "clip.h"
  28 #include "condition.h"
  29 #include "cpanel.h"
  30 #include "cplayback.h"
  31 #include "cwindow.h"
  32 #include "cwindowgui.h"
  33 #include "cwindowtool.h"
  34 #include "edl.h"
  35 #include "edlsession.h"
  36 #include "floatauto.h"
  37 #include "floatautos.h"
  38 #include "keys.h"
  39 #include "language.h"
  40 #include "localsession.h"
  41 #include "mainsession.h"
  42 #include "mainundo.h"
  43 #include "maskauto.h"
  44 #include "maskautos.h"
  45 #include "mutex.h"
  46 #include "mwindow.h"
  47 #include "mwindowgui.h"
  48 #include "theme.h"
  49 #include "track.h"
  50 #include "trackcanvas.h"
  51 #include "transportque.h"
  52
  53
  54 CWindowTool::CWindowTool(MWindow *mwindow, CWindowGUI *gui)
  55  : Thread(1, 0, 0)
  56 {
  57         this->mwindow = mwindow;
  58         this->gui = gui;
  59         tool_gui = 0;
  60         done = 0;
  61         current_tool = CWINDOW_NONE;
  62         set_synchronous(1);
  63         input_lock = new Condition(0, "CWindowTool::input_lock");
  64         output_lock = new Condition(1, "CWindowTool::output_lock");
  65         tool_gui_lock = new Mutex("CWindowTool::tool_gui_lock");
  66 }
  67
  68 CWindowTool::~CWindowTool()
  69 {
  70         done = 1;
  71         stop_tool();
  72         input_lock->unlock();
  73         Thread::join();
  74         delete input_lock;
  75         delete output_lock;
  76         delete tool_gui_lock;
  77 }
  78
  79 void CWindowTool::start_tool(int operation)
  80 {
  81         CWindowToolGUI *new_gui = 0;
  82         int result = 0;
  83
  84 //printf("CWindowTool::start_tool 1\n");
  85         if(current_tool != operation)
  86         {
  87                 current_tool = operation;
  88                 switch(operation)
  89                 {
  90                         case CWINDOW_EYEDROP:
  91                                 new_gui = new CWindowEyedropGUI(mwindow, this);
  92                                 break;
  93                         case CWINDOW_CROP:
  94                                 new_gui = new CWindowCropGUI(mwindow, this);
  95                                 break;
  96                         case CWINDOW_CAMERA:
  97                                 new_gui = new CWindowCameraGUI(mwindow, this);
  98                                 break;
  99                         case CWINDOW_PROJECTOR:
 100                                 new_gui = new CWindowProjectorGUI(mwindow, this);
 101                                 break;
 102                         case CWINDOW_MASK:
 103                                 new_gui = new CWindowMaskGUI(mwindow, this);
 104                                 break;
 105                         case CWINDOW_RULER:
 106                                 new_gui = new CWindowRulerGUI(mwindow, this);
 107                                 break;
 108                         default:
 109                                 result = 1;
 110                                 stop_tool();
 111                                 break;
 112                 }
 113
 114 //printf("CWindowTool::start_tool 1\n");
 115
 116
 117                 if(!result)
 118                 {
 119                         stop_tool();
 120 // Wait for previous tool GUI to finish
 121                         output_lock->lock("CWindowTool::start_tool");
 122                         this->tool_gui = new_gui;
 123                         tool_gui->create_objects();
 124
 125                         if(mwindow->edl->session->tool_window &&
 126                                 mwindow->session->show_cwindow) tool_gui->show_window();
 127                         tool_gui->lock_window("CWindowTool::start_tool 1");
 128                         tool_gui->flush();
 129                         tool_gui->unlock_window();
 130
 131
 132 // Signal thread to run next tool GUI
 133                         input_lock->unlock();
 134                 }
 135 //printf("CWindowTool::start_tool 1\n");
 136         }
 137         else
 138         if(tool_gui)
 139         {
 140                 tool_gui->lock_window("CWindowTool::start_tool");
 141                 tool_gui->update();
 142                 tool_gui->unlock_window();
 143         }
 144
 145 //printf("CWindowTool::start_tool 2\n");
 146
 147 }
 148
 149
 150 void CWindowTool::stop_tool()
 151 {
 152         if(tool_gui)
 153         {
 154                 tool_gui->lock_window("CWindowTool::stop_tool");
 155                 tool_gui->set_done(0);
 156                 tool_gui->unlock_window();
 157         }
 158 }
 159
 160 void CWindowTool::show_tool()
 161 {
 162         if(tool_gui && mwindow->edl->session->tool_window)
 163         {
 164                 tool_gui->lock_window("CWindowTool::show_tool");
 165                 tool_gui->show_window();
 166                 tool_gui->unlock_window();
 167         }
 168 }
 169
 170 void CWindowTool::hide_tool()
 171 {
 172         if(tool_gui && mwindow->edl->session->tool_window)
 173         {
 174                 tool_gui->lock_window("CWindowTool::show_tool");
 175                 tool_gui->hide_window();
 176                 tool_gui->unlock_window();
 177         }
 178 }
 179
 180
 181 void CWindowTool::run()
 182 {
 183         while(!done)
 184         {
 185                 input_lock->lock("CWindowTool::run");
 186                 if(!done)
 187                 {
 188                         tool_gui->run_window();
 189                         tool_gui_lock->lock("CWindowTool::run");
 190                         delete tool_gui;
 191                         tool_gui = 0;
 192                         tool_gui_lock->unlock();
 193                 }
 194                 output_lock->unlock();
 195         }
 196 }
 197
 198 void CWindowTool::update_show_window()
 199 {
 200         if(tool_gui)
 201         {
 202                 tool_gui->lock_window("CWindowTool::update_show_window");
 203
 204                 if(mwindow->edl->session->tool_window)
 205                 {
 206                         tool_gui->update();
 207                         tool_gui->show_window();
 208                 }
 209                 else
 210                         tool_gui->hide_window();
 211                 tool_gui->flush();
 212
 213                 tool_gui->unlock_window();
 214         }
 215 }
 216
 217 void CWindowTool::raise_window()
 218 {
 219         if(tool_gui)
 220         {
 221                 gui->unlock_window();
 222                 tool_gui->lock_window("CWindowTool::raise_window");
 223                 tool_gui->raise_window();
 224                 tool_gui->unlock_window();
 225                 gui->lock_window("CWindowTool::raise_window");
 226         }
 227 }
 228
 229 void CWindowTool::update_values()
 230 {
 231         tool_gui_lock->lock("CWindowTool::update_values");
 232         if(tool_gui)
 233         {
 234                 tool_gui->lock_window("CWindowTool::update_values");
 235                 tool_gui->update();
 236                 tool_gui->flush();
 237                 tool_gui->unlock_window();
 238         }
 239         tool_gui_lock->unlock();
 240 }
 241
 242
 243
 244
 245
 246
 247
 248 CWindowToolGUI::CWindowToolGUI(MWindow *mwindow,
 249         CWindowTool *thread,
 250         const char *title,
 251         int w,
 252         int h)
 253  : BC_Window(title,
 254         mwindow->session->ctool_x,
 255         mwindow->session->ctool_y,
 256         w,
 257         h,
 258         w,
 259         h,
 260         0,
 261         0,
 262         1)
 263 {
 264         this->mwindow = mwindow;
 265         this->thread = thread;
 266         current_operation = 0;
 267 }
 268
 269 CWindowToolGUI::~CWindowToolGUI()
 270 {
 271 }
 272
 273 int CWindowToolGUI::close_event()
 274 {
 275         hide_window();
 276         flush();
 277         mwindow->edl->session->tool_window = 0;
 278         unlock_window();
 279
 280
 281
 282         thread->gui->lock_window("CWindowToolGUI::close_event");
 283         thread->gui->composite_panel->set_operation(mwindow->edl->session->cwindow_operation);
 284         thread->gui->flush();
 285         thread->gui->unlock_window();
 286
 287         lock_window("CWindowToolGUI::close_event");
 288         return 1;
 289 ;}
 290
 291 int CWindowToolGUI::keypress_event()
 292 {
 293         if(get_keypress() == 'w' || get_keypress() == 'W')
 294                 return close_event();
 295         return 0;
 296 }
 297
 298 int CWindowToolGUI::translation_event()
 299 {
 300         mwindow->session->ctool_x = get_x();
 301         mwindow->session->ctool_y = get_y();
 302         return 0;
 303 }
 304
 305
 306
 307
 308
 309
 310 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int log_increment = 0)
 311  : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, 100)
 312 {
 313         this->gui = gui;
 314         set_log_floatincrement(log_increment);
 315 }
 316
 317 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value)
 318  : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, 100)
 319 {
 320         this->gui = gui;
 321 }
 322 int CWindowCoord::handle_event()
 323 {
 324         gui->event_caller = this;
 325         gui->handle_event();
 326         return 1;
 327 }
 328
 329
 330 CWindowCropOK::CWindowCropOK(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
 331  : BC_GenericButton(x, y, _("Do it"))
 332 {
 333         this->mwindow = mwindow;
 334         this->gui = gui;
 335 }
 336 int CWindowCropOK::handle_event()
 337 {
 338         mwindow->crop_video();
 339         return 1;
 340 }
 341
 342
 343 int CWindowCropOK::keypress_event()
 344 {
 345         if(get_keypress() == 0xd)
 346         {
 347                 handle_event();
 348                 return 1;
 349         }
 350         return 0;
 351 }
 352
 353
 354
 355
 356
 357
 358
 359 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
 360  : CWindowToolGUI(mwindow,
 361         thread,
 362         _(PROGRAM_NAME ": Crop"),
 363         330,
 364         100)
 365 {
 366 }
 367
 368
 369 CWindowCropGUI::~CWindowCropGUI()
 370 {
 371 }
 372
 373 void CWindowCropGUI::create_objects()
 374 {
 375         int x = 10, y = 10;
 376         BC_Title *title;
 377
 378         lock_window("CWindowCropGUI::create_objects");
 379         int column1 = 0;
 380         int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
 381                 BC_Title::calculate_h(this, "X")) + 5;
 382         add_subwindow(title = new BC_Title(x, y, "X1:"));
 383         column1 = MAX(column1, title->get_w());
 384         y += pad;
 385         add_subwindow(title = new BC_Title(x, y, _("W:")));
 386         column1 = MAX(column1, title->get_w());
 387         y += pad;
 388         add_subwindow(new CWindowCropOK(mwindow, thread->tool_gui, x, y));
 389
 390         x += column1 + 5;
 391         y = 10;
 392         x1 = new CWindowCoord(thread->tool_gui, x, y,
 393                 mwindow->edl->session->crop_x1);
 394         x1->create_objects();
 395         y += pad;
 396         width = new CWindowCoord(thread->tool_gui, x, y,
 397                 mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
 398         width->create_objects();
 399
 400
 401         x += x1->get_w() + 10;
 402         y = 10;
 403         int column2 = 0;
 404         add_subwindow(title = new BC_Title(x, y, "Y1:"));
 405         column2 = MAX(column2, title->get_w());
 406         y += pad;
 407         add_subwindow(title = new BC_Title(x, y, _("H:")));
 408         column2 = MAX(column2, title->get_w());
 409         y += pad;
 410
 411         y = 10;
 412         x += column2 + 5;
 413         y1 = new CWindowCoord(thread->tool_gui, x, y,
 414                 mwindow->edl->session->crop_y1);
 415         y1->create_objects();
 416         y += pad;
 417         height = new CWindowCoord(thread->tool_gui, x, y,
 418                 mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
 419         height->create_objects();
 420         unlock_window();
 421 }
 422
 423 void CWindowCropGUI::handle_event()
 424 {
 425         int new_x1, new_y1;
 426         new_x1 = atol(x1->get_text());
 427         new_y1 = atol(y1->get_text());
 428         if(new_x1 != mwindow->edl->session->crop_x1)
 429         {
 430                 mwindow->edl->session->crop_x2 = new_x1 +
 431                         mwindow->edl->session->crop_x2 -
 432                         mwindow->edl->session->crop_x1;
 433                 mwindow->edl->session->crop_x1 = new_x1;
 434         }
 435         if(new_y1 != mwindow->edl->session->crop_y1)
 436         {
 437                 mwindow->edl->session->crop_y2 = new_y1 +
 438                         mwindow->edl->session->crop_y2 -
 439                         mwindow->edl->session->crop_y1;
 440                 mwindow->edl->session->crop_y1 = atol(y1->get_text());
 441         }
 442         mwindow->edl->session->crop_x2 = atol(width->get_text()) +
 443                 mwindow->edl->session->crop_x1;
 444         mwindow->edl->session->crop_y2 = atol(height->get_text()) +
 445                 mwindow->edl->session->crop_y1;
 446         update();
 447         mwindow->cwindow->gui->lock_window("CWindowCropGUI::handle_event");
 448         mwindow->cwindow->gui->canvas->draw_refresh();
 449         mwindow->cwindow->gui->unlock_window();
 450 }
 451
 452 void CWindowCropGUI::update()
 453 {
 454         x1->update((int64_t)mwindow->edl->session->crop_x1);
 455         y1->update((int64_t)mwindow->edl->session->crop_y1);
 456         width->update((int64_t)mwindow->edl->session->crop_x2 -
 457                 mwindow->edl->session->crop_x1);
 458         height->update((int64_t)mwindow->edl->session->crop_y2 -
 459                 mwindow->edl->session->crop_y1);
 460 }
 461
 462
 463 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
 464  : CWindowToolGUI(mwindow,
 465         thread,
 466         _(PROGRAM_NAME ": Color"),
 467         200,
 468         250)
 469 {
 470 }
 471
 472 CWindowEyedropGUI::~CWindowEyedropGUI()
 473 {
 474 }
 475
 476 void CWindowEyedropGUI::create_objects()
 477 {
 478         int margin = mwindow->theme->widget_border;
 479         int x = margin;
 480         int y = margin;
 481         int x2 = 70;
 482         lock_window("CWindowEyedropGUI::create_objects");
 483         BC_Title *title1, *title2, *title3, *title4, *title5, *title6, *title7;
 484         add_subwindow(title7 = new BC_Title(x, y, _("Radius:")));
 485         y += BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1) + margin;
 486
 487         add_subwindow(title1 = new BC_Title(x, y, _("Red:")));
 488         y += title1->get_h() + margin;
 489         add_subwindow(title2 = new BC_Title(x, y, _("Green:")));
 490         y += title2->get_h() + margin;
 491         add_subwindow(title3 = new BC_Title(x, y, _("Blue:")));
 492         y += title3->get_h() + margin;
 493
 494         add_subwindow(title4 = new BC_Title(x, y, "Y:"));
 495         y += title4->get_h() + margin;
 496         add_subwindow(title5 = new BC_Title(x, y, "U:"));
 497         y += title5->get_h() + margin;
 498         add_subwindow(title6 = new BC_Title(x, y, "V:"));
 499
 500
 501         radius = new CWindowCoord(this, x2, title7->get_y(),
 502                 mwindow->edl->session->eyedrop_radius);
 503         radius->create_objects();
 504         radius->set_boundaries((int64_t)0, (int64_t)255);
 505
 506
 507         add_subwindow(red = new BC_Title(x2, title1->get_y(), "0"));
 508         add_subwindow(green = new BC_Title(x2, title2->get_y(), "0"));
 509         add_subwindow(blue = new BC_Title(x2, title3->get_y(), "0"));
 510
 511         add_subwindow(this->y = new BC_Title(x2, title4->get_y(), "0"));
 512         add_subwindow(this->u = new BC_Title(x2, title5->get_y(), "0"));
 513         add_subwindow(this->v = new BC_Title(x2, title6->get_y(), "0"));
 514
 515         y = title6->get_y() + this->v->get_h() + margin;
 516         add_subwindow(sample = new BC_SubWindow(x, y, 50, 50));
 517         update();
 518         unlock_window();
 519 }
 520
 521 void CWindowEyedropGUI::update()
 522 {
 523         radius->update((int64_t)mwindow->edl->session->eyedrop_radius);
 524
 525         red->update(mwindow->edl->local_session->red);
 526         green->update(mwindow->edl->local_session->green);
 527         blue->update(mwindow->edl->local_session->blue);
 528
 529         float y, u, v;
 530         YUV::rgb_to_yuv_f(mwindow->edl->local_session->red,
 531                 mwindow->edl->local_session->green,
 532                 mwindow->edl->local_session->blue,
 533                 y,
 534                 u,
 535                 v);
 536         this->y->update(y);
 537         this->u->update(u);
 538         this->v->update(v);
 539
 540         int red = (int)(CLIP(mwindow->edl->local_session->red, 0, 1) * 0xff);
 541         int green = (int)(CLIP(mwindow->edl->local_session->green, 0, 1) * 0xff);
 542         int blue = (int)(CLIP(mwindow->edl->local_session->blue, 0, 1) * 0xff);
 543         sample->set_color((red << 16) | (green << 8) | blue);
 544         sample->draw_box(0, 0, sample->get_w(), sample->get_h());
 545         sample->set_color(BLACK);
 546         sample->draw_rectangle(0, 0, sample->get_w(), sample->get_h());
 547         sample->flash();
 548 }
 549
 550 void CWindowEyedropGUI::handle_event()
 551 {
 552         int new_radius = atoi(radius->get_text());
 553         if(new_radius != mwindow->edl->session->eyedrop_radius)
 554         {
 555                 CWindowGUI *gui = mwindow->cwindow->gui;
 556                 if(gui->eyedrop_visible)
 557                 {
 558                         gui->lock_window("CWindowEyedropGUI::handle_event");
 559 // hide it
 560                         int rerender;
 561                         gui->canvas->do_eyedrop(rerender, 0, 1);
 562                 }
 563
 564                 mwindow->edl->session->eyedrop_radius = new_radius;
 565
 566                 if(gui->eyedrop_visible)
 567                 {
 568 // draw it
 569                         int rerender;
 570                         gui->canvas->do_eyedrop(rerender, 0, 1);
 571                         gui->unlock_window();
 572                 }
 573         }
 574 }
 575
 576
 577
 578 /* Buttons to control Keyframe-Curve-Mode for Projector or Camera */
 579
 580 // Configuration for all possible Keyframe Curve Mode toggles
 581 struct _CVD {
 582         FloatAuto::t_mode mode;
 583         bool use_camera;
 584         const char* icon_id;
 585         const char* tooltip;
 586 };
 587
 588 const _CVD Camera_Crv_Smooth =
 589         {       FloatAuto::SMOOTH,
 590                 true,
 591                 "tan_smooth",
 592                 _("\"smooth\" Curve on current Camera Keyframes")
 593         };
 594 const _CVD Camera_Crv_Linear =
 595         {       FloatAuto::LINEAR,
 596                 true,
 597                 "tan_linear",
 598                 _("\"linear\" Curve on current Camera Keyframes")
 599         };
 600 const _CVD Projector_Crv_Smooth =
 601         {       FloatAuto::SMOOTH,
 602                 false,
 603                 "tan_smooth",
 604                 _("\"smooth\" Curve on current Projector Keyframes")
 605         };
 606 const _CVD Projector_Crv_Linear =
 607         {       FloatAuto::LINEAR,
 608                 false,
 609                 "tan_linear",
 610                 _("\"linear\" Curve on current Projector Keyframes")
 611         };
 612
 613
 614 // Implementation Class für Keyframe Curve Mode buttons
 615 //
 616 // This button reflects the state of the "current" keyframe
 617 // (the nearest keyframe on the left) for all three automation
 618 // lines together. Clicking on this button (re)sets the curve
 619 // mode for the three "current" keyframes simultanously, but
 620 // never creates a new keyframe.
 621 //
 622 class CWindowCurveToggle : public BC_Toggle
 623 {
 624 public:
 625         CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
 626         void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
 627         int handle_event();
 628 private:
 629         _CVD cfg;
 630         MWindow *mwindow;
 631         CWindowToolGUI *gui;
 632 };
 633
 634
 635 CWindowCurveToggle::CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
 636  : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
 637    cfg(mode)
 638 {
 639         this->gui = gui;
 640         this->mwindow = mwindow;
 641         set_tooltip(cfg.tooltip);
 642 }
 643
 644 void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z)
 645 {
 646 // the toggle state is only set to ON if all
 647 // three automation lines have the same curve mode.
 648 // For mixed states the toggle stays off.
 649         set_value( x->curve_mode == this->cfg.mode &&
 650                    y->curve_mode == this->cfg.mode &&
 651                    z->curve_mode == this->cfg.mode
 652                  ,true // redraw to show new state
 653                  );
 654 }
 655
 656 int CWindowCurveToggle::handle_event()
 657 {
 658         FloatAuto *x=0, *y=0, *z=0;
 659         Track *track = mwindow->cwindow->calculate_affected_track();
 660
 661         if(track)
 662         {       mwindow->cwindow->calculate_affected_autos(&x, &y, &z,
 663                         track, cfg.use_camera, 0,0,0); // don't create new keyframe
 664
 665                 if(x)   x->change_curve_mode(cfg.mode);
 666                 if(y)   y->change_curve_mode(cfg.mode);
 667                 if(z)   z->change_curve_mode(cfg.mode);
 668
 669                 gui->update();
 670                 gui->update_preview();
 671         }
 672
 673         return 1;
 674 }
 675
 676
 677 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
 678  : CWindowToolGUI(mwindow,
 679         thread,
 680         _(PROGRAM_NAME ": Camera"),
 681         170,
 682         170)
 683 {
 684 }
 685 CWindowCameraGUI::~CWindowCameraGUI()
 686 {
 687 }
 688
 689 void CWindowCameraGUI::create_objects()
 690 {
 691         int x = 10, y = 10, x1;
 692         Track *track = mwindow->cwindow->calculate_affected_track();
 693         FloatAuto *x_auto = 0;
 694         FloatAuto *y_auto = 0;
 695         FloatAuto *z_auto = 0;
 696         BC_Title *title;
 697         BC_Button *button;
 698
 699         lock_window("CWindowCameraGUI::create_objects");
 700         if(track)
 701         {
 702                 mwindow->cwindow->calculate_affected_autos(&x_auto,
 703                         &y_auto, &z_auto, track, 1, 0, 0, 0);
 704         }
 705
 706         add_subwindow(title = new BC_Title(x, y, "X:"));
 707         x += title->get_w();
 708         this->x = new CWindowCoord(this, x, y,
 709                 x_auto ? x_auto->get_value() : (float)0);
 710         this->x->create_objects();
 711
 712
 713         y += 30;
 714         x = 10;
 715         add_subwindow(title = new BC_Title(x, y, "Y:"));
 716         x += title->get_w();
 717         this->y = new CWindowCoord(this, x, y,
 718                 y_auto ? y_auto->get_value() : (float)0);
 719         this->y->create_objects();
 720         y += 30;
 721         x = 10;
 722         add_subwindow(title = new BC_Title(x, y, "Z:"));
 723         x += title->get_w();
 724         this->z = new CWindowCoord(this, x, y,
 725                 z_auto ? z_auto->get_value() : (float)1);
 726         this->z->create_objects();
 727         this->z->set_increment(0.01);
 728
 729         y += 30;
 730         x1 = 10;
 731         add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
 732         x1 += button->get_w();
 733         add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
 734         x1 += button->get_w();
 735         add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
 736
 737         y += button->get_h();
 738         x1 = 10;
 739         add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
 740         x1 += button->get_w();
 741         add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
 742         x1 += button->get_w();
 743         add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
 744 // additional Buttons to control the curve mode of the "current" keyframe
 745         x1 += button->get_w() + 15;
 746         add_subwindow(this->t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
 747         x1 += button->get_w();
 748         add_subwindow(this->t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
 749
 750 // fill in current auto keyframe values, set toggle states.
 751         this->update();
 752         unlock_window();
 753 }
 754
 755 void CWindowCameraGUI::update_preview()
 756 {
 757         mwindow->restart_brender();
 758         mwindow->sync_parameters(CHANGE_PARAMS);
 759
 760         mwindow->cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 761                         CHANGE_NONE,
 762                         mwindow->edl,
 763                         1);
 764         mwindow->gui->lock_window("CWindowCameraGUI::update_preview");
 765         mwindow->gui->draw_overlays(1);
 766         mwindow->gui->unlock_window();
 767         mwindow->cwindow->gui->lock_window("CWindowCameraGUI::update_preview");
 768         mwindow->cwindow->gui->canvas->draw_refresh();
 769         mwindow->cwindow->gui->unlock_window();
 770 }
 771
 772
 773 void CWindowCameraGUI::handle_event()
 774 {
 775         FloatAuto *x_auto = 0;
 776         FloatAuto *y_auto = 0;
 777         FloatAuto *z_auto = 0;
 778         Track *track = mwindow->cwindow->calculate_affected_track();
 779         if(track)
 780         {
 781                 mwindow->undo->update_undo_before(_("camera"), this);
 782                 if(event_caller == x)
 783                 {
 784                         x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
 785                                 track->automation->autos[AUTOMATION_CAMERA_X],
 786                                 1);
 787                         if(x_auto)
 788                         {
 789                                 x_auto->set_value(atof(x->get_text()));
 790                                 update();
 791                                 update_preview();
 792                         }
 793                 }
 794                 else
 795                 if(event_caller == y)
 796                 {
 797                         y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
 798                                 track->automation->autos[AUTOMATION_CAMERA_Y],
 799                                 1);
 800                         if(y_auto)
 801                         {
 802                                 y_auto->set_value(atof(y->get_text()));
 803                                 update();
 804                                 update_preview();
 805                         }
 806                 }
 807                 else
 808                 if(event_caller == z)
 809                 {
 810                         z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
 811                                 track->automation->autos[AUTOMATION_CAMERA_Z],
 812                                 1);
 813                         if(z_auto)
 814                         {
 815                                 float zoom = atof(z->get_text());
 816                                 if(zoom > 10) zoom = 10;
 817                                 else
 818                                 if(zoom < 0) zoom = 0;
 819         // Doesn't allow user to enter from scratch
 820         //              if(zoom != atof(z->get_text()))
 821         //                      z->update(zoom);
 822
 823                                 z_auto->set_value(zoom);
 824                                 mwindow->gui->lock_window("CWindowCameraGUI::handle_event");
 825                                 mwindow->gui->draw_overlays(1);
 826                                 mwindow->gui->unlock_window();
 827                                 update();
 828                                 update_preview();
 829                         }
 830                 }
 831
 832                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
 833         }
 834 }
 835
 836 void CWindowCameraGUI::update()
 837 {
 838         FloatAuto *x_auto = 0;
 839         FloatAuto *y_auto = 0;
 840         FloatAuto *z_auto = 0;
 841         Track *track = mwindow->cwindow->calculate_affected_track();
 842
 843         if(track)
 844         {
 845                 mwindow->cwindow->calculate_affected_autos(&x_auto,
 846                         &y_auto,
 847                         &z_auto,
 848                         track,
 849                         1,
 850                         0,
 851                         0,
 852                         0);
 853         }
 854
 855         if(x_auto)
 856                 x->update(x_auto->get_value());
 857         if(y_auto)
 858                 y->update(y_auto->get_value());
 859         if(z_auto)
 860                 z->update(z_auto->get_value());
 861
 862         if( x_auto && y_auto && z_auto )
 863         {
 864                 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
 865                 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
 866         }
 867 }
 868
 869
 870
 871
 872 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
 873  : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
 874 {
 875         this->gui = gui;
 876         this->mwindow = mwindow;
 877         set_tooltip(_("Left justify"));
 878 }
 879 int CWindowCameraLeft::handle_event()
 880 {
 881         FloatAuto *x_auto = 0;
 882         FloatAuto *z_auto = 0;
 883         Track *track = mwindow->cwindow->calculate_affected_track();
 884         if(track)
 885         {
 886                 mwindow->cwindow->calculate_affected_autos(&x_auto,
 887                         0,
 888                         &z_auto,
 889                         track,
 890                         1,
 891                         1,
 892                         0,
 893                         0);
 894         }
 895
 896         if(x_auto && z_auto)
 897         {
 898                 int w = 0, h = 0;
 899                 track->get_source_dimensions(
 900                         mwindow->edl->local_session->get_selectionstart(1),
 901                         w,
 902                         h);
 903
 904                 if(w && h)
 905                 {
 906                         mwindow->undo->update_undo_before(_("camera"), 0);
 907                         x_auto->set_value(
 908                                 (double)track->track_w / z_auto->get_value() / 2 -
 909                                 (double)w / 2);
 910                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
 911                         gui->update();
 912                         gui->update_preview();
 913                 }
 914         }
 915
 916         return 1;
 917 }
 918
 919
 920 CWindowCameraCenter::CWindowCameraCenter(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
 921  : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
 922 {
 923         this->gui = gui;
 924         this->mwindow = mwindow;
 925         set_tooltip(_("Center horizontal"));
 926 }
 927 int CWindowCameraCenter::handle_event()
 928 {
 929         FloatAuto *x_auto = 0;
 930         Track *track = mwindow->cwindow->calculate_affected_track();
 931         if(track)
 932                 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
 933                         track->automation->autos[AUTOMATION_CAMERA_X],
 934                         1);
 935
 936         if(x_auto)
 937         {
 938                 mwindow->undo->update_undo_before(_("camera"), 0);
 939                 x_auto->set_value(0);
 940                 gui->update();
 941                 gui->update_preview();
 942                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
 943         }
 944
 945         return 1;
 946 }
 947
 948
 949 CWindowCameraRight::CWindowCameraRight(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
 950  : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
 951 {
 952         this->gui = gui;
 953         this->mwindow = mwindow;
 954         set_tooltip(_("Right justify"));
 955 }
 956 int CWindowCameraRight::handle_event()
 957 {
 958         FloatAuto *x_auto = 0;
 959         FloatAuto *z_auto = 0;
 960         Track *track = mwindow->cwindow->calculate_affected_track();
 961         if(track)
 962         {
 963                 mwindow->cwindow->calculate_affected_autos(&x_auto,
 964                         0,
 965                         &z_auto,
 966                         track,
 967                         1,
 968                         1,
 969                         0,
 970                         0);
 971         }
 972
 973         if(x_auto && z_auto)
 974         {
 975                 int w = 0, h = 0;
 976                 track->get_source_dimensions(
 977                         mwindow->edl->local_session->get_selectionstart(1),
 978                         w,
 979                         h);
 980
 981                 if(w && h)
 982                 {
 983                         mwindow->undo->update_undo_before(_("camera"), 0);
 984                         x_auto->set_value( -((double)track->track_w / z_auto->get_value() / 2 -
 985                                 (double)w / 2));
 986                         gui->update();
 987                         gui->update_preview();
 988                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
 989                 }
 990         }
 991
 992         return 1;
 993 }
 994
 995
 996 CWindowCameraTop::CWindowCameraTop(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
 997  : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
 998 {
 999         this->gui = gui;
1000         this->mwindow = mwindow;
1001         set_tooltip(_("Top justify"));
1002 }
1003 int CWindowCameraTop::handle_event()
1004 {
1005         FloatAuto *y_auto = 0;
1006         FloatAuto *z_auto = 0;
1007         Track *track = mwindow->cwindow->calculate_affected_track();
1008         if(track)
1009         {
1010                 mwindow->cwindow->calculate_affected_autos(0,
1011                         &y_auto,
1012                         &z_auto,
1013                         track,
1014                         1,
1015                         0,
1016                         1,
1017                         0);
1018         }
1019
1020         if(y_auto && z_auto)
1021         {
1022                 int w = 0, h = 0;
1023                 track->get_source_dimensions(
1024                         mwindow->edl->local_session->get_selectionstart(1),
1025                         w,
1026                         h);
1027
1028                 if(w && h)
1029                 {
1030                         mwindow->undo->update_undo_before(_("camera"), 0);
1031                         y_auto->set_value((double)track->track_h / z_auto->get_value() / 2 -
1032                                 (double)h / 2);
1033                         gui->update();
1034                         gui->update_preview();
1035                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1036                 }
1037         }
1038
1039         return 1;
1040 }
1041
1042
1043 CWindowCameraMiddle::CWindowCameraMiddle(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1044  : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1045 {
1046         this->gui = gui;
1047         this->mwindow = mwindow;
1048         set_tooltip(_("Center vertical"));
1049 }
1050 int CWindowCameraMiddle::handle_event()
1051 {
1052         FloatAuto *y_auto = 0;
1053         Track *track = mwindow->cwindow->calculate_affected_track();
1054         if(track)
1055                 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1056                         track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1057
1058         if(y_auto)
1059         {
1060                 mwindow->undo->update_undo_before(_("camera"), 0);
1061                 y_auto->set_value(0);
1062                 gui->update();
1063                 gui->update_preview();
1064                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1065         }
1066
1067         return 1;
1068 }
1069
1070
1071 CWindowCameraBottom::CWindowCameraBottom(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1072  : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1073 {
1074         this->gui = gui;
1075         this->mwindow = mwindow;
1076         set_tooltip(_("Bottom justify"));
1077 }
1078 int CWindowCameraBottom::handle_event()
1079 {
1080         FloatAuto *y_auto = 0;
1081         FloatAuto *z_auto = 0;
1082         Track *track = mwindow->cwindow->calculate_affected_track();
1083         if(track)
1084         {
1085                 mwindow->cwindow->calculate_affected_autos(0,
1086                         &y_auto,
1087                         &z_auto,
1088                         track,
1089                         1,
1090                         0,
1091                         1,
1092                         0);
1093         }
1094
1095         if(y_auto && z_auto)
1096         {
1097                 int w = 0, h = 0;
1098                 track->get_source_dimensions(
1099                         mwindow->edl->local_session->get_selectionstart(1),
1100                         w,
1101                         h);
1102
1103                 if(w && h)
1104                 {
1105                         mwindow->undo->update_undo_before(_("camera"), 0);
1106                         y_auto->set_value(-((double)track->track_h / z_auto->get_value() / 2 -
1107                                 (double)h / 2));
1108                         gui->update();
1109                         gui->update_preview();
1110                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1111                 }
1112         }
1113
1114         return 1;
1115 }
1116
1117
1118 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
1119  : CWindowToolGUI(mwindow,
1120         thread,
1121         _(PROGRAM_NAME ": Projector"),
1122         170,
1123         170)
1124 {
1125 }
1126 CWindowProjectorGUI::~CWindowProjectorGUI()
1127 {
1128 }
1129 void CWindowProjectorGUI::create_objects()
1130 {
1131         int x = 10, y = 10, x1;
1132         Track *track = mwindow->cwindow->calculate_affected_track();
1133         FloatAuto *x_auto = 0;
1134         FloatAuto *y_auto = 0;
1135         FloatAuto *z_auto = 0;
1136         BC_Title *title;
1137         BC_Button *button;
1138
1139         lock_window("CWindowProjectorGUI::create_objects");
1140         if(track)
1141         {
1142                 mwindow->cwindow->calculate_affected_autos(&x_auto,
1143                         &y_auto,
1144                         &z_auto,
1145                         track,
1146                         0,
1147                         0,
1148                         0,
1149                         0);
1150         }
1151
1152         add_subwindow(title = new BC_Title(x, y, "X:"));
1153         x += title->get_w();
1154         this->x = new CWindowCoord(this, x, y,
1155                 x_auto ? x_auto->get_value() : (float)0);
1156         this->x->create_objects();
1157         y += 30;
1158         x = 10;
1159         add_subwindow(title = new BC_Title(x, y, "Y:"));
1160         x += title->get_w();
1161         this->y = new CWindowCoord(this, x, y,
1162                 y_auto ? y_auto->get_value() : (float)0);
1163         this->y->create_objects();
1164         y += 30;
1165         x = 10;
1166         add_subwindow(title = new BC_Title(x, y, "Z:"));
1167         x += title->get_w();
1168         this->z = new CWindowCoord(this, x, y,
1169                 z_auto ? z_auto->get_value() : (float)1);
1170         this->z->create_objects();
1171         this->z->set_increment(0.01);
1172
1173         y += 30;
1174         x1 = 10;
1175         add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
1176         x1 += button->get_w();
1177         add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
1178         x1 += button->get_w();
1179         add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
1180
1181         y += button->get_h();
1182         x1 = 10;
1183         add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
1184         x1 += button->get_w();
1185         add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
1186         x1 += button->get_w();
1187         add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
1188
1189 // additional Buttons to control the curve mode of the "current" keyframe
1190         x1 += button->get_w() + 15;
1191         add_subwindow(this->t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
1192         x1 += button->get_w();
1193         add_subwindow(this->t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
1194
1195 // fill in current auto keyframe values, set toggle states.
1196         this->update();
1197         unlock_window();
1198 }
1199
1200 void CWindowProjectorGUI::update_preview()
1201 {
1202         mwindow->restart_brender();
1203         mwindow->sync_parameters(CHANGE_PARAMS);
1204         mwindow->cwindow->playback_engine->que->send_command(CURRENT_FRAME,
1205                         CHANGE_NONE,
1206                         mwindow->edl,
1207                         1);
1208         // TODO: really need to lock the main window??
1209         mwindow->gui->lock_window("CWindowProjectorGUI::update_preview");
1210         mwindow->gui->draw_overlays(1);
1211         mwindow->gui->unlock_window();
1212         mwindow->cwindow->gui->lock_window("CWindowProjectorGUI::update_preview");
1213         mwindow->cwindow->gui->canvas->draw_refresh();
1214         mwindow->cwindow->gui->unlock_window();
1215 }
1216
1217 void CWindowProjectorGUI::handle_event()
1218 {
1219         FloatAuto *x_auto = 0;
1220         FloatAuto *y_auto = 0;
1221         FloatAuto *z_auto = 0;
1222         Track *track = mwindow->cwindow->calculate_affected_track();
1223
1224         if(track)
1225         {
1226                 mwindow->undo->update_undo_before(_("projector"), this);
1227                 if(event_caller == x)
1228                 {
1229                         x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1230                                 track->automation->autos[AUTOMATION_PROJECTOR_X],
1231                                 1);
1232                         if(x_auto)
1233                         {
1234                                 x_auto->set_value(atof(x->get_text()));
1235                                 update();
1236                                 update_preview();
1237                         }
1238                 }
1239                 else
1240                 if(event_caller == y)
1241                 {
1242                         y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1243                                 track->automation->autos[AUTOMATION_PROJECTOR_Y],
1244                                 1);
1245                         if(y_auto)
1246                         {
1247                                 y_auto->set_value(atof(y->get_text()));
1248                                 update();
1249                                 update_preview();
1250                         }
1251                 }
1252                 else
1253                 if(event_caller == z)
1254                 {
1255                         z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1256                                 track->automation->autos[AUTOMATION_PROJECTOR_Z],
1257                                 1);
1258                         if(z_auto)
1259                         {
1260                                 float zoom = atof(z->get_text());
1261                                 if(zoom > 10000) zoom = 10000;
1262                                 else
1263                                 if(zoom < 0) zoom = 0;
1264 //                      if (zoom != atof(z->get_text()))
1265 //                              z->update(zoom);
1266                                 z_auto->set_value(zoom);
1267
1268                                 mwindow->gui->lock_window("CWindowProjectorGUI::handle_event");
1269                                 mwindow->gui->draw_overlays(1);
1270                                 mwindow->gui->unlock_window();
1271
1272                                 update();
1273                                 update_preview();
1274                         }
1275                 }
1276                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1277         }
1278 }
1279
1280 void CWindowProjectorGUI::update()
1281 {
1282         FloatAuto *x_auto = 0;
1283         FloatAuto *y_auto = 0;
1284         FloatAuto *z_auto = 0;
1285         Track *track = mwindow->cwindow->calculate_affected_track();
1286
1287         if(track)
1288         {
1289                 mwindow->cwindow->calculate_affected_autos(&x_auto,
1290                         &y_auto,
1291                         &z_auto,
1292                         track,
1293                         0,
1294                         0,
1295                         0,
1296                         0);
1297         }
1298
1299         if(x_auto)
1300                 x->update(x_auto->get_value());
1301         if(y_auto)
1302                 y->update(y_auto->get_value());
1303         if(z_auto)
1304                 z->update(z_auto->get_value());
1305
1306         if( x_auto && y_auto && z_auto )
1307         {
1308                 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1309                 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1310         }
1311 }
1312
1313 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1314  : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1315 {
1316         this->gui = gui;
1317         this->mwindow = mwindow;
1318         set_tooltip(_("Left justify"));
1319 }
1320 int CWindowProjectorLeft::handle_event()
1321 {
1322         FloatAuto *x_auto = 0;
1323         FloatAuto *z_auto = 0;
1324         Track *track = mwindow->cwindow->calculate_affected_track();
1325         if(track)
1326         {
1327                 mwindow->cwindow->calculate_affected_autos(&x_auto,
1328                         0,
1329                         &z_auto,
1330                         track,
1331                         0,
1332                         1,
1333                         0,
1334                         0);
1335         }
1336         if(x_auto && z_auto)
1337         {
1338                 mwindow->undo->update_undo_before(_("projector"), 0);
1339                 x_auto->set_value( (double)track->track_w * z_auto->get_value() / 2 -
1340                         (double)mwindow->edl->session->output_w / 2 );
1341                 gui->update();
1342                 gui->update_preview();
1343                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1344         }
1345
1346         return 1;
1347 }
1348
1349
1350 CWindowProjectorCenter::CWindowProjectorCenter(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1351  : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1352 {
1353         this->gui = gui;
1354         this->mwindow = mwindow;
1355         set_tooltip(_("Center horizontal"));
1356 }
1357 int CWindowProjectorCenter::handle_event()
1358 {
1359         FloatAuto *x_auto = 0;
1360         Track *track = mwindow->cwindow->calculate_affected_track();
1361         if(track)
1362                 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1363                         track->automation->autos[AUTOMATION_PROJECTOR_X],
1364                         1);
1365
1366         if(x_auto)
1367         {
1368                 mwindow->undo->update_undo_before(_("projector"), 0);
1369                 x_auto->set_value(0);
1370                 gui->update();
1371                 gui->update_preview();
1372                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1373         }
1374
1375         return 1;
1376 }
1377
1378
1379 CWindowProjectorRight::CWindowProjectorRight(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1380  : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1381 {
1382         this->gui = gui;
1383         this->mwindow = mwindow;
1384         set_tooltip(_("Right justify"));
1385 }
1386 int CWindowProjectorRight::handle_event()
1387 {
1388         FloatAuto *x_auto = 0;
1389         FloatAuto *z_auto = 0;
1390         Track *track = mwindow->cwindow->calculate_affected_track();
1391         if(track)
1392         {
1393                 mwindow->cwindow->calculate_affected_autos(&x_auto,
1394                         0,
1395                         &z_auto,
1396                         track,
1397                         0,
1398                         1,
1399                         0,
1400                         0);
1401         }
1402
1403         if(x_auto && z_auto)
1404         {
1405                 mwindow->undo->update_undo_before(_("projector"), 0);
1406                 x_auto->set_value( -((double)track->track_w * z_auto->get_value() / 2 -
1407                         (double)mwindow->edl->session->output_w / 2));
1408                 gui->update();
1409                 gui->update_preview();
1410                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1411         }
1412
1413         return 1;
1414 }
1415
1416
1417 CWindowProjectorTop::CWindowProjectorTop(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1418  : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1419 {
1420         this->gui = gui;
1421         this->mwindow = mwindow;
1422         set_tooltip(_("Top justify"));
1423 }
1424 int CWindowProjectorTop::handle_event()
1425 {
1426         FloatAuto *y_auto = 0;
1427         FloatAuto *z_auto = 0;
1428         Track *track = mwindow->cwindow->calculate_affected_track();
1429         if(track)
1430         {
1431                 mwindow->cwindow->calculate_affected_autos(0,
1432                         &y_auto,
1433                         &z_auto,
1434                         track,
1435                         0,
1436                         0,
1437                         1,
1438                         0);
1439         }
1440
1441         if(y_auto && z_auto)
1442         {
1443                 mwindow->undo->update_undo_before(_("projector"), 0);
1444                 y_auto->set_value( (double)track->track_h * z_auto->get_value() / 2 -
1445                         (double)mwindow->edl->session->output_h / 2 );
1446                 gui->update();
1447                 gui->update_preview();
1448                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1449         }
1450
1451         return 1;
1452 }
1453
1454
1455 CWindowProjectorMiddle::CWindowProjectorMiddle(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1456  : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1457 {
1458         this->gui = gui;
1459         this->mwindow = mwindow;
1460         set_tooltip(_("Center vertical"));
1461 }
1462 int CWindowProjectorMiddle::handle_event()
1463 {
1464         FloatAuto *y_auto = 0;
1465         Track *track = mwindow->cwindow->calculate_affected_track();
1466         if(track)
1467                 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1468                         track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1469
1470         if(y_auto)
1471         {
1472                 mwindow->undo->update_undo_before(_("projector"), 0);
1473                 y_auto->set_value(0);
1474                 gui->update();
1475                 gui->update_preview();
1476                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1477         }
1478
1479         return 1;
1480 }
1481
1482
1483 CWindowProjectorBottom::CWindowProjectorBottom(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1484  : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1485 {
1486         this->gui = gui;
1487         this->mwindow = mwindow;
1488         set_tooltip(_("Bottom justify"));
1489 }
1490 int CWindowProjectorBottom::handle_event()
1491 {
1492         FloatAuto *y_auto = 0;
1493         FloatAuto *z_auto = 0;
1494         Track *track = mwindow->cwindow->calculate_affected_track();
1495         if(track)
1496         {
1497                 mwindow->cwindow->calculate_affected_autos(0,
1498                         &y_auto,
1499                         &z_auto,
1500                         track,
1501                         0,
1502                         0,
1503                         1,
1504                         0);
1505         }
1506
1507         if(y_auto && z_auto)
1508         {
1509                 mwindow->undo->update_undo_before(_("projector"), 0);
1510                 y_auto->set_value( -((double)track->track_h * z_auto->get_value() / 2 -
1511                         (double)mwindow->edl->session->output_h / 2));
1512                 gui->update();
1513                 gui->update_preview();
1514                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1515         }
1516
1517         return 1;
1518 }
1519
1520
1521 CWindowMaskMode::CWindowMaskMode(MWindow *mwindow,
1522         CWindowToolGUI *gui, int x, int y, const char *text)
1523  : BC_PopupMenu(x, y, 220, text, 1)
1524 {
1525         this->mwindow = mwindow;
1526         this->gui = gui;
1527 }
1528
1529 void CWindowMaskMode::create_objects()
1530 {
1531         add_item(new BC_MenuItem(mode_to_text(MASK_MULTIPLY_ALPHA)));
1532         add_item(new BC_MenuItem(mode_to_text(MASK_SUBTRACT_ALPHA)));
1533 }
1534
1535 char* CWindowMaskMode::mode_to_text(int mode)
1536 {
1537         switch(mode)
1538         {
1539                 case MASK_MULTIPLY_ALPHA:
1540                         return _("Multiply alpha");
1541                         break;
1542
1543                 case MASK_SUBTRACT_ALPHA:
1544                         return _("Subtract alpha");
1545                         break;
1546         }
1547
1548         return _("Subtract alpha");
1549 }
1550
1551 int CWindowMaskMode::text_to_mode(char *text)
1552 {
1553         if(!strcasecmp(text, _("Multiply alpha")))
1554                 return MASK_MULTIPLY_ALPHA;
1555         else
1556         if(!strcasecmp(text, _("Subtract alpha")))
1557                 return MASK_SUBTRACT_ALPHA;
1558
1559         return MASK_SUBTRACT_ALPHA;
1560 }
1561
1562 int CWindowMaskMode::handle_event()
1563 {
1564         MaskAutos *autos;
1565         MaskAuto *keyframe;
1566         Track *track;
1567         MaskPoint *point;
1568         SubMask *mask;
1569 // Get existing keyframe
1570         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
1571         if(track)
1572         {
1573                 mwindow->undo->update_undo_before(_("mask mode"), 0);
1574 #ifdef USE_KEYFRAME_SPANNING
1575 // Create temp keyframe
1576                 MaskAuto temp_keyframe(mwindow->edl, autos);
1577                 temp_keyframe.copy_data(keyframe);
1578 // Update parameter
1579                 temp_keyframe.mode = text_to_mode(get_text());
1580 // Commit change to span of keyframes
1581                 autos->update_parameter(&temp_keyframe);
1582 #else
1583                 ((MaskAuto*)autos->default_auto)->mode =
1584                         text_to_mode(get_text());
1585 #endif
1586                 mwindow->undo->update_undo_after(_("mask mode"), LOAD_AUTOMATION);
1587         }
1588
1589 //printf("CWindowMaskMode::handle_event 1\n");
1590         gui->update_preview();
1591         return 1;
1592 }
1593
1594
1595
1596
1597
1598
1599
1600
1601 CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
1602         CWindowToolGUI *gui,
1603         int x,
1604         int y)
1605  : BC_GenericButton(x, y, _("Delete"))
1606 {
1607         this->mwindow = mwindow;
1608         this->gui = gui;
1609 }
1610
1611 int CWindowMaskDelete::handle_event()
1612 {
1613         MaskAutos *autos;
1614         MaskAuto *keyframe;
1615         Track *track;
1616         MaskPoint *point;
1617         SubMask *mask;
1618         int total_points = 0;
1619
1620 // Get existing keyframe
1621         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
1622
1623         if(track)
1624         {
1625                 mwindow->undo->update_undo_before(_("mask delete"), 0);
1626
1627 #ifdef USE_KEYFRAME_SPANNING
1628 // Create temp keyframe
1629                 MaskAuto temp_keyframe(mwindow->edl, autos);
1630                 temp_keyframe.copy_data(keyframe);
1631 // Update parameter
1632                 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1633                 for(int i = mwindow->cwindow->gui->affected_point;
1634                         i < submask->points.total - 1;
1635                         i++)
1636                 {
1637                         *submask->points.values[i] = *submask->points.values[i + 1];
1638                 }
1639
1640                 if(submask->points.total)
1641                 {
1642                         submask->points.remove_object(
1643                                 submask->points.values[submask->points.total - 1]);
1644                 }
1645                 total_points = submask->points.total;
1646
1647 // Commit change to span of keyframes
1648                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1649 #else
1650                 for(MaskAuto *current = (MaskAuto*)autos->default_auto;
1651                         current; )
1652                 {
1653                         SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1654
1655                         for(int i = mwindow->cwindow->gui->affected_point;
1656                                 i < submask->points.total - 1;
1657                                 i++)
1658                         {
1659                                 *submask->points.values[i] = *submask->points.values[i + 1];
1660                         }
1661
1662                         if(submask->points.total)
1663                         {
1664                                 submask->points.remove_object(
1665                                         submask->points.values[submask->points.total - 1]);
1666                         }
1667                         total_points = submask->points.total;
1668
1669                         if(current == (MaskAuto*)autos->default_auto)
1670                                 current = (MaskAuto*)autos->first;
1671                         else
1672                                 current = (MaskAuto*)NEXT;
1673                 }
1674 #endif
1675                 if( mwindow->cwindow->gui->affected_point >= total_points )
1676                         mwindow->cwindow->gui->affected_point =
1677                                 total_points > 0 ? total_points-1 : 0;
1678
1679                 gui->update();
1680                 gui->update_preview();
1681                 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
1682         }
1683
1684
1685         return 1;
1686 }
1687
1688 int CWindowMaskDelete::keypress_event()
1689 {
1690         if(get_keypress() == BACKSPACE ||
1691                 get_keypress() == DELETE)
1692                 return handle_event();
1693         return 0;
1694 }
1695
1696
1697 // CWindowMaskCycleNext::CWindowMaskCycleNext(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1698 //  : BC_GenericButton(x, y, _("Cycle next"))
1699 // {
1700 //      this->mwindow = mwindow;
1701 //      this->gui = gui;
1702 // }
1703 // int CWindowMaskCycleNext::handle_event()
1704 // {
1705 //      MaskAuto *keyframe;
1706 //      MaskAutos *autos;
1707 //      Track *track;
1708 //      MaskPoint *point;
1709 //      SubMask *mask;
1710 //      ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
1711 //
1712 //      MaskPoint *temp;
1713 //
1714 // // Should apply to all keyframes
1715 //      if(keyframe && mask->points.total)
1716 //      {
1717 //              temp = mask->points.values[0];
1718 //
1719 //              for(int i = 0; i < mask->points.total - 1; i++)
1720 //              {
1721 //                      mask->points.values[i] = mask->points.values[i + 1];
1722 //              }
1723 //              mask->points.values[mask->points.total - 1] = temp;
1724 //
1725 //              mwindow->cwindow->gui->affected_point--;
1726 //              if(mwindow->cwindow->gui->affected_point < 0)
1727 //                      mwindow->cwindow->gui->affected_point = mask->points.total - 1;
1728 //
1729 //              gui->update();
1730 //              gui->update_preview();
1731 //      }
1732 //
1733 //      return 1;
1734 // }
1735 //
1736 // CWindowMaskCyclePrev::CWindowMaskCyclePrev(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1737 //  : BC_GenericButton(x, y, _("Cycle prev"))
1738 // {
1739 //      this->mwindow = mwindow;
1740 //      this->gui = gui;
1741 // }
1742 // int CWindowMaskCyclePrev::handle_event()
1743 // {
1744 //      MaskAuto *keyframe;
1745 //      MaskAutos *autos;
1746 //      Track *track;
1747 //      MaskPoint *point;
1748 //      SubMask *mask;
1749 //      ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 0);
1750 //
1751 // // Should apply to all keyframes
1752 //      MaskPoint *temp;
1753 //      if(keyframe && mask->points.total)
1754 //      {
1755 //              temp = mask->points.values[mask->points.total - 1];
1756 //
1757 //              for(int i = mask->points.total - 1; i > 0; i--)
1758 //              {
1759 //                      mask->points.values[i] = mask->points.values[i - 1];
1760 //              }
1761 //              mask->points.values[0] = temp;
1762 //
1763 //              mwindow->cwindow->gui->affected_point++;
1764 //              if(mwindow->cwindow->gui->affected_point >= mask->points.total)
1765 //                      mwindow->cwindow->gui->affected_point = 0;
1766 //
1767 //              gui->update();
1768 //              gui->update_preview();
1769 //      }
1770 //      return 1;
1771 // }
1772
1773
1774 CWindowMaskNumber::CWindowMaskNumber(MWindow *mwindow,
1775         CWindowToolGUI *gui,
1776         int x,
1777         int y)
1778  : BC_TumbleTextBox(gui,
1779                 (int64_t)mwindow->edl->session->cwindow_mask,
1780                 (int64_t)0,
1781                 (int64_t)SUBMASKS - 1,
1782                 x,
1783                 y,
1784                 100)
1785 {
1786         this->mwindow = mwindow;
1787         this->gui = gui;
1788 }
1789
1790 CWindowMaskNumber::~CWindowMaskNumber()
1791 {
1792 }
1793
1794 int CWindowMaskNumber::handle_event()
1795 {
1796         mwindow->edl->session->cwindow_mask = atol(get_text());
1797         gui->update();
1798         gui->update_preview();
1799         return 1;
1800 }
1801
1802
1803 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
1804         CWindowToolGUI *gui, int x, int y)
1805  : BC_TumbleTextBox(gui,
1806                 (int64_t)mwindow->cwindow->gui->affected_point,
1807                 (int64_t)0, INT64_MAX, x, y, 100)
1808 {
1809         this->mwindow = mwindow;
1810         this->gui = gui;
1811 }
1812
1813 CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
1814 {
1815 }
1816
1817 int CWindowMaskAffectedPoint::handle_event()
1818 {
1819         int total_points = 0;
1820         int affected_point = atol(get_text());
1821         Track *track = mwindow->cwindow->calculate_affected_track();
1822         if(track) {
1823                 MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1824                 MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
1825                 if( keyframe ) {
1826                         SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
1827                         total_points = mask->points.size();
1828                 }
1829         }
1830         int active_point = affected_point;
1831         if( affected_point >= total_points )
1832                 affected_point = total_points - 1;
1833         else if( affected_point < 0 )
1834                 affected_point = 0;
1835         if( active_point != affected_point )
1836                 update((int64_t)affected_point);
1837         mwindow->cwindow->gui->affected_point = affected_point;
1838         gui->update();
1839         gui->update_preview();
1840         return 1;
1841 }
1842
1843
1844
1845
1846
1847 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1848  : BC_TumbleTextBox(gui,
1849                 (int64_t)0,
1850                 (int64_t)0,
1851                 (int64_t)0xff,
1852                 x,
1853                 y,
1854                 100)
1855 {
1856         this->mwindow = mwindow;
1857         this->gui = gui;
1858 }
1859 CWindowMaskFeather::~CWindowMaskFeather()
1860 {
1861 }
1862 int CWindowMaskFeather::handle_event()
1863 {
1864         MaskAutos *autos;
1865         MaskAuto *keyframe;
1866         Track *track;
1867         MaskPoint *point;
1868         SubMask *mask;
1869 #ifdef USE_KEYFRAME_SPANNING
1870         int create_it = 0;
1871 #else
1872         int create_it = 1;
1873 #endif
1874
1875         mwindow->undo->update_undo_before(_("mask feather"), this);
1876
1877 // Get existing keyframe
1878         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe,
1879                         mask, point, create_it);
1880
1881         if(track)
1882         {
1883 #ifdef USE_KEYFRAME_SPANNING
1884 // Create temp keyframe
1885                 MaskAuto temp_keyframe(mwindow->edl, autos);
1886                 temp_keyframe.copy_data(keyframe);
1887 // Update parameter
1888                 temp_keyframe.feather = atof(get_text());
1889 // Commit change to span of keyframes
1890                 autos->update_parameter(&temp_keyframe);
1891 #else
1892                 keyframe->feather = atof(get_text());
1893 #endif
1894
1895                 gui->update_preview();
1896         }
1897
1898         mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
1899         return 1;
1900 }
1901
1902
1903 CWindowMaskValue::CWindowMaskValue(MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
1904  : BC_ISlider(x,
1905                         y,
1906                         0,
1907                         200,
1908                         200,
1909                         0,
1910                         100,
1911                         0)
1912 {
1913         this->mwindow = mwindow;
1914         this->gui = gui;
1915 }
1916
1917 CWindowMaskValue::~CWindowMaskValue()
1918 {
1919 }
1920
1921 int CWindowMaskValue::handle_event()
1922 {
1923         MaskAutos *autos;
1924         MaskAuto *keyframe;
1925         Track *track;
1926         MaskPoint *point;
1927         SubMask *mask;
1928 #ifdef USE_KEYFRAME_SPANNING
1929         int create_it = 0;
1930 #else
1931         int create_it = 1;
1932 #endif
1933
1934         mwindow->undo->update_undo_before(_("mask value"), this);
1935         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe,
1936                 mask, point, create_it);
1937
1938         if(track)
1939         {
1940 #ifdef USE_KEYFRAME_SPANNING
1941 // Create temp keyframe
1942                 MaskAuto temp_keyframe(mwindow->edl, autos);
1943                 temp_keyframe.copy_data(keyframe);
1944 // Update parameter
1945                 temp_keyframe.value = get_value();
1946 // Commit change to span of keyframes
1947                 autos->update_parameter(&temp_keyframe);
1948 #else
1949                 keyframe->value = get_value();
1950 #endif
1951         }
1952
1953         gui->update_preview();
1954         mwindow->undo->update_undo_after(_("mask value"), LOAD_AUTOMATION);
1955         return 1;
1956 }
1957
1958
1959 CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowToolGUI *gui, int x, int y)
1960  : BC_CheckBox(x,
1961         y,
1962         1,
1963         _("Apply mask before plugins"))
1964 {
1965         this->gui = gui;
1966 }
1967
1968 int CWindowMaskBeforePlugins::handle_event()
1969 {
1970         Track *track;
1971         MaskAutos *autos;
1972         MaskAuto *keyframe;
1973         SubMask *mask;
1974         MaskPoint *point;
1975         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 1);
1976
1977         if (keyframe) {
1978                 keyframe->apply_before_plugins = get_value();
1979                 gui->update_preview();
1980         }
1981         return 1;
1982 }
1983
1984
1985 CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowToolGUI *gui, int x, int y)
1986  : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
1987 {
1988         this->gui = gui;
1989 }
1990
1991 int CWindowDisableOpenGLMasking::handle_event()
1992 {
1993         Track *track;
1994         MaskAutos *autos;
1995         MaskAuto *keyframe;
1996         SubMask *mask;
1997         MaskPoint *point;
1998         ((CWindowMaskGUI*)gui)->get_keyframe(track, autos, keyframe, mask, point, 1);
1999
2000         if (keyframe) {
2001                 keyframe->disable_opengl_masking = get_value();
2002                 gui->update_preview();
2003         }
2004         return 1;
2005 }
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
2016  : CWindowToolGUI(mwindow,
2017         thread,
2018         _(PROGRAM_NAME ": Mask"),
2019         330,
2020         310)
2021 {
2022         this->mwindow = mwindow;
2023         this->thread = thread;
2024         number = 0;
2025         active_point = 0;
2026         feather = 0;
2027 }
2028 CWindowMaskGUI::~CWindowMaskGUI()
2029 {
2030         lock_window("CWindowMaskGUI::~CWindowMaskGUI");
2031         delete number;
2032         delete active_point;
2033         delete feather;
2034         unlock_window();
2035 }
2036
2037 void CWindowMaskGUI::create_objects()
2038 {
2039         int x = 10, y = 10, margin = mwindow->theme->widget_border;
2040         //MaskAuto *keyframe = 0;
2041         //Track *track = mwindow->cwindow->calculate_affected_track();
2042         //if(track)
2043         //      keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(track->automation->autos[AUTOMATION_MASK], 0);
2044
2045         lock_window("CWindowMaskGUI::create_objects");
2046         BC_Title *title;
2047         add_subwindow(title = new BC_Title(x, y, _("Mode:")));
2048         add_subwindow(mode = new CWindowMaskMode(mwindow,
2049                 this, x + title->get_w() + margin, y, ""));
2050         mode->create_objects();
2051         y += mode->get_h() + margin;
2052         add_subwindow(title = new BC_Title(x, y, _("Value:")));
2053         add_subwindow(value = new CWindowMaskValue(mwindow, this, x + title->get_w() + margin, y));
2054         y += value->get_h() + margin;
2055         add_subwindow(delete_point = new CWindowMaskDelete(mwindow, this, x, y));
2056         int x1 = x + delete_point->get_w() + 2*margin;
2057         add_subwindow(title = new BC_Title(x1, y, _("Point:")));
2058         x1 += title->get_w() + margin;
2059         active_point = new CWindowMaskAffectedPoint(mwindow, this, x1, y);
2060         active_point->create_objects();
2061         y += delete_point->get_h() + margin;
2062         add_subwindow(title = new BC_Title(x, y, _("Mask number:")));
2063         number = new CWindowMaskNumber(mwindow,
2064                 this, x + title->get_w() + margin, y);
2065         number->create_objects();
2066         y += number->get_h() + margin;
2067         add_subwindow(title = new BC_Title(x, y, _("Feather:")));
2068         feather = new CWindowMaskFeather(mwindow,
2069                 this, x + title->get_w() + margin, y);
2070         feather->create_objects();
2071         y += feather->get_h() + margin;
2072         add_subwindow(title = new BC_Title(x, y, "X:"));
2073         x += title->get_w() + margin;
2074         this->x = new CWindowCoord(this, x, y, (float)0.0);
2075         this->x->create_objects();
2076         x += this->x->get_w() + margin;
2077         add_subwindow(title = new BC_Title(x, y, "Y:"));
2078         x += title->get_w() + margin;
2079         this->y = new CWindowCoord(this, x, y, (float)0.0);
2080         this->y->create_objects();
2081
2082         x = 10;
2083         y += this->y->get_h() + margin;
2084         add_subwindow(title = new BC_Title(x, y, _("Press Shift to move an end point")));
2085         y += title->get_h() + margin;
2086         add_subwindow(title = new BC_Title(x, y, _("Press Ctrl to move a control point")));
2087         y += title->get_h() + margin;
2088         add_subwindow(title = new BC_Title(x, y, _("Press Alt to translate the mask")));
2089         y += 30;
2090
2091         add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, 10, y));
2092         y += this->apply_before_plugins->get_h() + margin;
2093         add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, 10, y));
2094
2095         update();
2096         unlock_window();
2097 }
2098
2099 void CWindowMaskGUI::get_keyframe(Track* &track,
2100         MaskAutos* &autos,
2101         MaskAuto* &keyframe,
2102         SubMask* &mask,
2103         MaskPoint* &point,
2104         int create_it)
2105 {
2106         autos = 0;
2107         keyframe = 0;
2108
2109         track = mwindow->cwindow->calculate_affected_track();
2110         if(track)
2111         {
2112                 autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2113                 keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
2114                         autos,
2115                         create_it);
2116         }
2117
2118         if(keyframe)
2119                 mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2120         else
2121                 mask = 0;
2122
2123         point = 0;
2124         if(keyframe)
2125         {
2126                 if(mwindow->cwindow->gui->affected_point < mask->points.total &&
2127                         mwindow->cwindow->gui->affected_point >= 0)
2128                 {
2129                         point = mask->points.values[mwindow->cwindow->gui->affected_point];
2130                 }
2131         }
2132 }
2133
2134 void CWindowMaskGUI::update()
2135 {
2136         Track *track;
2137         MaskAutos *autos;
2138         MaskAuto *keyframe;
2139         SubMask *mask;
2140         MaskPoint *point;
2141 //printf("CWindowMaskGUI::update 1\n");
2142         get_keyframe(track, autos, keyframe, mask, point, 0);
2143
2144         double position = mwindow->edl->local_session->get_selectionstart(1);
2145         position = mwindow->edl->align_to_frame(position, 0);
2146         if(track)
2147         {
2148                 int64_t position_i = track->to_units(position, 0);
2149
2150                 if(point)
2151                 {
2152                         x->update(point->x);
2153                         y->update(point->y);
2154                 }
2155
2156                 if(mask)
2157                 {
2158                         feather->update((int64_t)autos->get_feather(position_i, PLAY_FORWARD));
2159                         value->update((int64_t)autos->get_value(position_i, PLAY_FORWARD));
2160                         apply_before_plugins->update((int64_t)keyframe->apply_before_plugins);
2161                         disable_opengl_masking->update((int64_t)keyframe->disable_opengl_masking);
2162                 }
2163         }
2164
2165 //printf("CWindowMaskGUI::update 1\n");
2166         active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
2167         number->update((int64_t)mwindow->edl->session->cwindow_mask);
2168
2169 //printf("CWindowMaskGUI::update 1\n");
2170         if(track)
2171         {
2172 #ifdef USE_KEYFRAME_SPANNING
2173                 mode->set_text(
2174                         CWindowMaskMode::mode_to_text(keyframe->mode));
2175 #else
2176                 mode->set_text(
2177                         CWindowMaskMode::mode_to_text(((MaskAuto*)autos->default_auto)->mode));
2178 #endif
2179         }
2180 //printf("CWindowMaskGUI::update 2\n");
2181 }
2182
2183 void CWindowMaskGUI::handle_event()
2184 {
2185         Track *track;
2186         MaskAuto *keyframe;
2187         MaskAutos *autos;
2188         SubMask *mask;
2189         MaskPoint *point;
2190         get_keyframe(track, autos, keyframe, mask, point, 0);
2191
2192         mwindow->undo->update_undo_before(_("mask point"), this);
2193
2194         if(point)
2195         {
2196 #ifdef USE_KEYFRAME_SPANNING
2197 // Create temp keyframe
2198                 MaskAuto temp_keyframe(mwindow->edl, autos);
2199                 temp_keyframe.copy_data(keyframe);
2200 // Get affected point in temp keyframe
2201                 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2202                 if(mwindow->cwindow->gui->affected_point < mask->points.total &&
2203                         mwindow->cwindow->gui->affected_point >= 0)
2204                 {
2205                         point = mask->points.values[mwindow->cwindow->gui->affected_point];
2206                 }
2207
2208                 if(point)
2209                 {
2210                         point->x = atof(x->get_text());
2211                         point->y = atof(y->get_text());
2212 // Commit to spanned keyframes
2213                         autos->update_parameter(&temp_keyframe);
2214                 }
2215 #else
2216                 point->x = atof(x->get_text());
2217                 point->y = atof(y->get_text());
2218 #endif
2219         }
2220
2221         update_preview();
2222         mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
2223 }
2224
2225 void CWindowMaskGUI::update_preview()
2226 {
2227         mwindow->restart_brender();
2228         mwindow->sync_parameters(CHANGE_PARAMS);
2229         mwindow->cwindow->playback_engine->que->send_command(CURRENT_FRAME,
2230                         CHANGE_NONE,
2231                         mwindow->edl,
2232                         1);
2233         mwindow->cwindow->gui->lock_window("CWindowMaskGUI::update_preview");
2234         mwindow->cwindow->gui->canvas->draw_refresh();
2235         mwindow->cwindow->gui->unlock_window();
2236 }
2237
2238
2239 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
2240  : CWindowToolGUI(mwindow,
2241         thread,
2242         _(PROGRAM_NAME ": Ruler"),
2243         320,
2244         240)
2245 {
2246 }
2247
2248 CWindowRulerGUI::~CWindowRulerGUI()
2249 {
2250 }
2251
2252 void CWindowRulerGUI::create_objects()
2253 {
2254         int x = 10, y = 10;
2255         BC_Title *title;
2256
2257         lock_window("CWindowRulerGUI::create_objects");
2258         add_subwindow(title = new BC_Title(x, y, _("Current:")));
2259         add_subwindow(current = new BC_Title(x + title->get_w() + 10, y, ""));
2260         y += title->get_h() + 5;
2261
2262         add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
2263         add_subwindow(point1 = new BC_Title(x + title->get_w() + 10, y, ""));
2264         y += title->get_h() + 5;
2265
2266         add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
2267         add_subwindow(point2 = new BC_Title(x + title->get_w() + 10, y, ""));
2268         y += title->get_h() + 5;
2269
2270         add_subwindow(title = new BC_Title(x, y, _("Distance:")));
2271         add_subwindow(distance = new BC_Title(x + title->get_w() + 10, y, ""));
2272         y += title->get_h() + 5;
2273         add_subwindow(title = new BC_Title(x, y, _("Angle:")));
2274         add_subwindow(angle = new BC_Title(x + title->get_w() + 10, y, ""));
2275         y += title->get_h() + 10;
2276         char string[BCTEXTLEN];
2277         sprintf(string, _("Press Ctrl to lock ruler to the\nnearest 45%c angle."), 0xb0);
2278         add_subwindow(title = new BC_Title(x,
2279                 y,
2280                 string));
2281         y += title->get_h() + 10;
2282         sprintf(string, _("Press Alt to translate the ruler."));
2283         add_subwindow(title = new BC_Title(x,
2284                 y,
2285                 string));
2286         update();
2287         unlock_window();
2288 }
2289
2290 void CWindowRulerGUI::update()
2291 {
2292         double distance_value =
2293                 sqrt(SQR(mwindow->edl->session->ruler_x2 - mwindow->edl->session->ruler_x1) +
2294                 SQR(mwindow->edl->session->ruler_y2 - mwindow->edl->session->ruler_y1));
2295         double angle_value = atan((mwindow->edl->session->ruler_y2 - mwindow->edl->session->ruler_y1) /
2296                 (mwindow->edl->session->ruler_x2 - mwindow->edl->session->ruler_x1)) *
2297                 360 /
2298                 2 /
2299                 M_PI;
2300
2301         if(EQUIV(distance_value, 0.0))
2302         {
2303                 angle_value = 0.0;
2304         }
2305         else
2306         if(angle_value < 0)
2307         {
2308                 angle_value *= -1;
2309         }
2310
2311         char string[BCTEXTLEN];
2312         sprintf(string, "%d, %d",
2313                 mwindow->session->cwindow_output_x,
2314                 mwindow->session->cwindow_output_y);
2315         current->update(string);
2316         sprintf(string, "%.0f, %.0f",
2317                 mwindow->edl->session->ruler_x1,
2318                 mwindow->edl->session->ruler_y1);
2319         point1->update(string);
2320         sprintf(string, "%.0f, %.0f",
2321                 mwindow->edl->session->ruler_x2,
2322                 mwindow->edl->session->ruler_y2);
2323         point2->update(string);
2324
2325         sprintf(string, _("%0.01f pixels"), distance_value);
2326         distance->update(string);
2327         sprintf(string, "%0.02f %c", angle_value, 0xb0);
2328         angle->update(string);
2329 }
2330
2331 void CWindowRulerGUI::handle_event()
2332 {
2333 }
2334
2335
2336
2337