1 #ifndef MESHLAB_XMLSTDPARDIALOG 2 #define MESHLAB_XMLSTDPARDIALOG 3 4 #include "../common/xmlfilterinfo.h" 5 #include "../common/scriptinterface.h" 6 #include "../common/interfaces.h" 7 #include "../common/mlexception.h" 8 #include<QCheckBox> 9 #include<QPushButton> 10 #include<QRadioButton> 11 #include<QSpinBox> 12 #include<QTableWidget> 13 #include<QComboBox> 14 #include<QHBoxLayout> 15 #include<QGridLayout> 16 #include<QDockWidget> 17 #include<QTextEdit> 18 #include<QLabel> 19 #include "qstyleoption.h" 20 #include "additionalgui.h" 21 22 class XMLWidgetException : public MLException 23 { 24 public: XMLWidgetException(const QString & text)25 XMLWidgetException(const QString& text) 26 :MLException(QString("XML Widget Error: ") + text){} 27 throw()28 ~XMLWidgetException() throw() {} 29 }; 30 31 class XMLPersistenToolbox : public QFrame 32 { 33 Q_OBJECT 34 public: 35 XMLPersistenToolbox(QWidget* parent); ~XMLPersistenToolbox()36 ~XMLPersistenToolbox() {} 37 38 private slots: 39 void saveClicked(); 40 void loadClicked(); 41 42 signals: 43 void saveRequested(); 44 void loadRequested(); 45 }; 46 47 class XMLMeshLabWidget : public QWidget 48 { 49 Q_OBJECT 50 public: 51 //WARNING! This constructor could rise up a set of MeshLabExceptions! this does it mean that the object COULD BE NOT correctly constructed! 52 XMLMeshLabWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* parent); 53 // bring the values from the Qt widgets to the parameter (e.g. from the checkBox to the parameter). 54 //virtual void collectWidgetValue() = 0; 55 //void reset(); 56 virtual void set(const QString& nwExpStr) = 0; 57 58 virtual QString getWidgetExpression() = 0; 59 //virtual void updateWidget(const XMLFilterInfo::XMLMap& xmlWidgetTag) = 0; 60 void setVisibility(const bool vis); 61 virtual void updateVisibility(const bool vis) = 0; 62 ~XMLMeshLabWidget()63 virtual ~XMLMeshLabWidget() {} helpLabel()64 inline QLabel* helpLabel() {return helpLab;} 65 66 virtual void addWidgetToGridLayout(QGridLayout* lay,const int r); 67 68 bool isImportant; 69 // called when the user press the 'default' button to reset the parameter values to its default. 70 // It just set the parameter value and then it calls the specialized resetWidgetValue() to update also the widget. 71 //void resetValue(); 72 // update the parameter with the current widget values and return it. 73 //Value& getWidgetValue(); 74 75 signals: 76 void parameterChanged(); 77 void savePersistentParameterValueRequested(QString name); 78 void loadPersistentParameterValueRequested(QString name); 79 //void widgetEvaluateExpression(const Expression& exp,Value** res); 80 //void insertParamInEnv(const QString& paramName,Expression* paramExp); 81 82 //int row; 83 //QGridLayout* gridLay; 84 private slots: 85 void savePersistentParameterValue(); 86 void loadPersistentParameterValue(); 87 protected: 88 QLabel* helpLab; 89 EnvWrap env; 90 XMLPersistenToolbox* perstb; 91 QString parname; 92 /*const XMLFilterInfo::XMLMap& map;*/ 93 //QLineEdit* lExprEditor; 94 //QTextEdit* tExprEditor; 95 }; 96 97 class XMLMeshLabWidgetFactory 98 { 99 public: 100 //WARNING! this function call constructors that could rise up a set of MeshLabExceptions but it is not able to manage it, so let the exceptions floating up! 101 //IN ANY CASE the callee MUST check if the returned value is not NULL. 102 static XMLMeshLabWidget* create(const MLXMLPluginInfo::XMLMap& widgetTable,EnvWrap& env,MeshDocument* md,QWidget* parent); 103 }; 104 105 // 106 class XMLCheckBoxWidget : public XMLMeshLabWidget 107 { 108 Q_OBJECT 109 public: 110 XMLCheckBoxWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* parent); 111 ~XMLCheckBoxWidget(); 112 113 // bring the values from the Qt widgets to the parameter (e.g. from the checkBox to the parameter). 114 void set(const QString& nwExpStr); 115 //void updateWidget(const XMLFilterInfo::XMLMap& xmlWidgetTag); 116 void updateVisibility(const bool vis); 117 QString getWidgetExpression(); 118 119 void addWidgetToGridLayout(QGridLayout* lay,const int r); 120 121 private: 122 //WHY WE NEED THIS FUNCTION? 123 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 124 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 125 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 126 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 127 //updateVisibility. 128 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 129 void setVisibility(const bool vis); 130 QCheckBox* cb; 131 }; 132 // 133 // 134 135 class XMLEditWidget : public XMLMeshLabWidget 136 { 137 Q_OBJECT 138 public: 139 XMLEditWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* parent); 140 ~XMLEditWidget(); 141 142 void set(const QString& nwExpStr); 143 //void updateWidget(const XMLFilterInfo::XMLMap& xmlWidgetTag); 144 void updateVisibility(const bool vis); 145 QString getWidgetExpression(); 146 147 void addWidgetToGridLayout(QGridLayout* lay,const int r); 148 private slots: 149 // void tooltipEvaluation(); 150 private: 151 //WHY WE NEED THIS FUNCTION? 152 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 153 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 154 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 155 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 156 //updateVisibility. 157 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 158 void setVisibility(const bool vis); 159 160 QHBoxLayout* hlay; 161 QLabel* fieldDesc; 162 QLineEdit* lineEdit; 163 }; 164 165 class XMLStringWidget : public XMLMeshLabWidget 166 { 167 Q_OBJECT 168 public: 169 XMLStringWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* parent); 170 ~XMLStringWidget(); 171 172 void set(const QString& nwExpStr); 173 //void updateWidget(const XMLFilterInfo::XMLMap& xmlWidgetTag); 174 void updateVisibility(const bool vis); 175 176 /*WARNING!!!! In order to be coherent with the scripting evaluation environment at the value of the XMLStringWidget a pair of double quotes is added at the beginning and at the end of the string*/ 177 /*The best, and safest way to remove them (if they are not needed), is to let the scripting environment to evaluate the resulting string: Env e; QString st = e.evaluate(string_widg->getWidgetExpr).toString(); */ 178 179 QString getWidgetExpression(); 180 181 void addWidgetToGridLayout(QGridLayout* lay,const int r); 182 private slots: 183 // void tooltipEvaluation(); 184 private: 185 //WHY WE NEED THIS FUNCTION? 186 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 187 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 188 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 189 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 190 //updateVisibility. 191 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 192 void setVisibility(const bool vis); 193 QHBoxLayout* hlay; 194 QLabel* fieldDesc; 195 QLineEdit* lineEdit; 196 }; 197 198 199 class XMLAbsWidget : public XMLMeshLabWidget 200 { 201 Q_OBJECT 202 public: 203 XMLAbsWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* parent); 204 ~XMLAbsWidget(); 205 206 void set(const QString& nwExpStr); 207 //void updateWidget(const XMLFilterInfo::XMLMap& xmlWidgetTag); 208 void updateVisibility(const bool vis); 209 QString getWidgetExpression(); 210 211 void addWidgetToGridLayout(QGridLayout* lay,const int r); 212 213 public slots: 214 void on_absSB_valueChanged(double newv); 215 void on_percSB_valueChanged(double newv); 216 217 signals: 218 void dialogParamChanged(); 219 220 private: 221 //WHY WE NEED THIS FUNCTION? 222 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 223 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 224 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 225 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 226 //updateVisibility. 227 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 228 void setVisibility(const bool vis); 229 QLabel* fieldDesc; 230 float m_min; 231 float m_max; 232 QLabel *absLab; 233 QLabel *percLab; 234 235 QDoubleSpinBox *absSB; 236 QDoubleSpinBox *percSB; 237 QGridLayout* glay; 238 }; 239 240 class XMLVec3Widget : public XMLMeshLabWidget 241 { 242 Q_OBJECT 243 public: 244 XMLVec3Widget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p); 245 ~XMLVec3Widget(); 246 QString paramName; 247 248 void set(const QString& nwExpStr); 249 //void updateWidget(const XMLFilterInfo::XMLMap& xmlWidgetTag); 250 void updateVisibility(const bool vis); 251 QString getWidgetExpression(); 252 253 void addWidgetToGridLayout(QGridLayout* lay,const int r); 254 255 public slots: 256 void getPoint(); 257 void setPoint( const QString& name,const vcg::Point3f& p ); 258 void setShot(const QString& name,const vcg::Shotf& val ); 259 signals: 260 void askViewDir(QString); 261 void askViewPos(QString); 262 void askSurfacePos(QString); 263 void askCameraPos(QString); 264 void askTrackballPos(QString); 265 void setExp(const QString& name,const QString& exp ); 266 protected: 267 QLineEdit * coordSB[3]; 268 QComboBox *getPoint3Combo; 269 QPushButton *getPoint3Button; 270 QLabel* descLab; 271 QWidget* curr_gla; 272 QHBoxLayout* hlay; 273 274 private: 275 //WHY WE NEED THIS FUNCTION? 276 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 277 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 278 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 279 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 280 //updateVisibility. 281 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 282 void setVisibility(const bool vis); 283 }; 284 285 class XMLColorWidget : public XMLMeshLabWidget 286 { 287 Q_OBJECT 288 289 QPushButton* colorButton; 290 QLabel* colorLabel; 291 QLabel* descLabel; 292 QColor pickcol; 293 294 public: 295 XMLColorWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p); 296 ~XMLColorWidget(); 297 298 void set(const QString& nwExpStr); 299 //void updateWidget(const XMLFilterInfo::XMLMap& xmlWidgetTag); 300 void updateVisibility(const bool vis); 301 QString getWidgetExpression(); 302 void addWidgetToGridLayout(QGridLayout* lay,const int r); 303 304 private: 305 //WHY WE NEED THIS FUNCTION? 306 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 307 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 308 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 309 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 310 //updateVisibility. 311 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 312 void setVisibility(const bool vis); 313 void updateColorInfo(const QColor& col); 314 QHBoxLayout* hlay; 315 316 signals: 317 void dialogParamChanged(); 318 private slots: 319 void pickColor(); 320 }; 321 322 class XMLSliderWidget : public XMLMeshLabWidget 323 { 324 Q_OBJECT 325 signals: 326 void dialogParamChanged(); 327 public: 328 XMLSliderWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p); 329 ~XMLSliderWidget(); 330 void set(const QString& nwExpStr); 331 void updateVisibility(const bool vis); 332 QString getWidgetExpression(); 333 void addWidgetToGridLayout(QGridLayout* lay,const int r); 334 335 public slots: 336 void setValue(int newv); 337 void setValue(); 338 void setValue(float newValue); 339 340 private: 341 //WHY WE NEED THIS FUNCTION? 342 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 343 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 344 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 345 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 346 //updateVisibility. 347 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 348 void setVisibility(const bool vis); 349 float intToFloat(int val); 350 int floatToInt(float val); 351 QLineEdit *valueLE; 352 QSlider *valueSlider; 353 QLabel* fieldDesc; 354 QHBoxLayout* hlay; 355 float minVal; 356 float maxVal; 357 }; 358 359 class XMLComboWidget : public XMLMeshLabWidget 360 { 361 Q_OBJECT 362 protected: 363 QComboBox *enumCombo; 364 QLabel *enumLabel; 365 QHBoxLayout* hlay; 366 367 public: 368 XMLComboWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p); 369 ~XMLComboWidget(); 370 void updateVisibility(const bool vis); 371 virtual QString getWidgetExpression(); set(const QString &)372 virtual void set(const QString &) {} 373 void addWidgetToGridLayout(QGridLayout* lay,const int r); 374 375 private: 376 //WHY WE NEED THIS FUNCTION? 377 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 378 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 379 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 380 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 381 //updateVisibility. 382 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 383 void setVisibility(const bool vis); 384 385 signals: 386 void dialogParamChanged(); 387 }; 388 389 class XMLEnumWidget : public XMLComboWidget 390 { 391 Q_OBJECT 392 393 public: 394 XMLEnumWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p); ~XMLEnumWidget()395 ~XMLEnumWidget(){}; 396 397 QString getWidgetExpression(); 398 void set(const QString&); 399 private: 400 QMap<int, QString> mp; 401 }; 402 403 class XMLMeshWidget : public XMLEnumWidget 404 { 405 Q_OBJECT 406 407 public: 408 XMLMeshWidget(MeshDocument* mdoc,const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p); ~XMLMeshWidget()409 ~XMLMeshWidget(){}; 410 411 private: 412 MeshDocument* md; 413 }; 414 415 class XMLShotWidget : public XMLMeshLabWidget 416 { 417 Q_OBJECT 418 419 public: 420 XMLShotWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p); ~XMLShotWidget()421 ~XMLShotWidget(){}; 422 void updateVisibility(const bool vis); 423 void set(const QString & expr); 424 425 QString paramName; 426 427 QString getWidgetExpression(); 428 void addWidgetToGridLayout(QGridLayout* lay,const int r); 429 430 public slots: 431 void getShot(); 432 void setShotValue(QString name, Shotm val); 433 signals: 434 void askRasterShot(QString); 435 void askMeshShot(QString); 436 void askViewerShot(QString); 437 void dialogParamChanged(); 438 439 protected: 440 QWidget *gla_curr; 441 Shotm curShot; 442 //QLineEdit * shotLE; 443 QComboBox *getShotCombo; 444 QLabel* descLab; 445 QPushButton* getShotButton; 446 QHBoxLayout* hlay; 447 448 private: 449 //WHY WE NEED THIS FUNCTION? 450 //IN C++ IS NOT HEALTHY AT ALL TO CALL A VIRTUAL FUNCTION FROM OBJECT CONSTRUCTOR. 451 //SO I CANNOT CALL DIRECTLY THE updateVisibility FUNCTION. 452 //THIS THING HAS AS CONSEQUENCE THAT I HAVE TO PASTE AND COPY THE updateVisibility CODE INSIDE THE CONSTRUCTOR. 453 //TO AVOID THIS FOR EACH WIDGET WE ADD A setVisibility FUNCTION (OBVIOUSLY NOT VIRTUAL) WITH THE CODE THAT WE SHOULD PUT INSIDE THE 454 //updateVisibility. 455 //THE CODE OF VIRTUAL FUNCTION updateVisibility WILL BE ONLY A CALL TO THE NON VIRTUAL FUNCTION setVisibility. 456 void setVisibility(const bool vis); 457 }; 458 459 class XMLStdParFrame : public QFrame 460 { 461 Q_OBJECT 462 public: 463 XMLStdParFrame(QWidget *p,QWidget *gla=0); 464 ~XMLStdParFrame(); 465 void loadFrameContent(const MeshLabXMLFilterContainer& filtcont, EnvWrap& envir, MeshDocument* md); 466 void extendedView(bool ext,bool help); 467 bool setValue(const QString& name, const QString& val); 468 bool getValue(const QString& name, QString& val); 469 470 void toggleHelp(const bool help); 471 472 QWidget *curr_gla; // used for having a link to the glarea that spawned the parameter asking. 473 signals: 474 void parameterChanged(); 475 void savePersistentParameterValueRequested(QString name, QString value); 476 void loadPersistentParameterValueRequested(QString name); 477 478 private slots: 479 void savePersistentParameterValue(QString name); 480 private: 481 QMap<QString, XMLMeshLabWidget*> xmlfieldwidgets; 482 QMap<QString, QLabel *> helpList; 483 bool extended; 484 485 }; 486 487 class MeshLabXMLStdDialog : public QDockWidget 488 { 489 Q_OBJECT 490 491 public: 492 MeshLabXMLStdDialog(QWidget *p); 493 ~MeshLabXMLStdDialog(); 494 495 void clearValues(); 496 void createFrame(); 497 void loadFrameContent(); 498 499 bool showAutoDialog(MeshLabXMLFilterContainer& mfc, PluginManager& pm, MeshDocument * md, MainWindowInterface *mwi, QWidget *gla=0); 500 bool isPreviewable() const; 501 void closeEvent ( QCloseEvent * event ); 502 void resetPointers(); 503 MeshModel *curModel; 504 //void dialogEvaluateExpression(const Expression& exp,Value** res); 505 //void expandView(bool exp); 506 507 MeshDocument * curMeshDoc; 508 private slots: 509 void applyClick(); 510 void closeClick(); 511 void resetExpressions(); 512 void toggleHelp(); 513 void togglePreview(); 514 void applyDynamic(); 515 void changeCurrentMesh(int meshInd); 516 void extendedView(bool ext); 517 void postFilterExecution(); 518 void loadPersistent(QString name); 519 void savePersistent(QString name, QString expr); 520 521 private: 522 void startFilterExecution(); 523 void setDialogStateRelativeToFilterExecution(const bool isfilterinexecution); 524 static QString applyButtonLabel(const bool applystate); 525 526 bool isfilterexecuting; 527 528 Env env; 529 QFrame *qf; 530 XMLStdParFrame *stdParFrame; 531 //QAction *curAction; 532 MeshModelState meshState; 533 MeshModelState meshCacheState; 534 QCheckBox *previewCB; 535 QWidget * curgla; 536 uint curmask; 537 MeshLabXMLFilterContainer* curmfc; 538 MainWindowInterface *curmwi; 539 MLXMLPluginInfo::XMLMapList curParMap; 540 //XMLFilterInfo::XMLMapList prevParMap; 541 QString applyContext; 542 QString previewContext; 543 bool validcache; 544 bool showHelp; 545 //we have to change the button caption when the filter has been launched for execution 546 QPushButton *applyButton; 547 QPushButton *helpButton; 548 QPushButton *closeButton; 549 QPushButton *defaultButton; 550 551 signals: 552 void filterInterrupt(const bool isinterruptrequested); 553 void filterParametersEvaluated(const QString& fnmame,const QMap<QString,QString>& parvalue); 554 }; 555 556 // This class provide a modal dialog box for asking a generic parameter set 557 // It can be used by anyone needing for some values in a structured form and having some integrated help 558 class OldScriptingSystemXMLParamDialog: public QDialog 559 { 560 Q_OBJECT 561 public: 562 OldScriptingSystemXMLParamDialog(QMap<QString,QString>& currparamvalues,MeshLabXMLFilterContainer& mfc, PluginManager& pm, MeshDocument * md, MainWindowInterface *mwi, QWidget* p, QWidget *gla=0); 563 ~OldScriptingSystemXMLParamDialog(); 564 565 566 void createFrame(); 567 568 public slots: 569 void getAccept(); 570 void toggleHelp(); 571 //reset the values on the gui back to the ones originally given to the dialog 572 void resetValues(); 573 //signals: 574 // void newParamValues(const QString fname, const QMap<QString,QString> pvals); 575 private: 576 Env _env; 577 QMap<QString,QString>& _paramvalues; 578 XMLStdParFrame* _stdparframe; 579 MeshLabXMLFilterContainer& _mfc; 580 PluginManager& _pm; 581 MeshDocument *_meshdocument; 582 MainWindowInterface* _mwi; 583 QWidget* _gla; 584 bool _showhelp; 585 }; 586 587 #endif 588