cinelerra-5.1/cinelerra/cwindowtool.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 2008-2017 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdint.h>
  23
  24 #include "automation.h"
  25 #include "bccolors.h"
  26 #include "bctimer.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 "file.h"
  37 #include "filexml.h"
  38 #include "floatauto.h"
  39 #include "floatautos.h"
  40 #include "gwindowgui.h"
  41 #include "keys.h"
  42 #include "language.h"
  43 #include "localsession.h"
  44 #include "mainsession.h"
  45 #include "mainundo.h"
  46 #include "maskauto.h"
  47 #include "maskautos.h"
  48 #include "mutex.h"
  49 #include "mwindow.h"
  50 #include "mwindowgui.h"
  51 #include "theme.h"
  52 #include "track.h"
  53 #include "tracks.h"
  54 #include "trackcanvas.h"
  55 #include "transportque.h"
  56 #include "zoombar.h"
  57
  58
  59 CWindowTool::CWindowTool(MWindow *mwindow, CWindowGUI *gui)
  60  : Thread(1, 0, 0)
  61 {
  62         this->mwindow = mwindow;
  63         this->gui = gui;
  64         tool_gui = 0;
  65         done = 0;
  66         current_tool = CWINDOW_NONE;
  67         set_synchronous(1);
  68         input_lock = new Condition(0, "CWindowTool::input_lock");
  69         output_lock = new Condition(1, "CWindowTool::output_lock");
  70         tool_gui_lock = new Mutex("CWindowTool::tool_gui_lock");
  71 }
  72
  73 CWindowTool::~CWindowTool()
  74 {
  75         done = 1;
  76         stop_tool();
  77         input_lock->unlock();
  78         Thread::join();
  79         delete input_lock;
  80         delete output_lock;
  81         delete tool_gui_lock;
  82 }
  83
  84 void CWindowTool::start_tool(int operation)
  85 {
  86         CWindowToolGUI *new_gui = 0;
  87         int result = 0;
  88
  89 //printf("CWindowTool::start_tool 1\n");
  90         if(current_tool != operation)
  91         {
  92                 int previous_tool = current_tool;
  93                 current_tool = operation;
  94                 switch(operation)
  95                 {
  96                         case CWINDOW_EYEDROP:
  97                                 new_gui = new CWindowEyedropGUI(mwindow, this);
  98                                 break;
  99                         case CWINDOW_CROP:
 100                                 new_gui = new CWindowCropGUI(mwindow, this);
 101                                 break;
 102                         case CWINDOW_CAMERA:
 103                                 new_gui = new CWindowCameraGUI(mwindow, this);
 104                                 break;
 105                         case CWINDOW_PROJECTOR:
 106                                 new_gui = new CWindowProjectorGUI(mwindow, this);
 107                                 break;
 108                         case CWINDOW_MASK:
 109                                 new_gui = new CWindowMaskGUI(mwindow, this);
 110                                 break;
 111                         case CWINDOW_RULER:
 112                                 new_gui = new CWindowRulerGUI(mwindow, this);
 113                                 break;
 114                         case CWINDOW_PROTECT:
 115                                 mwindow->edl->session->tool_window = 0;
 116                                 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(0);
 117                                 // fall thru
 118                         default:
 119                                 result = 1;
 120                                 stop_tool();
 121                                 break;
 122                 }
 123
 124 //printf("CWindowTool::start_tool 1\n");
 125
 126
 127                 if(!result)
 128                 {
 129                         stop_tool();
 130 // Wait for previous tool GUI to finish
 131                         output_lock->lock("CWindowTool::start_tool");
 132                         this->tool_gui = new_gui;
 133                         tool_gui->create_objects();
 134                         if( previous_tool == CWINDOW_PROTECT || previous_tool == CWINDOW_NONE ) {
 135                                 mwindow->edl->session->tool_window = 1;
 136                                 gui->composite_panel->operation[CWINDOW_TOOL_WINDOW]->update(1);
 137                         }
 138                         mwindow->edl->session->tool_window = new_gui ? 1 : 0;
 139                         update_show_window();
 140
 141 // Signal thread to run next tool GUI
 142                         input_lock->unlock();
 143                 }
 144 //printf("CWindowTool::start_tool 1\n");
 145         }
 146         else
 147         if(tool_gui)
 148         {
 149                 tool_gui->lock_window("CWindowTool::start_tool");
 150                 tool_gui->update();
 151                 tool_gui->unlock_window();
 152         }
 153
 154 //printf("CWindowTool::start_tool 2\n");
 155
 156 }
 157
 158
 159 void CWindowTool::stop_tool()
 160 {
 161         if(tool_gui)
 162         {
 163                 tool_gui->lock_window("CWindowTool::stop_tool");
 164                 tool_gui->set_done(0);
 165                 tool_gui->unlock_window();
 166         }
 167 }
 168
 169 void CWindowTool::show_tool()
 170 {
 171         if(tool_gui && mwindow->edl->session->tool_window)
 172         {
 173                 tool_gui->lock_window("CWindowTool::show_tool");
 174                 tool_gui->show_window();
 175                 tool_gui->unlock_window();
 176         }
 177 }
 178
 179 void CWindowTool::hide_tool()
 180 {
 181         if(tool_gui && mwindow->edl->session->tool_window)
 182         {
 183                 tool_gui->lock_window("CWindowTool::show_tool");
 184                 tool_gui->hide_window();
 185                 tool_gui->unlock_window();
 186         }
 187 }
 188
 189 void CWindowTool::raise_tool()
 190 {
 191         if(tool_gui && mwindow->edl->session->tool_window)
 192         {
 193                 tool_gui->lock_window("CWindowTool::show_tool");
 194                 tool_gui->raise_window();
 195                 tool_gui->unlock_window();
 196         }
 197 }
 198
 199
 200 void CWindowTool::run()
 201 {
 202         while(!done)
 203         {
 204                 input_lock->lock("CWindowTool::run");
 205                 if(!done)
 206                 {
 207                         tool_gui->run_window();
 208                         tool_gui_lock->lock("CWindowTool::run");
 209                         delete tool_gui;
 210                         tool_gui = 0;
 211                         tool_gui_lock->unlock();
 212                 }
 213                 output_lock->unlock();
 214         }
 215 }
 216
 217 void CWindowTool::update_show_window()
 218 {
 219         if(tool_gui)
 220         {
 221                 tool_gui->lock_window("CWindowTool::update_show_window");
 222
 223                 if(mwindow->edl->session->tool_window)
 224                 {
 225                         tool_gui->update();
 226                         tool_gui->show_window();
 227                 }
 228                 else
 229                         tool_gui->hide_window();
 230                 tool_gui->flush();
 231
 232                 tool_gui->unlock_window();
 233         }
 234 }
 235
 236 void CWindowTool::raise_window()
 237 {
 238         if(tool_gui)
 239         {
 240                 gui->unlock_window();
 241                 tool_gui->lock_window("CWindowTool::raise_window");
 242                 tool_gui->raise_window();
 243                 tool_gui->unlock_window();
 244                 gui->lock_window("CWindowTool::raise_window");
 245         }
 246 }
 247
 248 void CWindowTool::update_values()
 249 {
 250         tool_gui_lock->lock("CWindowTool::update_values");
 251         if(tool_gui)
 252         {
 253                 tool_gui->lock_window("CWindowTool::update_values");
 254                 tool_gui->update();
 255                 tool_gui->flush();
 256                 tool_gui->unlock_window();
 257         }
 258         tool_gui_lock->unlock();
 259 }
 260
 261
 262
 263
 264
 265
 266
 267 CWindowToolGUI::CWindowToolGUI(MWindow *mwindow,
 268         CWindowTool *thread, const char *title, int w, int h)
 269  : BC_Window(title,
 270                 mwindow->session->ctool_x, mwindow->session->ctool_y,
 271                 w, h, w, h, 0, 0, 1)
 272 {
 273         this->mwindow = mwindow;
 274         this->thread = thread;
 275         current_operation = 0;
 276 }
 277
 278 CWindowToolGUI::~CWindowToolGUI()
 279 {
 280 }
 281
 282 int CWindowToolGUI::close_event()
 283 {
 284         hide_window();
 285         flush();
 286         mwindow->edl->session->tool_window = 0;
 287         unlock_window();
 288         thread->gui->lock_window("CWindowToolGUI::close_event");
 289         thread->gui->composite_panel->set_operation(mwindow->edl->session->cwindow_operation);
 290         thread->gui->flush();
 291         thread->gui->unlock_window();
 292         lock_window("CWindowToolGUI::close_event");
 293         return 1;
 294 }
 295
 296 int CWindowToolGUI::keypress_event()
 297 {
 298         int result = 0;
 299
 300         switch( get_keypress() ) {
 301         case 'w':
 302         case 'W':
 303                 return close_event();
 304         case KEY_F1:
 305         case KEY_F2:
 306         case KEY_F3:
 307         case KEY_F4:
 308         case KEY_F5:
 309         case KEY_F6:
 310         case KEY_F7:
 311         case KEY_F8:
 312         case KEY_F9:
 313         case KEY_F10:
 314         case KEY_F11:
 315         case KEY_F12:
 316                 resend_event(thread->gui);
 317                 result = 1;
 318         }
 319
 320         return result;
 321 }
 322
 323 int CWindowToolGUI::translation_event()
 324 {
 325         mwindow->session->ctool_x = get_x();
 326         mwindow->session->ctool_y = get_y();
 327         return 0;
 328 }
 329
 330
 331 void CWindowToolGUI::update_preview(int changed_edl)
 332 {
 333         unlock_window();
 334         draw_preview(changed_edl);
 335         lock_window("CWindowToolGUI::update_preview");
 336 }
 337
 338 void CWindowToolGUI::draw_preview(int changed_edl)
 339 {
 340         CWindowGUI *cgui = mwindow->cwindow->gui;
 341         cgui->lock_window("CWindowToolGUI::draw_preview");
 342         int change_type = !changed_edl ? CHANGE_PARAMS : CHANGE_EDL;
 343         cgui->sync_parameters(change_type, 0, 1);
 344         cgui->unlock_window();
 345 }
 346
 347
 348 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, float value, int type)
 349  : BC_TumbleTextBox(gui, (float)value, (float)-65536, (float)65536, x, y, xS(70), 3)
 350 {
 351         this->gui = gui;
 352         this->type = type;
 353         slider = 0;
 354         range = 0;
 355 }
 356
 357 CWindowCoord::CWindowCoord(CWindowToolGUI *gui, int x, int y, int value, int type)
 358  : BC_TumbleTextBox(gui, (int64_t)value, (int64_t)-65536, (int64_t)65536, x, y, xS(70))
 359 {
 360         this->gui = gui;
 361         this->type = type;
 362         slider = 0;
 363         range = 0;
 364 }
 365
 366 void CWindowCoord::create_objects()
 367 {
 368         BC_TumbleTextBox::create_objects();
 369         if( type >= 0 ) {
 370                 int x1 = get_x() + BC_TumbleTextBox::get_w() + xS(10), y1 = get_y();
 371                 int group = Automation::autogrouptype(type, 0);
 372                 float min = gui->mwindow->edl->local_session->automation_mins[group];
 373                 float max = gui->mwindow->edl->local_session->automation_maxs[group];
 374                 float v = atof(get_text());
 375                 gui->add_subwindow(slider = new CWindowCoordSlider(this,
 376                                 x1, y1, xS(150), min, max, v));
 377                 x1 += slider->get_w() + xS(5);
 378                 gui->add_subwindow(range = new CWindowCoordRange(this, x1, y1));
 379         }
 380 }
 381
 382 void CWindowCoord::update_gui(float value)
 383 {
 384         BC_TumbleTextBox::update(value);
 385         if( slider ) {
 386                 int group = Automation::autogrouptype(type, 0);
 387                 LocalSession *local_session = gui->mwindow->edl->local_session;
 388                 slider->update(slider->get_pointer_motion_range(), value,
 389                         local_session->automation_mins[group],
 390                         local_session->automation_maxs[group]);
 391                 int x1 = range->get_x() + range->get_w() + xS(5);
 392                 int y1 = range->get_y() - yS(2), d = xS(16);
 393                 gui->set_color(GWindowGUI::auto_colors[type]);
 394                 gui->draw_disc(x1, y1, d, d);
 395         }
 396 }
 397
 398 int CWindowCoord::handle_event()
 399 {
 400         if( slider )
 401                 slider->update(atof(get_text()));
 402         gui->event_caller = this;
 403         gui->handle_event();
 404         return 1;
 405 }
 406
 407 CWindowCoordSlider::CWindowCoordSlider(CWindowCoord *coord,
 408                 int x, int y, int w, float mn, float mx, float value)
 409  : BC_FSlider(x, y, 0, w, w, mn, mx, value)
 410 {
 411         this->coord = coord;
 412         set_precision(0.01);
 413 }
 414
 415 CWindowCoordSlider::~CWindowCoordSlider()
 416 {
 417 }
 418
 419 int CWindowCoordSlider::handle_event()
 420 {
 421         float value = get_value();
 422         coord->update(value);
 423         coord->gui->event_caller = coord;
 424         coord->gui->handle_event();
 425         return 1;
 426 }
 427
 428 CWindowCoordRange::CWindowCoordRange(CWindowCoord *coord, int x, int y)
 429  : BC_Tumbler(x, y)
 430 {
 431         this->coord = coord;
 432 }
 433 CWindowCoordRange::~CWindowCoordRange()
 434 {
 435 }
 436
 437 int CWindowCoordRange::update(float scale)
 438 {
 439         MWindow *mwindow = coord->gui->mwindow;
 440         LocalSession *local_session = mwindow->edl->local_session;
 441         int group = Automation::autogrouptype(coord->type, 0);
 442         float min = local_session->automation_mins[group];
 443         float max = local_session->automation_maxs[group];
 444         if( min >= max ) {
 445                 switch( group ) {
 446                 case AUTOGROUPTYPE_ZOOM: min = 0.005;  max = 5.0;  break;
 447                 case AUTOGROUPTYPE_X:    min = -100;   max = 100;  break;
 448                 case AUTOGROUPTYPE_Y:    min = -100;   max = 100;  break;
 449                 }
 450         }
 451         float range = max - min;
 452         min -= range * scale;
 453         max += range * scale;
 454         switch( group ) {
 455         case AUTOGROUPTYPE_ZOOM:
 456                 if( min < 0.001 ) min = 0.001;
 457                 if( max > 1000. ) max = 1000.;
 458                 break;
 459         case AUTOGROUPTYPE_X:
 460         case AUTOGROUPTYPE_Y:
 461                 if( min < -32767 ) min = -32767;
 462                 if( max >  32767 ) max =  32767;
 463                 break;
 464         }
 465         CWindowCoordSlider *slider = coord->slider;
 466         coord->slider->update(slider->get_pointer_motion_range(),
 467                         slider->get_value(), min, max);
 468         unlock_window();
 469         MWindowGUI *mgui = mwindow->gui;
 470         mgui->lock_window("CWindowCoordRange::update");
 471         local_session->zoombar_showautotype = group;
 472         local_session->automation_mins[group] = min;
 473         local_session->automation_maxs[group] = max;
 474         mgui->zoombar->update_autozoom();
 475         mgui->draw_overlays(0);
 476         mgui->update_patchbay();
 477         mgui->flash_canvas(1);
 478         mgui->unlock_window();
 479         lock_window("CWindowCoordRange::update");
 480         return 1;
 481 }
 482
 483 int CWindowCoordRange::handle_up_event()
 484 {
 485         return update(0.5);
 486 }
 487 int CWindowCoordRange::handle_down_event()
 488 {
 489         return update(-0.25);
 490 }
 491
 492 CWindowCropApply::CWindowCropApply(MWindow *mwindow, CWindowCropGUI *crop_gui, int x, int y)
 493  : BC_GenericButton(x, y, _("Apply"))
 494 {
 495         this->mwindow = mwindow;
 496         this->crop_gui = crop_gui;
 497 }
 498 int CWindowCropApply::handle_event()
 499 {
 500         mwindow->crop_video(crop_gui->crop_mode->mode);
 501         return 1;
 502 }
 503
 504
 505 int CWindowCropApply::keypress_event()
 506 {
 507         if(get_keypress() == 0xd)
 508         {
 509                 handle_event();
 510                 return 1;
 511         }
 512         return 0;
 513 }
 514
 515 const char *CWindowCropOpMode::crop_ops[] = {
 516         N_("Reformat"),
 517         N_("Resize"),
 518         N_("Shrink"),
 519 };
 520
 521 CWindowCropOpMode::CWindowCropOpMode(MWindow *mwindow, CWindowCropGUI *crop_gui,
 522                         int mode, int x, int y)
 523  : BC_PopupMenu(x, y, xS(140), _(crop_ops[mode]), 1)
 524 {
 525         this->mwindow = mwindow;
 526         this->crop_gui = crop_gui;
 527         this->mode = mode;
 528 }
 529 CWindowCropOpMode::~CWindowCropOpMode()
 530 {
 531 }
 532
 533 void CWindowCropOpMode::create_objects()
 534 {
 535         for( int id=0,nid=sizeof(crop_ops)/sizeof(crop_ops[0]); id<nid; ++id )
 536                 add_item(new CWindowCropOpItem(this, _(crop_ops[id]), id));
 537         handle_event();
 538 }
 539
 540 int CWindowCropOpMode::handle_event()
 541 {
 542         set_text(_(crop_ops[mode]));
 543         return 1;
 544 }
 545
 546 CWindowCropOpItem::CWindowCropOpItem(CWindowCropOpMode *popup, const char *text, int id)
 547  : BC_MenuItem(text)
 548 {
 549         this->popup = popup;
 550         this->id = id;
 551 }
 552
 553 int CWindowCropOpItem::handle_event()
 554 {
 555         popup->set_text(get_text());
 556         popup->mode = id;
 557         return popup->handle_event();
 558 }
 559
 560
 561
 562
 563
 564 CWindowCropGUI::CWindowCropGUI(MWindow *mwindow, CWindowTool *thread)
 565  : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Crop"), xS(330), yS(100))
 566 {
 567 }
 568
 569
 570 CWindowCropGUI::~CWindowCropGUI()
 571 {
 572 }
 573
 574 void CWindowCropGUI::create_objects()
 575 {
 576         int xs5 = xS(5), xs10 = xS(10);
 577         int ys5 = yS(5), ys10 = yS(10);
 578         int x = xs10, y = ys10;
 579         BC_Title *title;
 580
 581         lock_window("CWindowCropGUI::create_objects");
 582         int column1 = 0;
 583         int pad = MAX(BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1),
 584                 BC_Title::calculate_h(this, "X")) + ys5;
 585         add_subwindow(title = new BC_Title(x, y, "X1:"));
 586         column1 = MAX(column1, title->get_w());
 587         y += pad;
 588         add_subwindow(title = new BC_Title(x, y, _("W:")));
 589         column1 = MAX(column1, title->get_w());
 590         y += pad;
 591         add_subwindow(new CWindowCropApply(mwindow, this, x, y));
 592
 593         x += column1 + xs5;
 594         y = ys10;
 595         x1 = new CWindowCoord(thread->tool_gui, x, y,
 596                 mwindow->edl->session->crop_x1);
 597         x1->create_objects();
 598         x1->set_boundaries((int64_t)0, (int64_t)65536);
 599         y += pad;
 600         width = new CWindowCoord(thread->tool_gui, x, y,
 601                 mwindow->edl->session->crop_x2 - mwindow->edl->session->crop_x1);
 602         width->create_objects();
 603         width->set_boundaries((int64_t)1, (int64_t)65536);
 604
 605
 606         x += x1->get_w() + xs10;
 607         y = ys10;
 608         int column2 = 0;
 609         add_subwindow(title = new BC_Title(x, y, "Y1:"));
 610         column2 = MAX(column2, title->get_w());
 611         y += pad;
 612         add_subwindow(title = new BC_Title(x, y, _("H:")));
 613         column2 = MAX(column2, title->get_w());
 614         y += pad;
 615
 616         y = ys10;
 617         x += column2 + xs5;
 618         y1 = new CWindowCoord(thread->tool_gui, x, y,
 619                 mwindow->edl->session->crop_y1);
 620         y1->create_objects();
 621         y1->set_boundaries((int64_t)0, (int64_t)65536);
 622         y += pad;
 623
 624         height = new CWindowCoord(thread->tool_gui, x, y,
 625                 mwindow->edl->session->crop_y2 - mwindow->edl->session->crop_y1);
 626         height->create_objects();
 627         height->set_boundaries((int64_t)1, (int64_t)65536);
 628         y += pad;
 629
 630         add_subwindow(crop_mode = new CWindowCropOpMode(mwindow, this,
 631                                 CROP_REFORMAT, x, y));
 632         crop_mode->create_objects();
 633
 634         unlock_window();
 635 }
 636
 637 void CWindowCropGUI::handle_event()
 638 {
 639         int new_x1, new_y1;
 640         new_x1 = atol(x1->get_text());
 641         new_y1 = atol(y1->get_text());
 642         if(new_x1 != mwindow->edl->session->crop_x1)
 643         {
 644                 mwindow->edl->session->crop_x2 = new_x1 +
 645                         mwindow->edl->session->crop_x2 -
 646                         mwindow->edl->session->crop_x1;
 647                 mwindow->edl->session->crop_x1 = new_x1;
 648         }
 649         if(new_y1 != mwindow->edl->session->crop_y1)
 650         {
 651                 mwindow->edl->session->crop_y2 = new_y1 +
 652                         mwindow->edl->session->crop_y2 -
 653                         mwindow->edl->session->crop_y1;
 654                 mwindow->edl->session->crop_y1 = atol(y1->get_text());
 655         }
 656         mwindow->edl->session->crop_x2 = atol(width->get_text()) +
 657                 mwindow->edl->session->crop_x1;
 658         mwindow->edl->session->crop_y2 = atol(height->get_text()) +
 659                 mwindow->edl->session->crop_y1;
 660         update();
 661         mwindow->cwindow->gui->canvas->redraw(1);
 662 }
 663
 664 void CWindowCropGUI::update()
 665 {
 666         x1->update((int64_t)mwindow->edl->session->crop_x1);
 667         y1->update((int64_t)mwindow->edl->session->crop_y1);
 668         width->update((int64_t)mwindow->edl->session->crop_x2 -
 669                 mwindow->edl->session->crop_x1);
 670         height->update((int64_t)mwindow->edl->session->crop_y2 -
 671                 mwindow->edl->session->crop_y1);
 672 }
 673
 674
 675 CWindowEyedropGUI::CWindowEyedropGUI(MWindow *mwindow, CWindowTool *thread)
 676  : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Color"), xS(220), yS(290))
 677 {
 678 }
 679
 680 CWindowEyedropGUI::~CWindowEyedropGUI()
 681 {
 682 }
 683
 684 void CWindowEyedropGUI::create_objects()
 685 {
 686         int xs10 = xS(10), ys10 = yS(10);
 687         int margin = mwindow->theme->widget_border;
 688         int x = xs10 + margin;
 689         int y = ys10 + margin;
 690         int x2 = xS(70), x3 = x2 + xS(60);
 691         lock_window("CWindowEyedropGUI::create_objects");
 692         BC_Title *title0, *title1, *title2, *title3, *title4, *title5, *title6, *title7;
 693         add_subwindow(title0 = new BC_Title(x, y,_("X,Y:")));
 694         y += title0->get_h() + margin;
 695         add_subwindow(title7 = new BC_Title(x, y, _("Radius:")));
 696         y += BC_TextBox::calculate_h(this, MEDIUMFONT, 1, 1) + margin;
 697
 698         add_subwindow(title1 = new BC_Title(x, y, _("Red:")));
 699         y += title1->get_h() + margin;
 700         add_subwindow(title2 = new BC_Title(x, y, _("Green:")));
 701         y += title2->get_h() + margin;
 702         add_subwindow(title3 = new BC_Title(x, y, _("Blue:")));
 703         y += title3->get_h() + margin;
 704
 705         add_subwindow(title4 = new BC_Title(x, y, "Y:"));
 706         y += title4->get_h() + margin;
 707         add_subwindow(title5 = new BC_Title(x, y, "U:"));
 708         y += title5->get_h() + margin;
 709         add_subwindow(title6 = new BC_Title(x, y, "V:"));
 710
 711         add_subwindow(current = new BC_Title(x2, title0->get_y(), ""));
 712
 713         radius = new CWindowCoord(this, x2, title7->get_y(),
 714                 mwindow->edl->session->eyedrop_radius);
 715         radius->create_objects();
 716         radius->set_boundaries((int64_t)0, (int64_t)255);
 717
 718         add_subwindow(red = new BC_Title(x2, title1->get_y(), "0"));
 719         add_subwindow(green = new BC_Title(x2, title2->get_y(), "0"));
 720         add_subwindow(blue = new BC_Title(x2, title3->get_y(), "0"));
 721         add_subwindow(rgb_hex = new BC_Title(x3, red->get_y(), "#000000"));
 722
 723         add_subwindow(this->y = new BC_Title(x2, title4->get_y(), "0"));
 724         add_subwindow(this->u = new BC_Title(x2, title5->get_y(), "0"));
 725         add_subwindow(this->v = new BC_Title(x2, title6->get_y(), "0"));
 726         add_subwindow(yuv_hex = new BC_Title(x3, this->y->get_y(), "#000000"));
 727
 728         y = title6->get_y() + this->v->get_h() + 2*margin;
 729         add_subwindow(sample = new BC_SubWindow(x, y, xS(50), yS(50)));
 730         y += sample->get_h() + margin;
 731         add_subwindow(use_max = new CWindowEyedropCheckBox(mwindow, this, x, y));
 732         update();
 733         unlock_window();
 734 }
 735
 736 void CWindowEyedropGUI::update()
 737 {
 738         char string[BCTEXTLEN];
 739         sprintf(string, "%d, %d",
 740                 thread->gui->eyedrop_x,
 741                 thread->gui->eyedrop_y);
 742         current->update(string);
 743
 744         radius->update((int64_t)mwindow->edl->session->eyedrop_radius);
 745
 746         LocalSession *local_session = mwindow->edl->local_session;
 747         int use_max = local_session->use_max;
 748         float r = use_max ? local_session->red_max : local_session->red;
 749         float g = use_max ? local_session->green_max : local_session->green;
 750         float b = use_max ? local_session->blue_max : local_session->blue;
 751         this->red->update(r);
 752         this->green->update(g);
 753         this->blue->update(b);
 754
 755         int rx = 255*r + 0.5;  bclamp(rx,0,255);
 756         int gx = 255*g + 0.5;  bclamp(gx,0,255);
 757         int bx = 255*b + 0.5;  bclamp(bx,0,255);
 758         char rgb_text[BCSTRLEN];
 759         sprintf(rgb_text, "#%02x%02x%02x", rx, gx, bx);
 760         rgb_hex->update(rgb_text);
 761
 762         float y, u, v;
 763         YUV::yuv.rgb_to_yuv_f(r, g, b, y, u, v);
 764         this->y->update(y);
 765         this->u->update(u += 0.5);
 766         this->v->update(v += 0.5);
 767
 768         int yx = 255*y + 0.5;  bclamp(yx,0,255);
 769         int ux = 255*u + 0.5;  bclamp(ux,0,255);
 770         int vx = 255*v + 0.5;  bclamp(vx,0,255);
 771         char yuv_text[BCSTRLEN];
 772         sprintf(yuv_text, "#%02x%02x%02x", yx, ux, vx);
 773         yuv_hex->update(yuv_text);
 774
 775         int rgb = (rx << 16) | (gx << 8) | (bx << 0);
 776         sample->set_color(rgb);
 777         sample->draw_box(0, 0, sample->get_w(), sample->get_h());
 778         sample->set_color(BLACK);
 779         sample->draw_rectangle(0, 0, sample->get_w(), sample->get_h());
 780         sample->flash();
 781 }
 782
 783 void CWindowEyedropGUI::handle_event()
 784 {
 785         int new_radius = atoi(radius->get_text());
 786         if(new_radius != mwindow->edl->session->eyedrop_radius)
 787         {
 788                 CWindowGUI *gui = mwindow->cwindow->gui;
 789                 if(gui->eyedrop_visible)
 790                 {
 791                         gui->lock_window("CWindowEyedropGUI::handle_event");
 792 // hide it
 793                         int rerender;
 794                         gui->canvas->do_eyedrop(rerender, 0, 1);
 795                 }
 796
 797                 mwindow->edl->session->eyedrop_radius = new_radius;
 798
 799                 if(gui->eyedrop_visible)
 800                 {
 801 // draw it
 802                         int rerender;
 803                         gui->canvas->do_eyedrop(rerender, 0, 1);
 804                         gui->unlock_window();
 805                 }
 806         }
 807 }
 808
 809
 810
 811 /* Buttons to control Keyframe-Curve-Mode for Projector or Camera */
 812
 813 // Configuration for all possible Keyframe Curve Mode toggles
 814 struct _CVD {
 815         FloatAuto::t_mode mode;
 816         bool use_camera;
 817         const char* icon_id;
 818         const char* tooltip;
 819 };
 820
 821 const _CVD Camera_Crv_Smooth =
 822         {       FloatAuto::SMOOTH,
 823                 true,
 824                 "tan_smooth",
 825                 N_("\"smooth\" Curve on current Camera Keyframes")
 826         };
 827 const _CVD Camera_Crv_Linear =
 828         {       FloatAuto::LINEAR,
 829                 true,
 830                 "tan_linear",
 831                 N_("\"linear\" Curve on current Camera Keyframes")
 832         };
 833 const _CVD Projector_Crv_Smooth =
 834         {       FloatAuto::SMOOTH,
 835                 false,
 836                 "tan_smooth",
 837                 N_("\"smooth\" Curve on current Projector Keyframes")
 838         };
 839 const _CVD Projector_Crv_Linear =
 840         {       FloatAuto::LINEAR,
 841                 false,
 842                 "tan_linear",
 843                 N_("\"linear\" Curve on current Projector Keyframes")
 844         };
 845
 846 // Implementation Class für Keyframe Curve Mode buttons
 847 //
 848 // This button reflects the state of the "current" keyframe
 849 // (the nearest keyframe on the left) for all three automation
 850 // lines together. Clicking on this button (re)sets the curve
 851 // mode for the three "current" keyframes simultanously, but
 852 // never creates a new keyframe.
 853 //
 854 class CWindowCurveToggle : public BC_Toggle
 855 {
 856 public:
 857         CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y);
 858         void check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z);
 859         int handle_event();
 860 private:
 861         _CVD cfg;
 862         MWindow *mwindow;
 863         CWindowToolGUI *gui;
 864 };
 865
 866
 867 CWindowCurveToggle::CWindowCurveToggle(_CVD mode, MWindow *mwindow, CWindowToolGUI *gui, int x, int y)
 868  : BC_Toggle(x, y, mwindow->theme->get_image_set(mode.icon_id), false),
 869    cfg(mode)
 870 {
 871         this->gui = gui;
 872         this->mwindow = mwindow;
 873         set_tooltip(_(cfg.tooltip));
 874 }
 875
 876 void CWindowCurveToggle::check_toggle_state(FloatAuto *x, FloatAuto *y, FloatAuto *z)
 877 {
 878 // the toggle state is only set to ON if all
 879 // three automation lines have the same curve mode.
 880 // For mixed states the toggle stays off.
 881         set_value( x->curve_mode == this->cfg.mode &&
 882                    y->curve_mode == this->cfg.mode &&
 883                    z->curve_mode == this->cfg.mode
 884                    ,true // redraw to show new state
 885                 );
 886 }
 887
 888 int CWindowCurveToggle::handle_event()
 889 {
 890         Track *track = mwindow->cwindow->calculate_affected_track();
 891         if(track) {
 892                 FloatAuto *x=0, *y=0, *z=0;
 893                 mwindow->cwindow->calculate_affected_autos(track,
 894                         &x, &y, &z, cfg.use_camera, 0,0,0); // don't create new keyframe
 895                 if( x ) x->change_curve_mode(cfg.mode);
 896                 if( y ) y->change_curve_mode(cfg.mode);
 897                 if( z ) z->change_curve_mode(cfg.mode);
 898
 899                 gui->update();
 900                 gui->update_preview();
 901         }
 902
 903         return 1;
 904 }
 905
 906
 907 CWindowEyedropCheckBox::CWindowEyedropCheckBox(MWindow *mwindow,
 908         CWindowEyedropGUI *gui, int x, int y)
 909  : BC_CheckBox(x, y, mwindow->edl->local_session->use_max, _("Use maximum"))
 910 {
 911         this->mwindow = mwindow;
 912         this->gui = gui;
 913 }
 914
 915 int CWindowEyedropCheckBox::handle_event()
 916 {
 917         mwindow->edl->local_session->use_max = get_value();
 918
 919         gui->update();
 920         return 1;
 921 }
 922
 923
 924 CWindowCameraGUI::CWindowCameraGUI(MWindow *mwindow, CWindowTool *thread)
 925  : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Camera"), xS(340), yS(170))
 926 {
 927 }
 928 CWindowCameraGUI::~CWindowCameraGUI()
 929 {
 930 }
 931
 932 void CWindowCameraGUI::create_objects()
 933 {
 934         int xs10 = xS(10), xs15 = xS(15);
 935         int ys10 = yS(10), ys30 = yS(30);
 936         int x = xs10, y = ys10;
 937         Track *track = mwindow->cwindow->calculate_affected_track();
 938         FloatAuto *x_auto = 0, *y_auto = 0, *z_auto = 0;
 939         BC_Title *title;
 940         BC_Button *button;
 941
 942         lock_window("CWindowCameraGUI::create_objects");
 943         if( track ) {
 944                 mwindow->cwindow->calculate_affected_autos(track,
 945                         &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
 946         }
 947
 948         add_subwindow(title = new BC_Title(x, y, "X:"));
 949         int x1 = x + title->get_w() + xS(3);
 950         float xvalue = x_auto ? x_auto->get_value() : 0;
 951         this->x = new CWindowCoord(this, x1, y, xvalue, AUTOMATION_CAMERA_X);
 952         this->x->create_objects();
 953         this->x->range->set_tooltip(_("expand X range"));
 954         y += ys30;
 955         add_subwindow(title = new BC_Title(x = xs10, y, "Y:"));
 956         float yvalue = y_auto ? y_auto->get_value() : 0;
 957         this->y = new CWindowCoord(this, x1, y, yvalue, AUTOMATION_CAMERA_Y);
 958         this->y->create_objects();
 959         this->y->range->set_tooltip(_("expand Y range"));
 960         y += ys30;
 961         add_subwindow(title = new BC_Title(x = xs10, y, "Z:"));
 962         x += title->get_w();
 963         float zvalue = z_auto ? z_auto->get_value() : 1;
 964         this->z = new CWindowCoord(this, x1, y, zvalue, AUTOMATION_CAMERA_Z);
 965         this->z->create_objects();
 966         this->z->set_increment(0.01);
 967         this->z->range->set_tooltip(_("expand Zoom range"));
 968
 969         y += ys30;
 970         x1 = xs10;
 971         add_subwindow(button = new CWindowCameraLeft(mwindow, this, x1, y));
 972         x1 += button->get_w();
 973         add_subwindow(button = new CWindowCameraCenter(mwindow, this, x1, y));
 974         x1 += button->get_w();
 975         add_subwindow(button = new CWindowCameraRight(mwindow, this, x1, y));
 976 // additional Buttons to control the curve mode of the "current" keyframe
 977         x1 += button->get_w() + xs15;
 978         add_subwindow(this->t_smooth = new CWindowCurveToggle(Camera_Crv_Smooth, mwindow, this, x1, y));
 979         x1 += button->get_w() + xs10;
 980         add_subwindow(this->t_linear = new CWindowCurveToggle(Camera_Crv_Linear, mwindow, this, x1, y));
 981
 982         y += button->get_h();
 983         x1 = xs10;
 984         add_subwindow(button = new CWindowCameraTop(mwindow, this, x1, y));
 985         x1 += button->get_w();
 986         add_subwindow(button = new CWindowCameraMiddle(mwindow, this, x1, y));
 987         x1 += button->get_w();
 988         add_subwindow(button = new CWindowCameraBottom(mwindow, this, x1, y));
 989         x1 += button->get_w() + xs15;
 990         add_subwindow(this->add_keyframe = new CWindowCameraAddKeyframe(mwindow, this, x1, y));
 991         x1 += button->get_w() + xs10;
 992         add_subwindow(this->reset = new CWindowCameraReset(mwindow, this, x1, y));
 993
 994 // fill in current auto keyframe values, set toggle states.
 995         this->update();
 996         unlock_window();
 997 }
 998
 999 void CWindowCameraGUI::handle_event()
1000 {
1001         FloatAuto *x_auto = 0;
1002         FloatAuto *y_auto = 0;
1003         FloatAuto *z_auto = 0;
1004         Track *track = mwindow->cwindow->calculate_affected_track();
1005         if(track)
1006         {
1007                 mwindow->undo->update_undo_before(_("camera"), this);
1008                 if(event_caller == x)
1009                 {
1010                         x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1011                                 track->automation->autos[AUTOMATION_CAMERA_X], 1);
1012                         if(x_auto)
1013                         {
1014                                 x_auto->set_value(atof(x->get_text()));
1015                                 update();
1016                                 update_preview();
1017                         }
1018                 }
1019                 else
1020                 if(event_caller == y)
1021                 {
1022                         y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1023                                 track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1024                         if(y_auto)
1025                         {
1026                                 y_auto->set_value(atof(y->get_text()));
1027                                 update();
1028                                 update_preview();
1029                         }
1030                 }
1031                 else
1032                 if(event_caller == z)
1033                 {
1034                         z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1035                                 track->automation->autos[AUTOMATION_CAMERA_Z], 1);
1036                         if(z_auto)
1037                         {
1038                                 float zoom = atof(z->get_text());
1039                                 if(zoom > 100.) zoom = 100.;
1040                                 else
1041                                 if(zoom < 0.01) zoom = 0.01;
1042         // Doesn't allow user to enter from scratch
1043         //              if(zoom != atof(z->get_text()))
1044         //                      z->update(zoom);
1045
1046                                 z_auto->set_value(zoom);
1047                                 mwindow->gui->lock_window("CWindowCameraGUI::handle_event");
1048                                 mwindow->gui->draw_overlays(1);
1049                                 mwindow->gui->unlock_window();
1050                                 update();
1051                                 update_preview();
1052                         }
1053                 }
1054
1055                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1056         }
1057 }
1058
1059 void CWindowCameraGUI::update()
1060 {
1061         FloatAuto *x_auto = 0;
1062         FloatAuto *y_auto = 0;
1063         FloatAuto *z_auto = 0;
1064         Track *track = mwindow->cwindow->calculate_affected_track();
1065         if( track ) {
1066                 mwindow->cwindow->calculate_affected_autos(track,
1067                         &x_auto, &y_auto, &z_auto, 1, 0, 0, 0);
1068         }
1069
1070         if( x_auto ) {
1071                 float xvalue = x_auto->get_value();
1072                 x->update_gui(xvalue);
1073         }
1074         if( y_auto ) {
1075                 float yvalue = y_auto->get_value();
1076                 y->update_gui(yvalue);
1077         }
1078         if( z_auto ) {
1079                 float zvalue = z_auto->get_value();
1080                 z->update_gui(zvalue);
1081                 thread->gui->lock_window("CWindowCameraGUI::update");
1082                 thread->gui->composite_panel->cpanel_zoom->update(zvalue);
1083                 thread->gui->unlock_window();
1084         }
1085
1086         if( x_auto && y_auto && z_auto ) {
1087                 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1088                 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1089         }
1090 }
1091
1092
1093
1094
1095 CWindowCameraLeft::CWindowCameraLeft(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1096  : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1097 {
1098         this->gui = gui;
1099         this->mwindow = mwindow;
1100         set_tooltip(_("Left justify"));
1101 }
1102 int CWindowCameraLeft::handle_event()
1103 {
1104         FloatAuto *x_auto = 0;
1105         FloatAuto *z_auto = 0;
1106         Track *track = mwindow->cwindow->calculate_affected_track();
1107         if( track ) {
1108                 mwindow->cwindow->calculate_affected_autos(track,
1109                         &x_auto, 0, &z_auto, 1, 1, 0, 0);
1110         }
1111
1112         if(x_auto && z_auto)
1113         {
1114                 int w = 0, h = 0;
1115                 track->get_source_dimensions(
1116                         mwindow->edl->local_session->get_selectionstart(1),
1117                         w, h);
1118
1119                 if(w && h)
1120                 {
1121                         mwindow->undo->update_undo_before(_("camera"), 0);
1122                         x_auto->set_value(
1123                                 (double)track->track_w / z_auto->get_value() / 2 -
1124                                 (double)w / 2);
1125                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1126                         gui->update();
1127                         gui->update_preview();
1128                 }
1129         }
1130
1131         return 1;
1132 }
1133
1134
1135 CWindowCameraCenter::CWindowCameraCenter(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1136  : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1137 {
1138         this->gui = gui;
1139         this->mwindow = mwindow;
1140         set_tooltip(_("Center horizontal"));
1141 }
1142 int CWindowCameraCenter::handle_event()
1143 {
1144         FloatAuto *x_auto = 0;
1145         Track *track = mwindow->cwindow->calculate_affected_track();
1146         if(track)
1147                 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1148                         track->automation->autos[AUTOMATION_CAMERA_X], 1);
1149
1150         if(x_auto)
1151         {
1152                 mwindow->undo->update_undo_before(_("camera"), 0);
1153                 x_auto->set_value(0);
1154                 gui->update();
1155                 gui->update_preview();
1156                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1157         }
1158
1159         return 1;
1160 }
1161
1162
1163 CWindowCameraRight::CWindowCameraRight(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1164  : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1165 {
1166         this->gui = gui;
1167         this->mwindow = mwindow;
1168         set_tooltip(_("Right justify"));
1169 }
1170 int CWindowCameraRight::handle_event()
1171 {
1172         FloatAuto *x_auto = 0;
1173         FloatAuto *z_auto = 0;
1174         Track *track = mwindow->cwindow->calculate_affected_track();
1175         if( track ) {
1176                 mwindow->cwindow->calculate_affected_autos(track,
1177                         &x_auto, 0, &z_auto, 1, 1, 0, 0);
1178         }
1179
1180         if(x_auto && z_auto)
1181         {
1182                 int w = 0, h = 0;
1183                 track->get_source_dimensions(
1184                         mwindow->edl->local_session->get_selectionstart(1),
1185                         w, h);
1186
1187                 if(w && h)
1188                 {
1189                         mwindow->undo->update_undo_before(_("camera"), 0);
1190                         x_auto->set_value( -((double)track->track_w / z_auto->get_value() / 2 -
1191                                 (double)w / 2));
1192                         gui->update();
1193                         gui->update_preview();
1194                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1195                 }
1196         }
1197
1198         return 1;
1199 }
1200
1201
1202 CWindowCameraTop::CWindowCameraTop(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1203  : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1204 {
1205         this->gui = gui;
1206         this->mwindow = mwindow;
1207         set_tooltip(_("Top justify"));
1208 }
1209 int CWindowCameraTop::handle_event()
1210 {
1211         FloatAuto *y_auto = 0;
1212         FloatAuto *z_auto = 0;
1213         Track *track = mwindow->cwindow->calculate_affected_track();
1214         if( track ) {
1215                 mwindow->cwindow->calculate_affected_autos(track,
1216                         0, &y_auto, &z_auto, 1, 0, 1, 0);
1217         }
1218
1219         if(y_auto && z_auto)
1220         {
1221                 int w = 0, h = 0;
1222                 track->get_source_dimensions(
1223                         mwindow->edl->local_session->get_selectionstart(1),
1224                         w, h);
1225
1226                 if(w && h)
1227                 {
1228                         mwindow->undo->update_undo_before(_("camera"), 0);
1229                         y_auto->set_value((double)track->track_h / z_auto->get_value() / 2 -
1230                                 (double)h / 2);
1231                         gui->update();
1232                         gui->update_preview();
1233                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1234                 }
1235         }
1236
1237         return 1;
1238 }
1239
1240
1241 CWindowCameraMiddle::CWindowCameraMiddle(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1242  : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1243 {
1244         this->gui = gui;
1245         this->mwindow = mwindow;
1246         set_tooltip(_("Center vertical"));
1247 }
1248 int CWindowCameraMiddle::handle_event()
1249 {
1250         FloatAuto *y_auto = 0;
1251         Track *track = mwindow->cwindow->calculate_affected_track();
1252         if(track)
1253                 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1254                         track->automation->autos[AUTOMATION_CAMERA_Y], 1);
1255
1256         if(y_auto)
1257         {
1258                 mwindow->undo->update_undo_before(_("camera"), 0);
1259                 y_auto->set_value(0);
1260                 gui->update();
1261                 gui->update_preview();
1262                 mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1263         }
1264
1265         return 1;
1266 }
1267
1268
1269 CWindowCameraBottom::CWindowCameraBottom(MWindow *mwindow, CWindowCameraGUI *gui, int x, int y)
1270  : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1271 {
1272         this->gui = gui;
1273         this->mwindow = mwindow;
1274         set_tooltip(_("Bottom justify"));
1275 }
1276 int CWindowCameraBottom::handle_event()
1277 {
1278         FloatAuto *y_auto = 0;
1279         FloatAuto *z_auto = 0;
1280         Track *track = mwindow->cwindow->calculate_affected_track();
1281         if( track ) {
1282                 mwindow->cwindow->calculate_affected_autos(track,
1283                         0, &y_auto, &z_auto, 1, 0, 1, 0);
1284         }
1285
1286         if(y_auto && z_auto)
1287         {
1288                 int w = 0, h = 0;
1289                 track->get_source_dimensions(
1290                         mwindow->edl->local_session->get_selectionstart(1),
1291                         w, h);
1292
1293                 if(w && h)
1294                 {
1295                         mwindow->undo->update_undo_before(_("camera"), 0);
1296                         y_auto->set_value(-((double)track->track_h / z_auto->get_value() / 2 -
1297                                 (double)h / 2));
1298                         gui->update();
1299                         gui->update_preview();
1300                         mwindow->undo->update_undo_after(_("camera"), LOAD_ALL);
1301                 }
1302         }
1303
1304         return 1;
1305 }
1306
1307 CWindowCameraAddKeyframe::CWindowCameraAddKeyframe(MWindow *mwindow,
1308                 CWindowToolGUI *gui, int x, int y)
1309  : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
1310 {
1311         this->mwindow = mwindow;
1312         this->gui = gui;
1313         set_tooltip(_("Add Keyframe: Shift-F11"));
1314 }
1315
1316 int CWindowCameraAddKeyframe::handle_event()
1317 {
1318         return gui->press(&CWindowCanvas::camera_keyframe);
1319 }
1320
1321 CWindowCameraReset::CWindowCameraReset(MWindow *mwindow,
1322                 CWindowToolGUI *gui, int x, int y)
1323  : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
1324 {
1325         this->mwindow = mwindow;
1326         this->gui = gui;
1327         set_tooltip(_("Reset Camera: F11"));
1328 }
1329
1330 int CWindowCameraReset::handle_event()
1331 {
1332         return gui->press(&CWindowCanvas::reset_camera);
1333 }
1334
1335
1336 CWindowProjectorGUI::CWindowProjectorGUI(MWindow *mwindow, CWindowTool *thread)
1337  : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Projector"), xS(340), yS(170))
1338 {
1339 }
1340 CWindowProjectorGUI::~CWindowProjectorGUI()
1341 {
1342 }
1343 void CWindowProjectorGUI::create_objects()
1344 {
1345         int xs10 = xS(10), xs15 = xS(15);
1346         int ys30 = yS(30);
1347         int x = xs10, y = yS(10);
1348         Track *track = mwindow->cwindow->calculate_affected_track();
1349         FloatAuto *x_auto = 0;
1350         FloatAuto *y_auto = 0;
1351         FloatAuto *z_auto = 0;
1352         BC_Title *title;
1353         BC_Button *button;
1354
1355         lock_window("CWindowProjectorGUI::create_objects");
1356         if( track ) {
1357                 mwindow->cwindow->calculate_affected_autos(track,
1358                         &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1359         }
1360
1361         add_subwindow(title = new BC_Title(x = xs10, y, "X:"));
1362         int x1 = x + title->get_w() + xS(3);
1363         float xvalue = x_auto ? x_auto->get_value() : 0;
1364         this->x = new CWindowCoord(this, x1, y, xvalue, AUTOMATION_PROJECTOR_X);
1365         this->x->create_objects();
1366         this->x->range->set_tooltip(_("expand X range"));
1367         y += ys30;
1368         add_subwindow(title = new BC_Title(x = xs10, y, "Y:"));
1369         float yvalue = y_auto ? y_auto->get_value() : 0;
1370         this->y = new CWindowCoord(this, x1, y, yvalue, AUTOMATION_PROJECTOR_Y);
1371         this->y->create_objects();
1372         this->y->range->set_tooltip(_("expand Y range"));
1373         y += ys30;
1374         add_subwindow(title = new BC_Title(x = xs10, y, "Z:"));
1375         float zvalue = z_auto ? z_auto->get_value() : 1;
1376         this->z = new CWindowCoord(this, x1, y, zvalue, AUTOMATION_PROJECTOR_Z);
1377         this->z->create_objects();
1378         this->z->range->set_tooltip(_("expand Zoom range"));
1379         this->z->set_increment(0.01);
1380
1381         y += ys30;
1382         x1 = xs10;
1383         add_subwindow(button = new CWindowProjectorLeft(mwindow, this, x1, y));
1384         x1 += button->get_w();
1385         add_subwindow(button = new CWindowProjectorCenter(mwindow, this, x1, y));
1386         x1 += button->get_w();
1387         add_subwindow(button = new CWindowProjectorRight(mwindow, this, x1, y));
1388 // additional Buttons to control the curve mode of the "current" keyframe
1389         x1 += button->get_w() + xs15;
1390         add_subwindow(this->t_smooth = new CWindowCurveToggle(Projector_Crv_Smooth, mwindow, this, x1, y));
1391         x1 += button->get_w() + xs10;
1392         add_subwindow(this->t_linear = new CWindowCurveToggle(Projector_Crv_Linear, mwindow, this, x1, y));
1393
1394         y += button->get_h();
1395         x1 = xs10;
1396         add_subwindow(button = new CWindowProjectorTop(mwindow, this, x1, y));
1397         x1 += button->get_w();
1398         add_subwindow(button = new CWindowProjectorMiddle(mwindow, this, x1, y));
1399         x1 += button->get_w();
1400         add_subwindow(button = new CWindowProjectorBottom(mwindow, this, x1, y));
1401         x1 += button->get_w() + xs15;
1402         add_subwindow(this->add_keyframe = new CWindowProjectorAddKeyframe(mwindow, this, x1, y));
1403         x1 += button->get_w() + xs10;
1404         add_subwindow(this->reset = new CWindowProjectorReset(mwindow, this, x1, y));
1405
1406 // fill in current auto keyframe values, set toggle states.
1407         this->update();
1408         unlock_window();
1409 }
1410
1411 void CWindowProjectorGUI::handle_event()
1412 {
1413         FloatAuto *x_auto = 0;
1414         FloatAuto *y_auto = 0;
1415         FloatAuto *z_auto = 0;
1416         Track *track = mwindow->cwindow->calculate_affected_track();
1417
1418         if(track)
1419         {
1420                 mwindow->undo->update_undo_before(_("projector"), this);
1421                 if(event_caller == x)
1422                 {
1423                         x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1424                                 track->automation->autos[AUTOMATION_PROJECTOR_X], 1);
1425                         if(x_auto)
1426                         {
1427                                 x_auto->set_value(atof(x->get_text()));
1428                                 update();
1429                                 update_preview();
1430                         }
1431                 }
1432                 else
1433                 if(event_caller == y)
1434                 {
1435                         y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1436                                 track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1437                         if(y_auto)
1438                         {
1439                                 y_auto->set_value(atof(y->get_text()));
1440                                 update();
1441                                 update_preview();
1442                         }
1443                 }
1444                 else
1445                 if(event_caller == z)
1446                 {
1447                         z_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1448                                 track->automation->autos[AUTOMATION_PROJECTOR_Z], 1);
1449                         if(z_auto)
1450                         {
1451                                 float zoom = atof(z->get_text());
1452                                 if(zoom > 100.) zoom = 100.;
1453                                 else if(zoom < 0.01) zoom = 0.01;
1454 //                      if (zoom != atof(z->get_text()))
1455 //                              z->update(zoom);
1456                                 z_auto->set_value(zoom);
1457
1458                                 mwindow->gui->lock_window("CWindowProjectorGUI::handle_event");
1459                                 mwindow->gui->draw_overlays(1);
1460                                 mwindow->gui->unlock_window();
1461
1462                                 update();
1463                                 update_preview();
1464                         }
1465                 }
1466                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1467         }
1468 }
1469
1470 void CWindowProjectorGUI::update()
1471 {
1472         FloatAuto *x_auto = 0;
1473         FloatAuto *y_auto = 0;
1474         FloatAuto *z_auto = 0;
1475         Track *track = mwindow->cwindow->calculate_affected_track();
1476         if( track ) {
1477                 mwindow->cwindow->calculate_affected_autos(track,
1478                         &x_auto, &y_auto, &z_auto, 0, 0, 0, 0);
1479         }
1480
1481         if( x_auto ) {
1482                 float xvalue = x_auto->get_value();
1483                 x->update_gui(xvalue);
1484         }
1485         if( y_auto ) {
1486                 float yvalue = y_auto->get_value();
1487                 y->update_gui(yvalue);
1488         }
1489         if( z_auto ) {
1490                 float zvalue = z_auto->get_value();
1491                 z->update_gui(zvalue);
1492                 thread->gui->lock_window("CWindowProjectorGUI::update");
1493                 thread->gui->composite_panel->cpanel_zoom->update(zvalue);
1494                 thread->gui->unlock_window();
1495         }
1496
1497         if( x_auto && y_auto && z_auto ) {
1498                 t_smooth->check_toggle_state(x_auto, y_auto, z_auto);
1499                 t_linear->check_toggle_state(x_auto, y_auto, z_auto);
1500         }
1501 }
1502
1503 CWindowProjectorLeft::CWindowProjectorLeft(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1504  : BC_Button(x, y, mwindow->theme->get_image_set("left_justify"))
1505 {
1506         this->gui = gui;
1507         this->mwindow = mwindow;
1508         set_tooltip(_("Left justify"));
1509 }
1510 int CWindowProjectorLeft::handle_event()
1511 {
1512         FloatAuto *x_auto = 0;
1513         FloatAuto *z_auto = 0;
1514         Track *track = mwindow->cwindow->calculate_affected_track();
1515         if( track ) {
1516                 mwindow->cwindow->calculate_affected_autos(track,
1517                         &x_auto, 0, &z_auto, 0, 1, 0, 0);
1518         }
1519         if(x_auto && z_auto)
1520         {
1521                 mwindow->undo->update_undo_before(_("projector"), 0);
1522                 x_auto->set_value( (double)track->track_w * z_auto->get_value() / 2 -
1523                         (double)mwindow->edl->session->output_w / 2 );
1524                 gui->update();
1525                 gui->update_preview();
1526                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1527         }
1528
1529         return 1;
1530 }
1531
1532
1533 CWindowProjectorCenter::CWindowProjectorCenter(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1534  : BC_Button(x, y, mwindow->theme->get_image_set("center_justify"))
1535 {
1536         this->gui = gui;
1537         this->mwindow = mwindow;
1538         set_tooltip(_("Center horizontal"));
1539 }
1540 int CWindowProjectorCenter::handle_event()
1541 {
1542         FloatAuto *x_auto = 0;
1543         Track *track = mwindow->cwindow->calculate_affected_track();
1544         if(track)
1545                 x_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1546                         track->automation->autos[AUTOMATION_PROJECTOR_X], 1);
1547
1548         if(x_auto)
1549         {
1550                 mwindow->undo->update_undo_before(_("projector"), 0);
1551                 x_auto->set_value(0);
1552                 gui->update();
1553                 gui->update_preview();
1554                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1555         }
1556
1557         return 1;
1558 }
1559
1560
1561 CWindowProjectorRight::CWindowProjectorRight(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1562  : BC_Button(x, y, mwindow->theme->get_image_set("right_justify"))
1563 {
1564         this->gui = gui;
1565         this->mwindow = mwindow;
1566         set_tooltip(_("Right justify"));
1567 }
1568 int CWindowProjectorRight::handle_event()
1569 {
1570         FloatAuto *x_auto = 0;
1571         FloatAuto *z_auto = 0;
1572         Track *track = mwindow->cwindow->calculate_affected_track();
1573         if( track ) {
1574                 mwindow->cwindow->calculate_affected_autos(track,
1575                         &x_auto, 0, &z_auto, 0, 1, 0, 0);
1576         }
1577
1578         if(x_auto && z_auto)
1579         {
1580                 mwindow->undo->update_undo_before(_("projector"), 0);
1581                 x_auto->set_value( -((double)track->track_w * z_auto->get_value() / 2 -
1582                         (double)mwindow->edl->session->output_w / 2));
1583                 gui->update();
1584                 gui->update_preview();
1585                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1586         }
1587
1588         return 1;
1589 }
1590
1591
1592 CWindowProjectorTop::CWindowProjectorTop(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1593  : BC_Button(x, y, mwindow->theme->get_image_set("top_justify"))
1594 {
1595         this->gui = gui;
1596         this->mwindow = mwindow;
1597         set_tooltip(_("Top justify"));
1598 }
1599 int CWindowProjectorTop::handle_event()
1600 {
1601         FloatAuto *y_auto = 0;
1602         FloatAuto *z_auto = 0;
1603         Track *track = mwindow->cwindow->calculate_affected_track();
1604         if( track ) {
1605                 mwindow->cwindow->calculate_affected_autos(track,
1606                         0, &y_auto, &z_auto, 0, 0, 1, 0);
1607         }
1608
1609         if(y_auto && z_auto)
1610         {
1611                 mwindow->undo->update_undo_before(_("projector"), 0);
1612                 y_auto->set_value( (double)track->track_h * z_auto->get_value() / 2 -
1613                         (double)mwindow->edl->session->output_h / 2 );
1614                 gui->update();
1615                 gui->update_preview();
1616                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1617         }
1618
1619         return 1;
1620 }
1621
1622
1623 CWindowProjectorMiddle::CWindowProjectorMiddle(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1624  : BC_Button(x, y, mwindow->theme->get_image_set("middle_justify"))
1625 {
1626         this->gui = gui;
1627         this->mwindow = mwindow;
1628         set_tooltip(_("Center vertical"));
1629 }
1630 int CWindowProjectorMiddle::handle_event()
1631 {
1632         FloatAuto *y_auto = 0;
1633         Track *track = mwindow->cwindow->calculate_affected_track();
1634         if(track)
1635                 y_auto = (FloatAuto*)mwindow->cwindow->calculate_affected_auto(
1636                         track->automation->autos[AUTOMATION_PROJECTOR_Y], 1);
1637
1638         if(y_auto)
1639         {
1640                 mwindow->undo->update_undo_before(_("projector"), 0);
1641                 y_auto->set_value(0);
1642                 gui->update();
1643                 gui->update_preview();
1644                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1645         }
1646
1647         return 1;
1648 }
1649
1650
1651 CWindowProjectorBottom::CWindowProjectorBottom(MWindow *mwindow, CWindowProjectorGUI *gui, int x, int y)
1652  : BC_Button(x, y, mwindow->theme->get_image_set("bottom_justify"))
1653 {
1654         this->gui = gui;
1655         this->mwindow = mwindow;
1656         set_tooltip(_("Bottom justify"));
1657 }
1658 int CWindowProjectorBottom::handle_event()
1659 {
1660         FloatAuto *y_auto = 0;
1661         FloatAuto *z_auto = 0;
1662         Track *track = mwindow->cwindow->calculate_affected_track();
1663         if( track ) {
1664                 mwindow->cwindow->calculate_affected_autos(track,
1665                         0, &y_auto, &z_auto, 0, 0, 1, 0);
1666         }
1667
1668         if(y_auto && z_auto)
1669         {
1670                 mwindow->undo->update_undo_before(_("projector"), 0);
1671                 y_auto->set_value( -((double)track->track_h * z_auto->get_value() / 2 -
1672                         (double)mwindow->edl->session->output_h / 2));
1673                 gui->update();
1674                 gui->update_preview();
1675                 mwindow->undo->update_undo_after(_("projector"), LOAD_ALL);
1676         }
1677
1678         return 1;
1679 }
1680
1681 CWindowProjectorAddKeyframe::CWindowProjectorAddKeyframe(MWindow *mwindow,
1682                 CWindowToolGUI *gui, int x, int y)
1683  : BC_Button(x, y, mwindow->theme->get_image_set("keyframe_button"))
1684 {
1685         this->mwindow = mwindow;
1686         this->gui = gui;
1687         set_tooltip(_("Add Keyframe: Shift-F12"));
1688 }
1689
1690 int CWindowProjectorAddKeyframe::handle_event()
1691 {
1692         return gui->press(&CWindowCanvas::projector_keyframe);
1693 }
1694
1695 CWindowProjectorReset::CWindowProjectorReset(MWindow *mwindow,
1696                 CWindowToolGUI *gui, int x, int y)
1697  : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
1698 {
1699         this->mwindow = mwindow;
1700         this->gui = gui;
1701         set_tooltip(_("Reset Projector: F12"));
1702 }
1703
1704 int CWindowProjectorReset::handle_event()
1705 {
1706         return gui->press(&CWindowCanvas::reset_projector);
1707 }
1708
1709 int CWindowToolGUI::press(void (CWindowCanvas::*fn)())
1710 {
1711         unlock_window();
1712         CWindowGUI *cw_gui = thread->gui;
1713         cw_gui->lock_window("CWindowGUI::press");
1714         (cw_gui->canvas->*fn)();
1715         cw_gui->unlock_window();
1716         lock_window("CWindowToolGUI::press");
1717         return 1;
1718 }
1719
1720 CWindowMaskOnTrack::CWindowMaskOnTrack(MWindow *mwindow, CWindowMaskGUI *gui,
1721                 int x, int y, int w, const char *text)
1722  : BC_PopupTextBox(gui, 0, text, x, y, w, yS(120))
1723 {
1724         this->mwindow = mwindow;
1725         this->gui = gui;
1726 }
1727
1728 CWindowMaskOnTrack::~CWindowMaskOnTrack()
1729 {
1730 }
1731
1732 int CWindowMaskOnTrack::handle_event()
1733 {
1734         CWindowMaskItem *track_item = 0;
1735         int k = get_number(), track_id = -1;
1736 //printf("selected %d = %s\n", k, k<0 ? "()" : track_items[k]->get_text());
1737         if( k >= 0 ) {
1738                 track_item = (CWindowMaskItem *)track_items[k];
1739                 Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1740                 if( track && track->record ) track_id = track->get_id();
1741         }
1742         else
1743                 track_id = mwindow->cwindow->mask_track_id;
1744         set_back_color(track_id >= 0 ?
1745                 gui->get_resources()->text_background :
1746                 gui->get_resources()->text_background_disarmed);
1747         if( mwindow->cwindow->mask_track_id != track_id )
1748                 gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1749         mwindow->cwindow->mask_track_id = track_id;
1750         mwindow->edl->local_session->solo_track_id = -1;
1751         gui->mask_solo_track->update(0);
1752         gui->update();
1753         gui->update_preview(1);
1754         return 1;
1755 }
1756
1757 void CWindowMaskOnTrack::update_items()
1758 {
1759         track_items.remove_all_objects();
1760         int high_color = gui->get_resources()->button_highlighted;
1761         for( Track *track=mwindow->edl->tracks->first; track; track=track->next ) {
1762                 if( track->data_type != TRACK_VIDEO ) continue;
1763                 MaskAutos *mask_autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
1764                 int color = !track->record ? RED : mask_autos->first ?  high_color : -1;
1765                 MaskAuto *mask_auto = (MaskAuto*)mask_autos->default_auto;
1766                 for( int i=0; color<0 && i<mask_auto->masks.size(); ++i )
1767                         if( mask_auto->masks[i]->points.size() > 0 ) color = high_color;
1768                 track_items.append(new CWindowMaskItem(track->title, track->get_id(), color));
1769         }
1770         update_list(&track_items);
1771 }
1772
1773 CWindowMaskTrackTumbler::CWindowMaskTrackTumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1774                 int x, int y)
1775  : BC_Tumbler(x, y)
1776 {
1777         this->mwindow = mwindow;
1778         this->gui = gui;
1779 }
1780 CWindowMaskTrackTumbler::~CWindowMaskTrackTumbler()
1781 {
1782 }
1783
1784 int CWindowMaskTrackTumbler::handle_up_event()
1785 {
1786         return do_event(1);
1787 }
1788
1789 int CWindowMaskTrackTumbler::handle_down_event()
1790 {
1791         return do_event(-1);
1792 }
1793
1794 int CWindowMaskTrackTumbler::do_event(int dir)
1795 {
1796         CWindowMaskItem *track_item = 0;
1797         CWindowMaskItem **items = (CWindowMaskItem**)&gui->mask_on_track->track_items[0];
1798         int n = gui->mask_on_track->track_items.size();
1799         int id = mwindow->cwindow->mask_track_id;
1800         if( n > 0 ) {
1801                 int k = n;
1802                 while( --k >= 0 && items[k]->id != id );
1803                 if( k >= 0 ) {
1804                         k += dir;
1805                         bclamp(k, 0, n-1);
1806                         track_item = items[k];
1807                 }
1808                 else
1809                         track_item = items[0];
1810         }
1811         Track *track = track_item ? mwindow->edl->tracks->get_track_by_id(track_item->id) : 0;
1812         int track_id = track_item && track && track->record ? track_item->id : -1;
1813         gui->mask_on_track->set_back_color(track_id >= 0 ?
1814                 gui->get_resources()->text_background :
1815                 gui->get_resources()->text_background_disarmed);
1816         gui->mask_on_track->update(track_item ? track_item->get_text() : "");
1817         mwindow->cwindow->mask_track_id = track_item ? track_item->id : -1;
1818         mwindow->edl->local_session->solo_track_id = -1;
1819         gui->mask_solo_track->update(0);
1820         gui->update();
1821         gui->update_preview(1);
1822         return 1;
1823 }
1824
1825
1826 CWindowMaskName::CWindowMaskName(MWindow *mwindow, CWindowMaskGUI *gui,
1827                 int x, int y, const char *text)
1828  : BC_PopupTextBox(gui, 0, text, x, y, xS(100), yS(160))
1829 {
1830         this->mwindow = mwindow;
1831         this->gui = gui;
1832 }
1833
1834 CWindowMaskName::~CWindowMaskName()
1835 {
1836 }
1837
1838 int CWindowMaskName::handle_event()
1839 {
1840         Track *track;
1841         MaskAutos *autos;
1842         MaskAuto *keyframe;
1843         SubMask *mask;
1844         MaskPoint *point;
1845 //printf("CWindowMaskGUI::update 1\n");
1846         gui->get_keyframe(track, autos, keyframe, mask, point, 0);
1847         if( track ) {
1848                 int k = get_number();
1849                 if( k < 0 ) k = mwindow->edl->session->cwindow_mask;
1850                 else mwindow->edl->session->cwindow_mask = k;
1851                 if( k >= 0 && k < mask_items.size() ) {
1852                         mask_items[k]->set_text(get_text());
1853                         update_list(&mask_items);
1854                 }
1855 #ifdef USE_KEYFRAME_SPANNING
1856                 MaskAuto temp_keyframe(mwindow->edl, autos);
1857                 temp_keyframe.copy_data(keyframe);
1858                 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
1859                 memset(submask->name, 0, sizeof(submask->name));
1860                 strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1861                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
1862 #else
1863                 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
1864                         SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
1865                         memset(submask->name, 0, sizeof(submask->name));
1866                         strncpy(submask->name, get_text(), sizeof(submask->name)-1);
1867                         current = current == (MaskAuto*)autos->default_auto ?
1868                                 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
1869                 }
1870 #endif
1871                 gui->update();
1872                 gui->update_preview();
1873         }
1874         return 1;
1875 }
1876
1877 void CWindowMaskName::update_items(MaskAuto *keyframe)
1878 {
1879         mask_items.remove_all_objects();
1880         int sz = !keyframe ? 0 : keyframe->masks.size();
1881         for( int i=0; i<SUBMASKS; ++i ) {
1882                 char text[BCSTRLEN];  memset(text, 0, sizeof(text));
1883                 if( i < sz ) {
1884                         SubMask *sub_mask = keyframe->masks.get(i);
1885                         strncpy(text, sub_mask->name, sizeof(text)-1);
1886                 }
1887                 else
1888                         sprintf(text, "%d", i);
1889                 mask_items.append(new CWindowMaskItem(text));
1890         }
1891         update_list(&mask_items);
1892 }
1893
1894
1895 CWindowMaskButton::CWindowMaskButton(MWindow *mwindow, CWindowMaskGUI *gui,
1896                  int x, int y, int no, int v)
1897  : BC_CheckBox(x, y, v)
1898 {
1899         this->mwindow = mwindow;
1900         this->gui = gui;
1901         this->no = no;
1902 }
1903
1904 CWindowMaskButton::~CWindowMaskButton()
1905 {
1906 }
1907
1908 int CWindowMaskButton::handle_event()
1909 {
1910         mwindow->edl->session->cwindow_mask = no;
1911         gui->mask_name->update(gui->mask_name->mask_items[no]->get_text());
1912         gui->update();
1913         gui->update_preview();
1914         return 1;
1915 }
1916
1917 CWindowMaskThumbler::CWindowMaskThumbler(MWindow *mwindow, CWindowMaskGUI *gui,
1918                 int x, int y)
1919  : BC_Tumbler(x, y)
1920 {
1921         this->mwindow = mwindow;
1922         this->gui = gui;
1923 }
1924
1925 CWindowMaskThumbler::~CWindowMaskThumbler()
1926 {
1927 }
1928
1929 int CWindowMaskThumbler::handle_up_event()
1930 {
1931         return do_event(1);
1932 }
1933
1934 int CWindowMaskThumbler::handle_down_event()
1935 {
1936         return do_event(-1);
1937 }
1938
1939 int CWindowMaskThumbler::do_event(int dir)
1940 {
1941         int k = mwindow->edl->session->cwindow_mask;
1942         if( (k+=dir) >= SUBMASKS ) k = 0;
1943         else if( k < 0 ) k = SUBMASKS-1;
1944         mwindow->edl->session->cwindow_mask = k;
1945         gui->mask_name->update(gui->mask_name->mask_items[k]->get_text());
1946         gui->update();
1947         gui->update_preview();
1948         return 1;
1949 }
1950
1951 CWindowMaskEnable::CWindowMaskEnable(MWindow *mwindow, CWindowMaskGUI *gui,
1952                  int x, int y, int no, int v)
1953  : BC_CheckBox(x, y, v)
1954 {
1955         this->mwindow = mwindow;
1956         this->gui = gui;
1957         this->no = no;
1958 }
1959
1960 CWindowMaskEnable::~CWindowMaskEnable()
1961 {
1962 }
1963
1964 int CWindowMaskEnable::handle_event()
1965 {
1966         Track *track = mwindow->cwindow->calculate_mask_track();
1967         if( track ) {
1968                 mwindow->undo->update_undo_before(_("mask enable"), this);
1969                 int bit = 1 << no;
1970                 if( get_value() )
1971                         track->masks |= bit;
1972                 else
1973                         track->masks &= ~bit;
1974                 gui->update();
1975                 gui->update_preview(1);
1976                 mwindow->undo->update_undo_after(_("mask enable"), LOAD_PATCHES);
1977         }
1978         return 1;
1979 }
1980
1981 CWindowMaskUnclear::CWindowMaskUnclear(MWindow *mwindow,
1982         CWindowMaskGUI *gui, int x, int y)
1983  : BC_Button(x, y, mwindow->theme->get_image_set("unclear_button"))
1984 {
1985         this->mwindow = mwindow;
1986         this->gui = gui;
1987         set_tooltip(_("Show/Hide mask"));
1988 }
1989
1990 int CWindowMaskUnclear::handle_event()
1991 {
1992         Track *track = mwindow->cwindow->calculate_mask_track();
1993         if( track ) {
1994                 mwindow->undo->update_undo_before(_("mask enables"), this);
1995                 int m = (1<<SUBMASKS)-1;
1996                 if( track->masks == m )
1997                         track->masks = 0;
1998                 else
1999                         track->masks = m;
2000                 for( int i=0; i<SUBMASKS; ++i )
2001                         gui->mask_enables[i]->update((track->masks>>i) & 1);
2002                 gui->update_preview(1);
2003                 mwindow->undo->update_undo_after(_("mask enables"), LOAD_PATCHES);
2004         }
2005         return 1;
2006 }
2007
2008 CWindowMaskSoloTrack::CWindowMaskSoloTrack(MWindow *mwindow,
2009         CWindowMaskGUI *gui, int x, int y, int v)
2010  : BC_CheckBox(x, y, v, _("Solo"))
2011 {
2012         this->mwindow = mwindow;
2013         this->gui = gui;
2014         set_tooltip(_("Solo video track"));
2015 }
2016
2017 int CWindowMaskSoloTrack::handle_event()
2018 {
2019         mwindow->edl->local_session->solo_track_id =
2020                 get_value() ? mwindow->cwindow->mask_track_id : -1;
2021         gui->update_preview(1);
2022         return 1;
2023 }
2024
2025 int CWindowMaskSoloTrack::calculate_w(BC_WindowBase *gui)
2026 {
2027         int w = 0, h = 0;
2028         calculate_extents(gui, &w, &h, _("Solo"));
2029         return w;
2030 }
2031
2032 CWindowMaskDelMask::CWindowMaskDelMask(MWindow *mwindow,
2033         CWindowMaskGUI *gui, int x, int y)
2034  : BC_GenericButton(x, y, _("Delete"))
2035 {
2036         this->mwindow = mwindow;
2037         this->gui = gui;
2038         set_tooltip(_("Delete mask"));
2039 }
2040
2041 int CWindowMaskDelMask::handle_event()
2042 {
2043         MaskAutos *autos;
2044         MaskAuto *keyframe;
2045         Track *track;
2046         MaskPoint *point;
2047         SubMask *mask;
2048         int total_points;
2049
2050 // Get existing keyframe
2051         gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2052
2053         if( track ) {
2054                 mwindow->undo->update_undo_before(_("mask delete"), 0);
2055
2056 #ifdef USE_KEYFRAME_SPANNING
2057 // Create temp keyframe
2058                 MaskAuto temp_keyframe(mwindow->edl, autos);
2059                 temp_keyframe.copy_data(keyframe);
2060                 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2061                 submask->points.remove_all_objects();
2062                 total_points = 0;
2063 // Commit change to span of keyframes
2064                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
2065 #else
2066                 for(MaskAuto *current = (MaskAuto*)autos->default_auto; current; ) {
2067                         SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
2068                         submask->points.remove_all_objects();
2069                         current = current == (MaskAuto*)autos->default_auto ?
2070                                 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
2071                 }
2072                 total_points = 0;
2073 #endif
2074                 if( mwindow->cwindow->gui->affected_point >= total_points )
2075                         mwindow->cwindow->gui->affected_point =
2076                                 total_points > 0 ? total_points-1 : 0;
2077
2078                 gui->update();
2079                 gui->update_preview();
2080                 mwindow->undo->update_undo_after(_("mask delete"), LOAD_AUTOMATION);
2081         }
2082
2083         return 1;
2084 }
2085
2086 CWindowMaskDelPoint::CWindowMaskDelPoint(MWindow *mwindow,
2087         CWindowMaskGUI *gui, int x, int y)
2088  : BC_GenericButton(x, y, _("Delete"))
2089 {
2090         this->mwindow = mwindow;
2091         this->gui = gui;
2092         set_tooltip(_("Delete point"));
2093 }
2094
2095 int CWindowMaskDelPoint::handle_event()
2096 {
2097         MaskAutos *autos;
2098         MaskAuto *keyframe;
2099         Track *track;
2100         MaskPoint *point;
2101         SubMask *mask;
2102         int total_points;
2103
2104 // Get existing keyframe
2105         gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2106         if( track ) {
2107                 mwindow->undo->update_undo_before(_("point delete"), 0);
2108
2109 #ifdef USE_KEYFRAME_SPANNING
2110 // Create temp keyframe
2111                 MaskAuto temp_keyframe(mwindow->edl, autos);
2112                 temp_keyframe.copy_data(keyframe);
2113 // Update parameter
2114                 SubMask *submask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
2115                 int i = mwindow->cwindow->gui->affected_point;
2116                 for( ; i<submask->points.total-1; ++i )
2117                         *submask->points.values[i] = *submask->points.values[i+1];
2118                 if( submask->points.total > 0 ) {
2119                         point = submask->points.values[submask->points.total-1];
2120                         submask->points.remove_object(point);
2121                 }
2122                 total_points = submask->points.total;
2123
2124 // Commit change to span of keyframes
2125                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->update_parameter(&temp_keyframe);
2126 #else
2127                 total_points = 0;
2128                 MaskAuto *current = (MaskAuto*)autos->default_auto;
2129                 while( current ) {
2130                         SubMask *submask = current->get_submask(mwindow->edl->session->cwindow_mask);
2131                         int i = mwindow->cwindow->gui->affected_point;
2132                         for( ; i<submask->points.total-1; ++i )
2133                                 *submask->points.values[i] = *submask->points.values[i+1];
2134                         if( submask->points.total > 0 ) {
2135                                 point = submask->points.values[submask->points.total-1];
2136                                 submask->points.remove_object(point);
2137                         }
2138                         total_points = submask->points.total;
2139                         current = current == (MaskAuto*)autos->default_auto ?
2140                                 (MaskAuto*)autos->first : (MaskAuto*)NEXT;
2141                 }
2142 #endif
2143                 if( mwindow->cwindow->gui->affected_point >= total_points )
2144                         mwindow->cwindow->gui->affected_point =
2145                                 total_points > 0 ? total_points-1 : 0;
2146
2147                 gui->update();
2148                 gui->update_preview();
2149                 mwindow->undo->update_undo_after(_("point delete"), LOAD_AUTOMATION);
2150         }
2151
2152         return 1;
2153 }
2154
2155
2156 CWindowMaskAffectedPoint::CWindowMaskAffectedPoint(MWindow *mwindow,
2157         CWindowMaskGUI *gui, int x, int y)
2158  : BC_TumbleTextBox(gui,
2159                 (int64_t)mwindow->cwindow->gui->affected_point,
2160                 (int64_t)0, INT64_MAX, x, y, xS(70))
2161 {
2162         this->mwindow = mwindow;
2163         this->gui = gui;
2164 }
2165
2166 CWindowMaskAffectedPoint::~CWindowMaskAffectedPoint()
2167 {
2168 }
2169
2170 int CWindowMaskAffectedPoint::handle_event()
2171 {
2172         int total_points = 0;
2173         int affected_point = atol(get_text());
2174         Track *track = mwindow->cwindow->calculate_mask_track();
2175         if(track) {
2176                 MaskAutos *autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2177                 MaskAuto *keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(autos, 0);
2178                 if( keyframe ) {
2179                         SubMask *mask = keyframe->get_submask(mwindow->edl->session->cwindow_mask);
2180                         total_points = mask->points.size();
2181                 }
2182         }
2183         int active_point = affected_point;
2184         if( affected_point >= total_points )
2185                 affected_point = total_points - 1;
2186         if( affected_point < 0 )
2187                 affected_point = 0;
2188         if( active_point != affected_point )
2189                 update((int64_t)affected_point);
2190         mwindow->cwindow->gui->affected_point = affected_point;
2191         gui->update();
2192         gui->update_preview();
2193         return 1;
2194 }
2195
2196
2197 CWindowMaskFocus::CWindowMaskFocus(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2198  : BC_CheckBox(x, y, gui->focused, _("Focus"))
2199 {
2200         this->mwindow = mwindow;
2201         this->gui = gui;
2202         set_tooltip(_("Center for rotate/scale"));
2203 }
2204
2205 CWindowMaskFocus::~CWindowMaskFocus()
2206 {
2207 }
2208
2209 int CWindowMaskFocus::handle_event()
2210 {
2211         gui->focused = get_value();
2212         gui->update();
2213         gui->update_preview();
2214         return 1;
2215 }
2216
2217 int CWindowMaskFocus::calculate_w(CWindowMaskGUI *gui)
2218 {
2219         int w, h;
2220         calculate_extents(gui, &w, &h, _("Focus"));
2221         return w;
2222 }
2223
2224 CWindowMaskScaleXY::CWindowMaskScaleXY(MWindow *mwindow, CWindowMaskGUI *gui,
2225                 int x, int y, VFrame **data, int v, int id, const char *tip)
2226  : BC_Toggle(x, y, data, v)
2227 {
2228         this->id = id;
2229         this->mwindow = mwindow;
2230         this->gui = gui;
2231         set_tooltip(tip);
2232 }
2233
2234 CWindowMaskScaleXY::~CWindowMaskScaleXY()
2235 {
2236 }
2237
2238 int CWindowMaskScaleXY::handle_event()
2239 {
2240         gui->scale_mode = id;
2241         gui->mask_scale_x->update(id == MASK_SCALE_X);
2242         gui->mask_scale_y->update(id == MASK_SCALE_Y);
2243         gui->mask_scale_xy->update(id == MASK_SCALE_XY);
2244         return 1;
2245 }
2246
2247 CWindowMaskHelp::CWindowMaskHelp(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2248  : BC_CheckBox(x, y, 0, _("Help"))
2249 {
2250         this->mwindow = mwindow;
2251         this->gui = gui;
2252         set_tooltip(_("Show help text"));
2253 }
2254
2255 CWindowMaskHelp::~CWindowMaskHelp()
2256 {
2257 }
2258
2259 int CWindowMaskHelp::handle_event()
2260 {
2261         gui->helped = get_value();
2262         gui->resize_window(gui->get_w(),
2263                 gui->helped ? gui->help_h : gui->help_y);
2264         gui->update();
2265         return 1;
2266 }
2267
2268 CWindowMaskDrawMarkers::CWindowMaskDrawMarkers(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2269  : BC_CheckBox(x, y, gui->markers, _("Markers"))
2270 {
2271         this->mwindow = mwindow;
2272         this->gui = gui;
2273         set_tooltip("Display points");
2274 }
2275
2276 CWindowMaskDrawMarkers::~CWindowMaskDrawMarkers()
2277 {
2278 }
2279
2280 int CWindowMaskDrawMarkers::handle_event()
2281 {
2282         gui->markers = get_value();
2283         gui->update();
2284         gui->update_preview();
2285         return 1;
2286 }
2287
2288 CWindowMaskDrawBoundary::CWindowMaskDrawBoundary(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2289  : BC_CheckBox(x, y, gui->boundary, _("Boundary"))
2290 {
2291         this->mwindow = mwindow;
2292         this->gui = gui;
2293         set_tooltip("Display mask outline");
2294 }
2295
2296 CWindowMaskDrawBoundary::~CWindowMaskDrawBoundary()
2297 {
2298 }
2299
2300 int CWindowMaskDrawBoundary::handle_event()
2301 {
2302         gui->boundary = get_value();
2303         gui->update();
2304         gui->update_preview();
2305         return 1;
2306 }
2307
2308
2309 CWindowMaskFeather::CWindowMaskFeather(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2310  : BC_TumbleTextBox(gui, 0, INT_MIN, INT_MAX, x, y, xS(64), 2)
2311 {
2312         this->mwindow = mwindow;
2313         this->gui = gui;
2314 }
2315 CWindowMaskFeather::~CWindowMaskFeather()
2316 {
2317 }
2318
2319 int CWindowMaskFeather::update(float v)
2320 {
2321         gui->feather_slider->update(v);
2322         return BC_TumbleTextBox::update(v);
2323 }
2324
2325 int CWindowMaskFeather::update_value(float v)
2326 {
2327         MaskAutos *autos;
2328         MaskAuto *keyframe;
2329         Track *track;
2330         MaskPoint *point;
2331         SubMask *mask;
2332 #ifdef USE_KEYFRAME_SPANNING
2333         int create_it = 0;
2334 #else
2335         int create_it = 1;
2336 #endif
2337
2338         mwindow->undo->update_undo_before(_("mask feather"), this);
2339
2340 // Get existing keyframe
2341         gui->get_keyframe(track, autos, keyframe,
2342                         mask, point, create_it);
2343         if( track ) {
2344                 int gang = gui->gang_feather->get_value();
2345 #ifdef USE_KEYFRAME_SPANNING
2346                 MaskAuto temp_keyframe(mwindow->edl, autos);
2347                 temp_keyframe.copy_data(keyframe);
2348                 keyframe = &temp_keyframe;
2349 #endif
2350                 float change = v - mask->feather;
2351                 int k = mwindow->edl->session->cwindow_mask;
2352                 int n = gang ? keyframe->masks.size() : k+1;
2353                 for( int i=gang? 0 : k; i<n; ++i ) {
2354                         if( !gui->mask_enables[i]->get_value() ) continue;
2355                         SubMask *sub_mask = keyframe->get_submask(i);
2356                         float feather = sub_mask->feather + change;
2357                         sub_mask->feather = feather;
2358                 }
2359 #ifdef USE_KEYFRAME_SPANNING
2360                 autos->update_parameter(keyframe);
2361 #endif
2362                 gui->update_preview();
2363         }
2364
2365         mwindow->undo->update_undo_after(_("mask feather"), LOAD_AUTOMATION);
2366         return 1;
2367 }
2368
2369 int CWindowMaskFeather::handle_event()
2370 {
2371         float v = atof(get_text());
2372         if( fabsf(v) > MAX_FEATHER )
2373                 BC_TumbleTextBox::update((float)(v>=0 ? MAX_FEATHER : -MAX_FEATHER));
2374         gui->feather_slider->update(v);
2375         return gui->feather->update_value(v);
2376 }
2377
2378 CWindowMaskFeatherSlider::CWindowMaskFeatherSlider(MWindow *mwindow,
2379                 CWindowMaskGUI *gui, int x, int y, int w, float v)
2380  : BC_FSlider(x, y, 0, w, w, -FEATHER_MAX-5, FEATHER_MAX+5, v)
2381 {
2382         this->mwindow = mwindow;
2383         this->gui = gui;
2384         set_precision(0.01);
2385         timer = new Timer();
2386         stick = 0;
2387         last_v = 0;
2388         max = FEATHER_MAX;
2389 }
2390
2391 CWindowMaskFeatherSlider::~CWindowMaskFeatherSlider()
2392 {
2393         delete timer;
2394 }
2395
2396 int CWindowMaskFeatherSlider::handle_event()
2397 {
2398         int sticky = 0;
2399         float v = get_value();
2400         if( fabsf(v) > MAX_FEATHER )
2401                 v = v>=0 ? MAX_FEATHER : -MAX_FEATHER;
2402         if( stick && timer->get_difference() >= 250 )
2403                 stick = 0; // no events for .25 sec
2404         if( stick && (last_v * (v-last_v)) < 0 )
2405                 stick = 0; // dv changed direction
2406         if( stick ) {
2407                 if( --stick > 0 ) {
2408                         timer->update();
2409                         update(last_v);
2410                         return 1;
2411                 }
2412                 if( last_v ) {
2413                         max *= 1.25;
2414                         if( max > MAX_FEATHER ) max = MAX_FEATHER;
2415                         update(get_w(), v=last_v, -max-5, max+5);
2416                         button_release_event();
2417                 }
2418         }
2419         else if( v > max ) { v = max;  sticky = 24; }
2420         else if( v < -max ) { v = -max; sticky = 24; }
2421         else if( v>=0 ? last_v<0 : last_v>=0 ) { v = 0;  sticky = 16; }
2422         if( sticky ) { update(v);  stick = sticky;  timer->update(); }
2423         last_v = v;
2424         gui->feather->BC_TumbleTextBox::update(v);
2425         return gui->feather->update_value(v);
2426 }
2427
2428 int CWindowMaskFeatherSlider::update(float v)
2429 {
2430         float vv = fabsf(v);
2431         if( vv > MAX_FEATHER ) vv = MAX_FEATHER;
2432         while( max < vv ) max *= 1.25;
2433         return update(get_w(), v, -max-5, max+5);
2434 }
2435 int CWindowMaskFeatherSlider::update(int r, float v, float mn, float mx)
2436 {
2437         return BC_FSlider::update(r, v, mn, mx);
2438 }
2439
2440 CWindowMaskFade::CWindowMaskFade(MWindow *mwindow, CWindowMaskGUI *gui, int x, int y)
2441  : BC_TumbleTextBox(gui, 0, -100.f, 100.f, x, y, xS(64), 2)
2442 {
2443         this->mwindow = mwindow;
2444         this->gui = gui;
2445 }
2446 CWindowMaskFade::~CWindowMaskFade()
2447 {
2448 }
2449
2450 int CWindowMaskFade::update(float v)
2451 {
2452         gui->fade_slider->update(v);
2453         return BC_TumbleTextBox::update(v);
2454 }
2455
2456 int CWindowMaskFade::update_value(float v)
2457 {
2458         MaskAutos *autos;
2459         MaskAuto *keyframe;
2460         Track *track;
2461         MaskPoint *point;
2462         SubMask *mask;
2463 #ifdef USE_KEYFRAME_SPANNING
2464         int create_it = 0;
2465 #else
2466         int create_it = 1;
2467 #endif
2468
2469         mwindow->undo->update_undo_before(_("mask fade"), this);
2470
2471 // Get existing keyframe
2472         gui->get_keyframe(track, autos, keyframe,
2473                         mask, point, create_it);
2474         if( track ) {
2475                 int gang = gui->gang_fader->get_value();
2476 #ifdef USE_KEYFRAME_SPANNING
2477                 MaskAuto temp_keyframe(mwindow->edl, autos);
2478                 temp_keyframe.copy_data(keyframe);
2479                 keyframe = &temp_keyframe;
2480 #endif
2481                 float change = v - mask->fader;
2482                 int k = mwindow->edl->session->cwindow_mask;
2483                 int n = gang ? keyframe->masks.size() : k+1;
2484                 for( int i=gang? 0 : k; i<n; ++i ) {
2485                         if( !gui->mask_enables[i]->get_value() ) continue;
2486                         SubMask *sub_mask = keyframe->get_submask(i);
2487                         float fader = sub_mask->fader + change;
2488                         bclamp(fader, -100.f, 100.f);
2489                         sub_mask->fader = fader;
2490                 }
2491 #ifdef USE_KEYFRAME_SPANNING
2492                 autos->update_parameter(keyframe);
2493 #endif
2494                 gui->update_preview();
2495         }
2496
2497         mwindow->undo->update_undo_after(_("mask fade"), LOAD_AUTOMATION);
2498         return 1;
2499 }
2500
2501 int CWindowMaskFade::handle_event()
2502 {
2503         float v = atof(get_text());
2504         gui->fade_slider->update(v);
2505         return gui->fade->update_value(v);
2506 }
2507
2508 CWindowMaskFadeSlider::CWindowMaskFadeSlider(MWindow *mwindow, CWindowMaskGUI *gui,
2509                 int x, int y, int w)
2510  : BC_ISlider(x, y, 0, w, w, -200, 200, 0)
2511 {
2512         this->mwindow = mwindow;
2513         this->gui = gui;
2514         timer = new Timer();
2515         stick = 0;
2516         last_v = 0;
2517 }
2518
2519 CWindowMaskFadeSlider::~CWindowMaskFadeSlider()
2520 {
2521         delete timer;
2522 }
2523
2524 int CWindowMaskFadeSlider::handle_event()
2525 {
2526         float v = 100*get_value()/200;
2527         if( stick > 0 ) {
2528                 int64_t ms = timer->get_difference();
2529                 if( ms < 250 && --stick > 0 ) {
2530                         if( get_value() == 0 ) return 1;
2531                         update(v = 0);
2532                 }
2533                 else {
2534                         stick = 0;
2535                         last_v = v;
2536                 }
2537         }
2538         else if( (last_v>=0 && v<0) || (last_v<0 && v>=0) ) {
2539                 stick = 16;
2540                 v = 0;
2541         }
2542         else
2543                 last_v = v;
2544         timer->update();
2545         gui->fade->BC_TumbleTextBox::update(v);
2546         return gui->fade->update_value(v);
2547 }
2548
2549 int CWindowMaskFadeSlider::update(int64_t v)
2550 {
2551         return BC_ISlider::update(200*v/100);
2552 }
2553
2554 CWindowMaskGangFader::CWindowMaskGangFader(MWindow *mwindow,
2555                 CWindowMaskGUI *gui, int x, int y)
2556  : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2557 {
2558         this->mwindow = mwindow;
2559         this->gui = gui;
2560         set_tooltip(_("Gang fader"));
2561 }
2562
2563 CWindowMaskGangFader::~CWindowMaskGangFader()
2564 {
2565 }
2566
2567 int CWindowMaskGangFader::handle_event()
2568 {
2569         return 1;
2570 }
2571
2572 CWindowMaskGangFocus::CWindowMaskGangFocus(MWindow *mwindow,
2573                 CWindowMaskGUI *gui, int x, int y)
2574  : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2575 {
2576         this->mwindow = mwindow;
2577         this->gui = gui;
2578         set_tooltip(_("Gang rotate/scale/translate"));
2579 }
2580
2581 CWindowMaskGangFocus::~CWindowMaskGangFocus()
2582 {
2583 }
2584
2585 int CWindowMaskGangFocus::handle_event()
2586 {
2587         return 1;
2588 }
2589
2590 CWindowMaskGangPoint::CWindowMaskGangPoint(MWindow *mwindow,
2591                 CWindowMaskGUI *gui, int x, int y)
2592  : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2593 {
2594         this->mwindow = mwindow;
2595         this->gui = gui;
2596         set_tooltip(_("Gang points"));
2597 }
2598
2599 CWindowMaskGangPoint::~CWindowMaskGangPoint()
2600 {
2601 }
2602
2603 int CWindowMaskGangPoint::handle_event()
2604 {
2605         return 1;
2606 }
2607
2608
2609 CWindowMaskSmoothButton::CWindowMaskSmoothButton(MWindow *mwindow, CWindowMaskGUI *gui,
2610                 const char *tip, int type, int on, int x, int y, const char *images)
2611  : BC_Button(x, y, mwindow->theme->get_image_set(images))
2612 {
2613         this->mwindow = mwindow;
2614         this->gui = gui;
2615         this->type = type;
2616         this->on = on;
2617         set_tooltip(tip);
2618 }
2619
2620 int CWindowMaskSmoothButton::handle_event()
2621 {
2622         return gui->smooth_mask(type, on);
2623 }
2624
2625 CWindowMaskBeforePlugins::CWindowMaskBeforePlugins(CWindowMaskGUI *gui, int x, int y)
2626  : BC_CheckBox(x, y, 1, _("Apply mask before plugins"))
2627 {
2628         this->gui = gui;
2629 }
2630
2631 int CWindowMaskBeforePlugins::handle_event()
2632 {
2633         Track *track;
2634         MaskAutos *autos;
2635         MaskAuto *keyframe;
2636         SubMask *mask;
2637         MaskPoint *point;
2638         gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2639
2640         if (keyframe) {
2641                 int v = get_value();
2642 #ifdef USE_KEYFRAME_SPANNING
2643                 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2644                 temp_keyframe.copy_data(keyframe);
2645                 temp_keyframe.apply_before_plugins = v;
2646                 autos->update_parameter(&temp_keyframe);
2647 #else
2648                 keyframe->apply_before_plugins = v;
2649 #endif
2650                 gui->update_preview();
2651         }
2652         return 1;
2653 }
2654
2655
2656 CWindowDisableOpenGLMasking::CWindowDisableOpenGLMasking(CWindowMaskGUI *gui, int x, int y)
2657  : BC_CheckBox(x, y, 1, _("Disable OpenGL masking"))
2658 {
2659         this->gui = gui;
2660 }
2661
2662 int CWindowDisableOpenGLMasking::handle_event()
2663 {
2664         Track *track;
2665         MaskAutos *autos;
2666         MaskAuto *keyframe;
2667         SubMask *mask;
2668         MaskPoint *point;
2669         gui->get_keyframe(track, autos, keyframe, mask, point, 1);
2670
2671         if( keyframe ) {
2672                 int v = get_value();
2673 #ifdef USE_KEYFRAME_SPANNING
2674                 MaskAuto temp_keyframe(gui->mwindow->edl, autos);
2675                 temp_keyframe.copy_data(keyframe);
2676                 temp_keyframe.disable_opengl_masking = v;
2677                 autos->update_parameter(&temp_keyframe);
2678 #else
2679                 keyframe->disable_opengl_masking = v;
2680 #endif
2681                 gui->update_preview();
2682         }
2683         return 1;
2684 }
2685
2686
2687 CWindowMaskClrMask::CWindowMaskClrMask(MWindow *mwindow,
2688                 CWindowMaskGUI *gui, int x, int y)
2689  : BC_Button(x, y, mwindow->theme->get_image_set("reset_button"))
2690 {
2691         this->mwindow = mwindow;
2692         this->gui = gui;
2693         set_tooltip(_("Delete all masks"));
2694 }
2695
2696 CWindowMaskClrMask::~CWindowMaskClrMask()
2697 {
2698 }
2699
2700 int CWindowMaskClrMask::calculate_w(MWindow *mwindow)
2701 {
2702         VFrame *vfrm = *mwindow->theme->get_image_set("reset_button");
2703         return vfrm->get_w();
2704 }
2705
2706 int CWindowMaskClrMask::handle_event()
2707 {
2708         MaskAutos *autos;
2709         MaskAuto *keyframe;
2710         Track *track;
2711         MaskPoint *point;
2712         SubMask *mask;
2713
2714 // Get existing keyframe
2715         gui->get_keyframe(track, autos, keyframe, mask, point, 0);
2716
2717         if( track ) {
2718                 mwindow->undo->update_undo_before(_("del masks"), 0);
2719                 ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->clear_all();
2720                 mwindow->undo->update_undo_after(_("del masks"), LOAD_AUTOMATION);
2721         }
2722
2723         gui->update();
2724         gui->update_preview(1);
2725         return 1;
2726 }
2727
2728 CWindowMaskGangFeather::CWindowMaskGangFeather(MWindow *mwindow,
2729                 CWindowMaskGUI *gui, int x, int y)
2730  : BC_Toggle(x, y, mwindow->theme->get_image_set("gangpatch_data"), 0)
2731 {
2732         this->mwindow = mwindow;
2733         this->gui = gui;
2734         set_tooltip(_("Gang feather"));
2735 }
2736
2737 CWindowMaskGangFeather::~CWindowMaskGangFeather()
2738 {
2739 }
2740
2741 int CWindowMaskGangFeather::handle_event()
2742 {
2743         return 1;
2744 }
2745
2746 CWindowMaskGUI::CWindowMaskGUI(MWindow *mwindow, CWindowTool *thread)
2747  : CWindowToolGUI(mwindow, thread,
2748         _(PROGRAM_NAME ": Mask"), xS(440), yS(700))
2749 {
2750         this->mwindow = mwindow;
2751         this->thread = thread;
2752         active_point = 0;
2753         fade = 0;
2754         feather = 0;
2755         focused = 0;
2756         scale_mode = 2;
2757         markers = 1;
2758         boundary = 1;
2759         preset_dialog = 0;
2760 }
2761 CWindowMaskGUI::~CWindowMaskGUI()
2762 {
2763         lock_window("CWindowMaskGUI::~CWindowMaskGUI");
2764         done_event();
2765         delete active_point;
2766         delete fade;
2767         delete feather;
2768         unlock_window();
2769         delete preset_dialog;
2770 }
2771
2772 void CWindowMaskGUI::create_objects()
2773 {
2774         int t[SUBMASKS];
2775         Theme *theme = mwindow->theme;
2776         int xs10 = xS(10), ys10 = yS(10);
2777         int x = xs10, y = ys10;
2778         int margin = theme->widget_border;
2779         int clr_w = CWindowMaskClrMask::calculate_w(mwindow);
2780         int clr_x = get_w()-x - clr_w;
2781
2782         lock_window("CWindowMaskGUI::create_objects");
2783         BC_TitleBar *title_bar;
2784         add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2785                         _("Masks on Track")));
2786         y += title_bar->get_h() + margin;
2787         BC_Title *title;
2788         add_subwindow(title = new BC_Title(x,y, _("Track:")));
2789         int x1 = x + xS(90), ww = clr_x-2*margin - x1;
2790         for( int i=0,n=sizeof(t)/sizeof(t[0]); i<n; ++i ) t[i] = x1+(i*ww)/n;
2791         int del_x = t[5];
2792         Track *track = mwindow->cwindow->calculate_affected_track();
2793         const char *text = track ? track->title : "";
2794         mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
2795         mask_on_track = new CWindowMaskOnTrack(mwindow, this, x1, y, xS(100), text);
2796         mask_on_track->create_objects();
2797         mask_on_track->set_tooltip(_("Video track"));
2798         int x2 = x1 + mask_on_track->get_w();
2799         add_subwindow(mask_track_tumbler = new CWindowMaskTrackTumbler(mwindow, this, x2, y));
2800         mwindow->edl->local_session->solo_track_id = -1;
2801         add_subwindow(mask_solo_track = new CWindowMaskSoloTrack(mwindow, this, del_x, y, 0));
2802         y += mask_on_track->get_h() + margin;
2803         add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2804                         _("Masks")));
2805         y += title_bar->get_h() + margin;
2806         add_subwindow(title = new BC_Title(x, y, _("Mask:")));
2807         mask_name = new CWindowMaskName(mwindow, this, x1, y, "");
2808         mask_name->create_objects();
2809         mask_name->set_tooltip(_("Mask name"));
2810         add_subwindow(mask_clr = new CWindowMaskClrMask(mwindow, this, clr_x, y));
2811         add_subwindow(mask_del = new CWindowMaskDelMask(mwindow, this, del_x, y));
2812         y += mask_name->get_h() + 2*margin;
2813         BC_Bar *bar;
2814 //      add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2815 //      y += bar->get_h() + 2*margin;
2816
2817         add_subwindow(title = new BC_Title(x, y, _("Select:")));
2818         int bw = 0, bh = 0;
2819         BC_CheckBox::calculate_extents(this, &bw, &bh);
2820         for( int i=0; i<SUBMASKS; ++i ) {
2821                 int v = i == mwindow->edl->session->cwindow_mask ? 1 : 0;
2822                 mask_buttons[i] = new CWindowMaskButton(mwindow, this, t[i], y, i, v);
2823                 add_subwindow(mask_buttons[i]);
2824         }
2825         add_subwindow(mask_thumbler = new CWindowMaskThumbler(mwindow, this, clr_x, y));
2826         y += bh + margin;
2827         for( int i=0; i<SUBMASKS; ++i ) {
2828                 char text[BCSTRLEN];  sprintf(text, "%d", i);
2829                 int tx = (bw - get_text_width(MEDIUMFONT, text)) / 2;
2830                 mask_blabels[i] = new BC_Title(t[i]+tx, y, text);
2831                 add_subwindow(mask_blabels[i]);
2832         }
2833         y += mask_blabels[0]->get_h() + margin;
2834         add_subwindow(title = new BC_Title(x, y, _("Enable:")));
2835         for( int i=0; i<SUBMASKS; ++i ) {
2836                 mask_enables[i] = new CWindowMaskEnable(mwindow, this, t[i], y, i, 1);
2837                 add_subwindow(mask_enables[i]);
2838         }
2839         add_subwindow(mask_unclr = new CWindowMaskUnclear(mwindow, this, clr_x, y));
2840         y += mask_enables[0]->get_h() + 2*margin;
2841         add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2842                         _("Preset Shapes")));
2843         y += title_bar->get_h() + margin;
2844         add_subwindow(mask_shape_sqr = new CWindowMaskShape(mwindow, this,
2845                 "mask_prst_sqr_images", MASK_SHAPE_SQUARE, t[0], y, _("Square")));
2846         add_subwindow(mask_shape_crc = new CWindowMaskShape(mwindow, this,
2847                 "mask_prst_crc_images", MASK_SHAPE_CIRCLE, t[1], y, _("Circle")));
2848         add_subwindow(mask_shape_tri = new CWindowMaskShape(mwindow, this,
2849                 "mask_prst_tri_images", MASK_SHAPE_TRIANGLE, t[2], y, _("Triangle")));
2850         add_subwindow(mask_shape_ovl = new CWindowMaskShape(mwindow, this,
2851                 "mask_prst_ovl_images", MASK_SHAPE_OVAL, t[3], y, _("Oval")));
2852         add_subwindow(mask_load_list = new CWindowMaskLoadList(mwindow, this));
2853         add_subwindow(mask_load = new CWindowMaskLoad(mwindow, this, t[5], y, xS(80)));
2854         add_subwindow(mask_save = new CWindowMaskSave(mwindow, this, t[6], y, xS(80)));
2855         add_subwindow(mask_delete = new CWindowMaskDelete(mwindow, this, t[7], y, xS(80)));
2856         y += mask_load->get_h() + 2*margin;
2857         add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2858                         _("Position & Scale")));
2859         y += title_bar->get_h() + 2*margin;
2860         add_subwindow(mask_center = new CWindowMaskCenter(mwindow, this, t[0], y, xS(80)));
2861         add_subwindow(mask_normal = new CWindowMaskNormal(mwindow, this, t[1], y, xS(80)));
2862
2863         add_subwindow(mask_scale_x = new CWindowMaskScaleXY(mwindow, this,
2864                 t[5], y, theme->get_image_set("mask_scale_x"), 0, MASK_SCALE_X, _("xlate/scale x")));
2865         add_subwindow(mask_scale_y = new CWindowMaskScaleXY(mwindow, this,
2866                 t[6], y, theme->get_image_set("mask_scale_y"), 0, MASK_SCALE_Y, _("xlate/scale y")));
2867         add_subwindow(mask_scale_xy = new CWindowMaskScaleXY(mwindow, this,
2868                 t[7], y, theme->get_image_set("mask_scale_xy"), 1, MASK_SCALE_XY, _("xlate/scale xy")));
2869         y += mask_center->get_h() + 2*margin;
2870         add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2871                         _("Fade & Feather")));
2872         y += title_bar->get_h() + 2*margin;
2873
2874         add_subwindow(title = new BC_Title(x, y, _("Fade:")));
2875         fade = new CWindowMaskFade(mwindow, this, x1, y);
2876         fade->create_objects();
2877         x2 = x1 + fade->get_w() + 2*margin;
2878         int w2 = clr_x-2*margin - x2;
2879         add_subwindow(fade_slider = new CWindowMaskFadeSlider(mwindow, this, x2, y, w2));
2880         add_subwindow(gang_fader = new CWindowMaskGangFader(mwindow, this, clr_x, y));
2881         y += fade->get_h() + margin;
2882         add_subwindow(title = new BC_Title(x, y, _("Feather:")));
2883         feather = new CWindowMaskFeather(mwindow, this, x1, y);
2884         feather->create_objects();
2885         w2 = clr_x - 2*margin - x2;
2886         feather_slider = new CWindowMaskFeatherSlider(mwindow, this, x2, y, w2, 0);
2887         add_subwindow(feather_slider);
2888         add_subwindow(gang_feather = new CWindowMaskGangFeather(mwindow, this, clr_x, y));
2889         y += feather->get_h() + 2*margin;
2890         add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2891                         _("Mask Points")));
2892         y += title_bar->get_h() + margin;
2893
2894         add_subwindow(title = new BC_Title(x, y, _("Point:")));
2895         active_point = new CWindowMaskAffectedPoint(mwindow, this, t[0], y);
2896         active_point->create_objects();
2897 // typ=0, this mask, this point
2898         add_subwindow(mask_pnt_linear = new CWindowMaskSmoothButton(mwindow, this,
2899                 _("linear point"), 0, 0, t[3], y, "mask_pnt_linear_images"));
2900         add_subwindow(mask_pnt_smooth = new CWindowMaskSmoothButton(mwindow, this,
2901                 _("smooth point"), 0, 1, t[4], y, "mask_pnt_smooth_images"));
2902         add_subwindow(del_point = new CWindowMaskDelPoint(mwindow, this, del_x, y));
2903         add_subwindow(gang_point = new CWindowMaskGangPoint(mwindow, this, clr_x, y));
2904         y += active_point->get_h() + margin;
2905         add_subwindow(title = new BC_Title(x, y, "X:"));
2906         this->x = new CWindowCoord(this, t[0], y, (float)0.0);
2907         this->x->create_objects();
2908 // typ>0, this mask, all points
2909         add_subwindow(mask_crv_linear = new CWindowMaskSmoothButton(mwindow, this,
2910                 _("linear curve"), 1, 0, t[3], y, "mask_crv_linear_images"));
2911         add_subwindow(mask_crv_smooth = new CWindowMaskSmoothButton(mwindow, this,
2912                 _("smooth curve"), 1, 1, t[4], y, "mask_crv_smooth_images"));
2913         add_subwindow(draw_markers = new CWindowMaskDrawMarkers(mwindow, this, del_x, y));
2914         y += this->x->get_h() + margin;
2915         add_subwindow(title = new BC_Title(x, y, "Y:"));
2916         this->y = new CWindowCoord(this, x1, y, (float)0.0);
2917         this->y->create_objects();
2918 // typ<0, all masks, all points
2919         add_subwindow(mask_all_linear = new CWindowMaskSmoothButton(mwindow, this,
2920                 _("linear all"), -1, 0, t[3], y, "mask_all_linear_images"));
2921         add_subwindow(mask_all_smooth = new CWindowMaskSmoothButton(mwindow, this,
2922                 _("smooth all"), -1, 1, t[4], y, "mask_all_smooth_images"));
2923         add_subwindow(draw_boundary = new CWindowMaskDrawBoundary(mwindow, this, del_x, y));
2924         y += this->y->get_h() + 2*margin;
2925         add_subwindow(title_bar = new BC_TitleBar(x, y, get_w()-2*x, xS(20), xS(10),
2926                         _("Pivot Point")));
2927         y += title_bar->get_h() + margin;
2928
2929         add_subwindow(title = new BC_Title(x, y, "X:"));
2930         float cx = mwindow->edl->session->output_w / 2.f;
2931         focus_x = new CWindowCoord(this, x1, y, cx);
2932         focus_x->create_objects();
2933         add_subwindow(focus = new CWindowMaskFocus(mwindow, this, del_x, y));
2934         add_subwindow(gang_focus = new CWindowMaskGangFocus(mwindow, this, clr_x, y));
2935         y += focus_x->get_h() + margin;
2936         add_subwindow(title = new BC_Title(x, y, "Y:"));
2937         float cy = mwindow->edl->session->output_h / 2.f;
2938         focus_y = new CWindowCoord(this, x1, y, cy);
2939         focus_y->create_objects();
2940         y += focus_y->get_h() + 2*margin;
2941         add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2942         y += bar->get_h() + margin;
2943         add_subwindow(this->apply_before_plugins = new CWindowMaskBeforePlugins(this, x, y));
2944         y += this->apply_before_plugins->get_h();
2945         add_subwindow(this->disable_opengl_masking = new CWindowDisableOpenGLMasking(this, x, y));
2946         add_subwindow(help = new CWindowMaskHelp(mwindow, this, del_x, y));
2947         y += this->disable_opengl_masking->get_h() + 2*margin;
2948         help_y = y;
2949         add_subwindow(bar = new BC_Bar(x, y, get_w()-2*x));
2950         y += bar->get_h() + 2*margin;
2951         add_subwindow(title = new BC_Title(x, y, _(
2952                 "Shift+LMB: move an end point\n"
2953                 "Ctrl+LMB: move a control point\n"
2954                 "Alt+LMB: to drag translate the mask\n"
2955                 "Shift+MMB: Set Pivot Point at pointer\n"
2956                 "Wheel: rotate around Pivot Point\n"
2957                 "Shift+Wheel: scale around Pivot Point\n"
2958                 "Ctrl+Wheel: rotate/scale around pointer")));
2959         help_h = y + title->get_h() + 2*margin;
2960         update();
2961         resize_window(get_w(), help_y);
2962         unlock_window();
2963 }
2964
2965 int CWindowMaskGUI::close_event()
2966 {
2967         done_event();
2968         return CWindowToolGUI::close_event();
2969 }
2970
2971 void CWindowMaskGUI::done_event()
2972 {
2973         if( mwindow->in_destructor ) return;
2974         int &solo_track_id = mwindow->edl->local_session->solo_track_id;
2975         if( solo_track_id >= 0 ) {
2976                 solo_track_id = -1;
2977                 update_preview();
2978         }
2979 }
2980
2981 void CWindowMaskGUI::get_keyframe(Track* &track,
2982                 MaskAutos* &autos, MaskAuto* &keyframe,
2983                 SubMask* &mask, MaskPoint* &point, int create_it)
2984 {
2985         autos = 0;
2986         keyframe = 0;
2987
2988         track = mwindow->cwindow->calculate_mask_track();
2989         if( !track )
2990                 track = mwindow->cwindow->calculate_affected_track();
2991
2992         if(track) {
2993                 autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
2994                 keyframe = (MaskAuto*)mwindow->cwindow->calculate_affected_auto(
2995                         autos,
2996                         create_it);
2997         }
2998
2999         mask = !keyframe ? 0 :
3000                 keyframe->get_submask(mwindow->edl->session->cwindow_mask);
3001
3002         point = 0;
3003         if( keyframe ) {
3004                 if( mwindow->cwindow->gui->affected_point < mask->points.total &&
3005                         mwindow->cwindow->gui->affected_point >= 0 ) {
3006                         point = mask->points.values[mwindow->cwindow->gui->affected_point];
3007                 }
3008         }
3009 }
3010
3011 void CWindowMaskGUI::update()
3012 {
3013         Track *track;
3014         MaskAutos *autos;
3015         MaskAuto *keyframe;
3016         SubMask *mask;
3017         MaskPoint *point;
3018 //printf("CWindowMaskGUI::update 1\n");
3019         get_keyframe(track, autos, keyframe, mask, point, 0);
3020         mwindow->cwindow->mask_track_id = track ? track->get_id() : -1;
3021         mask_on_track->set_back_color(!track || track->record ?
3022                 get_resources()->text_background :
3023                 get_resources()->text_background_disarmed);
3024         mask_on_track->update_items();
3025         mask_on_track->update(!track ? "" : track->title);
3026         mask_name->update_items(keyframe);
3027         const char *text = "";
3028         int sz = !keyframe ? 0 : keyframe->masks.size();
3029         int k = mwindow->edl->session->cwindow_mask;
3030         if( k >= 0 && k < sz )
3031                 text = keyframe->masks[k]->name;
3032         else
3033                 k = mwindow->edl->session->cwindow_mask = 0;
3034         mask_name->update(text);
3035         update_buttons(keyframe, k);
3036         if( point ) {
3037                 x->update(point->x);
3038                 y->update(point->y);
3039         }
3040         if( track ) {
3041                 double position = mwindow->edl->local_session->get_selectionstart(1);
3042                 int64_t position_i = track->to_units(position, 0);
3043                 feather->update(autos->get_feather(position_i, k, PLAY_FORWARD));
3044                 fade->update(autos->get_fader(position_i, k, PLAY_FORWARD));
3045                 int show_mask = track->masks;
3046                 for( int i=0; i<SUBMASKS; ++i )
3047                         mask_enables[i]->update((show_mask>>i) & 1);
3048         }
3049         if( keyframe ) {
3050                 apply_before_plugins->update(keyframe->apply_before_plugins);
3051                 disable_opengl_masking->update(keyframe->disable_opengl_masking);
3052         }
3053         active_point->update((int64_t)mwindow->cwindow->gui->affected_point);
3054 }
3055
3056 void CWindowMaskGUI::handle_event()
3057 {
3058         int redraw = 0;
3059         if( event_caller == this->focus_x ||
3060             event_caller == this->focus_y ) {
3061                 redraw = 1;
3062         }
3063         else if( event_caller == this->x ||
3064                  event_caller == this->y ) {
3065                 Track *track;
3066                 MaskAuto *keyframe;
3067                 MaskAutos *autos;
3068                 SubMask *mask;
3069                 MaskPoint *point;
3070                 get_keyframe(track, autos, keyframe, mask, point, 0);
3071
3072                 mwindow->undo->update_undo_before(_("mask point"), this);
3073
3074                 if( point ) {
3075                         float px = atof(x->get_text());
3076                         float py = atof(y->get_text());
3077                         float dx = px - point->x, dy = py - point->y;
3078 #ifdef USE_KEYFRAME_SPANNING
3079 // Create temp keyframe
3080                         MaskAuto temp_keyframe(mwindow->edl, autos);
3081                         temp_keyframe.copy_data(keyframe);
3082 // Get affected point in temp keyframe
3083                         mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3084 #endif
3085                         MaskPoints &points = mask->points;
3086                         int gang = gang_point->get_value();
3087                         int k = mwindow->cwindow->gui->affected_point;
3088                         int n = gang ? points.size() : k+1;
3089                         for( int i=gang? 0 : k; i<n; ++i ) {
3090                                 if( i < 0 || i >= points.size() ) continue;
3091                                 MaskPoint *point = points[i];
3092                                 point->x += dx;  point->y += dy;
3093                         }
3094 #ifdef USE_KEYFRAME_SPANNING
3095 // Commit to spanned keyframes
3096                         autos->update_parameter(&temp_keyframe);
3097 #endif
3098                 }
3099                 mwindow->undo->update_undo_after(_("mask point"), LOAD_AUTOMATION);
3100                 redraw = 1;
3101         }
3102
3103         if( redraw )
3104                 update_preview();
3105 }
3106
3107 void CWindowMaskGUI::set_focused(int v, float cx, float cy)
3108 {
3109         CWindowGUI *cgui = mwindow->cwindow->gui;
3110         cgui->unlock_window();
3111         lock_window("CWindowMaskGUI::set_focused");
3112         if( focused != v )
3113                 focus->update(focused = v);
3114         focus_x->update(cx);
3115         focus_y->update(cy);
3116         unlock_window();
3117         cgui->lock_window("CWindowCanvas::set_focused");
3118 }
3119
3120 void CWindowMaskGUI::update_buttons(MaskAuto *keyframe, int k)
3121 {
3122         int text_color = get_resources()->default_text_color;
3123         int high_color = get_resources()->button_highlighted;
3124         for( int i=0; i<SUBMASKS; ++i ) {
3125                 int color = text_color;
3126                 if( keyframe ) {
3127                         SubMask *submask = keyframe->get_submask(i);
3128                         if( submask && submask->points.size() )
3129                                 color = high_color;
3130                 }
3131                 mask_blabels[i]->set_color(color);
3132                 mask_buttons[i]->update(i==k ? 1 : 0);
3133         }
3134 }
3135
3136 // typ=0, this mask, this point
3137 // typ>0, this mask, all points
3138 // typ<0, all masks, all points
3139 // dxy= on? pt[+1]-pt[-1] : dxy=0
3140 int CWindowMaskGUI::smooth_mask(int typ, int on)
3141 {
3142         MaskAutos *autos;
3143         MaskAuto *keyframe;
3144         Track *track;
3145         MaskPoint *point;
3146         SubMask *mask;
3147 #ifdef USE_KEYFRAME_SPANNING
3148         int create_it = 0;
3149 #else
3150         int create_it = 1;
3151 #endif
3152
3153         mwindow->undo->update_undo_before(_("mask smooth"), this);
3154
3155 // Get existing keyframe
3156         get_keyframe(track, autos, keyframe,
3157                         mask, point, create_it);
3158         if( track ) {
3159 #ifdef USE_KEYFRAME_SPANNING
3160                 MaskAuto temp_keyframe(mwindow->edl, autos);
3161                 temp_keyframe.copy_data(keyframe);
3162                 keyframe = &temp_keyframe;
3163 #endif
3164                 int k = mwindow->edl->session->cwindow_mask;
3165                 int n = typ>=0 ? k+1 : keyframe->masks.size();
3166                 for( int j=typ<0? 0 : k; j<n; ++j ) {
3167                         if( !mask_enables[j]->get_value() ) continue;
3168                         SubMask *sub_mask = keyframe->get_submask(j);
3169                         MaskPoints &points = sub_mask->points;
3170                         int psz = points.size();
3171                         if( psz < 3 ) continue;
3172                         int l = mwindow->cwindow->gui->affected_point;
3173                         if( l > psz ) l = psz;
3174                         int m = typ ? psz : l+1;
3175                         for( int i=typ ? 0 : l; i<m; ++i ) {
3176                                 int i0 = i-1, i1 = i+1;
3177                                 if( i0 < 0 ) i0 = psz-1;
3178                                 if( i1 >= psz ) i1 = 0;
3179                                 MaskPoint *p0 = points[i0];
3180                                 MaskPoint *p  = points[i];
3181                                 MaskPoint *p1 = points[i1];
3182                                 float dx = !on ? 0 : p1->x - p0->x;
3183                                 float dy = !on ? 0 : p1->y - p0->y;
3184                                 p->control_x1 = -dx/4;  p->control_y1 = -dy/4;
3185                                 p->control_x2 =  dx/4;  p->control_y2 =  dy/4;
3186                         }
3187                 }
3188 #ifdef USE_KEYFRAME_SPANNING
3189                 autos->update_parameter(keyframe);
3190 #endif
3191                 update_preview();
3192         }
3193
3194         mwindow->undo->update_undo_after(_("mask smooth"), LOAD_AUTOMATION);
3195         return 1;
3196 }
3197
3198 int CWindowMaskGUI::save_mask(const char *nm)
3199 {
3200         int k = mwindow->edl->session->cwindow_mask;
3201         MaskAutos *autos;
3202         MaskAuto *keyframe;
3203         Track *track;
3204         MaskPoint *point;
3205         SubMask *mask;
3206         get_keyframe(track, autos, keyframe, mask, point, 0);
3207         if( !track ) return 0;
3208         SubMask *sub_mask = keyframe->get_submask(k);
3209         ArrayList<SubMask *> masks;
3210         load_masks(masks);
3211         int i = masks.size();
3212         while( --i >= 0 ) {
3213                 if( strcmp(masks[i]->name, nm) ) continue;
3214                 masks.remove_object_number(i++);
3215         }
3216         mask = new SubMask(0, -1);
3217         strncpy(mask->name, nm, sizeof(mask->name)-1);
3218         mask->copy_from(*sub_mask, 0);
3219         masks.append(mask);
3220         save_masks(masks);
3221         masks.remove_all_objects();
3222         return 1;
3223 }
3224
3225 int CWindowMaskGUI::del_mask(const char *nm)
3226 {
3227         ArrayList<SubMask *> masks;
3228         load_masks(masks);
3229         int i = masks.size();
3230         while( --i >= 0 ) {
3231                 if( strcmp(masks[i]->name, nm) ) continue;
3232                 masks.remove_object_number(i++);
3233         }
3234         save_masks(masks);
3235         masks.remove_all_objects();
3236         return 1;
3237 }
3238
3239 int CWindowMaskGUI::center_mask()
3240 {
3241         int k = mwindow->edl->session->cwindow_mask;
3242         MaskAutos *autos;
3243         MaskAuto *keyframe;
3244         Track *track;
3245         MaskPoint *point;
3246         SubMask *mask;
3247 #ifdef USE_KEYFRAME_SPANNING
3248         int create_it = 0;
3249 #else
3250         int create_it = 1;
3251 #endif
3252         get_keyframe(track, autos, keyframe,
3253                         mask, point, create_it);
3254         if( !track ) return 0;
3255         mwindow->undo->update_undo_before(_("mask center"), this);
3256
3257 // Get existing keyframe
3258 #ifdef USE_KEYFRAME_SPANNING
3259         MaskAuto temp_keyframe(mwindow->edl, autos);
3260         temp_keyframe.copy_data(keyframe);
3261         keyframe = &temp_keyframe;
3262 #endif
3263         SubMask *sub_mask = keyframe->get_submask(k);
3264         MaskPoints &points = sub_mask->points;
3265         int psz = points.size();
3266         if( psz > 0 ) {
3267                 float cx = 0, cy = 0;
3268                 for( int i=0; i<psz; ++i ) {
3269                         MaskPoint *p  = points[i];
3270                         cx += p->x;  cy += p->y;
3271                 }
3272                 cx /= psz;  cy /= psz;
3273                 cx -= mwindow->edl->session->output_w / 2.f;
3274                 cy -= mwindow->edl->session->output_h / 2.f;
3275                 for( int i=0; i<psz; ++i ) {
3276                         MaskPoint *p  = points[i];
3277                         p->x -= cx;  p->y -= cy;
3278                 }
3279         }
3280 #ifdef USE_KEYFRAME_SPANNING
3281         autos->update_parameter(keyframe);
3282 #endif
3283         update_preview();
3284         mwindow->undo->update_undo_after(_("mask center"), LOAD_AUTOMATION);
3285         return 1;
3286 }
3287
3288 int CWindowMaskGUI::normal_mask()
3289 {
3290         int k = mwindow->edl->session->cwindow_mask;
3291         MaskAutos *autos;
3292         MaskAuto *keyframe;
3293         Track *track;
3294         MaskPoint *point;
3295         SubMask *mask;
3296 #ifdef USE_KEYFRAME_SPANNING
3297         int create_it = 0;
3298 #else
3299         int create_it = 1;
3300 #endif
3301 // Get existing keyframe
3302         get_keyframe(track, autos, keyframe,
3303                         mask, point, create_it);
3304         if( !track ) return 0;
3305         mwindow->undo->update_undo_before(_("mask normal"), this);
3306
3307 #ifdef USE_KEYFRAME_SPANNING
3308         MaskAuto temp_keyframe(mwindow->edl, autos);
3309         temp_keyframe.copy_data(keyframe);
3310         keyframe = &temp_keyframe;
3311 #endif
3312         SubMask *sub_mask = keyframe->get_submask(k);
3313         MaskPoints &points = sub_mask->points;
3314         int psz = points.size();
3315         float cx = 0, cy = 0;
3316         double dr = 0;
3317         if( psz > 0 ) {
3318                 for( int i=0; i<psz; ++i ) {
3319                         MaskPoint *p  = points[i];
3320                         cx += p->x;  cy += p->y;
3321                 }
3322                 cx /= psz;  cy /= psz;
3323                 for( int i=0; i<psz; ++i ) {
3324                         MaskPoint *p  = points[i];
3325                         float dx = fabsf(p->x-cx), dy = fabsf(p->y-cy);
3326                         double d = sqrt(dx*dx + dy*dy);
3327                         if( dr < d ) dr = d;
3328                 }
3329         }
3330         if( dr > 0 ) {
3331                 float out_w = mwindow->edl->session->output_w;
3332                 float out_h = mwindow->edl->session->output_h;
3333                 float r = bmax(out_w, out_h);
3334                 float s = r / (4 * dr * sqrt(2.));
3335                 for( int i=0; i<psz; ++i ) {
3336                         MaskPoint *p  = points[i];
3337                         float x = p->x, y = p->y;
3338                         p->x = (x-cx) * s + cx;
3339                         p->y = (y-cy) * s + cy;
3340                         p->control_x1 *= s;  p->control_y1 *= s;
3341                         p->control_x2 *= s;  p->control_y2 *= s;
3342                 }
3343         }
3344 #ifdef USE_KEYFRAME_SPANNING
3345         autos->update_parameter(keyframe);
3346 #endif
3347         update_preview();
3348
3349         mwindow->undo->update_undo_after(_("mask normal"), LOAD_AUTOMATION);
3350         return 1;
3351 }
3352
3353
3354 CWindowMaskLoadList::CWindowMaskLoadList(MWindow *mwindow, CWindowMaskGUI *gui)
3355  : BC_ListBox(-1, -1, 1, 1, LISTBOX_TEXT, 0, 0, 0, 1, 0, 1)
3356 {
3357         this->mwindow = mwindow;
3358         this->gui = gui;
3359         set_use_button(0);
3360 }
3361
3362 CWindowMaskLoadList::~CWindowMaskLoadList()
3363 {
3364 }
3365
3366
3367 int CWindowMaskLoadList::handle_event()
3368 {
3369         MaskAutos *autos;
3370         MaskAuto *keyframe;
3371         Track *track;
3372         MaskPoint *point;
3373         SubMask *mask;
3374 #ifdef USE_KEYFRAME_SPANNING
3375         int create_it = 0;
3376 #else
3377         int create_it = 1;
3378 #endif
3379
3380         mwindow->undo->update_undo_before(_("mask shape"), this);
3381
3382 // Get existing keyframe
3383         gui->get_keyframe(track, autos, keyframe,
3384                         mask, point, create_it);
3385         CWindowMaskItem *item = (CWindowMaskItem *) get_selection(0, 0);
3386         if( track && item ) {
3387 #ifdef USE_KEYFRAME_SPANNING
3388                 MaskAuto temp_keyframe(mwindow->edl, autos);
3389                 temp_keyframe.copy_data(keyframe);
3390                 keyframe = &temp_keyframe;
3391                 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3392 #endif
3393                 ArrayList<SubMask *> masks;
3394                 gui->load_masks(masks);
3395                 mask->copy_from(*masks[item->id], 0);
3396                 masks.remove_all_objects();
3397 #ifdef USE_KEYFRAME_SPANNING
3398                 autos->update_parameter(keyframe);
3399 #endif
3400                 gui->update();
3401                 gui->update_preview(1);
3402         }
3403         mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3404         return 1;
3405 }
3406
3407 void CWindowMaskLoadList::create_objects()
3408 {
3409         shape_items.remove_all_objects();
3410         ArrayList<SubMask *> masks;
3411         gui->load_masks(masks);
3412         for( int i=0; i<masks.size(); ++i )
3413                 shape_items.append(new CWindowMaskItem(masks[i]->name, i));
3414         masks.remove_all_objects();
3415         update(&shape_items, 0, 0, 1);
3416 }
3417
3418 CWindowMaskLoad::CWindowMaskLoad(MWindow *mwindow,
3419         CWindowMaskGUI *gui, int x, int y, int w)
3420  : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_load_images"))
3421 {
3422         this->mwindow = mwindow;
3423         this->gui = gui;
3424         set_tooltip(_("Load preset"));
3425 }
3426
3427 int CWindowMaskLoad::handle_event()
3428 {
3429         gui->mask_load_list->create_objects();
3430         int px, py;
3431         get_abs_cursor(px, py);
3432         return gui->mask_load_list->activate(px, py, xS(120),yS(160));
3433 }
3434
3435
3436 CWindowMaskSave::CWindowMaskSave(MWindow *mwindow,
3437         CWindowMaskGUI *gui, int x, int y, int w)
3438  : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_save_images"))
3439 {
3440         this->mwindow = mwindow;
3441         this->gui = gui;
3442         set_tooltip(_("Save preset"));
3443 }
3444
3445 CWindowMaskSave::~CWindowMaskSave()
3446 {
3447 }
3448
3449 int CWindowMaskSave::handle_event()
3450 {
3451         Track *track;
3452         MaskAutos *autos;
3453         MaskAuto *keyframe;
3454         SubMask *mask;
3455         MaskPoint *point;
3456         gui->get_keyframe(track, autos, keyframe, mask, point, 0);
3457         if( track ) {
3458                 int sx = 0, sy = 0;
3459                 gui->get_abs_cursor(sx, sy);
3460                 if( !gui->preset_dialog )
3461                         gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3462                 gui->preset_dialog->start_dialog(sx, sy, keyframe);
3463         }
3464         return 1;
3465 }
3466
3467 CWindowMaskPresetDialog::CWindowMaskPresetDialog(MWindow *mwindow, CWindowMaskGUI *gui)
3468  : BC_DialogThread()
3469 {
3470         this->mwindow = mwindow;
3471         this->gui = gui;
3472         pgui = 0;
3473 }
3474
3475 CWindowMaskPresetDialog::~CWindowMaskPresetDialog()
3476 {
3477         close_window();
3478 }
3479
3480 void CWindowMaskPresetDialog::handle_close_event(int result)
3481 {
3482         pgui = 0;
3483 }
3484
3485 void CWindowMaskPresetDialog::handle_done_event(int result)
3486 {
3487         if( result ) return;
3488         const char *nm = pgui->preset_text->get_text();
3489         if( keyframe )
3490                 gui->save_mask(nm);
3491         else
3492                 gui->del_mask(nm);
3493 }
3494
3495 BC_Window* CWindowMaskPresetDialog::new_gui()
3496 {
3497         pgui = new CWindowMaskPresetGUI(this, sx, sy,
3498                 keyframe ? _(PROGRAM_NAME ": Save Mask") :
3499                            _(PROGRAM_NAME ": Delete Mask"));
3500         pgui->create_objects();
3501         return pgui;
3502 }
3503
3504 void CWindowMaskPresetDialog::start_dialog(int sx, int sy, MaskAuto *keyframe)
3505 {
3506         close_window();
3507         this->sx = sx;  this->sy = sy;
3508         this->keyframe = keyframe;
3509         start();
3510 }
3511
3512 CWindowMaskPresetGUI::CWindowMaskPresetGUI(CWindowMaskPresetDialog *preset_dialog,
3513                         int x, int y, const char *title)
3514  : BC_Window(title, x, y, xS(320), yS(100), xS(320), yS(100), 0, 0, 1)
3515 {
3516         this->preset_dialog = preset_dialog;
3517 }
3518
3519 void CWindowMaskPresetGUI::create_objects()
3520 {
3521         int xs8 = xS(8), xs10 = xS(10);
3522         int ys10 = yS(10);
3523         int x = xs10, y = ys10;
3524         lock_window("CWindowMaskPresetGUI::create_objects");
3525         BC_Title *title;
3526         add_subwindow(title = new BC_Title(x, y,
3527                 preset_dialog->keyframe ? _("Save mask:") : _("Delete mask:")));
3528         int x1 = x + title->get_w() + xs8;
3529         int x2 = get_w() - x - xs8 - x1 -
3530                 BC_WindowBase::get_resources()->listbox_button[0]->get_w();
3531         CWindowMaskGUI *gui = preset_dialog->gui;
3532         preset_text = new CWindowMaskPresetText(this,
3533                 x1, y, x2, yS(120), gui->mask_name->get_text());
3534         preset_text->create_objects();
3535         preset_text->set_tooltip(_("Mask name"));
3536         preset_text->update_items();
3537         add_subwindow(new BC_OKButton(this));
3538         add_subwindow(new BC_CancelButton(this));
3539         show_window();
3540         raise_window();
3541         unlock_window();
3542 }
3543
3544 CWindowMaskPresetText::CWindowMaskPresetText(CWindowMaskPresetGUI *pgui,
3545                 int x, int y, int w, int h, const char *text)
3546  : BC_PopupTextBox(pgui, 0, text, x, y, w, h)
3547 {
3548         this->pgui = pgui;
3549 }
3550
3551 int CWindowMaskPresetText::handle_event()
3552 {
3553         int k = get_number();
3554         if( k >= 0 && k<mask_items.size() )
3555                 update(mask_items[k]->get_text());
3556         return 1;
3557 }
3558
3559 void CWindowMaskPresetText::update_items()
3560 {
3561         mask_items.remove_all_objects();
3562         ArrayList<SubMask *> masks;
3563         pgui->preset_dialog->gui->load_masks(masks);
3564         for( int i=0; i<masks.size(); ++i ) {
3565                 char text[BCSTRLEN];  memset(text, 0, sizeof(text));
3566                 strncpy(text, masks[i]->name, sizeof(text)-1);
3567                 mask_items.append(new CWindowMaskItem(text));
3568         }
3569         masks.remove_all_objects();
3570         update_list(&mask_items);
3571 }
3572
3573
3574 CWindowMaskDelete::CWindowMaskDelete(MWindow *mwindow,
3575         CWindowMaskGUI *gui, int x, int y, int w)
3576  : BC_Button(x, y, mwindow->theme->get_image_set("mask_prst_trsh_images"))
3577 {
3578         this->mwindow = mwindow;
3579         this->gui = gui;
3580         set_tooltip(_("Delete preset"));
3581 }
3582
3583 int CWindowMaskDelete::handle_event()
3584 {
3585         int sx = 0, sy = 0;
3586         gui->get_abs_cursor(sx, sy);
3587         if( !gui->preset_dialog )
3588                 gui->preset_dialog = new CWindowMaskPresetDialog(mwindow, gui);
3589         gui->preset_dialog->start_dialog(sx, sy, 0);
3590         return 1;
3591 }
3592
3593
3594 CWindowMaskCenter::CWindowMaskCenter(MWindow *mwindow,
3595         CWindowMaskGUI *gui, int x, int y, int w)
3596  : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_cen_images"))
3597 {
3598         this->mwindow = mwindow;
3599         this->gui = gui;
3600         set_tooltip(_("center mask"));
3601 }
3602
3603 int CWindowMaskCenter::handle_event()
3604 {
3605         return gui->center_mask();
3606 }
3607
3608
3609 CWindowMaskNormal::CWindowMaskNormal(MWindow *mwindow,
3610         CWindowMaskGUI *gui, int x, int y, int w)
3611  : BC_Button(x, y, mwindow->theme->get_image_set("mask_pstn_nrm_images"))
3612 {
3613         this->mwindow = mwindow;
3614         this->gui = gui;
3615         set_tooltip(_("normalize mask"));
3616 }
3617
3618 int CWindowMaskNormal::handle_event()
3619 {
3620         return gui->normal_mask();
3621 }
3622
3623
3624 CWindowMaskShape::CWindowMaskShape(MWindow *mwindow, CWindowMaskGUI *gui,
3625                 const char *images, int shape, int x, int y, const char *tip)
3626  : BC_Button(x, y, mwindow->theme->get_image_set(images))
3627 {
3628         this->mwindow = mwindow;
3629         this->gui = gui;
3630         this->shape = shape;
3631         set_tooltip(tip);
3632 }
3633
3634 CWindowMaskShape::~CWindowMaskShape()
3635 {
3636 }
3637
3638 void CWindowMaskShape::builtin_shape(int i, SubMask *sub_mask)
3639 {
3640         int out_w = mwindow->edl->session->output_w;
3641         int out_h = mwindow->edl->session->output_h;
3642         float cx = out_w/2.f, cy = out_h/2.f;
3643         float r = bmax(cx, cy) / 4.f;
3644         double c = 4*(sqrt(2.)-1)/3; // bezier aprox circle
3645         float r2 = r / 2.f, rc = r*c, r4 = r / 4.f;
3646         MaskPoint *pt = 0;
3647         MaskPoints &points = sub_mask->points;
3648         points.remove_all_objects();
3649         switch( i ) {
3650         case MASK_SHAPE_SQUARE:
3651                 points.append(pt = new MaskPoint());
3652                 pt->x = cx - r;  pt->y = cy - r;
3653                 points.append(pt = new MaskPoint());
3654                 pt->x = cx + r;  pt->y = cy - r;
3655                 points.append(pt = new MaskPoint());
3656                 pt->x = cx + r;  pt->y = cy + r;
3657                 points.append(pt = new MaskPoint());
3658                 pt->x = cx - r;  pt->y = cy + r;
3659                 break;
3660         case MASK_SHAPE_CIRCLE:
3661                 points.append(pt = new MaskPoint());
3662                 pt->x = cx - r;  pt->y = cy - r;
3663                 pt->control_x1 = -rc;  pt->control_y1 =  rc;
3664                 pt->control_x2 =  rc;  pt->control_y2 = -rc;
3665                 points.append(pt = new MaskPoint());
3666                 pt->x = cx + r;  pt->y = cy - r;
3667                 pt->control_x1 = -rc;  pt->control_y1 = -rc;
3668                 pt->control_x2 =  rc;  pt->control_y2 =  rc;
3669                 points.append(pt = new MaskPoint());
3670                 pt->x = cx + r;  pt->y = cy + r;
3671                 pt->control_x1 =  rc;  pt->control_y1 = -rc;
3672                 pt->control_x2 = -rc;  pt->control_y2 =  rc;
3673                 points.append(pt = new MaskPoint());
3674                 pt->x = cx - r;  pt->y = cy + r;
3675                 pt->control_x1 =  rc;  pt->control_y1 =  rc;
3676                 pt->control_x2 = -rc;  pt->control_y2 = -rc;
3677                 break;
3678         case MASK_SHAPE_TRIANGLE:
3679                 points.append(pt = new MaskPoint());
3680                 pt->x = cx + 0;  pt->y = cy - r*(sqrt(3.)-1.);
3681                 points.append(pt = new MaskPoint());
3682                 pt->x = cx + r;  pt->y = cy + r;
3683                 points.append(pt = new MaskPoint());
3684                 pt->x = cx - r;  pt->y = cy + r;
3685                 break;
3686         case MASK_SHAPE_OVAL:
3687                 points.append(pt = new MaskPoint());
3688                 pt->x = cx - r;  pt->y = cy - r2;
3689                 pt->control_x1 = -r2;  pt->control_y1 =  r4;
3690                 pt->control_x2 =  r2;  pt->control_y2 = -r4;
3691                 points.append(pt = new MaskPoint());
3692                 pt->x = cx + r;  pt->y = cy - r2;
3693                 pt->control_x1 = -r2;  pt->control_y1 = -r4;
3694                 pt->control_x2 =  r2;  pt->control_y2 =  r4;
3695                 points.append(pt = new MaskPoint());
3696                 pt->x = cx + r;  pt->y = cy + r2;
3697                 pt->control_x1 =  r2;  pt->control_y1 = -r4;
3698                 pt->control_x2 = -r2;  pt->control_y2 =  r4;
3699                 points.append(pt = new MaskPoint());
3700                 pt->x = cx - r;  pt->y = cy + r2;
3701                 pt->control_x1 =  r2;  pt->control_y1 =  r4;
3702                 pt->control_x2 = -r2;  pt->control_y2 = -r4;
3703                 break;
3704         }
3705 }
3706
3707 int CWindowMaskShape::handle_event()
3708 {
3709         MaskAutos *autos;
3710         MaskAuto *keyframe;
3711         Track *track;
3712         MaskPoint *point;
3713         SubMask *mask;
3714 #ifdef USE_KEYFRAME_SPANNING
3715         int create_it = 0;
3716 #else
3717         int create_it = 1;
3718 #endif
3719
3720         mwindow->undo->update_undo_before(_("mask shape"), this);
3721
3722 // Get existing keyframe
3723         gui->get_keyframe(track, autos, keyframe,
3724                         mask, point, create_it);
3725         if( track ) {
3726 #ifdef USE_KEYFRAME_SPANNING
3727                 MaskAuto temp_keyframe(mwindow->edl, autos);
3728                 temp_keyframe.copy_data(keyframe);
3729                 keyframe = &temp_keyframe;
3730                 mask = temp_keyframe.get_submask(mwindow->edl->session->cwindow_mask);
3731 #endif
3732                 if( mask ) {
3733                         builtin_shape(shape, mask);
3734 #ifdef USE_KEYFRAME_SPANNING
3735                         autos->update_parameter(keyframe);
3736 #endif
3737                         gui->update();
3738                         gui->update_preview(1);
3739                 }
3740         }
3741         mwindow->undo->update_undo_after(_("mask shape"), LOAD_AUTOMATION);
3742         return 1;
3743 }
3744
3745 void CWindowMaskGUI::load_masks(ArrayList<SubMask *> &masks)
3746 {
3747         char path[BCTEXTLEN];
3748         sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3749         FileSystem fs;
3750         fs.complete_path(path);
3751         FileXML file;
3752         file.read_from_file(path, 1);
3753
3754         masks.remove_all_objects();
3755         int result;
3756         while( !(result = file.read_tag()) ) {
3757                 if( file.tag.title_is("MASK") ) {
3758                         SubMask *sub_mask = new SubMask(0, -1);
3759                         char name[BCTEXTLEN];  name[0] = 0;
3760                         file.tag.get_property("NAME", name);
3761                         strncpy(sub_mask->name, name, sizeof(sub_mask->name));
3762                         sub_mask->load(&file);
3763                         masks.append(sub_mask);
3764                 }
3765         }
3766 }
3767
3768 void CWindowMaskGUI::save_masks(ArrayList<SubMask *> &masks)
3769 {
3770         FileXML file;
3771         for( int i=0; i<masks.size(); ++i ) {
3772                 SubMask *sub_mask = masks[i];
3773                 sub_mask->copy(&file);
3774         }
3775         file.terminate_string();
3776
3777         char path[BCTEXTLEN];
3778         sprintf(path, "%s/%s", File::get_config_path(), MASKS_FILE);
3779         FileSystem fs;
3780         fs.complete_path(path);
3781         file.write_to_file(path);
3782 }
3783
3784
3785 CWindowRulerGUI::CWindowRulerGUI(MWindow *mwindow, CWindowTool *thread)
3786  : CWindowToolGUI(mwindow, thread, _(PROGRAM_NAME ": Ruler"), xS(320), yS(240))
3787 {
3788 }
3789
3790 CWindowRulerGUI::~CWindowRulerGUI()
3791 {
3792 }
3793
3794 void CWindowRulerGUI::create_objects()
3795 {
3796         int xs10 = xS(10), xs200 = xS(200);
3797         int ys5 = yS(5), ys10 = yS(10);
3798         int x = xs10, y = ys10, x1 = xS(100);
3799         BC_Title *title;
3800
3801         lock_window("CWindowRulerGUI::create_objects");
3802         add_subwindow(title = new BC_Title(x, y, _("Current:")));
3803         add_subwindow(current = new BC_TextBox(x1, y, xs200, 1, ""));
3804         y += title->get_h() + ys5;
3805         add_subwindow(title = new BC_Title(x, y, _("Point 1:")));
3806         add_subwindow(point1 = new BC_TextBox(x1, y, xs200, 1, ""));
3807         y += title->get_h() + ys5;
3808         add_subwindow(title = new BC_Title(x, y, _("Point 2:")));
3809         add_subwindow(point2 = new BC_TextBox(x1, y, xs200, 1, ""));
3810         y += title->get_h() + ys5;
3811         add_subwindow(title = new BC_Title(x, y, _("Deltas:")));
3812         add_subwindow(deltas = new BC_TextBox(x1, y, xs200, 1, ""));
3813         y += title->get_h() + ys5;
3814         add_subwindow(title = new BC_Title(x, y, _("Distance:")));
3815         add_subwindow(distance = new BC_TextBox(x1, y, xs200, 1, ""));
3816         y += title->get_h() + ys5;
3817         add_subwindow(title = new BC_Title(x, y, _("Angle:")));
3818         add_subwindow(angle = new BC_TextBox(x1, y, xs200, 1, ""));
3819         y += title->get_h() + ys10;
3820         char string[BCTEXTLEN];
3821         sprintf(string,
3822                  _("Press Ctrl to lock ruler to the\nnearest 45%c%c angle."),
3823                 0xc2, 0xb0); // degrees utf
3824         add_subwindow(title = new BC_Title(x,
3825                 y,
3826                 string));
3827         y += title->get_h() + ys10;
3828         sprintf(string, _("Press Alt to translate the ruler."));
3829         add_subwindow(title = new BC_Title(x,
3830                 y,
3831                 string));
3832         update();
3833         unlock_window();
3834 }
3835
3836 void CWindowRulerGUI::update()
3837 {
3838         char string[BCTEXTLEN];
3839         int cx = mwindow->session->cwindow_output_x;
3840         int cy = mwindow->session->cwindow_output_y;
3841         sprintf(string, "%d, %d", cx, cy);
3842         current->update(string);
3843         double x1 = mwindow->edl->session->ruler_x1;
3844         double y1 = mwindow->edl->session->ruler_y1;
3845         sprintf(string, "%.0f, %.0f", x1, y1);
3846         point1->update(string);
3847         double x2 = mwindow->edl->session->ruler_x2;
3848         double y2 = mwindow->edl->session->ruler_y2;
3849         sprintf(string, "%.0f, %.0f", x2, y2);
3850         point2->update(string);
3851         double dx = x2 - x1, dy = y2 - y1;
3852         sprintf(string, "%s%.0f, %s%.0f", (dx>=0? "+":""), dx, (dy>=0? "+":""), dy);
3853         deltas->update(string);
3854         double d = sqrt(dx*dx + dy*dy);
3855         sprintf(string, _("%0.01f pixels"), d);
3856         distance->update(string);
3857         double a = d > 0 ? (atan2(-dy, dx) * 180/M_PI) : 0.;
3858         sprintf(string, "%0.02f %c%c", a, 0xc2, 0xb0);
3859         angle->update(string);
3860 }
3861
3862 void CWindowRulerGUI::handle_event()
3863 {
3864 }
3865