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