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