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