cinelerra-5.1/plugins/motion-hv/motionwindow-hv.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2012 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "bcdisplayinfo.h"
  23 #include "clip.h"
  24 #include "language.h"
  25 #include "motion-hv.h"
  26 #include "motionscan-hv.h"
  27 #include "motionwindow-hv.h"
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38 MotionHVWindow::MotionHVWindow(MotionHVMain *plugin)
  39  : PluginClientWindow(plugin, 600, 650, 600, 650, 0)
  40 {
  41         this->plugin = plugin;
  42 }
  43
  44 MotionHVWindow::~MotionHVWindow()
  45 {
  46 }
  47
  48 void MotionHVWindow::create_objects()
  49 {
  50         int x1 = 10, x = 10, y = 10;
  51         int x2 = 310;
  52         BC_Title *title;
  53
  54
  55
  56 //      add_subwindow(global = new MotionHVGlobal(plugin,
  57 //              this,
  58 //              x1,
  59 //              y));
  60
  61         add_subwindow(rotate = new MotionHVRotate(plugin,
  62                 this,
  63                 x2,
  64                 y));
  65         y += 50;
  66
  67         add_subwindow(title = new BC_Title(x1,
  68                 y,
  69                 _("Translation search radius:\n(W/H Percent of image)")));
  70         add_subwindow(global_range_w = new GlobalRange(plugin,
  71                 x1 + title->get_w() + 10,
  72                 y,
  73                 &plugin->config.global_range_w));
  74         add_subwindow(global_range_h = new GlobalRange(plugin,
  75                 x1 + title->get_w() + 10 + global_range_w->get_w(),
  76                 y,
  77                 &plugin->config.global_range_h));
  78
  79         add_subwindow(title = new BC_Title(x2,
  80                 y,
  81                 _("Rotation search radius:\n(Degrees)")));
  82         add_subwindow(rotation_range = new RotationRange(plugin,
  83                 x2 + title->get_w() + 10,
  84                 y));
  85
  86         y += 50;
  87         add_subwindow(title = new BC_Title(x1,
  88                 y,
  89                 _("Translation block size:\n(W/H Percent of image)")));
  90         add_subwindow(global_block_w = new BlockSize(plugin,
  91                 x1 + title->get_w() + 10,
  92                 y,
  93                 &plugin->config.global_block_w));
  94         add_subwindow(global_block_h = new BlockSize(plugin,
  95                 x1 + title->get_w() + 10 + global_block_w->get_w(),
  96                 y,
  97                 &plugin->config.global_block_h));
  98
  99 //      add_subwindow(title = new BC_Title(x2,
 100 //              y,
 101 //              _("Rotation block size:\n(W/H Percent of image)")));
 102 //      add_subwindow(rotation_block_w = new BlockSize(plugin,
 103 //              x2 + title->get_w() + 10,
 104 //              y,
 105 //              &plugin->config.rotation_block_w));
 106 //      add_subwindow(rotation_block_h = new BlockSize(plugin,
 107 //              x2 + title->get_w() + 10 + rotation_block_w->get_w(),
 108 //              y,
 109 //              &plugin->config.rotation_block_h));
 110
 111 //      y += 50;
 112 //      add_subwindow(title = new BC_Title(x1, y, _("Translation search steps:")));
 113 //      add_subwindow(global_search_positions = new GlobalSearchPositions(plugin,
 114 //              x1 + title->get_w() + 10,
 115 //              y,
 116 //              80));
 117 //      global_search_positions->create_objects();
 118 //
 119 //      add_subwindow(title = new BC_Title(x2, y, _("Rotation search steps:")));
 120 //      add_subwindow(rotation_search_positions = new RotationSearchPositions(plugin,
 121 //              x2 + title->get_w() + 10,
 122 //              y,
 123 //              80));
 124 //      rotation_search_positions->create_objects();
 125
 126         y += 50;
 127         add_subwindow(title = new BC_Title(x, y, _("Translation direction:")));
 128         add_subwindow(track_direction = new TrackDirection(plugin,
 129                 this,
 130                 x + title->get_w() + 10,
 131                 y));
 132         track_direction->create_objects();
 133
 134         y += 40;
 135         add_subwindow(title = new BC_Title(x, y + 10, _("Block X:")));
 136         add_subwindow(block_x = new MotionHVBlockX(plugin,
 137                 this,
 138                 x + title->get_w() + 10,
 139                 y));
 140         add_subwindow(block_x_text = new MotionHVBlockXText(plugin,
 141                 this,
 142                 x + title->get_w() + 10 + block_x->get_w() + 10,
 143                 y + 10));
 144
 145         add_subwindow(title = new BC_Title(x2, y, _("Rotation center:")));
 146         add_subwindow(rotation_center = new RotationCenter(plugin,
 147                 x2 + title->get_w() + 10,
 148                 y));
 149
 150
 151
 152         int y1 = y;
 153         y += 50;
 154         add_subwindow(title = new BC_Title(x2, y + 10, _("Maximum angle offset:")));
 155         add_subwindow(rotate_magnitude = new MotionHVRMagnitude(plugin,
 156                 x2 + title->get_w() + 10,
 157                 y));
 158
 159         y += 40;
 160         add_subwindow(title = new BC_Title(x2, y + 10, _("Rotation settling speed:")));
 161         add_subwindow(rotate_return_speed = new MotionHVRReturnSpeed(plugin,
 162                 x2 + title->get_w() + 10,
 163                 y));
 164
 165
 166
 167         y = y1;
 168         y += 40;
 169         add_subwindow(title = new BC_Title(x, y + 10, _("Block Y:")));
 170         add_subwindow(block_y = new MotionHVBlockY(plugin,
 171                 this,
 172                 x + title->get_w() + 10,
 173                 y));
 174         add_subwindow(block_y_text = new MotionHVBlockYText(plugin,
 175                 this,
 176                 x + title->get_w() + 10 + block_y->get_w() + 10,
 177                 y + 10));
 178
 179         y += 50;
 180         add_subwindow(title = new BC_Title(x, y + 10, _("Maximum absolute offset:")));
 181         add_subwindow(magnitude = new MotionHVMagnitude(plugin,
 182                 x + title->get_w() + 10,
 183                 y));
 184
 185         y += 40;
 186         add_subwindow(title = new BC_Title(x, y + 10, _("MotionHV settling speed:")));
 187         add_subwindow(return_speed = new MotionHVReturnSpeed(plugin,
 188                 x + title->get_w() + 10,
 189                 y));
 190
 191
 192
 193         y += 40;
 194         add_subwindow(vectors = new MotionHVDrawVectors(plugin,
 195                 this,
 196                 x,
 197                 y));
 198
 199
 200         y += 40;
 201         add_subwindow(track_single = new TrackSingleFrame(plugin,
 202                 this,
 203                 x,
 204                 y));
 205         add_subwindow(title = new BC_Title(x + track_single->get_w() + 20,
 206                 y,
 207                 _("Frame number:")));
 208         add_subwindow(track_frame_number = new TrackFrameNumber(plugin,
 209                 this,
 210                 x + track_single->get_w() + title->get_w() + 20,
 211                 y));
 212         if(plugin->config.tracking_object != MotionHVScan::TRACK_SINGLE)
 213                 track_frame_number->disable();
 214
 215         y += 20;
 216         add_subwindow(track_previous = new TrackPreviousFrame(plugin,
 217                 this,
 218                 x,
 219                 y));
 220
 221         y += 20;
 222         add_subwindow(previous_same = new PreviousFrameSameBlock(plugin,
 223                 this,
 224                 x,
 225                 y));
 226
 227         y += 40;
 228         y1 = y;
 229         add_subwindow(title = new BC_Title(x, y, _("Master layer:")));
 230         add_subwindow(master_layer = new MasterLayer(plugin,
 231                 this,
 232                 x + title->get_w() + 10,
 233                 y));
 234         master_layer->create_objects();
 235         y += 30;
 236
 237
 238         add_subwindow(title = new BC_Title(x, y, _("Action:")));
 239         add_subwindow(action_type = new ActionType(plugin,
 240                 this,
 241                 x + title->get_w() + 10,
 242                 y));
 243         action_type->create_objects();
 244         y += 30;
 245
 246
 247
 248
 249         add_subwindow(title = new BC_Title(x, y, _("Calculation:")));
 250         add_subwindow(tracking_type = new TrackingType(plugin,
 251                 this,
 252                 x + title->get_w() + 10,
 253                 y));
 254         tracking_type->create_objects();
 255
 256
 257
 258         show_window(1);
 259 }
 260
 261 void MotionHVWindow::update_mode()
 262 {
 263         global_range_w->update(plugin->config.global_range_w,
 264                 MIN_RADIUS,
 265                 MAX_RADIUS);
 266         global_range_h->update(plugin->config.global_range_h,
 267                 MIN_RADIUS,
 268                 MAX_RADIUS);
 269         rotation_range->update(plugin->config.rotation_range,
 270                 MIN_ROTATION,
 271                 MAX_ROTATION);
 272         vectors->update(plugin->config.draw_vectors);
 273 //      global->update(plugin->config.global);
 274         rotate->update(plugin->config.rotate);
 275 }
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289 GlobalRange::GlobalRange(MotionHVMain *plugin,
 290         int x,
 291         int y,
 292         int *value)
 293  : BC_IPot(x,
 294                 y,
 295                 (int64_t)*value,
 296                 (int64_t)MIN_RADIUS,
 297                 (int64_t)MAX_RADIUS)
 298 {
 299         this->plugin = plugin;
 300         this->value = value;
 301 }
 302
 303
 304 int GlobalRange::handle_event()
 305 {
 306         *value = (int)get_value();
 307         plugin->send_configure_change();
 308         return 1;
 309 }
 310
 311
 312
 313
 314 RotationRange::RotationRange(MotionHVMain *plugin,
 315         int x,
 316         int y)
 317  : BC_IPot(x,
 318                 y,
 319                 (int64_t)plugin->config.rotation_range,
 320                 (int64_t)MIN_ROTATION,
 321                 (int64_t)MAX_ROTATION)
 322 {
 323         this->plugin = plugin;
 324 }
 325
 326
 327 int RotationRange::handle_event()
 328 {
 329         plugin->config.rotation_range = (int)get_value();
 330         plugin->send_configure_change();
 331         return 1;
 332 }
 333
 334
 335
 336
 337 RotationCenter::RotationCenter(MotionHVMain *plugin,
 338         int x,
 339         int y)
 340  : BC_IPot(x,
 341                 y,
 342                 (int64_t)plugin->config.rotation_center,
 343                 (int64_t)-MAX_ROTATION,
 344                 (int64_t)MAX_ROTATION)
 345 {
 346         this->plugin = plugin;
 347 }
 348
 349
 350 int RotationCenter::handle_event()
 351 {
 352         plugin->config.rotation_center = (int)get_value();
 353         plugin->send_configure_change();
 354         return 1;
 355 }
 356
 357
 358
 359
 360
 361
 362 BlockSize::BlockSize(MotionHVMain *plugin,
 363         int x,
 364         int y,
 365         int *value)
 366  : BC_IPot(x,
 367                 y,
 368                 (int64_t)*value,
 369                 (int64_t)MIN_BLOCK,
 370                 (int64_t)MAX_BLOCK)
 371 {
 372         this->plugin = plugin;
 373         this->value = value;
 374 }
 375
 376
 377 int BlockSize::handle_event()
 378 {
 379         *value = (int)get_value();
 380         plugin->send_configure_change();
 381         return 1;
 382 }
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396 // GlobalSearchPositions::GlobalSearchPositions(MotionHVMain *plugin,
 397 //      int x,
 398 //      int y,
 399 //      int w)
 400 //  : BC_PopupMenu(x,
 401 //      y,
 402 //      w,
 403 //      "",
 404 //      1)
 405 // {
 406 //      this->plugin = plugin;
 407 // }
 408 // void GlobalSearchPositions::create_objects()
 409 // {
 410 //      add_item(new BC_MenuItem("16"));
 411 //      add_item(new BC_MenuItem("32"));
 412 //      add_item(new BC_MenuItem("64"));
 413 //      add_item(new BC_MenuItem("128"));
 414 //      add_item(new BC_MenuItem("256"));
 415 //      add_item(new BC_MenuItem("512"));
 416 //      add_item(new BC_MenuItem("1024"));
 417 //      add_item(new BC_MenuItem("2048"));
 418 //      add_item(new BC_MenuItem("4096"));
 419 //      add_item(new BC_MenuItem("8192"));
 420 //      add_item(new BC_MenuItem("16384"));
 421 //      add_item(new BC_MenuItem("32768"));
 422 //      add_item(new BC_MenuItem("65536"));
 423 //      add_item(new BC_MenuItem("131072"));
 424 //      char string[BCTEXTLEN];
 425 //      sprintf(string, "%d", plugin->config.global_positions);
 426 //      set_text(string);
 427 // }
 428 //
 429 // int GlobalSearchPositions::handle_event()
 430 // {
 431 //      plugin->config.global_positions = atoi(get_text());
 432 //      plugin->send_configure_change();
 433 //      return 1;
 434 // }
 435 //
 436 //
 437 //
 438 //
 439 //
 440 //
 441 //
 442 // RotationSearchPositions::RotationSearchPositions(MotionHVMain *plugin,
 443 //      int x,
 444 //      int y,
 445 //      int w)
 446 //  : BC_PopupMenu(x,
 447 //      y,
 448 //      w,
 449 //      "",
 450 //      1)
 451 // {
 452 //      this->plugin = plugin;
 453 // }
 454 // void RotationSearchPositions::create_objects()
 455 // {
 456 //      add_item(new BC_MenuItem("4"));
 457 //      add_item(new BC_MenuItem("8"));
 458 //      add_item(new BC_MenuItem("16"));
 459 //      add_item(new BC_MenuItem("32"));
 460 //      char string[BCTEXTLEN];
 461 //      sprintf(string, "%d", plugin->config.rotate_positions);
 462 //      set_text(string);
 463 // }
 464 //
 465 // int RotationSearchPositions::handle_event()
 466 // {
 467 //      plugin->config.rotate_positions = atoi(get_text());
 468 //      plugin->send_configure_change();
 469 //      return 1;
 470 // }
 471
 472
 473
 474
 475
 476
 477
 478
 479 MotionHVMagnitude::MotionHVMagnitude(MotionHVMain *plugin,
 480         int x,
 481         int y)
 482  : BC_IPot(x,
 483                 y,
 484                 (int64_t)plugin->config.magnitude,
 485                 (int64_t)0,
 486                 (int64_t)100)
 487 {
 488         this->plugin = plugin;
 489 }
 490
 491 int MotionHVMagnitude::handle_event()
 492 {
 493         plugin->config.magnitude = (int)get_value();
 494         plugin->send_configure_change();
 495         return 1;
 496 }
 497
 498
 499 MotionHVReturnSpeed::MotionHVReturnSpeed(MotionHVMain *plugin,
 500         int x,
 501         int y)
 502  : BC_IPot(x,
 503                 y,
 504                 (int64_t)plugin->config.return_speed,
 505                 (int64_t)0,
 506                 (int64_t)100)
 507 {
 508         this->plugin = plugin;
 509 }
 510
 511 int MotionHVReturnSpeed::handle_event()
 512 {
 513         plugin->config.return_speed = (int)get_value();
 514         plugin->send_configure_change();
 515         return 1;
 516 }
 517
 518
 519
 520 MotionHVRMagnitude::MotionHVRMagnitude(MotionHVMain *plugin,
 521         int x,
 522         int y)
 523  : BC_IPot(x,
 524                 y,
 525                 (int64_t)plugin->config.rotate_magnitude,
 526                 (int64_t)0,
 527                 (int64_t)90)
 528 {
 529         this->plugin = plugin;
 530 }
 531
 532 int MotionHVRMagnitude::handle_event()
 533 {
 534         plugin->config.rotate_magnitude = (int)get_value();
 535         plugin->send_configure_change();
 536         return 1;
 537 }
 538
 539
 540
 541 MotionHVRReturnSpeed::MotionHVRReturnSpeed(MotionHVMain *plugin,
 542         int x,
 543         int y)
 544  : BC_IPot(x,
 545                 y,
 546                 (int64_t)plugin->config.rotate_return_speed,
 547                 (int64_t)0,
 548                 (int64_t)100)
 549 {
 550         this->plugin = plugin;
 551 }
 552
 553 int MotionHVRReturnSpeed::handle_event()
 554 {
 555         plugin->config.rotate_return_speed = (int)get_value();
 556         plugin->send_configure_change();
 557         return 1;
 558 }
 559
 560
 561
 562
 563
 564 // MotionHVGlobal::MotionHVGlobal(MotionHVMain *plugin,
 565 //      MotionHVWindow *gui,
 566 //      int x,
 567 //      int y)
 568 //  : BC_CheckBox(x,
 569 //      y,
 570 //      plugin->config.global,
 571 //      _("Track translation"))
 572 // {
 573 //      this->plugin = plugin;
 574 //      this->gui = gui;
 575 // }
 576 //
 577 // int MotionHVGlobal::handle_event()
 578 // {
 579 //      plugin->config.global = get_value();
 580 //      plugin->send_configure_change();
 581 //      return 1;
 582 // }
 583
 584 MotionHVRotate::MotionHVRotate(MotionHVMain *plugin,
 585         MotionHVWindow *gui,
 586         int x,
 587         int y)
 588  : BC_CheckBox(x,
 589         y,
 590         plugin->config.rotate,
 591         _("Track rotation"))
 592 {
 593         this->plugin = plugin;
 594         this->gui = gui;
 595 }
 596
 597 int MotionHVRotate::handle_event()
 598 {
 599         plugin->config.rotate = get_value();
 600         plugin->send_configure_change();
 601         return 1;
 602 }
 603
 604
 605
 606
 607
 608 MotionHVBlockX::MotionHVBlockX(MotionHVMain *plugin,
 609         MotionHVWindow *gui,
 610         int x,
 611         int y)
 612  : BC_FPot(x,
 613         y,
 614         plugin->config.block_x,
 615         (float)0,
 616         (float)100)
 617 {
 618         this->plugin = plugin;
 619         this->gui = gui;
 620 }
 621
 622 int MotionHVBlockX::handle_event()
 623 {
 624         plugin->config.block_x = get_value();
 625         gui->block_x_text->update((float)plugin->config.block_x);
 626         plugin->send_configure_change();
 627         return 1;
 628 }
 629
 630
 631
 632
 633 MotionHVBlockY::MotionHVBlockY(MotionHVMain *plugin,
 634         MotionHVWindow *gui,
 635         int x,
 636         int y)
 637  : BC_FPot(x,
 638         y,
 639         (float)plugin->config.block_y,
 640         (float)0,
 641         (float)100)
 642 {
 643         this->plugin = plugin;
 644         this->gui = gui;
 645 }
 646
 647 int MotionHVBlockY::handle_event()
 648 {
 649         plugin->config.block_y = get_value();
 650         gui->block_y_text->update((float)plugin->config.block_y);
 651         plugin->send_configure_change();
 652         return 1;
 653 }
 654
 655 MotionHVBlockXText::MotionHVBlockXText(MotionHVMain *plugin,
 656         MotionHVWindow *gui,
 657         int x,
 658         int y)
 659  : BC_TextBox(x,
 660         y,
 661         75,
 662         1,
 663         (float)plugin->config.block_x)
 664 {
 665         this->plugin = plugin;
 666         this->gui = gui;
 667         set_precision(4);
 668 }
 669
 670 int MotionHVBlockXText::handle_event()
 671 {
 672         plugin->config.block_x = atof(get_text());
 673         gui->block_x->update(plugin->config.block_x);
 674         plugin->send_configure_change();
 675         return 1;
 676 }
 677
 678
 679
 680
 681 MotionHVBlockYText::MotionHVBlockYText(MotionHVMain *plugin,
 682         MotionHVWindow *gui,
 683         int x,
 684         int y)
 685  : BC_TextBox(x,
 686         y,
 687         75,
 688         1,
 689         (float)plugin->config.block_y)
 690 {
 691         this->plugin = plugin;
 692         this->gui = gui;
 693         set_precision(4);
 694 }
 695
 696 int MotionHVBlockYText::handle_event()
 697 {
 698         plugin->config.block_y = atof(get_text());
 699         gui->block_y->update(plugin->config.block_y);
 700         plugin->send_configure_change();
 701         return 1;
 702 }
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719 MotionHVDrawVectors::MotionHVDrawVectors(MotionHVMain *plugin,
 720         MotionHVWindow *gui,
 721         int x,
 722         int y)
 723  : BC_CheckBox(x,
 724         y,
 725         plugin->config.draw_vectors,
 726         _("Draw vectors"))
 727 {
 728         this->gui = gui;
 729         this->plugin = plugin;
 730 }
 731
 732 int MotionHVDrawVectors::handle_event()
 733 {
 734         plugin->config.draw_vectors = get_value();
 735         plugin->send_configure_change();
 736         return 1;
 737 }
 738
 739
 740
 741
 742
 743
 744
 745
 746 TrackSingleFrame::TrackSingleFrame(MotionHVMain *plugin,
 747         MotionHVWindow *gui,
 748         int x,
 749         int y)
 750  : BC_Radial(x,
 751         y,
 752         plugin->config.tracking_object == MotionHVScan::TRACK_SINGLE,
 753         _("Track single frame"))
 754 {
 755         this->plugin = plugin;
 756         this->gui = gui;
 757 }
 758
 759 int TrackSingleFrame::handle_event()
 760 {
 761         plugin->config.tracking_object = MotionHVScan::TRACK_SINGLE;
 762         gui->track_previous->update(0);
 763         gui->previous_same->update(0);
 764         gui->track_frame_number->enable();
 765         plugin->send_configure_change();
 766         return 1;
 767 }
 768
 769
 770
 771
 772
 773
 774
 775
 776 TrackFrameNumber::TrackFrameNumber(MotionHVMain *plugin,
 777         MotionHVWindow *gui,
 778         int x,
 779         int y)
 780  : BC_TextBox(x, y, 100, 1, plugin->config.track_frame)
 781 {
 782         this->plugin = plugin;
 783         this->gui = gui;
 784 }
 785
 786 int TrackFrameNumber::handle_event()
 787 {
 788         plugin->config.track_frame = atol(get_text());
 789         plugin->send_configure_change();
 790         return 1;
 791 }
 792
 793
 794
 795
 796
 797
 798
 799 TrackPreviousFrame::TrackPreviousFrame(MotionHVMain *plugin,
 800         MotionHVWindow *gui,
 801         int x,
 802         int y)
 803  : BC_Radial(x,
 804         y,
 805         plugin->config.tracking_object == MotionHVScan::TRACK_PREVIOUS,
 806         _("Track previous frame"))
 807 {
 808         this->plugin = plugin;
 809         this->gui = gui;
 810 }
 811 int TrackPreviousFrame::handle_event()
 812 {
 813         plugin->config.tracking_object = MotionHVScan::TRACK_PREVIOUS;
 814         gui->track_single->update(0);
 815         gui->previous_same->update(0);
 816         gui->track_frame_number->disable();
 817         plugin->send_configure_change();
 818         return 1;
 819 }
 820
 821
 822
 823
 824
 825
 826
 827
 828 PreviousFrameSameBlock::PreviousFrameSameBlock(MotionHVMain *plugin,
 829         MotionHVWindow *gui,
 830         int x,
 831         int y)
 832  : BC_Radial(x,
 833         y,
 834         plugin->config.tracking_object == MotionHVScan::PREVIOUS_SAME_BLOCK,
 835         _("Previous frame same block"))
 836 {
 837         this->plugin = plugin;
 838         this->gui = gui;
 839 }
 840 int PreviousFrameSameBlock::handle_event()
 841 {
 842         plugin->config.tracking_object = MotionHVScan::PREVIOUS_SAME_BLOCK;
 843         gui->track_single->update(0);
 844         gui->track_previous->update(0);
 845         gui->track_frame_number->disable();
 846         plugin->send_configure_change();
 847         return 1;
 848 }
 849
 850
 851
 852
 853
 854
 855
 856
 857 MasterLayer::MasterLayer(MotionHVMain *plugin, MotionHVWindow *gui, int x, int y)
 858  : BC_PopupMenu(x,
 859         y,
 860         calculate_w(gui),
 861         to_text(plugin->config.bottom_is_master))
 862 {
 863         this->plugin = plugin;
 864         this->gui = gui;
 865 }
 866
 867 int MasterLayer::handle_event()
 868 {
 869         plugin->config.bottom_is_master = from_text(get_text());
 870         plugin->send_configure_change();
 871         return 1;
 872 }
 873
 874 void MasterLayer::create_objects()
 875 {
 876         add_item(new BC_MenuItem(to_text(0)));
 877         add_item(new BC_MenuItem(to_text(1)));
 878 }
 879
 880 int MasterLayer::from_text(char *text)
 881 {
 882         if(!strcmp(text, _("Top"))) return 0;
 883         return 1;
 884 }
 885
 886 char* MasterLayer::to_text(int mode)
 887 {
 888         return mode ? _("Bottom") : _("Top");
 889 }
 890
 891 int MasterLayer::calculate_w(MotionHVWindow *gui)
 892 {
 893         int result = 0;
 894         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(0)));
 895         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(1)));
 896         return result + 50;
 897 }
 898
 899
 900
 901
 902
 903
 904
 905
 906 ActionType::ActionType(MotionHVMain *plugin, MotionHVWindow *gui, int x, int y)
 907  : BC_PopupMenu(x,
 908         y,
 909         calculate_w(gui),
 910         to_text(plugin->config.action_type))
 911 {
 912         this->plugin = plugin;
 913         this->gui = gui;
 914 }
 915
 916 int ActionType::handle_event()
 917 {
 918         plugin->config.action_type = from_text(get_text());
 919         plugin->send_configure_change();
 920         return 1;
 921 }
 922
 923 void ActionType::create_objects()
 924 {
 925         add_item(new BC_MenuItem(to_text(MotionHVScan::TRACK)));
 926         add_item(new BC_MenuItem(to_text(MotionHVScan::TRACK_PIXEL)));
 927         add_item(new BC_MenuItem(to_text(MotionHVScan::STABILIZE)));
 928         add_item(new BC_MenuItem(to_text(MotionHVScan::STABILIZE_PIXEL)));
 929         add_item(new BC_MenuItem(to_text(MotionHVScan::NOTHING)));
 930 }
 931
 932 int ActionType::from_text(char *text)
 933 {
 934         if(!strcmp(text, _("Track Subpixel"))) return MotionHVScan::TRACK;
 935         if(!strcmp(text, _("Track Pixel"))) return MotionHVScan::TRACK_PIXEL;
 936         if(!strcmp(text, _("Stabilize Subpixel"))) return MotionHVScan::STABILIZE;
 937         if(!strcmp(text, _("Stabilize Pixel"))) return MotionHVScan::STABILIZE_PIXEL;
 938         //if(!strcmp(text, _("Do Nothing"))) return MotionHVScan::NOTHING;
 939         return MotionHVScan::NOTHING;
 940 }
 941
 942 char* ActionType::to_text(int mode)
 943 {
 944         switch(mode)
 945         {
 946                 case MotionHVScan::TRACK:
 947                         return _("Track Subpixel");
 948                 case MotionHVScan::TRACK_PIXEL:
 949                         return _("Track Pixel");
 950                 case MotionHVScan::STABILIZE:
 951                         return _("Stabilize Subpixel");
 952                 case MotionHVScan::STABILIZE_PIXEL:
 953                         return _("Stabilize Pixel");
 954                 default:
 955                 case MotionHVScan::NOTHING:
 956                         return _("Do Nothing");
 957         }
 958 }
 959
 960 int ActionType::calculate_w(MotionHVWindow *gui)
 961 {
 962         int result = 0;
 963         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::TRACK)));
 964         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::TRACK_PIXEL)));
 965         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::STABILIZE)));
 966         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::STABILIZE_PIXEL)));
 967         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::NOTHING)));
 968         return result + 50;
 969 }
 970
 971
 972
 973
 974
 975 TrackingType::TrackingType(MotionHVMain *plugin, MotionHVWindow *gui, int x, int y)
 976  : BC_PopupMenu(x,
 977         y,
 978         calculate_w(gui),
 979         to_text(plugin->config.tracking_type))
 980 {
 981         this->plugin = plugin;
 982         this->gui = gui;
 983 }
 984
 985 int TrackingType::handle_event()
 986 {
 987         plugin->config.tracking_type = from_text(get_text());
 988         plugin->send_configure_change();
 989         return 1;
 990 }
 991
 992 void TrackingType::create_objects()
 993 {
 994         add_item(new BC_MenuItem(to_text(MotionHVScan::NO_CALCULATE)));
 995         add_item(new BC_MenuItem(to_text(MotionHVScan::CALCULATE)));
 996         add_item(new BC_MenuItem(to_text(MotionHVScan::SAVE)));
 997         add_item(new BC_MenuItem(to_text(MotionHVScan::LOAD)));
 998 }
 999
1000 int TrackingType::from_text(char *text)
1001 {
1002         if(!strcmp(text, _("Save coords to /tmp"))) return MotionHVScan::SAVE;
1003         if(!strcmp(text, _("Load coords from /tmp"))) return MotionHVScan::LOAD;
1004         if(!strcmp(text, _("Recalculate"))) return MotionHVScan::CALCULATE;
1005         //if(!strcmp(text, _("Don't Calculate"))) return MotionHVScan::NO_CALCULATE;
1006         return MotionHVScan::NO_CALCULATE;
1007 }
1008
1009 char* TrackingType::to_text(int mode)
1010 {
1011         switch(mode)
1012         {
1013                 case MotionHVScan::SAVE:
1014                         return _("Save coords to /tmp");
1015                 case MotionHVScan::LOAD:
1016                         return _("Load coords from /tmp");
1017                 case MotionHVScan::CALCULATE:
1018                         return _("Recalculate");
1019                 default:
1020                 case MotionHVScan::NO_CALCULATE:
1021                         return _("Don't Calculate");
1022         }
1023 }
1024
1025 int TrackingType::calculate_w(MotionHVWindow *gui)
1026 {
1027         int result = 0;
1028         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::NO_CALCULATE)));
1029         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::CALCULATE)));
1030         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::SAVE)));
1031         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(MotionHVScan::LOAD)));
1032         return result + 50;
1033 }
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044 TrackDirection::TrackDirection(MotionHVMain *plugin, MotionHVWindow *gui, int x, int y)
1045  : BC_PopupMenu(x,
1046         y,
1047         calculate_w(gui),
1048         to_text(plugin->config.horizontal_only, plugin->config.vertical_only))
1049 {
1050         this->plugin = plugin;
1051         this->gui = gui;
1052 }
1053
1054 int TrackDirection::handle_event()
1055 {
1056         from_text(&plugin->config.horizontal_only, &plugin->config.vertical_only, get_text());
1057         plugin->send_configure_change();
1058         return 1;
1059 }
1060
1061 void TrackDirection::create_objects()
1062 {
1063         add_item(new BC_MenuItem(to_text(1, 0)));
1064         add_item(new BC_MenuItem(to_text(0, 1)));
1065         add_item(new BC_MenuItem(to_text(0, 0)));
1066 }
1067
1068 void TrackDirection::from_text(int *horizontal_only, int *vertical_only, char *text)
1069 {
1070         *horizontal_only = 0;
1071         *vertical_only = 0;
1072         if(!strcmp(text, to_text(1, 0))) *horizontal_only = 1;
1073         if(!strcmp(text, to_text(0, 1))) *vertical_only = 1;
1074 }
1075
1076 char* TrackDirection::to_text(int horizontal_only, int vertical_only)
1077 {
1078         if(horizontal_only) return _("Horizontal only");
1079         if(vertical_only) return _("Vertical only");
1080         return _("Both");
1081 }
1082
1083 int TrackDirection::calculate_w(MotionHVWindow *gui)
1084 {
1085         int result = 0;
1086         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(1, 0)));
1087         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(0, 1)));
1088         result = MAX(result, gui->get_text_width(MEDIUMFONT, to_text(0, 0)));
1089         return result + 50;
1090 }
1091