1
2
3 #include "toonzqt/paramfield.h"
4 #include "toonzqt/gutil.h"
5 #include "toonzqt/fxsettings.h"
6 #include "toonzqt/intfield.h"
7 #include "toonzqt/spectrumfield.h"
8 #include "toonzqt/colorfield.h"
9 #include "toonzqt/doublepairfield.h"
10 #include "toonzqt/tonecurvefield.h"
11 #include "toonzqt/checkbox.h"
12
13 #include "tdoubleparam.h"
14 #include "tnotanimatableparam.h"
15 #include "tparamset.h"
16 #include "tw/stringtable.h"
17
18 #include <QString>
19 #include <QHBoxLayout>
20 #include <QLabel>
21 #include <QPainter>
22 #include <QComboBox>
23 #include <QFontComboBox>
24 #include <QKeyEvent>
25
26 using namespace DVGui;
27
28 //-----------------------------------------------------------------------------
29 /*! FxSettingsに共通のUndo
30 */
31 class FxSettingsUndo : public TUndo {
32 protected:
33 TFxHandle *m_fxHandle;
34 QString m_name;
35
36 public:
FxSettingsUndo(QString name,TFxHandle * fxHandle)37 FxSettingsUndo(QString name, TFxHandle *fxHandle)
38 : m_name(name), m_fxHandle(fxHandle) {}
39
getSize() const40 int getSize() const override { return sizeof(*this); }
getHistoryType()41 int getHistoryType() override { return HistoryType::Fx; }
42 };
43
44 class AnimatableFxSettingsUndo : public FxSettingsUndo {
45 protected:
46 bool m_wasKeyframe;
47 int m_frame;
48
49 public:
AnimatableFxSettingsUndo(QString name,int frame,TFxHandle * fxHandle)50 AnimatableFxSettingsUndo(QString name, int frame, TFxHandle *fxHandle)
51 : FxSettingsUndo(name, fxHandle), m_frame(frame) {}
52
getHistoryString()53 QString getHistoryString() override {
54 QString str = QObject::tr("Modify Fx Param : %1").arg(m_name);
55 if (m_wasKeyframe)
56 str += QString(" Frame : %1").arg(QString::number(m_frame + 1));
57 else
58 str += QString(" (Default Value)");
59 return str;
60 }
61 };
62
63 //-----------------------------------------------------------------------------
64 /*! MeasuredDoubleParamField Undo
65 */
66 class MeasuredDoubleParamFieldUndo final : public AnimatableFxSettingsUndo {
67 TDoubleParamP m_param;
68 double m_oldValue, m_newValue;
69
70 public:
MeasuredDoubleParamFieldUndo(const TDoubleParamP param,QString name,int frame,TFxHandle * fxHandle)71 MeasuredDoubleParamFieldUndo(const TDoubleParamP param, QString name,
72 int frame, TFxHandle *fxHandle)
73 : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {
74 m_oldValue = param->getValue(frame);
75 m_newValue = m_oldValue;
76 m_wasKeyframe = m_param->isKeyframe(frame);
77 }
78
onAdd()79 void onAdd() override { m_newValue = m_param->getValue(m_frame); }
80
undo() const81 void undo() const override {
82 if (!m_wasKeyframe)
83 m_param->setDefaultValue(m_oldValue);
84 else
85 m_param->setValue(m_frame, m_oldValue);
86
87 if (m_fxHandle) {
88 m_fxHandle->notifyFxChanged();
89 }
90 }
91
redo() const92 void redo() const override {
93 if (!m_wasKeyframe)
94 m_param->setDefaultValue(m_newValue);
95 else
96 m_param->setValue(m_frame, m_newValue);
97 if (m_fxHandle) m_fxHandle->notifyFxChanged();
98 }
99 };
100
101 //-----------------------------------------------------------------------------
102 /*! RangeParamField Undo
103 */
104 class RangeParamFieldUndo final : public AnimatableFxSettingsUndo {
105 TRangeParamP m_param;
106 DoublePair m_oldValue, m_newValue;
107
108 public:
RangeParamFieldUndo(const TRangeParamP param,QString name,int frame,TFxHandle * fxHandle)109 RangeParamFieldUndo(const TRangeParamP param, QString name, int frame,
110 TFxHandle *fxHandle)
111 : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {
112 m_oldValue = param->getValue(frame);
113 m_newValue = m_oldValue;
114 m_wasKeyframe = m_param->isKeyframe(frame);
115 }
116
onAdd()117 void onAdd() override { m_newValue = m_param->getValue(m_frame); }
118
undo() const119 void undo() const override {
120 if (!m_wasKeyframe)
121 m_param->setDefaultValue(m_oldValue);
122 else
123 m_param->setValue(m_frame, m_oldValue);
124
125 if (m_fxHandle) {
126 m_fxHandle->notifyFxChanged();
127 }
128 }
129
redo() const130 void redo() const override {
131 if (!m_wasKeyframe)
132 m_param->setDefaultValue(m_newValue);
133 else
134 m_param->setValue(m_frame, m_newValue);
135 if (m_fxHandle) m_fxHandle->notifyFxChanged();
136 }
137 };
138
139 //-----------------------------------------------------------------------------
140 /*! PixelParamField Undo
141 */
142 class PixelParamFieldUndo final : public AnimatableFxSettingsUndo {
143 TPixelParamP m_param;
144 TPixel32 m_oldValue, m_newValue;
145
146 public:
PixelParamFieldUndo(const TPixelParamP param,QString name,int frame,TFxHandle * fxHandle)147 PixelParamFieldUndo(const TPixelParamP param, QString name, int frame,
148 TFxHandle *fxHandle)
149 : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {
150 m_oldValue = param->getValue(frame);
151 m_newValue = m_oldValue;
152 m_wasKeyframe = m_param->isKeyframe(frame);
153 }
154
onAdd()155 void onAdd() override { m_newValue = m_param->getValue(m_frame); }
156
undo() const157 void undo() const override {
158 if (!m_wasKeyframe)
159 m_param->setDefaultValue(m_oldValue);
160 else
161 m_param->setValue(m_frame, m_oldValue);
162
163 if (m_fxHandle) {
164 m_fxHandle->notifyFxChanged();
165 }
166 }
167
redo() const168 void redo() const override {
169 if (!m_wasKeyframe)
170 m_param->setDefaultValue(m_newValue);
171 else
172 m_param->setValue(m_frame, m_newValue);
173 if (m_fxHandle) m_fxHandle->notifyFxChanged();
174 }
175 };
176
177 //-----------------------------------------------------------------------------
178 /*! PointParamField Undo
179 */
180 class PointParamFieldUndo final : public AnimatableFxSettingsUndo {
181 TPointParamP m_param;
182 TPointD m_oldValue, m_newValue;
183
184 public:
PointParamFieldUndo(const TPointParamP param,QString name,int frame,TFxHandle * fxHandle)185 PointParamFieldUndo(const TPointParamP param, QString name, int frame,
186 TFxHandle *fxHandle)
187 : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {
188 m_oldValue = param->getValue(frame);
189 m_newValue = m_oldValue;
190 m_wasKeyframe = m_param->isKeyframe(frame);
191 }
192
onAdd()193 void onAdd() override { m_newValue = m_param->getValue(m_frame); }
194
undo() const195 void undo() const override {
196 if (!m_wasKeyframe)
197 m_param->setDefaultValue(m_oldValue);
198 else
199 m_param->setValue(m_frame, m_oldValue);
200
201 if (m_fxHandle) m_fxHandle->notifyFxChanged();
202 }
203
redo() const204 void redo() const override {
205 if (!m_wasKeyframe)
206 m_param->setDefaultValue(m_newValue);
207 else
208 m_param->setValue(m_frame, m_newValue);
209 if (m_fxHandle) m_fxHandle->notifyFxChanged();
210 }
211 };
212
213 //-----------------------------------------------------------------------------
214 /*! EnumParamField Undo
215 */
216 class EnumParamFieldUndo final : public FxSettingsUndo {
217 TIntEnumParamP m_param;
218 std::string m_oldString, m_newString;
219
220 public:
EnumParamFieldUndo(const TIntEnumParamP param,std::string oldString,std::string newString,QString name,TFxHandle * fxHandle)221 EnumParamFieldUndo(const TIntEnumParamP param, std::string oldString,
222 std::string newString, QString name, TFxHandle *fxHandle)
223 : FxSettingsUndo(name, fxHandle)
224 , m_param(param)
225 , m_oldString(oldString)
226 , m_newString(newString) {}
227
undo() const228 void undo() const override {
229 m_param->setValue(m_oldString);
230 if (m_fxHandle) m_fxHandle->notifyFxChanged();
231 }
232
redo() const233 void redo() const override {
234 m_param->setValue(m_newString);
235 if (m_fxHandle) m_fxHandle->notifyFxChanged();
236 }
237
getHistoryString()238 QString getHistoryString() override {
239 QString str = QObject::tr("Modify Fx Param : %1 : %2 -> %3")
240 .arg(m_name)
241 .arg(QString::fromStdString(m_oldString))
242 .arg(QString::fromStdString(m_newString));
243 return str;
244 }
245 };
246
247 //-----------------------------------------------------------------------------
248 /*! IntParamFieldのUndo
249 */
250 class IntParamFieldUndo final : public FxSettingsUndo {
251 TIntParamP m_param;
252 int m_oldValue, m_newValue;
253
254 public:
IntParamFieldUndo(const TIntParamP param,QString name,TFxHandle * fxHandle)255 IntParamFieldUndo(const TIntParamP param, QString name, TFxHandle *fxHandle)
256 : FxSettingsUndo(name, fxHandle), m_param(param) {
257 m_oldValue = param->getValue();
258 m_newValue = m_oldValue;
259 }
260
onAdd()261 void onAdd() override { m_newValue = m_param->getValue(); }
262
undo() const263 void undo() const override {
264 m_param->setValue(m_oldValue);
265 if (m_fxHandle) m_fxHandle->notifyFxChanged();
266 }
267
redo() const268 void redo() const override {
269 m_param->setValue(m_newValue);
270 if (m_fxHandle) m_fxHandle->notifyFxChanged();
271 }
272
getHistoryString()273 QString getHistoryString() override {
274 QString str = QObject::tr("Modify Fx Param : %1 : %2 -> %3")
275 .arg(m_name)
276 .arg(QString::number(m_oldValue))
277 .arg(QString::number(m_newValue));
278 return str;
279 }
280 };
281
282 //-----------------------------------------------------------------------------
283 /*! BoolParamFieldのUndo
284 */
285 class BoolParamFieldUndo final : public FxSettingsUndo {
286 TBoolParamP m_param;
287 bool m_newState;
288
289 public:
BoolParamFieldUndo(const TBoolParamP param,QString name,TFxHandle * fxHandle)290 BoolParamFieldUndo(const TBoolParamP param, QString name, TFxHandle *fxHandle)
291 : FxSettingsUndo(name, fxHandle), m_param(param) {
292 m_newState = param->getValue();
293 }
294
undo() const295 void undo() const override {
296 m_param->setValue(!m_newState);
297 if (m_fxHandle) m_fxHandle->notifyFxChanged();
298 }
299
redo() const300 void redo() const override {
301 m_param->setValue(m_newState);
302 if (m_fxHandle) m_fxHandle->notifyFxChanged();
303 }
304
getHistoryString()305 QString getHistoryString() override {
306 QString str = QObject::tr("Modify Fx Param : ");
307 if (m_newState)
308 str += QObject::tr("ON : %1").arg(m_name);
309 else
310 str += QObject::tr("OFF : %1").arg(m_name);
311 return str;
312 }
313 };
314
315 //-----------------------------------------------------------------------------
316 /*! SpectrumParamFieldのUndo
317 */
318 class SpectrumParamFieldUndo final : public AnimatableFxSettingsUndo {
319 TSpectrumParamP m_param;
320 TSpectrum m_oldSpectrum, m_newSpectrum;
321
322 public:
SpectrumParamFieldUndo(const TSpectrumParamP param,QString name,int frame,TFxHandle * fxHandle)323 SpectrumParamFieldUndo(const TSpectrumParamP param, QString name, int frame,
324 TFxHandle *fxHandle)
325 : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {
326 m_oldSpectrum = param->getValue(frame);
327 m_newSpectrum = m_oldSpectrum;
328 m_wasKeyframe = m_param->isKeyframe(frame);
329 }
330
onAdd()331 void onAdd() override { m_newSpectrum = m_param->getValue(m_frame); }
332
undo() const333 void undo() const override {
334 if (!m_wasKeyframe)
335 m_param->setDefaultValue(m_oldSpectrum);
336 else
337 m_param->setValue(m_frame, m_oldSpectrum);
338
339 if (m_fxHandle) {
340 m_fxHandle->notifyFxChanged();
341 }
342 }
343
redo() const344 void redo() const override {
345 if (!m_wasKeyframe)
346 m_param->setDefaultValue(m_newSpectrum);
347 else
348 m_param->setValue(m_frame, m_newSpectrum);
349 if (m_fxHandle) m_fxHandle->notifyFxChanged();
350 }
351 };
352
353 //-----------------------------------------------------------------------------
354 /*! SpectrumParamField Undo
355 ※
356 SpectrumParamFieldは、表示更新時にactualParamとcurrentParamのKeyの数が
357 一致していなくてはならないので、２つ同時に変更する必要が有る。
358 */
359 class SpectrumParamFieldAddRemoveKeyUndo final : public FxSettingsUndo {
360 TSpectrumParamP m_actualParam;
361 TSpectrumParamP m_currentParam;
362 TSpectrum::ColorKey m_key;
363 int m_index;
364
365 bool m_isAddUndo;
366
367 public:
SpectrumParamFieldAddRemoveKeyUndo(const TSpectrumParamP actualParam,const TSpectrumParamP currentParam,TSpectrum::ColorKey key,int index,bool isAddUndo,QString name,TFxHandle * fxHandle)368 SpectrumParamFieldAddRemoveKeyUndo(const TSpectrumParamP actualParam,
369 const TSpectrumParamP currentParam,
370 TSpectrum::ColorKey key, int index,
371 bool isAddUndo, QString name,
372 TFxHandle *fxHandle)
373 : FxSettingsUndo(name, fxHandle)
374 , m_actualParam(actualParam)
375 , m_currentParam(currentParam)
376 , m_key(key)
377 , m_index(index)
378 , m_isAddUndo(isAddUndo) {}
379
removeKeys() const380 void removeKeys() const {
381 m_actualParam->removeKey(m_index);
382 m_currentParam->removeKey(m_index);
383 }
384
addKeys() const385 void addKeys() const {
386 m_actualParam->insertKey(m_index, m_key.first, m_key.second);
387 m_currentParam->insertKey(m_index, m_key.first, m_key.second);
388 }
389
undo() const390 void undo() const override {
391 if (m_isAddUndo)
392 removeKeys();
393 else
394 addKeys();
395
396 if (m_fxHandle) m_fxHandle->notifyFxChanged();
397 }
398
redo() const399 void redo() const override {
400 if (m_isAddUndo)
401 addKeys();
402 else
403 removeKeys();
404 if (m_fxHandle) m_fxHandle->notifyFxChanged();
405 }
406
getHistoryString()407 QString getHistoryString() override {
408 QString str =
409 QObject::tr("Modify Fx Param : %1 : %2 Key")
410 .arg(m_name)
411 .arg((m_isAddUndo) ? QObject::tr("Add") : QObject::tr("Remove"));
412 return str;
413 }
414 };
415
416 //-----------------------------------------------------------------------------
417 /*! StringParamField Undo
418 */
419 class StringParamFieldUndo final : public FxSettingsUndo {
420 TStringParamP m_param;
421 std::wstring m_oldValue, m_newValue;
422
423 public:
StringParamFieldUndo(const TStringParamP param,QString name,TFxHandle * fxHandle)424 StringParamFieldUndo(const TStringParamP param, QString name,
425 TFxHandle *fxHandle)
426 : FxSettingsUndo(name, fxHandle), m_param(param) {
427 m_oldValue = param->getValue();
428 m_newValue = m_oldValue;
429 }
430
onAdd()431 void onAdd() override { m_newValue = m_param->getValue(); }
432
undo() const433 void undo() const override {
434 m_param->setValue(m_oldValue);
435 if (m_fxHandle) m_fxHandle->notifyFxChanged();
436 }
437
redo() const438 void redo() const override {
439 m_param->setValue(m_newValue);
440 if (m_fxHandle) m_fxHandle->notifyFxChanged();
441 }
442
getHistoryString()443 QString getHistoryString() override {
444 QString str = QObject::tr("Modify Fx Param : %1 : %2 -> %3")
445 .arg(m_name)
446 .arg(QString::fromStdWString(m_oldValue))
447 .arg(QString::fromStdWString(m_newValue));
448 return str;
449 }
450 };
451
452 //-----------------------------------------------------------------------------
453 /*! FontParamFieldUndo
454 */
455 class FontParamFieldUndo final : public FxSettingsUndo {
456 TFontParamP m_param;
457 std::wstring m_oldValue, m_newValue;
458
459 public:
FontParamFieldUndo(const TFontParamP param,QString name,TFxHandle * fxHandle)460 FontParamFieldUndo(const TFontParamP param, QString name, TFxHandle *fxHandle)
461 : FxSettingsUndo(name, fxHandle), m_param(param) {
462 m_oldValue = param->getValue();
463 m_newValue = m_oldValue;
464 }
465
onAdd()466 void onAdd() override { m_newValue = m_param->getValue(); }
467
undo() const468 void undo() const override {
469 m_param->setValue(m_oldValue);
470 if (m_fxHandle) m_fxHandle->notifyFxChanged();
471 }
472
redo() const473 void redo() const override {
474 m_param->setValue(m_newValue);
475 if (m_fxHandle) m_fxHandle->notifyFxChanged();
476 }
477
getHistoryString()478 QString getHistoryString() override {
479 QString str = QObject::tr("Modify Fx Param : %1").arg(m_name);
480 return str;
481 }
482 };
483
484 //-----------------------------------------------------------------------------
485 /*! ToneCurveParamField Undo
486 */
487 class ToneCurveParamFieldUndo final : public AnimatableFxSettingsUndo {
488 TToneCurveParamP m_param;
489 QList<TPointD> m_oldPoints, m_newPoints;
490
491 public:
ToneCurveParamFieldUndo(const TToneCurveParamP param,QString name,int frame,TFxHandle * fxHandle)492 ToneCurveParamFieldUndo(const TToneCurveParamP param, QString name, int frame,
493 TFxHandle *fxHandle)
494 : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {
495 m_oldPoints = param->getValue(frame);
496 m_newPoints = m_oldPoints;
497 m_wasKeyframe = m_param->isKeyframe(frame);
498 }
499
onAdd()500 void onAdd() override { m_newPoints = m_param->getValue(m_frame); }
501
undo() const502 void undo() const override {
503 if (!m_wasKeyframe)
504 m_param->setDefaultValue(m_oldPoints);
505 else
506 m_param->setValue(m_frame, m_oldPoints);
507
508 if (m_fxHandle) m_fxHandle->notifyFxChanged();
509 }
510
redo() const511 void redo() const override {
512 if (!m_wasKeyframe)
513 m_param->setDefaultValue(m_newPoints);
514 else
515 m_param->setValue(m_frame, m_newPoints);
516 if (m_fxHandle) m_fxHandle->notifyFxChanged();
517 }
518 };
519
520 //-----------------------------------------------------------------------------
521 /*! ToneCurveParamField Undo
522 ※
523 ToneCurveParamFieldは、表示更新時にactualParamとcurrentParamのPointの数が
524 一致していなくてはならないので、２つ同時に変更する必要が有る。
525 */
526
527 class ToneCurveParamFieldAddRemovePointUndo final : public FxSettingsUndo {
528 TToneCurveParamP m_actualParam;
529 TToneCurveParamP m_currentParam;
530 QList<TPointD> m_value;
531 int m_index;
532
533 bool m_isAddUndo;
534
535 public:
ToneCurveParamFieldAddRemovePointUndo(const TToneCurveParamP actualParam,const TToneCurveParamP currentParam,QList<TPointD> value,int index,bool isAddUndo,QString name,TFxHandle * fxHandle)536 ToneCurveParamFieldAddRemovePointUndo(const TToneCurveParamP actualParam,
537 const TToneCurveParamP currentParam,
538 QList<TPointD> value, int index,
539 bool isAddUndo, QString name,
540 TFxHandle *fxHandle)
541 : FxSettingsUndo(name, fxHandle)
542 , m_actualParam(actualParam)
543 , m_currentParam(currentParam)
544 , m_value(value)
545 , m_index(index)
546 , m_isAddUndo(isAddUndo) {}
547
removePoints() const548 void removePoints() const {
549 m_actualParam->removeValue(0, m_index);
550 m_currentParam->removeValue(0, m_index);
551 }
552
addPoints() const553 void addPoints() const {
554 m_actualParam->addValue(0, m_value, m_index);
555 m_currentParam->addValue(0, m_value, m_index);
556 }
557
undo() const558 void undo() const override {
559 if (m_isAddUndo)
560 removePoints();
561 else
562 addPoints();
563
564 if (m_fxHandle) m_fxHandle->notifyFxChanged();
565 }
566
redo() const567 void redo() const override {
568 if (m_isAddUndo)
569 addPoints();
570 else
571 removePoints();
572 if (m_fxHandle) m_fxHandle->notifyFxChanged();
573 }
574
getHistoryString()575 QString getHistoryString() override {
576 QString str =
577 QObject::tr("Modify Fx Param : %1 : %2 Point")
578 .arg(m_name)
579 .arg((m_isAddUndo) ? QObject::tr("Add") : QObject::tr("Remove"));
580 return str;
581 }
582 };
583
584 //-----------------------------------------------------------------------------
585 /*! ToneCurveParamField Undo (Linearのトグル)
586 */
587 class ToneCurveParamFieldToggleLinearUndo final : public FxSettingsUndo {
588 TToneCurveParamP m_actualParam;
589 TToneCurveParamP m_currentParam;
590 bool m_newState;
591
592 public:
ToneCurveParamFieldToggleLinearUndo(const TToneCurveParamP actualParam,const TToneCurveParamP currentParam,QString name,TFxHandle * fxHandle)593 ToneCurveParamFieldToggleLinearUndo(const TToneCurveParamP actualParam,
594 const TToneCurveParamP currentParam,
595 QString name, TFxHandle *fxHandle)
596 : FxSettingsUndo(name, fxHandle)
597 , m_actualParam(actualParam)
598 , m_currentParam(currentParam) {
599 m_newState = actualParam->isLinear();
600 }
601
undo() const602 void undo() const override {
603 m_actualParam->setIsLinear(!m_newState);
604 m_currentParam->setIsLinear(!m_newState);
605 if (m_fxHandle) m_fxHandle->notifyFxChanged();
606 }
607
redo() const608 void redo() const override {
609 m_actualParam->setIsLinear(m_newState);
610 m_currentParam->setIsLinear(m_newState);
611 if (m_fxHandle) m_fxHandle->notifyFxChanged();
612 }
613
getHistoryString()614 QString getHistoryString() override {
615 QString str = QObject::tr("Modify Fx Param : ");
616 if (m_newState)
617 str += QObject::tr("%1 : Linear ON").arg(m_name);
618 else
619 str += QObject::tr("%1 : Linear OFF").arg(m_name);
620 return str;
621 }
622 };
623
624 //=============================================================================
625 // ParamField
626 //-----------------------------------------------------------------------------
627
ParamField(QWidget * parent,QString paramName,const TParamP & param,bool addEmptyLabel)628 ParamField::ParamField(QWidget *parent, QString paramName, const TParamP ¶m,
629 bool addEmptyLabel)
630 : QWidget(parent)
631 , m_paramName(paramName)
632 , m_interfaceName(param->hasUILabel()
633 ? QString::fromStdString(param->getUILabel())
634 : paramName)
635 , m_description(QString::fromStdString(param->getDescription())) {
636 QString str;
637 m_layout = new QHBoxLayout(this);
638 m_layout->setMargin(0);
639 m_layout->setSpacing(5);
640 }
641
642 //-----------------------------------------------------------------------------
643
~ParamField()644 ParamField::~ParamField() {}
645
646 //-----------------------------------------------------------------------------
647
648 TFxHandle *ParamField::m_fxHandleStat = 0;
setFxHandle(TFxHandle * fxHandle)649 void ParamField::setFxHandle(TFxHandle *fxHandle) {
650 ParamField::m_fxHandleStat = fxHandle;
651 }
652
653 //=============================================================================
654 // ParamFieldKeyToggle
655 //-----------------------------------------------------------------------------
656
ParamFieldKeyToggle(QWidget * parent,std::string name)657 ParamFieldKeyToggle::ParamFieldKeyToggle(QWidget *parent, std::string name)
658 : QWidget(parent), m_status(NOT_ANIMATED), m_highlighted(false) {
659 setFixedSize(20, 20);
660 }
661
662 //-----------------------------------------------------------------------------
663
setStatus(Status status)664 void ParamFieldKeyToggle::setStatus(Status status) {
665 m_status = status;
666 update();
667 }
668
669 //-----------------------------------------------------------------------------
670
setStatus(bool hasKeyframes,bool isKeyframe,bool hasBeenChanged)671 void ParamFieldKeyToggle::setStatus(bool hasKeyframes, bool isKeyframe,
672 bool hasBeenChanged) {
673 if (!hasKeyframes)
674 setStatus(NOT_ANIMATED);
675 else if (hasBeenChanged)
676 setStatus(MODIFIED);
677 else if (isKeyframe)
678 setStatus(KEYFRAME);
679 else
680 setStatus(NOT_KEYFRAME);
681 }
682
683 //-----------------------------------------------------------------------------
684
getStatus() const685 ParamFieldKeyToggle::Status ParamFieldKeyToggle::getStatus() const {
686 return m_status;
687 }
688
689 //-----------------------------------------------------------------------------
690
paintEvent(QPaintEvent * e)691 void ParamFieldKeyToggle::paintEvent(QPaintEvent *e) {
692 QIcon icon;
693 const int iconSize = 20;
694 const int radius = 2;
695
696 // Create rounded rect for key button states
697 QPainter p(this);
698 p.setRenderHint(p.Antialiasing, true);
699 QPainterPath path;
700 path.addRoundedRect(
701 QRectF(0.5, 0.5, 19, 19), radius,
702 radius); // Nudge rect by half pixel so QPen looks pixel perfect
703 QPen pen = QColor(0, 0, 0, 0);
704 p.setPen(pen);
705
706 switch (m_status) {
707 case NOT_ANIMATED:
708 pen = QColor(getKeyBorderOffColor());
709 p.setPen(pen);
710 p.fillPath(path, getKeyOffColor());
711 m_pixmap = QPixmap(createQIcon("key_off").pixmap(
712 iconSize, iconSize, QIcon::Normal, QIcon::Off));
713 icon.addPixmap(m_pixmap);
714 icon.paint(&p, QRect(0, 0, iconSize, iconSize));
715 break;
716 case KEYFRAME:
717 pen = QColor(getKeyBorderOnColor());
718 p.setPen(pen);
719 p.fillPath(path, getKeyOnColor());
720 m_pixmap =
721 QPixmap(createQIcon("key_on", true)
722 .pixmap(iconSize, iconSize, QIcon::Normal, QIcon::Off));
723 icon.addPixmap(m_pixmap);
724 icon.paint(&p, QRect(0, 0, iconSize, iconSize));
725 break;
726 case MODIFIED:
727 pen = QColor(getKeyBorderModifiedColor());
728 p.setPen(pen);
729 p.fillPath(path, getKeyModifiedColor());
730 m_pixmap =
731 QPixmap(createQIcon("key_modified", true)
732 .pixmap(iconSize, iconSize, QIcon::Normal, QIcon::Off));
733 icon.addPixmap(m_pixmap);
734 icon.paint(&p, QRect(0, 0, iconSize, iconSize));
735 break;
736 default:
737 pen = QColor(getKeyBorderInbetweenColor());
738 p.setPen(pen);
739 p.fillPath(path, getKeyInbetweenColor());
740 m_pixmap =
741 QPixmap(createQIcon("key_on", true)
742 .pixmap(iconSize, iconSize, QIcon::Normal, QIcon::Off));
743 icon.addPixmap(m_pixmap);
744 icon.paint(&p, QRect(0, 0, iconSize, iconSize));
745 break;
746 }
747 p.drawPath(path);
748
749 if (m_highlighted) {
750 pen = QColor(getKeyBorderHighlightColor());
751 p.setPen(pen);
752 p.fillPath(path, getKeyHighlightColor());
753 p.drawPath(path);
754 }
755
756 p.end();
757 }
758
759 //-----------------------------------------------------------------------------
760
mousePressEvent(QMouseEvent * e)761 void ParamFieldKeyToggle::mousePressEvent(QMouseEvent *e) { emit keyToggled(); }
762
763 //-----------------------------------------------------------------------------
764
enterEvent(QEvent *)765 void ParamFieldKeyToggle::enterEvent(QEvent *) {
766 m_highlighted = true;
767 update();
768 }
769
770 //-----------------------------------------------------------------------------
771
leaveEvent(QEvent *)772 void ParamFieldKeyToggle::leaveEvent(QEvent *) {
773 m_highlighted = false;
774 update();
775 }
776
777 //=============================================================================
778 // MeasuredDoubleParamField
779 //-----------------------------------------------------------------------------
780
MeasuredDoubleParamField(QWidget * parent,QString name,const TDoubleParamP & param)781 MeasuredDoubleParamField::MeasuredDoubleParamField(QWidget *parent,
782 QString name,
783 const TDoubleParamP ¶m)
784 : AnimatedParamField<double, TDoubleParamP>(parent, name, param) {
785 QString str;
786 m_paramName = str.fromStdString(param->getName());
787
788 m_measuredDoubleField = new MeasuredDoubleField(this, false);
789
790 m_measuredDoubleField->setSizePolicy(QSizePolicy::Expanding,
791 QSizePolicy::Minimum);
792 m_measuredDoubleField->setMeasure(param->getMeasureName());
793 m_measuredDoubleField->setValue(param->getValue(m_frame));
794 m_measuredDoubleField->setDecimals(3);
795
796 double min = 0, max = 100, step = 1;
797 param->getValueRange(min, max, step);
798 assert(min < max);
799 m_measuredDoubleField->setRange(min, max);
800
801 //----layout
802 m_layout->addWidget(m_keyToggle);
803 m_layout->addWidget(m_measuredDoubleField);
804 setLayout(m_layout);
805
806 //----signal-slot connection
807 bool ret = connect(m_measuredDoubleField, SIGNAL(valueChanged(bool)),
808 SLOT(onChange(bool)));
809 ret = ret && connect(m_keyToggle, SIGNAL(keyToggled()), SLOT(onKeyToggled()));
810
811 assert(ret);
812 }
813
814 //-----------------------------------------------------------------------------
815
updateField(double value)816 void MeasuredDoubleParamField::updateField(double value) {
817 m_measuredDoubleField->setValue(value);
818 }
819
820 //-----------------------------------------------------------------------------
821
onChange(bool dragging)822 void MeasuredDoubleParamField::onChange(bool dragging) {
823 if (dragging) return;
824
825 TDoubleParamP doubleParam = m_actualParam;
826
827 TUndo *undo = 0;
828 /*-- Undoを登録する条件：
829 値が変更されていて、かつ
830 キーフレーム上か、または、まだキーフレームが無い
831 （すなわち、実際にシーンの情報を変えることになる）場合
832 --*/
833 if (doubleParam &&
834 doubleParam->getValue(m_frame) != m_measuredDoubleField->getValue() &&
835 (m_actualParam->isKeyframe(m_frame) ||
836 !m_actualParam.getPointer()->hasKeyframes()))
837 undo = new MeasuredDoubleParamFieldUndo(
838 doubleParam, m_interfaceName, m_frame, ParamField::m_fxHandleStat);
839
840 setValue(m_measuredDoubleField->getValue());
841
842 if (undo) TUndoManager::manager()->add(undo);
843 }
844
845 //-----------------------------------------------------------------------------
846
onKeyToggled()847 void MeasuredDoubleParamField::onKeyToggled() { onKeyToggle(); }
848
849 //=============================================================================
850 // MeasuredRangeParamField
851 //-----------------------------------------------------------------------------
852
MeasuredRangeParamField(QWidget * parent,QString name,const TRangeParamP & param)853 MeasuredRangeParamField::MeasuredRangeParamField(QWidget *parent, QString name,
854 const TRangeParamP ¶m)
855 : AnimatedParamField<DoublePair, TRangeParamP>(parent, name, param) {
856 QString str;
857 m_paramName = str.fromStdString(param->getName());
858
859 m_valueField = new MeasuredDoublePairField(this);
860 m_valueField->setLabelsEnabled(false);
861 m_valueField->setMeasure(param->getMin()->getMeasureName());
862 m_valueField->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
863 double a, b, c, min, max;
864 param->getMin()->getValueRange(a, b, c);
865 min = a;
866 param->getMax()->getValueRange(a, b, c);
867 max = b;
868 if (min < max && max - min < 1e10) // se min=-inf e max=inf
869 m_valueField->setRange(min, max);
870
871 m_layout->addWidget(m_keyToggle);
872 m_layout->addWidget(m_valueField);
873 setLayout(m_layout);
874
875 bool ret =
876 connect(m_valueField, SIGNAL(valuesChanged(bool)), SLOT(onChange(bool)));
877 ret = ret && connect(m_keyToggle, SIGNAL(keyToggled()), SLOT(onKeyToggled()));
878 assert(ret);
879 }
880
881 //-----------------------------------------------------------------------------
882
updateField(DoublePair value)883 void MeasuredRangeParamField::updateField(DoublePair value) {
884 m_valueField->setValues(value);
885 }
886
887 //-----------------------------------------------------------------------------
888
onChange(bool dragging)889 void MeasuredRangeParamField::onChange(bool dragging) {
890 if (dragging) return;
891
892 TRangeParamP rangeParam = m_actualParam;
893
894 DoublePair value = m_valueField->getValues();
895
896 TUndo *undo = 0;
897
898 /*-- Undoを登録する条件：
899 値が変更されていて
900 キーフレーム上か、または、まだキーフレームが無い
901 （すなわち、実際にシーンの情報を変えることになる）場合
902 --*/
903 if (rangeParam && rangeParam->getValue(m_frame) != value &&
904 (m_actualParam->isKeyframe(m_frame) ||
905 !m_actualParam.getPointer()->hasKeyframes()))
906 undo = new RangeParamFieldUndo(rangeParam, m_interfaceName, m_frame,
907 ParamField::m_fxHandleStat);
908
909 setValue(value);
910
911 if (undo) TUndoManager::manager()->add(undo);
912 }
913
914 //-----------------------------------------------------------------------------
915
onKeyToggled()916 void MeasuredRangeParamField::onKeyToggled() { onKeyToggle(); }
917
918 //-----------------------------------------------------------------------------
919
setPrecision(int precision)920 void MeasuredRangeParamField::setPrecision(int precision) {
921 m_valueField->setPrecision(precision);
922 }
923
924 //=============================================================================
925 // PointParamField
926 //-----------------------------------------------------------------------------
927
PointParamField(QWidget * parent,QString name,const TPointParamP & param)928 PointParamField::PointParamField(QWidget *parent, QString name,
929 const TPointParamP ¶m)
930 : AnimatedParamField<TPointD, TPointParamP>(parent, name, param) {
931 QString str;
932 m_paramName = str.fromStdString(param->getName());
933
934 QLabel *xLabel = new QLabel(tr("X:"), this);
935 m_xFld = new MeasuredDoubleField(this, false);
936 QLabel *yLabel = new QLabel(tr("Y:"), this);
937 m_yFld = new MeasuredDoubleField(this, false);
938
939 double xmin = -(std::numeric_limits<double>::max)(),
940 xmax = (std::numeric_limits<double>::max)();
941 double ymin = -(std::numeric_limits<double>::max)(),
942 ymax = (std::numeric_limits<double>::max)();
943
944 #if 1
945 /* これを有効にすれば PointParamField に範囲が設定できることが UI
946 の見た目が変わってしまう.
947 これまで誰も TPointParam に対して range
948 を設定していないなら(どうせ効いてなかったのだから)無条件に設定してもよさそうだが
949 実際は Pinned Texture などの FX
950 が設定しており(効いてないなかったが、この修正により)動作が変わってしまうので
951 plugin から要求された場合でのみ range を有効にする. */
952 if (param->isFromPlugin()) {
953 double xstep, ystep;
954 param->getX()->getValueRange(xmin, xmax, xstep);
955 param->getY()->getValueRange(ymin, ymax, ystep);
956 }
957 #endif
958
959 m_xFld->setMaximumWidth(100);
960 m_xFld->setRange(xmin, xmax);
961 m_xFld->setMeasure(param->getX()->getMeasureName());
962 m_xFld->setValue(param->getX()->getValue(m_frame));
963
964 m_yFld->setMaximumWidth(100);
965 m_yFld->setRange(ymin, ymax);
966 m_yFld->setMeasure(param->getY()->getMeasureName());
967 m_yFld->setValue(param->getY()->getValue(m_frame));
968
969 //----layout
970 m_layout->addWidget(m_keyToggle);
971 m_layout->addWidget(xLabel);
972 m_layout->addWidget(m_xFld);
973
974 m_layout->addSpacing(5);
975
976 m_layout->addWidget(yLabel);
977 m_layout->addWidget(m_yFld);
978
979 m_layout->addStretch(1);
980
981 setLayout(m_layout);
982
983 //----signal-slot connections
984 bool ret =
985 connect(m_xFld, SIGNAL(valueChanged(bool)), this, SLOT(onChange(bool)));
986 ret = ret &&
987 connect(m_yFld, SIGNAL(valueChanged(bool)), this, SLOT(onChange(bool)));
988 ret = ret && connect(m_keyToggle, SIGNAL(keyToggled()), SLOT(onKeyToggled()));
989 assert(ret);
990 }
991
992 //-----------------------------------------------------------------------------
993
setPointValue(const TPointD & p)994 void PointParamField::setPointValue(const TPointD &p) {
995 m_xFld->setValue(p.x);
996 m_yFld->setValue(p.y);
997 setValue(p);
998 }
999
1000 //-----------------------------------------------------------------------------
1001
updateField(TPointD value)1002 void PointParamField::updateField(TPointD value) {
1003 m_xFld->setValue(value.x);
1004 m_yFld->setValue(value.y);
1005 }
1006
1007 //-----------------------------------------------------------------------------
1008
onChange(bool dragging)1009 void PointParamField::onChange(bool dragging) {
1010 if (dragging) return;
1011
1012 TPointParamP pointParam = m_actualParam;
1013 TPointD pos(m_xFld->getValue(), m_yFld->getValue());
1014
1015 TUndo *undo = 0;
1016 /*-- Undoを登録する条件：
1017 値が変更されていて
1018 キーフレーム上か、または、まだキーフレームが無い
1019 （すなわち、実際にシーンの情報を変えることになる）場合
1020 --*/
1021 if (pointParam && pointParam->getValue(m_frame) != pos &&
1022 (m_actualParam->isKeyframe(m_frame) ||
1023 !m_actualParam.getPointer()->hasKeyframes()))
1024 undo = new PointParamFieldUndo(pointParam, m_interfaceName, m_frame,
1025 ParamField::m_fxHandleStat);
1026
1027 setValue(pos);
1028
1029 if (undo) TUndoManager::manager()->add(undo);
1030 }
1031
1032 //-----------------------------------------------------------------------------
1033
onKeyToggled()1034 void PointParamField::onKeyToggled() { onKeyToggle(); }
1035
1036 //=============================================================================
1037 // PixelParamField
1038 //-----------------------------------------------------------------------------
1039
PixelParamField(QWidget * parent,QString name,const TPixelParamP & param)1040 PixelParamField::PixelParamField(QWidget *parent, QString name,
1041 const TPixelParamP ¶m)
1042 : AnimatedParamField<TPixel32, TPixelParamP>(parent, name, param) {
1043 QString str;
1044 m_paramName = str.fromStdString(param->getName());
1045
1046 m_colorField = new ColorField(this, param->isMatteEnabled());
1047
1048 //----layout
1049 m_layout->addWidget(m_keyToggle);
1050 m_layout->addWidget(m_colorField);
1051 m_layout->addStretch();
1052 setLayout(m_layout);
1053
1054 //----signal-slot connections
1055 bool ret = connect(m_colorField, SIGNAL(colorChanged(const TPixel32 &, bool)),
1056 this, SLOT(onChange(const TPixel32 &, bool)));
1057 ret = ret && connect(m_keyToggle, SIGNAL(keyToggled()), SLOT(onKeyToggled()));
1058 assert(ret);
1059 }
1060
1061 //-----------------------------------------------------------------------------
1062
updateField(TPixel32 value)1063 void PixelParamField::updateField(TPixel32 value) {
1064 m_colorField->setColor(value);
1065 }
1066
1067 //-----------------------------------------------------------------------------
1068
onChange(const TPixel32 & value,bool isDragging)1069 void PixelParamField::onChange(const TPixel32 &value, bool isDragging) {
1070 if (isDragging) return;
1071
1072 TPixelParamP pixelParam = m_actualParam;
1073
1074 TUndo *undo = 0;
1075 /*-- Undoを登録する条件:
1076 値が変更されていて
1077 キーフレーム上か、または、まだキーフレームが無い
1078 （すなわち、実際にシーンの情報を変えることになる）場合
1079 --*/
1080 if (pixelParam && pixelParam->getValue(m_frame) != value &&
1081 (m_actualParam->isKeyframe(m_frame) ||
1082 !m_actualParam.getPointer()->hasKeyframes()))
1083 undo = new PixelParamFieldUndo(pixelParam, m_interfaceName, m_frame,
1084 ParamField::m_fxHandleStat);
1085
1086 setValue(value);
1087
1088 if (undo) TUndoManager::manager()->add(undo);
1089 }
1090
1091 //-----------------------------------------------------------------------------
1092
onKeyToggled()1093 void PixelParamField::onKeyToggled() { onKeyToggle(); }
1094
1095 //-----------------------------------------------------------------------------
1096
getColor()1097 TPixel32 PixelParamField::getColor() { return m_colorField->getColor(); }
1098
1099 //-----------------------------------------------------------------------------
1100
setColor(TPixel32 value)1101 void PixelParamField::setColor(TPixel32 value) {
1102 m_colorField->setColor(value);
1103 onChange(value, false);
1104 }
1105
1106 //=============================================================================
1107 // RGB Link Button
1108 //-----------------------------------------------------------------------------
1109
RgbLinkButtons(QString str1,QString str2,QWidget * parent,PixelParamField * field1,PixelParamField * field2)1110 RgbLinkButtons::RgbLinkButtons(QString str1, QString str2, QWidget *parent,
1111 PixelParamField *field1, PixelParamField *field2)
1112 : QWidget(parent), m_field1(field1), m_field2(field2) {
1113 QString copyButtonStr = tr("Copy RGB : %1 > %2").arg(str1).arg(str2);
1114 QString swapButtonStr = tr("Swap %1 and %2").arg(str1).arg(str2);
1115 QPushButton *copyButton = new QPushButton(copyButtonStr, this);
1116 QPushButton *swapButton = new QPushButton(swapButtonStr, this);
1117
1118 copyButton->setFixedHeight(21);
1119 swapButton->setFixedHeight(21);
1120
1121 QHBoxLayout *lay = new QHBoxLayout();
1122 lay->setMargin(0);
1123 lay->setSpacing(5);
1124 {
1125 lay->addWidget(copyButton, 0);
1126 lay->addWidget(swapButton, 0);
1127 lay->addStretch(1);
1128 }
1129 setLayout(lay);
1130
1131 connect(copyButton, SIGNAL(clicked()), this, SLOT(onCopyButtonClicked()));
1132 connect(swapButton, SIGNAL(clicked()), this, SLOT(onSwapButtonClicked()));
1133 }
1134
1135 //-----------------------------------------------------------------------------
1136
onCopyButtonClicked()1137 void RgbLinkButtons::onCopyButtonClicked() {
1138 if (!m_field1 || !m_field2) return;
1139 TPixel32 val1 = m_field1->getColor();
1140 TPixel32 val2 = m_field2->getColor();
1141
1142 // keep alpha channel unchanged
1143 val1.m = val2.m;
1144
1145 if (val1 == val2) return;
1146
1147 m_field2->setColor(val1);
1148 }
1149
1150 //-----------------------------------------------------------------------------
1151
onSwapButtonClicked()1152 void RgbLinkButtons::onSwapButtonClicked() {
1153 if (!m_field1 || !m_field2) return;
1154 TPixel32 val1 = m_field1->getColor();
1155 TPixel32 val2 = m_field2->getColor();
1156
1157 if (val1 == val2) return;
1158
1159 TUndoManager::manager()->beginBlock();
1160 m_field2->setColor(val1);
1161 m_field1->setColor(val2);
1162 TUndoManager::manager()->endBlock();
1163 }
1164
1165 //=============================================================================
1166 // SpectrumParamField
1167 //-----------------------------------------------------------------------------
1168
SpectrumParamField(QWidget * parent,QString name,const TSpectrumParamP & param)1169 SpectrumParamField::SpectrumParamField(QWidget *parent, QString name,
1170 const TSpectrumParamP ¶m)
1171 : AnimatedParamField<TSpectrum, TSpectrumParamP>(parent, name, param) {
1172 QString str;
1173 m_paramName = str.fromStdString(param->getName());
1174
1175 m_spectrumField = new SpectrumField(this);
1176 m_spectrumField->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
1177 m_spectrumField->setCurrentKeyIndex(0);
1178
1179 //--- layout
1180 m_layout->addWidget(m_keyToggle);
1181 m_layout->addWidget(m_spectrumField);
1182 setLayout(m_layout);
1183
1184 //--- signal-slot connections
1185 bool ret = true;
1186 ret = ret && connect(m_spectrumField, SIGNAL(keyColorChanged(bool)), this,
1187 SLOT(onChange(bool)));
1188 ret = ret && connect(m_spectrumField, SIGNAL(keyPositionChanged(bool)), this,
1189 SLOT(onChange(bool)));
1190 ret = ret && connect(m_spectrumField, SIGNAL(keyAdded(int)), this,
1191 SLOT(onKeyAdded(int)));
1192 ret = ret && connect(m_spectrumField, SIGNAL(keyRemoved(int)), this,
1193 SLOT(onKeyRemoved(int)));
1194 ret = ret && connect(m_keyToggle, SIGNAL(keyToggled()), SLOT(onKeyToggled()));
1195 assert(ret);
1196 }
1197
1198 //-----------------------------------------------------------------------------
1199
updateField(TSpectrum value)1200 void SpectrumParamField::updateField(TSpectrum value) {
1201 if (m_spectrumField->getSpectrum() == value) return;
1202 m_spectrumField->setSpectrum(value);
1203 }
1204
1205 //-----------------------------------------------------------------------------
1206
setParams()1207 void SpectrumParamField::setParams() {
1208 TSpectrum spectrum = m_spectrumField->getSpectrum();
1209 // if(m_currentParam->getValue(0) == spectrum) return; //Rivedi quando sistemi
1210 // lo SwatchViewer
1211
1212 m_currentParam->setValue(m_frame, spectrum);
1213 if (m_actualParam->isKeyframe(m_frame)) {
1214 m_actualParam->setValue(m_frame, spectrum);
1215 emit actualParamChanged();
1216 } else if (!m_actualParam->hasKeyframes()) {
1217 m_actualParam->setDefaultValue(spectrum);
1218 emit actualParamChanged();
1219 }
1220 updateKeyToggle();
1221
1222 emit currentParamChanged();
1223 }
1224
1225 //-----------------------------------------------------------------------------
1226
onKeyToggled()1227 void SpectrumParamField::onKeyToggled() { onKeyToggle(); }
1228
1229 //-----------------------------------------------------------------------------
1230
onChange(bool isDragging)1231 void SpectrumParamField::onChange(bool isDragging) {
1232 if (isDragging) return;
1233
1234 TSpectrumParamP spectrumParam = m_actualParam;
1235 TUndo *undo = 0;
1236 if (spectrumParam &&
1237 spectrumParam->getValue(m_frame) != m_spectrumField->getSpectrum() &&
1238 (m_actualParam->isKeyframe(m_frame) ||
1239 !m_actualParam.getPointer()->hasKeyframes()))
1240 undo = new SpectrumParamFieldUndo(spectrumParam, m_interfaceName, m_frame,
1241 ParamField::m_fxHandleStat);
1242
1243 setParams();
1244
1245 if (undo) TUndoManager::manager()->add(undo);
1246 }
1247
1248 //-----------------------------------------------------------------------------
1249
onKeyAdded(int keyIndex)1250 void SpectrumParamField::onKeyAdded(int keyIndex) {
1251 TSpectrum::ColorKey key = m_spectrumField->getSpectrum().getKey(keyIndex);
1252
1253 TSpectrumParamP actualSpectrumParam = m_actualParam;
1254 assert(actualSpectrumParam);
1255 actualSpectrumParam->addKey(key.first, key.second);
1256
1257 TSpectrumParamP currentSpectrumParam = m_currentParam;
1258 assert(currentSpectrumParam);
1259 currentSpectrumParam->addKey(key.first, key.second);
1260
1261 TUndoManager::manager()->add(new SpectrumParamFieldAddRemoveKeyUndo(
1262 actualSpectrumParam, currentSpectrumParam, key, keyIndex, true,
1263 m_interfaceName, ParamField::m_fxHandleStat));
1264 }
1265
1266 //-----------------------------------------------------------------------------
1267
onKeyRemoved(int keyIndex)1268 void SpectrumParamField::onKeyRemoved(int keyIndex) {
1269 TUndo *undo = 0;
1270 TSpectrumParamP actualSpectrumParam = m_actualParam;
1271 TSpectrumParamP currentSpectrumParam = m_currentParam;
1272 if (currentSpectrumParam && actualSpectrumParam) {
1273 TSpectrum::ColorKey key =
1274 actualSpectrumParam->getValue(m_frame).getKey(keyIndex);
1275 undo = new SpectrumParamFieldAddRemoveKeyUndo(
1276 actualSpectrumParam, currentSpectrumParam, key, keyIndex, false,
1277 m_interfaceName, ParamField::m_fxHandleStat);
1278 }
1279
1280 m_currentParam->removeKey(keyIndex);
1281 m_actualParam->removeKey(keyIndex);
1282
1283 setParams();
1284
1285 if (undo) TUndoManager::manager()->add(undo);
1286 }
1287
1288 //=============================================================================
1289 // Mode Sensitive Box
1290 //-----------------------------------------------------------------------------
1291
ModeSensitiveBox(QWidget * parent,ModeChangerParamField * modeChanger,QList<int> modes)1292 ModeSensitiveBox::ModeSensitiveBox(QWidget *parent,
1293 ModeChangerParamField *modeChanger,
1294 QList<int> modes)
1295 : QWidget(parent), m_modes(modes) {
1296 connect(modeChanger, SIGNAL(modeChanged(int)), this,
1297 SLOT(onModeChanged(int)));
1298 }
1299
1300 //-----------------------------------------------------------------------------
1301
onModeChanged(int modeValue)1302 void ModeSensitiveBox::onModeChanged(int modeValue) {
1303 setVisible(m_modes.contains(modeValue));
1304 }
1305
1306 //=============================================================================
1307 // EnumParamField
1308 //-----------------------------------------------------------------------------
1309
EnumParamField(QWidget * parent,QString name,const TIntEnumParamP & param)1310 EnumParamField::EnumParamField(QWidget *parent, QString name,
1311 const TIntEnumParamP ¶m)
1312 : ModeChangerParamField(parent, name, param) {
1313 QString str;
1314 m_paramName = str.fromStdString(param->getName());
1315 m_om = new QComboBox(this);
1316 m_om->setFixedHeight(20);
1317
1318 for (int i = 0; i < param->getItemCount(); i++) {
1319 int value = 0;
1320 std::string caption;
1321 param->getItem(i, value, caption);
1322 QString str;
1323 m_om->addItem(str.fromStdString(caption));
1324 }
1325 connect(m_om, SIGNAL(activated(const QString &)), this,
1326 SLOT(onChange(const QString &)));
1327 m_layout->addWidget(m_om);
1328
1329 m_layout->addStretch();
1330
1331 setLayout(m_layout);
1332 }
1333
1334 //-----------------------------------------------------------------------------
1335
onChange(const QString & str)1336 void EnumParamField::onChange(const QString &str) {
1337 TIntEnumParamP intEnumParam = m_actualParam;
1338 std::string newStdStr = str.toStdString();
1339 TUndo *undo = 0;
1340 if (intEnumParam) {
1341 /*--クリックしただけで実際のカレントアイテムが変わっていない場合はreturn--*/
1342 std::string oldStr;
1343 for (int i = 0; i < intEnumParam->getItemCount(); i++) {
1344 int oldVal;
1345 intEnumParam->getItem(i, oldVal, oldStr);
1346 if (oldVal == intEnumParam->getValue()) {
1347 if (oldStr == newStdStr)
1348 return;
1349 else
1350 break;
1351 }
1352 }
1353
1354 undo = new EnumParamFieldUndo(intEnumParam, oldStr, newStdStr,
1355 m_interfaceName, ParamField::m_fxHandleStat);
1356 }
1357
1358 m_currentParam->setValue(newStdStr);
1359 m_actualParam->setValue(newStdStr);
1360
1361 emit currentParamChanged();
1362 emit actualParamChanged();
1363
1364 emit modeChanged(m_actualParam->getValue());
1365
1366 if (undo) TUndoManager::manager()->add(undo);
1367 }
1368
1369 //-----------------------------------------------------------------------------
1370
setParam(const TParamP & current,const TParamP & actual,int frame)1371 void EnumParamField::setParam(const TParamP ¤t, const TParamP &actual,
1372 int frame) {
1373 m_currentParam = current;
1374 m_actualParam = actual;
1375 assert(m_currentParam);
1376 assert(m_actualParam);
1377 update(frame);
1378 emit modeChanged(m_actualParam->getValue());
1379 }
1380
1381 //-----------------------------------------------------------------------------
1382
update(int frame)1383 void EnumParamField::update(int frame) {
1384 if (!m_actualParam || !m_currentParam) return;
1385 TIntEnumParamP param = m_actualParam;
1386 for (int i = 0; i < param->getItemCount(); i++) {
1387 int value = 0;
1388 std::string caption;
1389 param->getItem(i, value, caption);
1390 if (value != param->getValue()) continue;
1391 if (m_om->currentIndex() == i) return;
1392 m_om->setCurrentIndex(i);
1393 return;
1394 }
1395 }
1396
1397 //=============================================================================
1398 // BoolParamField
1399 //-----------------------------------------------------------------------------
1400
BoolParamField(QWidget * parent,QString name,const TBoolParamP & param)1401 BoolParamField::BoolParamField(QWidget *parent, QString name,
1402 const TBoolParamP ¶m)
1403 : ModeChangerParamField(parent, name, param) {
1404 QString str;
1405 m_paramName = str.fromStdString(param->getName());
1406 if (!param->hasUILabel()) m_interfaceName = name;
1407
1408 m_checkBox = new CheckBox("", this);
1409
1410 /*-- Undo時には反応しないように、toggledでなくclickedにする --*/
1411 connect(m_checkBox, SIGNAL(clicked(bool)), this, SLOT(onToggled(bool)));
1412 m_layout->addWidget(m_checkBox);
1413 m_layout->addStretch();
1414 setLayout(m_layout);
1415
1416 /*-- visibleToggleインタフェースのため --*/
1417 connect(m_checkBox, SIGNAL(toggled(bool)), this, SIGNAL(toggled(bool)));
1418 }
1419
1420 //-----------------------------------------------------------------------------
1421
onToggled(bool checked)1422 void BoolParamField::onToggled(bool checked) {
1423 m_actualParam->setValue(checked);
1424 m_currentParam->setValue(checked);
1425
1426 emit currentParamChanged();
1427 emit actualParamChanged();
1428
1429 emit modeChanged((checked) ? 1 : 0);
1430
1431 TBoolParamP boolParam = m_actualParam;
1432 if (boolParam)
1433 TUndoManager::manager()->add(new BoolParamFieldUndo(
1434 boolParam, m_interfaceName, ParamField::m_fxHandleStat));
1435 }
1436
1437 //-----------------------------------------------------------------------------
1438
setParam(const TParamP & current,const TParamP & actual,int frame)1439 void BoolParamField::setParam(const TParamP ¤t, const TParamP &actual,
1440 int frame) {
1441 m_currentParam = current;
1442 m_actualParam = actual;
1443 assert(m_currentParam);
1444 assert(m_actualParam);
1445 update(frame);
1446 emit modeChanged((m_actualParam->getValue()) ? 1 : 0);
1447 }
1448
1449 //-----------------------------------------------------------------------------
1450
update(int frame)1451 void BoolParamField::update(int frame) {
1452 if (!m_actualParam || !m_currentParam) return;
1453 bool value = m_actualParam->getValue();
1454 if (m_checkBox->isChecked() == value) return;
1455 m_checkBox->setChecked(value);
1456 }
1457
1458 //=============================================================================
1459 // IntParamField
1460 //-----------------------------------------------------------------------------
1461
IntParamField(QWidget * parent,QString name,const TIntParamP & param)1462 IntParamField::IntParamField(QWidget *parent, QString name,
1463 const TIntParamP ¶m)
1464 : ParamField(parent, name, param) {
1465 QString str;
1466 m_paramName = str.fromStdString(param->getName());
1467 m_intField = new IntField(this, false);
1468 m_intField->setMaximumWidth(43);
1469 m_intField->enableSlider(false);
1470 m_intField->enableRoller(param->isWheelEnabled());
1471 int min, max;
1472 param->getValueRange(min, max);
1473 assert(min < max);
1474 m_intField->setRange(min, max);
1475 connect(m_intField, SIGNAL(valueChanged(bool)), SLOT(onChange(bool)));
1476
1477 m_layout->addWidget(m_intField);
1478 m_layout->addStretch();
1479
1480 setLayout(m_layout);
1481 }
1482
1483 //-----------------------------------------------------------------------------
1484
onChange(bool isDragging)1485 void IntParamField::onChange(bool isDragging) {
1486 if (isDragging) return;
1487
1488 int value = m_intField->getValue();
1489 int min, max;
1490 m_intField->getRange(min, max);
1491 if (value > max)
1492 value = max;
1493 else if (value < min)
1494 value = min;
1495
1496 TUndo *undo = 0;
1497
1498 TIntParamP intParam = m_actualParam;
1499 if (intParam && intParam->getValue() != value)
1500 undo = new IntParamFieldUndo(intParam, m_interfaceName,
1501 ParamField::m_fxHandleStat);
1502
1503 m_actualParam->setValue(value);
1504 emit currentParamChanged();
1505 m_currentParam->setValue(value);
1506 emit actualParamChanged();
1507
1508 if (undo) TUndoManager::manager()->add(undo);
1509 }
1510
1511 //-----------------------------------------------------------------------------
1512
setParam(const TParamP & current,const TParamP & actual,int frame)1513 void IntParamField::setParam(const TParamP ¤t, const TParamP &actual,
1514 int frame) {
1515 m_currentParam = current;
1516 m_actualParam = actual;
1517 assert(m_currentParam);
1518 assert(m_actualParam);
1519 update(frame);
1520 }
1521
1522 //-----------------------------------------------------------------------------
1523
update(int frame)1524 void IntParamField::update(int frame) {
1525 if (!m_actualParam || !m_currentParam) return;
1526 int value = m_actualParam->getValue();
1527 if (m_intField->getValue() == value) return;
1528 m_intField->setValue(value);
1529 }
1530
1531 //=============================================================================
1532 // StringParamField
1533 //-----------------------------------------------------------------------------
1534
1535 namespace component {
1536
keyPressEvent(QKeyEvent * event)1537 void MyTextEdit::keyPressEvent(QKeyEvent *event) {
1538 QTextEdit::keyPressEvent(event);
1539 if (event->key() == Qt::Key_Return) emit edited();
1540 }
1541
focusOutEvent(QFocusEvent * event)1542 void MyTextEdit::focusOutEvent(QFocusEvent *event) {
1543 QTextEdit::focusOutEvent(event);
1544 emit edited();
1545 }
1546 }; // namespace component
1547
StringParamField(QWidget * parent,QString name,const TStringParamP & param)1548 StringParamField::StringParamField(QWidget *parent, QString name,
1549 const TStringParamP ¶m)
1550 : ParamField(parent, name, param) {
1551 QString str;
1552 m_paramName = str.fromStdString(param->getName());
1553
1554 bool ret = true;
1555 if (param->isMultiLineEnabled()) {
1556 m_multiTextFld = new component::MyTextEdit(name, this);
1557 m_multiTextFld->setFixedHeight(80);
1558 m_multiTextFld->setAcceptRichText(false);
1559 m_multiTextFld->setStyleSheet(
1560 "background:white;\ncolor:black;\nborder:1 solid black;");
1561 ret = ret &&
1562 connect(m_multiTextFld, SIGNAL(edited()), this, SLOT(onChange()));
1563 m_layout->addWidget(m_multiTextFld);
1564 } else {
1565 m_textFld = new LineEdit(name, this);
1566 m_textFld->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
1567 ret = ret &&
1568 connect(m_textFld, SIGNAL(editingFinished()), this, SLOT(onChange()));
1569 m_layout->addWidget(m_textFld);
1570 }
1571 setLayout(m_layout);
1572 assert(ret);
1573 }
1574
1575 //-----------------------------------------------------------------------------
1576
onChange()1577 void StringParamField::onChange() {
1578 std::wstring value;
1579 if (m_multiTextFld)
1580 value = m_multiTextFld->toPlainText().toStdWString();
1581 else
1582 value = m_textFld->text().toStdWString();
1583 TUndo *undo = 0;
1584
1585 if (!m_actualParam || m_actualParam->getValue() == value) return;
1586
1587 if (m_actualParam->getValue() != value)
1588 undo = new StringParamFieldUndo(m_actualParam, m_interfaceName,
1589 ParamField::m_fxHandleStat);
1590
1591 m_actualParam->setValue(value);
1592 m_currentParam->setValue(value);
1593
1594 emit currentParamChanged();
1595 emit actualParamChanged();
1596
1597 if (undo) TUndoManager::manager()->add(undo);
1598 }
1599
1600 //-----------------------------------------------------------------------------
1601
setParam(const TParamP & current,const TParamP & actual,int frame)1602 void StringParamField::setParam(const TParamP ¤t, const TParamP &actual,
1603 int frame) {
1604 m_currentParam = current;
1605 m_actualParam = actual;
1606 assert(m_currentParam);
1607 assert(m_actualParam);
1608 update(frame);
1609 }
1610
1611 //-----------------------------------------------------------------------------
1612
update(int frame)1613 void StringParamField::update(int frame) {
1614 if (!m_actualParam || !m_currentParam) return;
1615 QString str;
1616 QString strValue = str.fromStdWString(m_actualParam->getValue());
1617
1618 if (m_textFld) {
1619 if (m_textFld->text() == strValue) return;
1620 m_textFld->setText(strValue);
1621
1622 // Faccio in modo che il cursore sia sulla prima cifra, cosi' se la stringa
1623 // da visualizzare e' piu' lunga del campo le cifre che vengono troncate
1624 // sono
1625 // le ultime e non le prime (dovrebbero essere quelle dopo la virgola).
1626 m_textFld->setCursorPosition(0);
1627 } else {
1628 if (m_multiTextFld->toPlainText() == strValue) return;
1629 m_multiTextFld->setPlainText(strValue);
1630 }
1631 }
1632
1633 //=============================================================================
1634 // FontParamField
1635 //-----------------------------------------------------------------------------
1636
FontParamField(QWidget * parent,QString name,const TFontParamP & param)1637 FontParamField::FontParamField(QWidget *parent, QString name,
1638 const TFontParamP ¶m)
1639 : ParamField(parent, name, param) {
1640 m_paramName = QString::fromStdString(param->getName());
1641
1642 m_fontCombo = new QFontComboBox(this);
1643 m_styleCombo = new QComboBox(this);
1644 m_sizeField = new IntField(this, false);
1645
1646 m_sizeField->setRange(1, 500);
1647 m_sizeField->enableSlider(false);
1648
1649 m_layout->addWidget(m_fontCombo);
1650 m_layout->addSpacing(5);
1651 m_layout->addWidget(new QLabel(tr("Style:"), this), 0,
1652 Qt::AlignRight | Qt::AlignVCenter);
1653 m_layout->addWidget(m_styleCombo);
1654 m_layout->addSpacing(5);
1655 m_layout->addWidget(new QLabel(tr("Size:"), this), 0,
1656 Qt::AlignRight | Qt::AlignVCenter);
1657 m_layout->addWidget(m_sizeField);
1658
1659 m_layout->addStretch();
1660
1661 setLayout(m_layout);
1662
1663 bool ret = true;
1664 ret = ret && connect(m_fontCombo, SIGNAL(activated(const QString &)), this,
1665 SLOT(onChange()));
1666 ret = ret && connect(m_styleCombo, SIGNAL(activated(const QString &)), this,
1667 SLOT(onChange()));
1668 ret = ret && connect(m_sizeField, SIGNAL(valueChanged(bool)), this,
1669 SLOT(onSizeChange(bool)));
1670 assert(ret);
1671
1672 findStyles(m_fontCombo->currentFont());
1673 }
1674
1675 //-----------------------------------------------------------------------------
1676
findStyles(const QFont & font)1677 void FontParamField::findStyles(const QFont &font) {
1678 QFontDatabase fontDatabase;
1679 QString currentItem = m_styleCombo->currentText();
1680 m_styleCombo->clear();
1681
1682 for (const QString &style : fontDatabase.styles(font.family()))
1683 m_styleCombo->addItem(style);
1684
1685 int styleIndex = m_styleCombo->findText(currentItem);
1686
1687 if (styleIndex == -1)
1688 m_styleCombo->setCurrentIndex(0);
1689 else
1690 m_styleCombo->setCurrentIndex(styleIndex);
1691 }
1692
1693 //-----------------------------------------------------------------------------
1694
onSizeChange(bool isDragging)1695 void FontParamField::onSizeChange(bool isDragging) {
1696 if (isDragging) return;
1697 onChange();
1698 }
1699
1700 //-----------------------------------------------------------------------------
1701
onChange()1702 void FontParamField::onChange() {
1703 QString family = m_fontCombo->currentFont().family();
1704
1705 TFontParamP fontParam = m_actualParam;
1706 QFont currentFont;
1707 currentFont.fromString(QString::fromStdWString(fontParam->getValue()));
1708 if (family != currentFont.family()) {
1709 findStyles(QFont(family));
1710 }
1711 QString style = m_styleCombo->currentText();
1712 int size = m_sizeField->getValue();
1713 int min, max;
1714 m_sizeField->getRange(min, max);
1715 if (size < min) size = min;
1716
1717 QFontDatabase fontDatabase;
1718 QFont font = fontDatabase.font(family, style, 10);
1719 font.setPixelSize(size);
1720
1721 TUndo *undo = 0;
1722
1723 if (fontParam && currentFont != font)
1724 undo = new FontParamFieldUndo(fontParam, m_interfaceName,
1725 ParamField::m_fxHandleStat);
1726
1727 m_actualParam->setValue(font.toString().toStdWString());
1728 emit currentParamChanged();
1729 m_currentParam->setValue(font.toString().toStdWString());
1730 emit actualParamChanged();
1731
1732 if (undo) TUndoManager::manager()->add(undo);
1733 }
1734
1735 //-----------------------------------------------------------------------------
1736
setParam(const TParamP & current,const TParamP & actual,int frame)1737 void FontParamField::setParam(const TParamP ¤t, const TParamP &actual,
1738 int frame) {
1739 m_currentParam = current;
1740 m_actualParam = actual;
1741 assert(m_currentParam);
1742 assert(m_actualParam);
1743 update(frame);
1744 }
1745
1746 //-----------------------------------------------------------------------------
1747
update(int frame)1748 void FontParamField::update(int frame) {
1749 if (!m_actualParam || !m_currentParam) return;
1750 QFont font;
1751 font.fromString(QString::fromStdWString(m_actualParam->getValue()));
1752 if (m_fontCombo->currentText() != font.family()) {
1753 m_fontCombo->setCurrentFont(font);
1754 findStyles(font);
1755 }
1756 m_styleCombo->setCurrentText(font.styleName());
1757 m_sizeField->setValue(font.pixelSize());
1758 }
1759
1760 //=============================================================================
1761 // ToneCurveParamField
1762 //-----------------------------------------------------------------------------
1763
ToneCurveParamField(QWidget * parent,QString name,const TToneCurveParamP & param)1764 ToneCurveParamField::ToneCurveParamField(QWidget *parent, QString name,
1765 const TToneCurveParamP ¶m)
1766 : AnimatedParamField<const QList<TPointD>, TToneCurveParamP>(parent, name,
1767 param, false) {
1768 QString str;
1769 m_paramName = str.fromStdString(param->getName());
1770
1771 ParamsPage *paramsPage = dynamic_cast<ParamsPage *>(parent);
1772 FxHistogramRender *fxHistogramRender =
1773 (paramsPage) ? paramsPage->getFxHistogramRender() : 0;
1774 m_toneCurveField = new ToneCurveField(this, fxHistogramRender);
1775 m_toneCurveField->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
1776
1777 //--- layout
1778 m_layout->addWidget(m_keyToggle);
1779 m_layout->addWidget(m_toneCurveField);
1780 m_layout->addStretch();
1781 setLayout(m_layout);
1782
1783 connect(m_keyToggle, SIGNAL(keyToggled()), SLOT(onKeyToggled()));
1784 connect(m_toneCurveField, SIGNAL(currentChannelIndexChanged(int)),
1785 SLOT(onChannelChanged(int)));
1786 // on enlarged, make the ParamPageSet to recompute the preferred size
1787 if (paramsPage)
1788 connect(m_toneCurveField, SIGNAL(sizeChanged()), paramsPage,
1789 SIGNAL(preferredPageSizeChanged()));
1790
1791 int i;
1792 for (i = 0; i < m_toneCurveField->getChannelCount(); i++) {
1793 ChennelCurveEditor *c = m_toneCurveField->getChannelEditor(i);
1794
1795 connect(c, SIGNAL(controlPointChanged(bool)), this, SLOT(onChange(bool)));
1796 connect(c, SIGNAL(controlPointAdded(int)), this, SLOT(onPointAdded(int)));
1797 connect(c, SIGNAL(controlPointRemoved(int)), this,
1798 SLOT(onPointRemoved(int)));
1799 }
1800 connect(m_toneCurveField, SIGNAL(isLinearChanged(bool)), this,
1801 SLOT(onIsLinearChanged(bool)));
1802 updateField(param->getValue(0));
1803 }
1804
1805 //-----------------------------------------------------------------------------
1806
updateField(const QList<TPointD> value)1807 void ToneCurveParamField::updateField(const QList<TPointD> value) {
1808 if (m_actualParam) {
1809 assert(m_currentParam && m_currentParam->getCurrentChannel() ==
1810 m_actualParam->getCurrentChannel());
1811 m_toneCurveField->setCurrentChannel(m_actualParam->getCurrentChannel());
1812 assert(m_currentParam &&
1813 m_currentParam->isLinear() == m_actualParam->isLinear());
1814 m_toneCurveField->setIsLinearCheckBox(m_actualParam->isLinear());
1815 }
1816 m_toneCurveField->getCurrentChannelEditor()->setPoints(value);
1817 }
1818
1819 //-----------------------------------------------------------------------------
1820
setParams()1821 void ToneCurveParamField::setParams() {
1822 QList<TPointD> value =
1823 m_toneCurveField->getCurrentChannelEditor()->getPoints();
1824 m_currentParam->setValue(m_frame, value);
1825 if (m_actualParam->isKeyframe(m_frame)) {
1826 m_actualParam->setValue(m_frame, value);
1827 emit actualParamChanged();
1828 } else if (!m_actualParam->hasKeyframes()) {
1829 m_actualParam->setDefaultValue(value);
1830 emit actualParamChanged();
1831 }
1832 updateKeyToggle();
1833
1834 emit currentParamChanged();
1835 }
1836
1837 //-----------------------------------------------------------------------------
1838
getPreferedSize()1839 QSize ToneCurveParamField::getPreferedSize() {
1840 if (m_toneCurveField->isEnlarged())
1841 return QSize(676, 640);
1842 else
1843 return QSize(420, 384);
1844 }
1845
1846 //-----------------------------------------------------------------------------
1847
onChannelChanged(int channel)1848 void ToneCurveParamField::onChannelChanged(int channel) {
1849 if (m_actualParam->getCurrentChannel() ==
1850 TToneCurveParam::ToneChannel(channel)) {
1851 assert(m_currentParam->getCurrentChannel() ==
1852 TToneCurveParam::ToneChannel(channel));
1853 return;
1854 }
1855 m_currentParam->setCurrentChannel(TToneCurveParam::ToneChannel(channel));
1856 m_actualParam->setCurrentChannel(TToneCurveParam::ToneChannel(channel));
1857 updateField(m_currentParam->getValue(m_frame));
1858 updateKeyToggle();
1859
1860 emit currentParamChanged();
1861 }
1862
1863 //-----------------------------------------------------------------------------
1864
onChange(bool isDragging)1865 void ToneCurveParamField::onChange(bool isDragging) {
1866 if (isDragging) return;
1867
1868 TToneCurveParamP toneCurveParam = m_actualParam;
1869
1870 TUndo *undo = 0;
1871 /*--- Undoを登録する条件：
1872 値が変更されていて
1873 キーフレーム上か、または、まだキーフレームが無い
1874 （すなわち、実際にシーンの情報を変えることになる）場合
1875 ---*/
1876 if (toneCurveParam &&
1877 toneCurveParam->getValue(m_frame) !=
1878 m_toneCurveField->getCurrentChannelEditor()->getPoints() &&
1879 (m_actualParam->isKeyframe(m_frame) ||
1880 !m_actualParam.getPointer()->hasKeyframes()))
1881 undo = new ToneCurveParamFieldUndo(toneCurveParam, m_interfaceName, m_frame,
1882 ParamField::m_fxHandleStat);
1883
1884 setParams();
1885
1886 if (undo) TUndoManager::manager()->add(undo);
1887 }
1888
1889 //-----------------------------------------------------------------------------
1890
onPointAdded(int index)1891 void ToneCurveParamField::onPointAdded(int index) {
1892 QList<TPointD> value =
1893 m_toneCurveField->getCurrentChannelEditor()->getPoints();
1894 m_currentParam->addValue(0, value, index);
1895 m_actualParam->addValue(0, value, index);
1896
1897 emit actualParamChanged();
1898 emit currentParamChanged();
1899
1900 TToneCurveParamP toneCurveActualParam = m_actualParam;
1901 TToneCurveParamP toneCurveCurrentParam = m_currentParam;
1902 if (toneCurveActualParam && toneCurveCurrentParam)
1903 TUndoManager::manager()->add(new ToneCurveParamFieldAddRemovePointUndo(
1904 toneCurveActualParam, toneCurveCurrentParam, value, index, true,
1905 m_interfaceName, ParamField::m_fxHandleStat));
1906 }
1907
1908 //-----------------------------------------------------------------------------
1909
onPointRemoved(int index)1910 void ToneCurveParamField::onPointRemoved(int index) {
1911 TToneCurveParamP toneCurveActualParam = m_actualParam;
1912 TToneCurveParamP toneCurveCurrentParam = m_currentParam;
1913 if (toneCurveActualParam && toneCurveCurrentParam) {
1914 QList<TPointD> value =
1915 m_toneCurveField->getCurrentChannelEditor()->getPoints();
1916
1917 TUndoManager::manager()->add(new ToneCurveParamFieldAddRemovePointUndo(
1918 toneCurveActualParam, toneCurveCurrentParam, value, index, false,
1919 m_interfaceName, ParamField::m_fxHandleStat));
1920 }
1921
1922 m_currentParam->removeValue(0, index);
1923 m_actualParam->removeValue(0, index);
1924
1925 emit currentParamChanged();
1926 emit actualParamChanged();
1927 }
1928
1929 //-----------------------------------------------------------------------------
1930
onIsLinearChanged(bool isLinear)1931 void ToneCurveParamField::onIsLinearChanged(bool isLinear) {
1932 m_currentParam->setIsLinear(isLinear);
1933 m_actualParam->setIsLinear(isLinear);
1934
1935 emit actualParamChanged();
1936 emit currentParamChanged();
1937
1938 TToneCurveParamP toneCurveActualParam = m_actualParam;
1939 TToneCurveParamP toneCurveCurrentParam = m_currentParam;
1940 if (toneCurveActualParam && toneCurveCurrentParam)
1941 TUndoManager::manager()->add(new ToneCurveParamFieldToggleLinearUndo(
1942 toneCurveActualParam, toneCurveCurrentParam, m_interfaceName,
1943 ParamField::m_fxHandleStat));
1944 }
1945
1946 //-----------------------------------------------------------------------------
1947
onKeyToggled()1948 void ToneCurveParamField::onKeyToggled() { onKeyToggle(); }
1949
1950 //=============================================================================
1951 // ParamField::create()
1952 //-----------------------------------------------------------------------------
1953
create(QWidget * parent,QString name,const TParamP & param)1954 ParamField *ParamField::create(QWidget *parent, QString name,
1955 const TParamP ¶m) {
1956 if (TDoubleParamP doubleParam = param)
1957 return new MeasuredDoubleParamField(parent, name, doubleParam);
1958 else if (TRangeParamP rangeParam = param)
1959 return new MeasuredRangeParamField(parent, name, rangeParam);
1960 else if (TPixelParamP pixelParam = param)
1961 return new PixelParamField(parent, name, pixelParam);
1962 else if (TPointParamP pointParam = param)
1963 return new PointParamField(parent, name, pointParam);
1964 else if (TIntEnumParamP enumParam = param)
1965 return new EnumParamField(parent, name, enumParam);
1966 else if (TIntParamP intParam = param)
1967 return new IntParamField(parent, name, intParam);
1968 else if (TBoolParamP boolParam = param)
1969 return new BoolParamField(parent, name, boolParam);
1970 else if (TSpectrumParamP spectrumParam = param)
1971 return new SpectrumParamField(parent, name, spectrumParam);
1972 else if (TStringParamP stringParam = param)
1973 return new StringParamField(parent, name, stringParam);
1974 else if (TToneCurveParamP toneCurveParam = param)
1975 return new ToneCurveParamField(parent, name, toneCurveParam);
1976 else if (TFontParamP fontParam = param)
1977 return new FontParamField(parent, name, fontParam);
1978 else
1979 return 0;
1980 }
1981
1982 //=============================================================================
1983 // Custom Components
1984 //-----------------------------------------------------------------------------
1985 #include <sstream>
1986
1987 namespace component {
1988 //
1989 // LineEdit_double
1990 //
LineEdit_double(QWidget * parent,QString name,TDoubleParamP const & param)1991 LineEdit_double::LineEdit_double(QWidget *parent, QString name,
1992 TDoubleParamP const ¶m)
1993 : ParamField(parent, name, param), frame_(0) {
1994 m_paramName = QString::fromStdString(param->getName());
1995
1996 value_ = new QLineEdit(this);
1997 value_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
1998 value_->setText(QString::number(param->getValue(0)));
1999
2000 connect(value_, SIGNAL(textChanged(QString const &)), this,
2001 SLOT(update_value(QString const &)));
2002
2003 m_layout->addWidget(value_);
2004
2005 setLayout(m_layout);
2006 }
2007
setParam(TParamP const & current,TParamP const & actual,int frame)2008 void LineEdit_double::setParam(TParamP const ¤t, TParamP const &actual,
2009 int frame) {
2010 current_ = current;
2011 actual_ = actual;
2012 update(frame);
2013 }
2014
update(int frame)2015 void LineEdit_double::update(int frame) {
2016 frame_ = frame;
2017
2018 if (!actual_ || !current_) {
2019 return;
2020 }
2021
2022 const double value = actual_->getValue(frame);
2023 if (value == value_->text().toDouble()) {
2024 return;
2025 }
2026
2027 value_->setText(QString::number(value));
2028 }
2029
update_value(QString const & text)2030 void LineEdit_double::update_value(QString const &text) {
2031 const double value = text.toDouble();
2032
2033 current_->setValue(frame_, value);
2034 emit currentParamChanged();
2035
2036 actual_->setValue(frame_, value);
2037 emit actualParamChanged();
2038 }
2039
2040 //
2041 // Slider_double
2042 //
Slider_double(QWidget * parent,QString name,TDoubleParamP const & param)2043 Slider_double::Slider_double(QWidget *parent, QString name,
2044 TDoubleParamP const ¶m)
2045 : ParamField(parent, name, param) {
2046 m_paramName = QString::fromStdString(param->getName());
2047
2048 value_ = new QSlider(Qt::Horizontal, this);
2049 value_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
2050 value_->setValue(param->getValue(0));
2051
2052 double minvalue;
2053 double maxvalue;
2054 double valuestep;
2055 if (param->getValueRange(minvalue, maxvalue, valuestep)) {
2056 value_->setRange(minvalue * 100, maxvalue * 100);
2057 }
2058
2059 connect(value_, SIGNAL(valueChanged(int)), this, SLOT(update_value(int)));
2060
2061 m_layout->addWidget(value_);
2062
2063 setLayout(m_layout);
2064 }
2065
setParam(TParamP const & current,TParamP const & actual,int frame)2066 void Slider_double::setParam(TParamP const ¤t, TParamP const &actual,
2067 int frame) {
2068 current_ = current;
2069 actual_ = actual;
2070 update(frame);
2071 }
2072
update(int frame)2073 void Slider_double::update(int frame) {
2074 frame_ = frame;
2075
2076 if (!actual_ || !current_) {
2077 return;
2078 }
2079
2080 const double value = actual_->getValue(frame);
2081 if (value == value_->value() / 100.0) {
2082 return;
2083 }
2084
2085 value_->setValue(value * 100);
2086 }
2087
update_value(int slider_value)2088 void Slider_double::update_value(int slider_value) {
2089 const double value = slider_value / 100.0;
2090
2091 current_->setValue(frame_, value);
2092 emit currentParamChanged();
2093
2094 actual_->setValue(frame_, value);
2095 emit actualParamChanged();
2096 }
2097
2098 //
2099 // SpinBox_double
2100 //
SpinBox_double(QWidget * parent,QString name,TDoubleParamP const & param)2101 SpinBox_double::SpinBox_double(QWidget *parent, QString name,
2102 TDoubleParamP const ¶m)
2103 : ParamField(parent, name, param) {
2104 m_paramName = QString::fromStdString(param->getName());
2105
2106 value_ = new QDoubleSpinBox(this);
2107 value_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
2108
2109 double minvalue;
2110 double maxvalue;
2111 double valuestep;
2112 if (param->getValueRange(minvalue, maxvalue, valuestep)) {
2113 value_->setRange(minvalue, maxvalue);
2114 value_->setSingleStep(valuestep / 100.0);
2115 }
2116
2117 connect(value_, SIGNAL(valueChanged(double)), this,
2118 SLOT(update_value(double)));
2119
2120 m_layout->addWidget(value_);
2121
2122 setLayout(m_layout);
2123 }
2124
setParam(TParamP const & current,TParamP const & actual,int frame)2125 void SpinBox_double::setParam(TParamP const ¤t, TParamP const &actual,
2126 int frame) {
2127 current_ = current;
2128 actual_ = actual;
2129 update(frame);
2130 }
2131
update(int frame)2132 void SpinBox_double::update(int frame) {
2133 frame_ = frame;
2134
2135 if (!actual_ || !current_) {
2136 return;
2137 }
2138
2139 const double value = actual_->getValue(frame);
2140 if (value == value_->value()) {
2141 return;
2142 }
2143
2144 value_->setValue(value);
2145 }
2146
update_value(double value)2147 void SpinBox_double::update_value(double value) {
2148 current_->setValue(frame_, value);
2149 emit currentParamChanged();
2150
2151 actual_->setValue(frame_, value);
2152 emit actualParamChanged();
2153 }
2154 } // end of namespace component
2155
2156 namespace component {
2157 //
2158 // LineEdit_int
2159 //
LineEdit_int(QWidget * parent,QString name,TIntParamP const & param)2160 LineEdit_int::LineEdit_int(QWidget *parent, QString name,
2161 TIntParamP const ¶m)
2162 : ParamField(parent, name, param) {
2163 m_paramName = QString::fromStdString(param->getName());
2164
2165 value_ = new QLineEdit(this);
2166 value_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
2167 value_->setText(QString::number(param->getValue()));
2168
2169 connect(value_, SIGNAL(textChanged(QString const &)), this,
2170 SLOT(update_value(QString const &)));
2171
2172 m_layout->addWidget(value_);
2173
2174 setLayout(m_layout);
2175 }
2176
setParam(TParamP const & current,TParamP const & actual,int frame)2177 void LineEdit_int::setParam(TParamP const ¤t, TParamP const &actual,
2178 int frame) {
2179 current_ = current;
2180 actual_ = actual;
2181 update(frame);
2182 }
2183
update(int frame)2184 void LineEdit_int::update(int frame) {
2185 frame_ = frame;
2186
2187 if (!actual_ || !current_) {
2188 return;
2189 }
2190
2191 const int value = actual_->getValue();
2192 if (value == value_->text().toInt()) {
2193 return;
2194 }
2195
2196 value_->setText(QString::number(value));
2197 }
2198
update_value(QString const & text)2199 void LineEdit_int::update_value(QString const &text) {
2200 const int value = text.toInt();
2201
2202 current_->setValue(value);
2203 emit currentParamChanged();
2204
2205 actual_->setValue(value);
2206 emit actualParamChanged();
2207 }
2208
2209 //
2210 // Slider_int
2211 //
Slider_int(QWidget * parent,QString name,TIntParamP const & param)2212 Slider_int::Slider_int(QWidget *parent, QString name, TIntParamP const ¶m)
2213 : ParamField(parent, name, param) {
2214 m_paramName = QString::fromStdString(param->getName());
2215
2216 value_ = new QSlider(Qt::Horizontal, this);
2217 value_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
2218 value_->setValue(param->getValue());
2219
2220 int minvalue;
2221 int maxvalue;
2222 if (param->getValueRange(minvalue, maxvalue)) {
2223 value_->setRange(minvalue, maxvalue);
2224 } else {
2225 value_->setRange(0, 100);
2226 }
2227
2228 connect(value_, SIGNAL(valueChanged(int)), this, SLOT(update_value(int)));
2229
2230 m_layout->addWidget(value_);
2231
2232 setLayout(m_layout);
2233 }
2234
setParam(TParamP const & current,TParamP const & actual,int frame)2235 void Slider_int::setParam(TParamP const ¤t, TParamP const &actual,
2236 int frame) {
2237 current_ = current;
2238 actual_ = actual;
2239 update(frame);
2240 }
2241
update(int frame)2242 void Slider_int::update(int frame) {
2243 frame_ = frame;
2244
2245 if (!actual_ || !current_) {
2246 return;
2247 }
2248
2249 const int value = actual_->getValue();
2250 if (value == value_->value()) {
2251 return;
2252 }
2253
2254 value_->setValue(value);
2255 }
2256
update_value(int value)2257 void Slider_int::update_value(int value) {
2258 current_->setValue(value);
2259 emit currentParamChanged();
2260
2261 actual_->setValue(value);
2262 emit actualParamChanged();
2263 }
2264
2265 //
2266 // SpinBox_int
2267 //
SpinBox_int(QWidget * parent,QString name,TIntParamP const & param)2268 SpinBox_int::SpinBox_int(QWidget *parent, QString name, TIntParamP const ¶m)
2269 : ParamField(parent, name, param) {
2270 m_paramName = QString::fromStdString(param->getName());
2271
2272 value_ = new QSpinBox(this);
2273 value_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
2274
2275 int minvalue;
2276 int maxvalue;
2277 if (param->getValueRange(minvalue, maxvalue)) {
2278 value_->setRange(minvalue, maxvalue);
2279 } else {
2280 value_->setRange(0, 100);
2281 }
2282
2283 connect(value_, SIGNAL(valueChanged(int)), this, SLOT(update_value(int)));
2284
2285 m_layout->addWidget(value_);
2286
2287 setLayout(m_layout);
2288 }
2289
setParam(TParamP const & current,TParamP const & actual,int frame)2290 void SpinBox_int::setParam(TParamP const ¤t, TParamP const &actual,
2291 int frame) {
2292 current_ = current;
2293 actual_ = actual;
2294 update(frame);
2295 }
2296
update(int frame)2297 void SpinBox_int::update(int frame) {
2298 frame_ = frame;
2299
2300 if (!actual_ || !current_) {
2301 return;
2302 }
2303
2304 const int value = actual_->getValue();
2305 if (value == value_->value()) {
2306 return;
2307 }
2308
2309 value_->setValue(value);
2310 }
2311
update_value(int value)2312 void SpinBox_int::update_value(int value) {
2313 current_->setValue(value);
2314 emit currentParamChanged();
2315
2316 actual_->setValue(value);
2317 emit actualParamChanged();
2318 }
2319 } // end of namespace component
2320
2321 namespace component {
2322 //
2323 // CheckBox_bool
2324 //
CheckBox_bool(QWidget * parent,QString name,TBoolParamP const & param)2325 CheckBox_bool::CheckBox_bool(QWidget *parent, QString name,
2326 TBoolParamP const ¶m)
2327 : ParamField(parent, name, param) {
2328 m_paramName = QString::fromStdString(param->getName());
2329
2330 value_ = new QCheckBox(this);
2331 value_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
2332
2333 connect(value_, SIGNAL(stateChanged(int)), this, SLOT(update_value(int)));
2334
2335 m_layout->addWidget(value_);
2336
2337 setLayout(m_layout);
2338 }
2339
setParam(TParamP const & current,TParamP const & actual,int frame)2340 void CheckBox_bool::setParam(TParamP const ¤t, TParamP const &actual,
2341 int frame) {
2342 current_ = current;
2343 actual_ = actual;
2344 update(frame);
2345 }
2346
update(int frame)2347 void CheckBox_bool::update(int frame) {
2348 frame_ = frame;
2349
2350 if (!actual_ || !current_) {
2351 return;
2352 }
2353
2354 bool const value = actual_->getValue();
2355 if (value == (value_->checkState() != Qt::Unchecked)) {
2356 return;
2357 }
2358
2359 value_->setCheckState(value ? Qt::Checked : Qt::Unchecked);
2360 }
2361
update_value(int checkbox_value)2362 void CheckBox_bool::update_value(int checkbox_value) {
2363 bool const value = checkbox_value != Qt::Unchecked;
2364
2365 current_->setValue(value);
2366 emit currentParamChanged();
2367
2368 actual_->setValue(value);
2369 emit actualParamChanged();
2370 }
2371 } // end of namespace component
2372
2373 namespace component {
2374 //
2375 // RadioButton_enum
2376 //
RadioButton_enum(QWidget * parent,QString name,TIntEnumParamP const & param)2377 RadioButton_enum::RadioButton_enum(QWidget *parent, QString name,
2378 TIntEnumParamP const ¶m)
2379 : ParamField(parent, name, param) {
2380 m_paramName = QString::fromStdString(param->getName());
2381
2382 value_ = new QButtonGroup(this);
2383
2384 for (int i = 0, count = param->getItemCount(); i < count; i++) {
2385 int item;
2386 std::string caption;
2387 param->getItem(i, item, caption);
2388
2389 QRadioButton *button = new QRadioButton(caption.c_str(), this);
2390 button->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
2391 value_->addButton(button, item);
2392 m_layout->addWidget(button);
2393 }
2394
2395 connect(value_, SIGNAL(buttonClicked(int)), this, SLOT(update_value(int)));
2396
2397 setLayout(m_layout);
2398 }
2399
setParam(TParamP const & current,TParamP const & actual,int frame)2400 void RadioButton_enum::setParam(TParamP const ¤t, TParamP const &actual,
2401 int frame) {
2402 current_ = current;
2403 actual_ = actual;
2404 update(frame);
2405 }
2406
update(int frame)2407 void RadioButton_enum::update(int frame) {
2408 frame_ = frame;
2409
2410 if (!actual_ || !current_) {
2411 return;
2412 }
2413
2414 const int value = actual_->getValue();
2415 if (value == value_->checkedId()) {
2416 return;
2417 }
2418
2419 value_->button(value)->setChecked(true);
2420 }
2421
update_value(int value)2422 void RadioButton_enum::update_value(int value) {
2423 current_->setValue(value);
2424 emit currentParamChanged();
2425
2426 actual_->setValue(value);
2427 emit actualParamChanged();
2428 }
2429
2430 //
2431 // ComboBox_enum
2432 //
ComboBox_enum(QWidget * parent,QString name,TIntEnumParamP const & param)2433 ComboBox_enum::ComboBox_enum(QWidget *parent, QString name,
2434 TIntEnumParamP const ¶m)
2435 : ParamField(parent, name, param) {
2436 m_paramName = QString::fromStdString(param->getName());
2437
2438 value_ = new QComboBox(this);
2439 value_->setFixedHeight(20);
2440 value_->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
2441
2442 for (int i = 0, count = param->getItemCount(); i < count; i++) {
2443 int item;
2444 std::string caption;
2445 param->getItem(i, item, caption);
2446
2447 value_->addItem(QString::fromStdString(caption));
2448 }
2449
2450 connect(value_, SIGNAL(currentIndexChanged(int)), this,
2451 SLOT(update_value(int)));
2452
2453 setLayout(m_layout);
2454 }
2455
setParam(TParamP const & current,TParamP const & actual,int frame)2456 void ComboBox_enum::setParam(TParamP const ¤t, TParamP const &actual,
2457 int frame) {
2458 current_ = current;
2459 actual_ = actual;
2460 update(frame);
2461 }
2462
update(int frame)2463 void ComboBox_enum::update(int frame) {
2464 frame_ = frame;
2465
2466 if (!actual_ || !current_) {
2467 return;
2468 }
2469
2470 const int value = actual_->getValue();
2471 if (value == value_->currentIndex()) {
2472 return;
2473 }
2474
2475 value_->setCurrentIndex(value);
2476 }
2477
update_value(int value)2478 void ComboBox_enum::update_value(int value) {
2479 current_->setValue(value);
2480 emit currentParamChanged();
2481
2482 actual_->setValue(value);
2483 emit actualParamChanged();
2484 }
2485 } // end of namespace component
2486
2487 namespace component {
2488 //
2489 // LineEdit_string
2490 //
LineEdit_string(QWidget * parent,QString name,TStringParamP const & param)2491 LineEdit_string::LineEdit_string(QWidget *parent, QString name,
2492 TStringParamP const ¶m)
2493 : ParamField(parent, name, param), frame_(0) {
2494 m_paramName = QString::fromStdString(param->getName());
2495
2496 value_ = new QLineEdit(this);
2497 value_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
2498 value_->setText(QString::fromStdWString(param->getValue()));
2499
2500 connect(value_, SIGNAL(textChanged(QString const &)), this,
2501 SLOT(update_value(QString const &)));
2502
2503 m_layout->addWidget(value_);
2504
2505 setLayout(m_layout);
2506 }
2507
setParam(TParamP const & current,TParamP const & actual,int frame)2508 void LineEdit_string::setParam(TParamP const ¤t, TParamP const &actual,
2509 int frame) {
2510 current_ = current;
2511 actual_ = actual;
2512 update(frame);
2513 }
2514
update(int frame)2515 void LineEdit_string::update(int frame) {
2516 frame_ = frame;
2517
2518 if (!actual_ || !current_) {
2519 return;
2520 }
2521
2522 QString const value = QString::fromStdWString(actual_->getValue());
2523 if (value == value_->text()) {
2524 return;
2525 }
2526
2527 value_->setText(value);
2528 }
2529
update_value(QString const & text)2530 void LineEdit_string::update_value(QString const &text) {
2531 std::wstring const value = text.toStdWString();
2532
2533 current_->setValue(value);
2534 emit currentParamChanged();
2535
2536 actual_->setValue(value);
2537 emit actualParamChanged();
2538 }
2539 } // end of namespace component
2540
make_lineedit(QWidget * parent,QString name,TParamP const & param)2541 ParamField *make_lineedit(QWidget *parent, QString name, TParamP const ¶m) {
2542 if (0)
2543 ;
2544 else if (TDoubleParamP _ = param) {
2545 return new component::LineEdit_double(parent, name, _);
2546 } else if (TIntParamP _ = param) {
2547 return new component::LineEdit_int(parent, name, _);
2548 } else if (TStringParamP _ = param) {
2549 return new component::LineEdit_string(parent, name, _);
2550 }
2551
2552 return NULL;
2553 }
2554
make_slider(QWidget * parent,QString name,TParamP const & param)2555 ParamField *make_slider(QWidget *parent, QString name, TParamP const ¶m) {
2556 if (0)
2557 ;
2558 else if (TDoubleParamP _ = param) {
2559 return new component::Slider_double(parent, name, _);
2560 } else if (TIntParamP _ = param) {
2561 return new component::Slider_int(parent, name, _);
2562 }
2563
2564 return NULL;
2565 }
2566
make_spinbox(QWidget * parent,QString name,TParamP const & param)2567 ParamField *make_spinbox(QWidget *parent, QString name, TParamP const ¶m) {
2568 if (0)
2569 ;
2570 else if (TDoubleParamP _ = param) {
2571 return new component::SpinBox_double(parent, name, _);
2572 } else if (TIntParamP _ = param) {
2573 return new component::SpinBox_int(parent, name, _);
2574 }
2575
2576 return NULL;
2577 }
2578
make_checkbox(QWidget * parent,QString name,TParamP const & param)2579 ParamField *make_checkbox(QWidget *parent, QString name, TParamP const ¶m) {
2580 if (0)
2581 ;
2582 else if (TBoolParamP _ = param) {
2583 return new component::CheckBox_bool(parent, name, _);
2584 }
2585
2586 return NULL;
2587 }
2588
make_radiobutton(QWidget * parent,QString name,TParamP const & param)2589 ParamField *make_radiobutton(QWidget *parent, QString name,
2590 TParamP const ¶m) {
2591 if (0)
2592 ;
2593 else if (TIntEnumParamP _ = param) {
2594 return new component::RadioButton_enum(parent, name, _);
2595 }
2596
2597 return NULL;
2598 }
2599
make_combobox(QWidget * parent,QString name,TParamP const & param)2600 ParamField *make_combobox(QWidget *parent, QString name, TParamP const ¶m) {
2601 if (0)
2602 ;
2603 else if (TIntEnumParamP _ = param) {
2604 return new component::ComboBox_enum(parent, name, _);
2605 }
2606
2607 return NULL;
2608 }
2609