1 #include "xmlstdpardialog.h"
2 #include <climits>
3 #include <QColorDialog>
4 #include <QFileDialog>
5 #include <QDialogButtonBox>
6 #include "mainwindow.h"
7
updateRenderingData(GLArea * glarea,MeshModel * curmodel)8 static void updateRenderingData(GLArea* glarea, MeshModel* curmodel)
9 {
10 MLSceneGLSharedDataContext* shar = glarea->getSceneGLSharedContext();
11 if (shar != NULL)
12 {
13 shar->meshAttributesUpdated(curmodel->id(), true, MLRenderingData::RendAtts(true));
14 shar->manageBuffers(curmodel->id());
15 }
16 }
17
MeshLabXMLStdDialog(QWidget * p)18 MeshLabXMLStdDialog::MeshLabXMLStdDialog(QWidget *p)
19 :QDockWidget(QString("Plugin"), p),isfilterexecuting(false),env(),previewCB(nullptr),showHelp(false)
20 {
21 curmask = 0;
22 qf = NULL;
23 stdParFrame=NULL;
24 clearValues();
25 }
26
~MeshLabXMLStdDialog()27 MeshLabXMLStdDialog::~MeshLabXMLStdDialog()
28 {
29
30 }
31
clearValues()32 void MeshLabXMLStdDialog::clearValues()
33 {
34 //curAction = NULL;
35 curModel = NULL;
36 curmfc = NULL;
37 curmwi = NULL;
38 }
39
createFrame()40 void MeshLabXMLStdDialog::createFrame()
41 {
42 if(qf) delete qf;
43
44 QFrame *newqf= new QFrame(this);
45 setWidget(newqf);
46 qf = newqf;
47 }
48
loadFrameContent()49 void MeshLabXMLStdDialog::loadFrameContent()
50 {
51 assert(qf);
52 // qf->hide();
53 QLabel *ql;
54
55
56 QGridLayout *gridLayout = new QGridLayout(qf);
57 QString fname(curmfc->filterName());
58 setWindowTitle(fname);
59 ql = new QLabel("<i>"+curmfc->xmlInfo->filterHelp(fname)+"</i>",qf);
60 ql->setTextFormat(Qt::RichText);
61 ql->setWordWrap(true);
62 gridLayout->addWidget(ql,0,0,1,2,Qt::AlignTop); // this widgets spans over two columns.
63
64 stdParFrame = new XMLStdParFrame(this,curgla);
65 connect(stdParFrame, SIGNAL(savePersistentParameterValueRequested(QString, QString)), this, SLOT(savePersistent(QString, QString)));
66 connect(stdParFrame, SIGNAL(loadPersistentParameterValueRequested(QString)), this, SLOT(loadPersistent(QString)));
67
68 EnvWrap wrap(env);
69 stdParFrame->loadFrameContent(*curmfc, wrap, curMeshDoc);
70 gridLayout->addWidget(stdParFrame,1,0,1,2);
71
72 //int buttonRow = 2; // the row where the line of buttons start
73
74 helpButton = new QPushButton("Help", qf);
75 closeButton = new QPushButton("Close", qf);
76 applyButton = new QPushButton("Apply", qf);
77 defaultButton = new QPushButton("Default", qf);
78 applyButton->setFocus();
79 #ifdef Q_OS_MAC
80 // Hack needed on mac for correct sizes of button in the bottom of the dialog.
81 helpButton->setStyleSheet("QPushButton {min-height: 30px; } ");
82 closeButton->setStyleSheet("QPushButton {min-height: 30px; }");
83 applyButton->setStyleSheet("QPushButton {min-height: 30px; }");
84 defaultButton->setStyleSheet("QPushButton {min-height: 30px; }");
85 #endif
86 bool onlyimportant = true;
87 connect(this->parentWidget(),SIGNAL(filterExecuted()),this,SLOT(postFilterExecution()));
88 QString postCond = curmfc->xmlInfo->filterAttribute(fname,MLXMLElNames::filterPostCond);
89 QStringList postCondList = postCond.split(QRegExp("\\W+"), QString::SkipEmptyParts);
90 curmask = MeshLabFilterInterface::convertStringListToMeshElementEnum(postCondList);
91 if(isPreviewable())
92 {
93 previewCB = new QCheckBox("Preview", qf);
94 previewCB->setCheckState(Qt::Unchecked);
95 gridLayout->addWidget(previewCB, gridLayout->rowCount(),0,Qt::AlignBottom);
96 connect(previewCB,SIGNAL(toggled(bool)),this,SLOT( togglePreview() ));
97 //buttonRow++;
98 }
99
100 connect(helpButton,SIGNAL(clicked()),this,SLOT(toggleHelp()));
101 connect(closeButton,SIGNAL(clicked()),this,SLOT(closeClick()));
102 connect(defaultButton,SIGNAL(clicked()),this,SLOT(resetExpressions()));
103 connect(applyButton,SIGNAL(clicked()),this,SLOT(applyClick()));
104
105 MLXMLPluginInfo::XMLMapList mplist = curmfc->xmlInfo->filterParametersExtendedInfo(curmfc->filterName());
106 foreach(MLXMLPluginInfo::XMLMap mp,mplist)
107 {
108 bool important = (wrap.evalBool(mp[MLXMLElNames::paramIsImportant]));
109 onlyimportant &= important;
110 }
111 if (!onlyimportant)
112 {
113 ExpandButtonWidget* exp = new ExpandButtonWidget(qf);
114 connect(exp,SIGNAL(expandView(bool)),this,SLOT(extendedView(bool)));
115 gridLayout->addWidget(exp,gridLayout->rowCount(),0,1,2,Qt::AlignJustify);
116 }
117 int firstButLine = gridLayout->rowCount();
118 gridLayout->addWidget(helpButton, firstButLine,1,Qt::AlignBottom);
119 gridLayout->addWidget(defaultButton,firstButLine,0,Qt::AlignBottom);
120 int secButLine = gridLayout->rowCount();
121 gridLayout->addWidget(closeButton, secButLine,0,Qt::AlignBottom);
122 gridLayout->addWidget(applyButton, secButLine,1,Qt::AlignBottom);
123
124 qf->setLayout(gridLayout);
125 qf->showNormal();
126 this->showNormal();
127 }
128
showAutoDialog(MeshLabXMLFilterContainer & mfc,PluginManager & pm,MeshDocument * md,MainWindowInterface * mwi,QWidget * gla)129 bool MeshLabXMLStdDialog::showAutoDialog(MeshLabXMLFilterContainer& mfc,PluginManager& pm,MeshDocument * md, MainWindowInterface *mwi, QWidget *gla/*=0*/ )
130 {
131 /*if (mfc.filterInterface == NULL)
132 return false;*/
133 curMeshDoc = md;
134 if (curMeshDoc == NULL)
135 return false;
136 if (mfc.xmlInfo == NULL)
137 return false;
138 if (mfc.act == NULL)
139 return false;
140
141 validcache = false;
142 //curAction=mfc.act;
143 curmfc=&mfc;
144 curmwi=mwi;
145 curParMap.clear();
146 //prevParMap.clear();
147 curModel = md->mm();
148 curgla=gla;
149
150 QString fname = mfc.act->text();
151
152 curParMap = mfc.xmlInfo->filterParametersExtendedInfo(fname);
153 //curmask = mfc->xmlInfo->filterAttribute(mfc->act->text(),QString("postCond"));
154 if(curParMap.isEmpty() && !isPreviewable())
155 return false;
156
157 GLArea* tmpgl = qobject_cast<GLArea*>(curgla);
158
159 if ((tmpgl != NULL) && (tmpgl->mw() != NULL))
160 {
161 QMap<QString, QString> persistentparam;
162 foreach(RichParameter* rp, tmpgl->mw()->currentGlobalPars().paramList)
163 {
164 if ((rp != NULL) && (rp->isDerivedFromXMLParam()))
165 persistentparam[rp->name] = RichParameterAdapter::convertToStringValue(*rp);
166 }
167
168 env.loadMLScriptEnv(*md, pm, persistentparam);
169 }
170 else
171 env.loadMLScriptEnv(*md, pm);
172
173 QElapsedTimer tt;
174 tt.start();
175 createFrame();
176 loadFrameContent();
177
178 curMeshDoc->Log.Logf(GLLogStream::SYSTEM,"GUI created in %i msec",tt.elapsed());
179 //QString postCond = mfc.xmlInfo->filterAttribute(fname,MLXMLElNames::filterPostCond);
180 //QStringList postCondList = postCond.split(QRegExp("\\W+"), QString::SkipEmptyParts);
181 //curmask = MeshLabFilterInterface::convertStringListToMeshElementEnum(postCondList);
182 if(isPreviewable())
183 {
184 meshState.create(curmask, curModel);
185 connect(stdParFrame,SIGNAL(parameterChanged()), this, SLOT(applyDynamic()));
186 }
187 connect(curMeshDoc, SIGNAL(currentMeshChanged(int)),this, SLOT(changeCurrentMesh(int)));
188 raise();
189 activateWindow();
190 return true;
191 }
192
applyClick()193 void MeshLabXMLStdDialog::applyClick()
194 {
195 if (stdParFrame == NULL)
196 throw MLException("MeshLabXMLStdDialog: stdParFrame is NULL. It should not happen!");
197
198 if ((curmfc == NULL) || (!curmfc->isValid()))
199 throw MLException("MeshLabXMLStdDialog: curmfc is NULL and/or not valid. It should not happen!");
200
201 QString fname = curmfc->act->text();
202 if ((isfilterexecuting) && (curmfc->xmlInfo->filterAttribute(fname,MLXMLElNames::filterIsInterruptible) == "true"))
203 {
204 emit filterInterrupt(true);
205 return;
206 }
207
208 QMap<QString,QString> parvalue;
209
210 for(int ii = 0;ii < curParMap.size();++ii)
211 {
212 QString exp;
213
214 bool valid = stdParFrame->getValue(curParMap[ii][MLXMLElNames::paramName], exp);
215 if (!valid)
216 {
217 QString err = QString("MeshLabXMLStdDialog: the widget corresponding to the parameter ") + curParMap[ii][MLXMLElNames::paramName] + " has not been found!";
218 throw MLException(err.toLocal8Bit());
219 }
220
221 parvalue[curParMap[ii][MLXMLElNames::paramName]] = exp;
222 }
223 emit filterParametersEvaluated(fname,parvalue);
224 ////int mask = 0;//curParSet.getDynamicFloatMask();
225 if(curmask)
226 meshState.apply(curModel);
227 //applyContext = env.currentContext()->toString();
228 ////PreView Caching: if the apply parameters are the same to those used in the preview mode
229 ////we don't need to reapply the filter to the mesh
230 //bool isEqual = (applyContext == previewContext);
231 //if ((isEqual) && (validcache))
232 // meshCacheState.apply(curModel);
233 //else
234 //{
235 startFilterExecution();
236 curmwi->executeFilter(curmfc,parvalue,false);
237 /*}*/
238 //env.popContext();
239
240 if(curmask)
241 meshState.create(curmask, curModel);
242 if (this->curgla)
243 {
244 this->curgla->update();
245 }
246 }
247
closeClick()248 void MeshLabXMLStdDialog::closeClick()
249 {
250 if(curmask != MeshModel::MM_UNKNOWN)
251 meshState.apply(curModel);
252 curmask = MeshModel::MM_UNKNOWN;
253
254 // Perform the update only if there is Valid GLarea.
255 if (this->curgla)
256 {
257 GLArea* glarea = qobject_cast<GLArea*>(curgla);
258 if ((previewCB != NULL) && (previewCB->isChecked()) && (glarea != NULL))
259 glarea->updateAllDecorators();
260 this->curgla->update();
261 }
262 close();
263 }
264
toggleHelp()265 void MeshLabXMLStdDialog::toggleHelp()
266 {
267 showHelp = !showHelp;
268 stdParFrame->toggleHelp(showHelp);
269 qf->updateGeometry();
270 qf->adjustSize();
271 this->updateGeometry();
272 this->adjustSize();
273 }
274
extendedView(bool ext)275 void MeshLabXMLStdDialog::extendedView(bool ext)
276 {
277 stdParFrame->extendedView(ext,showHelp);
278 qf->updateGeometry();
279 qf->adjustSize();
280 this->updateGeometry();
281 this->adjustSize();
282 }
283
togglePreview()284 void MeshLabXMLStdDialog::togglePreview()
285 {
286 if (previewCB == NULL)
287 return;
288
289 GLArea* glarea = qobject_cast<GLArea*>(curgla);
290 if(previewCB->isChecked())
291 {
292 applyDynamic();
293 if (glarea != NULL)
294 glarea->updateAllDecorators();
295 }
296 else
297 {
298 meshState.apply(curModel);
299 updateRenderingData(glarea, curModel);
300 if (glarea != NULL)
301 glarea->updateAllDecorators();
302 }
303
304 curgla->update();
305 }
306
applyDynamic()307 void MeshLabXMLStdDialog::applyDynamic()
308 {
309 if(!previewCB->isChecked())
310 return;
311
312 QMap<QString, QString> parvalue;
313
314 for (int ii = 0; ii < curParMap.size(); ++ii)
315 {
316 if (curParMap[ii][MLXMLElNames::paramIsPersistent] != QString("true"))
317 {
318 QString exp;
319
320 bool valid = stdParFrame->getValue(curParMap[ii][MLXMLElNames::paramName], exp);
321 if (!valid)
322 {
323 QString err = QString("MeshLabXMLStdDialog: the widget corresponding to the parameter ") + curParMap[ii][MLXMLElNames::paramName] + " has not been found!";
324 throw MLException(err.toLocal8Bit());
325 }
326
327 parvalue[curParMap[ii][MLXMLElNames::paramName]] = exp;
328 }
329 }
330 //two different executions give the identical result if the two contexts (with the filter's parameters inside) are identical
331 //previewContext = env.currentContext()->toString();
332
333 meshState.apply(curModel);
334 startFilterExecution();
335 curmwi->executeFilter(this->curmfc, parvalue, true);
336 //env.pushContext();
337 meshCacheState.create(curmask,curModel);
338 validcache = true;
339
340 if(this->curgla)
341 this->curgla->update();
342 }
343
changeCurrentMesh(int meshInd)344 void MeshLabXMLStdDialog::changeCurrentMesh( int meshInd )
345 {
346 if(isPreviewable() && (curModel) && (curModel->id() != meshInd))
347 {
348 meshState.apply(curModel);
349 curModel=curMeshDoc->getMesh(meshInd);
350 meshState.create(curmask, curModel);
351 applyDynamic();
352 }
353 }
354
355 //void MeshLabXMLStdDialog::closeEvent( QCloseEvent * event )
356 //{
357 //
358 //}
359
isPreviewable() const360 bool MeshLabXMLStdDialog::isPreviewable() const
361 {
362 if( (curmask == MeshModel::MM_UNKNOWN) || (curmask == MeshModel::MM_NONE) )
363 return false;
364
365 if( (curmask & MeshModel::MM_VERTNUMBER ) ||
366 (curmask & MeshModel::MM_FACENUMBER ) )
367 return false;
368
369 return true;
370 }
371
resetExpressions()372 void MeshLabXMLStdDialog::resetExpressions()
373 {
374 QString fname(curmfc->act->text());
375 for (int ii = 0; ii < curParMap.size(); ++ii)
376 {
377 if (!stdParFrame->setValue(curParMap[ii][MLXMLElNames::paramName], curParMap[ii][MLXMLElNames::paramDefExpr]))
378 {
379 QString err = QString("MeshLabXMLStdDialog: the widget corresponding to the parameter ") + curParMap[ii][MLXMLElNames::paramName] + " has not been found!";
380 throw MLException(err.toLocal8Bit());
381 }
382 }
383 }
384
closeEvent(QCloseEvent *)385 void MeshLabXMLStdDialog::closeEvent( QCloseEvent * /*event*/ )
386 {
387 closeClick();
388 }
389
resetPointers()390 void MeshLabXMLStdDialog::resetPointers()
391 {
392 curMeshDoc = NULL;
393 curgla = NULL;
394 curModel = NULL;
395 }
396
postFilterExecution()397 void MeshLabXMLStdDialog::postFilterExecution()
398 {
399 setDialogStateRelativeToFilterExecution(false);
400 }
401
loadPersistent(QString name)402 void MeshLabXMLStdDialog::loadPersistent(QString name)
403 {
404 if (curmfc == NULL)
405 throw MLException(QString("MeshLabXMLStdDialog: curmfc is NULL!"));
406
407 if (stdParFrame == NULL)
408 throw MLException(QString("MeshLabXMLStdDialog: stdParFrame is NULL!"));
409
410 QString valexpr = curmfc->readPersistentValueFromSettings(name);
411 stdParFrame->setValue(name, valexpr);
412 }
413
savePersistent(QString name,QString expr)414 void MeshLabXMLStdDialog::savePersistent(QString name, QString expr)
415 {
416 if (curmfc == nullptr)
417 throw MLException(QString("MeshLabXMLStdDialog: curmfc is NULL!"));
418
419 if (curmfc->xmlInfo == nullptr)
420 throw MLException(QString("MeshLabXMLStdDialog: xmlinfo is NULL!"));
421
422 curmfc->writePersistentValueIntoSettings(name, expr);
423 }
424
startFilterExecution()425 void MeshLabXMLStdDialog::startFilterExecution()
426 {
427 setDialogStateRelativeToFilterExecution(true);
428 }
429
setDialogStateRelativeToFilterExecution(const bool isfilterinexecution)430 void MeshLabXMLStdDialog::setDialogStateRelativeToFilterExecution( const bool isfilterinexecution )
431 {
432 isfilterexecuting = isfilterinexecution;
433 if (curmfc == NULL)
434 return;
435 QString inter = curmfc->xmlInfo->filterAttribute(curmfc->act->text(),MLXMLElNames::filterIsInterruptible);
436
437 if (inter == "true")
438 {
439 applyButton->setEnabled(true);
440 //during filter execution Stop label should appear, otherwise the apply button is in the usual apply state
441 applyButton->setText(MeshLabXMLStdDialog::applyButtonLabel(!isfilterinexecution));
442 }
443 else
444 {
445 applyButton->setText(MeshLabXMLStdDialog::applyButtonLabel(true));
446 applyButton->setEnabled(!isfilterexecuting);
447 }
448 stdParFrame->setEnabled(!isfilterexecuting);
449 }
450
applyButtonLabel(const bool applystate)451 QString MeshLabXMLStdDialog::applyButtonLabel( const bool applystate )
452 {
453 if (applystate)
454 return QString("Apply");
455 else
456 return QString("Stop");
457 return QString();
458 }
459
XMLStdParFrame(QWidget * p,QWidget * gla)460 XMLStdParFrame::XMLStdParFrame( QWidget *p,QWidget *gla/*=0*/ )
461 :QFrame(p),extended(false)
462 {
463 curr_gla=gla;
464 //vLayout = new QGridLayout();
465 //vLayout->setAlignment(Qt::AlignTop);
466 //setLayout(vLayout);
467 //connect(p,SIGNAL(expandView(bool)),this,SLOT(expandView(bool)));
468 //updateFrameContent(parMap,false);
469 //this->setMinimumWidth(vLayout->sizeHint().width());
470
471
472 //this->showNormal();
473 //this->adjustSize();
474 }
475
~XMLStdParFrame()476 XMLStdParFrame::~XMLStdParFrame()
477 {
478
479 }
480
loadFrameContent(const MeshLabXMLFilterContainer & filtcont,EnvWrap & envir,MeshDocument * md)481 void XMLStdParFrame::loadFrameContent(const MeshLabXMLFilterContainer& filtcont, EnvWrap& envir, MeshDocument* md)
482 {
483 if ((filtcont.act == nullptr) || (filtcont.xmlInfo == nullptr))
484 return;
485
486 QGridLayout* glay = new QGridLayout();
487 int ii = 0;
488
489 MeshLabXMLStdDialog* parent = qobject_cast<MeshLabXMLStdDialog*>(parentWidget());
490 if (parent == NULL)
491 return;
492 MLXMLPluginInfo::XMLMapList mplist = filtcont.xmlInfo->filterParametersExtendedInfo(filtcont.filterName());
493 for (MLXMLPluginInfo::XMLMapList::const_iterator it = mplist.constBegin(); it != mplist.constEnd(); ++it)
494 {
495 XMLMeshLabWidget* widg = XMLMeshLabWidgetFactory::create(*it, envir, md, this);
496 if (widg == NULL)
497 return;
498
499 if (envir.evalBool((*it)[MLXMLElNames::paramIsPersistent]))
500 {
501 QString pers = filtcont.readPersistentValueFromSettings((*it)[MLXMLElNames::paramName]);
502 widg->set(pers);
503 }
504
505 connect(widg, SIGNAL(loadPersistentParameterValueRequested(QString)), this, SIGNAL(loadPersistentParameterValueRequested(QString)));
506 connect(widg, SIGNAL(savePersistentParameterValueRequested(QString)), this, SLOT(savePersistentParameterValue(QString)));
507 xmlfieldwidgets[(*it)[MLXMLElNames::paramName]] = widg;
508 helpList[(*it)[MLXMLElNames::paramName]] = widg->helpLabel();
509 widg->addWidgetToGridLayout(glay, ii);
510 ++ii;
511 }
512 setLayout(glay);
513 //showNormal();
514 updateGeometry();
515 adjustSize();
516 }
517
toggleHelp(bool help)518 void XMLStdParFrame::toggleHelp(bool help)
519 {
520 for (QMap<QString, QLabel*>::iterator it = helpList.begin(); it != helpList.end(); ++it)
521 it.value()->setVisible(help && xmlfieldwidgets[it.key()]->isVisible());
522 updateGeometry();
523 adjustSize();
524 }
525
savePersistentParameterValue(QString name)526 void XMLStdParFrame::savePersistentParameterValue(QString name)
527 {
528 auto it = xmlfieldwidgets.find(name);
529
530 if (it != xmlfieldwidgets.end())
531 {
532 XMLMeshLabWidget* widg = it.value();
533 if (widg != nullptr)
534 {
535 /*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*/
536 /*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(); */
537 QString expr = widg->getWidgetExpression();
538 XMLStringWidget* stringwid = qobject_cast<XMLStringWidget*>(widg);
539 if (stringwid != nullptr)
540 {
541 /*WARNING!!!! WHY NOT USING THE ENV PATTERN FOR ALL THE CASES? Because QT when convert a QScriptValue to a QString of a javascript array (eg. [i0,i1,...,in]) return a i0,i1,...,in without the square brackets, making impossible to correctly re evaluate again the resulting value*/
542 Env e;
543 expr = e.evaluate(expr).toString();
544 }
545 emit savePersistentParameterValueRequested(name,expr);
546 }
547 }
548 }
549
extendedView(bool ext,bool help)550 void XMLStdParFrame::extendedView(bool ext,bool help)
551 {
552 for (QMap<QString, XMLMeshLabWidget*>::iterator it = xmlfieldwidgets.begin(); it != xmlfieldwidgets.end(); ++it)
553 (*it)->setVisibility(ext || (*it)->isImportant);
554 if (help)
555 toggleHelp(help);
556 updateGeometry();
557 adjustSize();
558 }
559
setValue(const QString & name,const QString & val)560 bool XMLStdParFrame::setValue(const QString& name, const QString& val)
561 {
562 bool isvalid = false;
563
564 QMap<QString, XMLMeshLabWidget*>::iterator it = xmlfieldwidgets.find(name);
565 if ((it != xmlfieldwidgets.end()) && (it.value() != NULL))
566 {
567 (*it)->set(val);
568 isvalid = true;
569 }
570
571 return isvalid;
572 }
573
getValue(const QString & name,QString & val)574 bool XMLStdParFrame::getValue(const QString& name, QString& val)
575 {
576 bool isvalid = false;
577 QMap<QString, XMLMeshLabWidget*>::iterator it = xmlfieldwidgets.find(name);
578 if ((it != xmlfieldwidgets.end()) && (it.value() != NULL))
579 {
580 val = (*it)->getWidgetExpression();
581 isvalid = true;
582 }
583 return isvalid;
584 }
585
586
XMLMeshLabWidget(const MLXMLPluginInfo::XMLMap & mp,EnvWrap & envir,QWidget * parent)587 XMLMeshLabWidget::XMLMeshLabWidget(const MLXMLPluginInfo::XMLMap& mp,EnvWrap& envir,QWidget* parent )
588 :QWidget(parent),env(envir)
589 {
590 //WARNING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
591 //It's not nice at all doing the connection for an external object! The connect should be called in XMLStdParFrame::loadFrameContent but in this way
592 //we must break the construction of the widget in two steps because otherwise in the constructor (called by XMLMeshLabWidgetFactory::create) the emit is invoked
593 //before the connection!
594 //connect(this,SIGNAL(widgetEvaluateExpression(const Expression&,Value**)),parent,SIGNAL(frameEvaluateExpression(const Expression&,Value**)),Qt::DirectConnection);
595 parname = mp[MLXMLElNames::paramName];
596 isImportant = env.evalBool(mp[MLXMLElNames::paramIsImportant]);
597 setVisible(isImportant);
598
599 helpLab = new QLabel("<small>"+ mp[MLXMLElNames::paramHelpTag] +"</small>",this);
600 helpLab->setTextFormat(Qt::RichText);
601 helpLab->setWordWrap(true);
602 helpLab->setVisible(false);
603 helpLab->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
604 helpLab->setMinimumWidth(250);
605 helpLab->setMaximumWidth(QWIDGETSIZE_MAX);
606 perstb = new XMLPersistenToolbox(this);
607 perstb->setVisible(env.evalBool(mp[MLXMLElNames::paramIsPersistent]));
608 perstb->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
609 connect(perstb, SIGNAL(saveRequested()), this, SLOT(savePersistentParameterValue()));
610 connect(perstb, SIGNAL(loadRequested()), this, SLOT(loadPersistentParameterValue()));
611 }
612
setVisibility(const bool vis)613 void XMLMeshLabWidget::setVisibility( const bool vis )
614 {
615 helpLabel()->setVisible(helpLabel()->isVisible() && vis);
616 perstb->setVisible(perstb->isVisible() && vis);
617 updateVisibility(vis);
618 setVisible(vis);
619 }
620
addWidgetToGridLayout(QGridLayout * lay,const int r)621 void XMLMeshLabWidget::addWidgetToGridLayout( QGridLayout* lay,const int r )
622 {
623 if (lay != NULL)
624 lay->addWidget(helpLab, r, 3, 1, 1);
625 }
626
savePersistentParameterValue()627 void XMLMeshLabWidget::savePersistentParameterValue()
628 {
629 emit savePersistentParameterValueRequested(parname);
630 }
631
loadPersistentParameterValue()632 void XMLMeshLabWidget::loadPersistentParameterValue()
633 {
634 emit loadPersistentParameterValueRequested(parname);
635 }
636
XMLCheckBoxWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * parent)637 XMLCheckBoxWidget::XMLCheckBoxWidget( const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* parent )
638 :XMLMeshLabWidget(xmlWidgetTag,envir,parent)
639 {
640 cb = new QCheckBox(xmlWidgetTag[MLXMLElNames::guiLabel],this);
641 cb->setToolTip(xmlWidgetTag[MLXMLElNames::paramHelpTag]);
642 bool defVal = env.evalBool(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
643 cb->setChecked(defVal);
644 //cb->setVisible(isImportant);
645
646 ////gridlay->addWidget(this,i,0,1,1,Qt::AlignTop);
647
648 ////int row = gridLay->rowCount() -1 ;
649 ////WARNING!!!!!!!!!!!!!!!!!! HORRIBLE PATCH FOR THE BOOL WIDGET PROBLEM
650 //if (row == 1)
651 // gridLay->addWidget(cb,row + 1,0,1,2,Qt::AlignTop);
652 ///////////////////////////////////////////////////////////////////////////
653 //else
654 // gridLay->addWidget(cb,row,0,1,2,Qt::AlignTop);
655
656 setVisibility(isImportant);
657 //cb->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
658 connect(cb,SIGNAL(stateChanged(int)),parent,SIGNAL(parameterChanged()));
659 }
660
~XMLCheckBoxWidget()661 XMLCheckBoxWidget::~XMLCheckBoxWidget()
662 {
663
664 }
665
set(const QString & nwExpStr)666 void XMLCheckBoxWidget::set( const QString& nwExpStr )
667 {
668 cb->setChecked(env.evalBool(nwExpStr));
669 }
670
updateVisibility(const bool vis)671 void XMLCheckBoxWidget::updateVisibility( const bool vis )
672 {
673 setVisibility(vis);
674 }
675
getWidgetExpression()676 QString XMLCheckBoxWidget::getWidgetExpression()
677 {
678 QString state;
679 if (cb->isChecked())
680 state = QString("true");
681 else
682 state = QString("false");
683 return state;
684 }
685
setVisibility(const bool vis)686 void XMLCheckBoxWidget::setVisibility( const bool vis )
687 {
688 cb->setVisible(vis);
689 }
690
addWidgetToGridLayout(QGridLayout * lay,const int r)691 void XMLCheckBoxWidget::addWidgetToGridLayout(QGridLayout* lay, const int r)
692 {
693 if (lay != NULL)
694 {
695 QHBoxLayout* hlay = new QHBoxLayout();
696 hlay->addWidget(cb);
697 hlay->addWidget(perstb);
698 hlay->addStretch();
699 lay->addLayout(hlay, r, 0, 1, 2);
700 }
701 XMLMeshLabWidget::addWidgetToGridLayout(lay, r);
702 }
703
create(const MLXMLPluginInfo::XMLMap & widgetTable,EnvWrap & env,MeshDocument * md,QWidget * parent)704 XMLMeshLabWidget* XMLMeshLabWidgetFactory::create(const MLXMLPluginInfo::XMLMap& widgetTable,EnvWrap& env,MeshDocument* md,QWidget* parent)
705 {
706 QString guiType = widgetTable[MLXMLElNames::guiType];
707 if (guiType == MLXMLElNames::editTag)
708 return new XMLEditWidget(widgetTable, env, parent);
709
710 if (guiType == MLXMLElNames::checkBoxTag)
711 return new XMLCheckBoxWidget(widgetTable, env, parent);
712
713 if (guiType == MLXMLElNames::absPercTag)
714 return new XMLAbsWidget(widgetTable, env, parent);
715
716 if (guiType == MLXMLElNames::vec3WidgetTag)
717 return new XMLVec3Widget(widgetTable, env, parent);
718
719 if (guiType == MLXMLElNames::colorWidgetTag)
720 return new XMLColorWidget(widgetTable, env, parent);
721
722 if (guiType == MLXMLElNames::sliderWidgetTag)
723 return new XMLSliderWidget(widgetTable, env, parent);
724
725 if (guiType == MLXMLElNames::enumWidgetTag)
726 return new XMLEnumWidget(widgetTable, env, parent);
727
728 if (guiType == MLXMLElNames::meshWidgetTag)
729 return new XMLMeshWidget(md, widgetTable, env, parent);
730
731 if (guiType == MLXMLElNames::shotWidgetTag)
732 return new XMLShotWidget(widgetTable, env, parent);
733
734 if (guiType == MLXMLElNames::stringWidgetTag)
735 return new XMLStringWidget(widgetTable, env, parent);
736 return NULL;
737 }
738
XMLEditWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * parent)739 XMLEditWidget::XMLEditWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* parent)
740 :XMLMeshLabWidget(xmlWidgetTag,envir,parent)
741 {
742 fieldDesc = new QLabel(xmlWidgetTag[MLXMLElNames::guiLabel],this);
743 fieldDesc->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
744 lineEdit = new QLineEdit(this);
745 lineEdit->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
746 //int row = gridLay->rowCount() -1;
747 hlay = new QHBoxLayout();
748 hlay->addWidget(lineEdit);
749
750 hlay->addWidget(perstb);
751
752 fieldDesc->setToolTip(xmlWidgetTag[MLXMLElNames::paramHelpTag]);
753 lineEdit->setText(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
754
755 //gridLay->addWidget(fieldDesc,row,0,Qt::AlignTop);
756 //gridLay->addWidget(lineEdit,row,1,Qt::AlignTop);
757 connect(lineEdit,SIGNAL(editingFinished()),parent,SIGNAL(parameterChanged()));
758 // connect(lineEdit,SIGNAL(selectionChanged()),this,SLOT(tooltipEvaluation()));
759
760 setVisibility(isImportant);
761 }
762
763
764
~XMLEditWidget()765 XMLEditWidget::~XMLEditWidget()
766 {
767
768 }
769
770
771
set(const QString & nwExpStr)772 void XMLEditWidget::set( const QString& nwExpStr )
773 {
774 lineEdit->setText(nwExpStr);
775 }
776
updateVisibility(const bool vis)777 void XMLEditWidget::updateVisibility( const bool vis )
778 {
779 setVisibility(vis);
780 }
781
782 //void XMLEditWidget::tooltipEvaluation()
783 //{
784 // try
785 // {
786 // QString exp = lineEdit->selectedText();
787 // QString res = env.evalString(exp);
788 // lineEdit->setToolTip(res);
789 // }
790 // catch (MeshLabException& /*e*/)
791 // {
792 // //WARNING!!! it's needed otherwise there is a stack overflow due to the Qt selection mechanism!
793 // return;
794 // }
795 //}
796
getWidgetExpression()797 QString XMLEditWidget::getWidgetExpression()
798 {
799 return this->lineEdit->text();
800 }
801
setVisibility(const bool vis)802 void XMLEditWidget::setVisibility( const bool vis )
803 {
804 fieldDesc->setVisible(vis);
805 this->lineEdit->setVisible(vis);
806 }
807
addWidgetToGridLayout(QGridLayout * lay,const int r)808 void XMLEditWidget::addWidgetToGridLayout( QGridLayout* lay,const int r )
809 {
810 if (lay != nullptr)
811 {
812 lay->addWidget(fieldDesc, r, 0);
813 lay->addLayout(hlay, r, 1);
814 }
815 XMLMeshLabWidget::addWidgetToGridLayout(lay,r);
816 }
817
XMLStringWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * parent)818 XMLStringWidget::XMLStringWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* parent)
819 :XMLMeshLabWidget(xmlWidgetTag,envir,parent)
820 {
821 fieldDesc = new QLabel(xmlWidgetTag[MLXMLElNames::guiLabel],this);
822
823 fieldDesc->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
824 lineEdit = new QLineEdit(this);
825 lineEdit->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
826 //int row = gridLay->rowCount() -1;
827 hlay = new QHBoxLayout();
828 hlay->addWidget(lineEdit);
829 hlay->addWidget(perstb);
830
831
832 fieldDesc->setToolTip(xmlWidgetTag[MLXMLElNames::paramHelpTag]);
833 lineEdit->setText(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
834
835 //gridLay->addWidget(fieldDesc,row,0,Qt::AlignTop);
836 //gridLay->addWidget(lineEdit,row,1,Qt::AlignTop);
837 connect(lineEdit,SIGNAL(editingFinished()),parent,SIGNAL(parameterChanged()));
838 // connect(lineEdit,SIGNAL(selectionChanged()),this,SLOT(tooltipEvaluation()));
839
840 setVisibility(isImportant);
841 }
842
843
844
~XMLStringWidget()845 XMLStringWidget::~XMLStringWidget()
846 {
847
848 }
849
850
851
set(const QString & nwExpStr)852 void XMLStringWidget::set( const QString& nwExpStr )
853 {
854 lineEdit->setText(nwExpStr);
855 }
856
updateVisibility(const bool vis)857 void XMLStringWidget::updateVisibility( const bool vis )
858 {
859 setVisibility(vis);
860 }
861
862
863 /*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*/
864 /*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(); */
865
getWidgetExpression()866 QString XMLStringWidget::getWidgetExpression()
867 {
868 return QString("\"")+this->lineEdit->text()+QString("\"");
869 }
870
setVisibility(const bool vis)871 void XMLStringWidget::setVisibility( const bool vis )
872 {
873 fieldDesc->setVisible(vis);
874 this->lineEdit->setVisible(vis);
875 }
876
addWidgetToGridLayout(QGridLayout * lay,const int r)877 void XMLStringWidget::addWidgetToGridLayout( QGridLayout* lay,const int r )
878 {
879 if (lay != nullptr)
880 {
881 lay->addWidget(fieldDesc,r,0);
882 lay->addLayout(hlay, r, 1);
883 }
884 XMLMeshLabWidget::addWidgetToGridLayout(lay,r);
885 }
886
887
888
XMLAbsWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * parent)889 XMLAbsWidget::XMLAbsWidget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag, EnvWrap& envir,QWidget* parent )
890 :XMLMeshLabWidget(xmlWidgetTag,envir,parent)
891 {
892 m_min = env.evalFloat(xmlWidgetTag[MLXMLElNames::guiMinExpr]);
893 m_max = env.evalFloat(xmlWidgetTag[MLXMLElNames::guiMaxExpr]);
894
895 fieldDesc = new QLabel(xmlWidgetTag[MLXMLElNames::guiLabel] + " (abs and %)",this);
896 fieldDesc->setToolTip(xmlWidgetTag[MLXMLElNames::paramHelpTag]);
897 absSB = new QDoubleSpinBox(this);
898 absSB->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
899 percSB = new QDoubleSpinBox(this);
900 percSB->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
901
902 absSB->setMinimum(m_min-(m_max-m_min));
903 absSB->setMaximum(m_max*2);
904 absSB->setAlignment(Qt::AlignRight);
905
906 int decimals= 7-ceil(log10(fabs(m_max-m_min)) ) ;
907 //qDebug("range is (%f %f) %f ",m_max,m_min,fabs(m_max-m_min));
908 //qDebug("log range is %f ",log10(fabs(m_max-m_min)));
909 absSB->setDecimals(decimals);
910 absSB->setSingleStep((m_max-m_min)/100.0);
911 float initVal = env.evalFloat(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
912 absSB->setValue(initVal);
913
914 percSB->setMinimum(-200);
915 percSB->setMaximum(200);
916 percSB->setAlignment(Qt::AlignRight);
917 percSB->setSingleStep(0.5);
918 percSB->setValue((100*(initVal - m_min))/(m_max - m_min));
919 percSB->setDecimals(3);
920 absLab=new QLabel("<i> <small> world unit</small></i>",this);
921 percLab=new QLabel("<i> <small> perc on"+QString("(%1 .. %2)").arg(m_min).arg(m_max)+"</small></i>",this);
922
923 //gridLay->addWidget(fieldDesc,row,0,Qt::AlignLeft);
924 glay = new QGridLayout();
925 glay->addWidget(absLab,0,0,Qt::AlignHCenter);
926 glay->addWidget(percLab,0,1,Qt::AlignHCenter);
927 glay->addWidget(absSB,1,0,Qt::AlignTop);
928 glay->addWidget(percSB,1,1,Qt::AlignTop);
929 glay->addWidget(perstb, 0, 2, 2, 1, Qt::AlignVCenter);
930
931
932 connect(absSB,SIGNAL(valueChanged(double)),this,SLOT(on_absSB_valueChanged(double)));
933 connect(percSB,SIGNAL(valueChanged(double)),this,SLOT(on_percSB_valueChanged(double)));
934 connect(this,SIGNAL(dialogParamChanged()),parent,SIGNAL(parameterChanged()));
935 setVisibility(isImportant);
936 }
937
~XMLAbsWidget()938 XMLAbsWidget::~XMLAbsWidget()
939 {
940 }
941
set(const QString & nwExpStr)942 void XMLAbsWidget::set( const QString& nwExpStr )
943 {
944 absSB->setValue(env.evalFloat(nwExpStr));
945 }
946
updateVisibility(const bool vis)947 void XMLAbsWidget::updateVisibility( const bool vis )
948 {
949 setVisibility(vis);
950 }
951
getWidgetExpression()952 QString XMLAbsWidget::getWidgetExpression()
953 {
954 return QString::number(absSB->value());
955 }
956
on_absSB_valueChanged(double newv)957 void XMLAbsWidget::on_absSB_valueChanged(double newv)
958 {
959 disconnect(percSB, SIGNAL(valueChanged(double)), this, SLOT(on_percSB_valueChanged(double)));
960 percSB->setValue((100*(newv - m_min))/(m_max - m_min));
961 connect(percSB, SIGNAL(valueChanged(double)), this, SLOT(on_percSB_valueChanged(double)));
962 emit dialogParamChanged();
963 }
964
on_percSB_valueChanged(double newv)965 void XMLAbsWidget::on_percSB_valueChanged(double newv)
966 {
967 disconnect(absSB, SIGNAL(valueChanged(double)), this, SLOT(on_absSB_valueChanged(double)));
968 absSB->setValue((m_max - m_min)*0.01*newv + m_min);
969 connect(absSB, SIGNAL(valueChanged(double)), this, SLOT(on_absSB_valueChanged(double)));
970 emit dialogParamChanged();
971 }
972
setVisibility(const bool vis)973 void XMLAbsWidget::setVisibility( const bool vis )
974 {
975 this->absLab->setVisible(vis);
976 this->percLab->setVisible(vis);
977 this->fieldDesc->setVisible(vis);
978 this->absSB->setVisible(vis);
979 this->percSB->setVisible(vis);
980 }
981
addWidgetToGridLayout(QGridLayout * lay,const int r)982 void XMLAbsWidget::addWidgetToGridLayout( QGridLayout* lay,const int r )
983 {
984 if (lay != NULL)
985 {
986 lay->addWidget(fieldDesc,r,0,Qt::AlignLeft);
987 lay->addLayout(glay,r,1,Qt::AlignTop);
988 }
989 XMLMeshLabWidget::addWidgetToGridLayout(lay,r);
990 }
991
XMLVec3Widget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * p)992 XMLVec3Widget::XMLVec3Widget(const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p)
993 :XMLMeshLabWidget(xmlWidgetTag,envir,p)
994 {
995 XMLStdParFrame* par = qobject_cast<XMLStdParFrame*>(p);
996 if (par != NULL)
997 {
998 curr_gla = par->curr_gla;
999 paramName = xmlWidgetTag[MLXMLElNames::paramName];
1000 //int row = gridLay->rowCount() - 1;
1001
1002 descLab = new QLabel( xmlWidgetTag[MLXMLElNames::guiLabel],this);
1003 descLab->setToolTip(xmlWidgetTag[MLXMLElNames::paramHelpTag]);
1004 //gridLay->addWidget(descLab,row,0,Qt::AlignTop);
1005
1006 hlay = new QHBoxLayout();
1007
1008 for(int i =0;i<3;++i)
1009 {
1010 coordSB[i]= new QLineEdit(this);
1011 QFont baseFont=coordSB[i]->font();
1012 if(baseFont.pixelSize() != -1) baseFont.setPixelSize(baseFont.pixelSize()*3/4);
1013 else baseFont.setPointSize(baseFont.pointSize()*3/4);
1014 coordSB[i]->setFont(baseFont);
1015 //coordSB[i]->setMinimumWidth(coordSB[i]->sizeHint().width()/4);
1016 coordSB[i]->setMinimumWidth(0);
1017 coordSB[i]->setMaximumWidth(coordSB[i]->sizeHint().width()/2);
1018 //coordSB[i]->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
1019 coordSB[i]->setValidator(new QDoubleValidator(this));
1020 coordSB[i]->setAlignment(Qt::AlignRight);
1021 //this->addWidget(coordSB[i],1,Qt::AlignHCenter);
1022 coordSB[i]->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
1023 hlay->addWidget(coordSB[i]);
1024 }
1025 vcg::Point3f def = envir.evalVec3(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
1026 this->setPoint(paramName,def);
1027 if(curr_gla) // if we have a connection to the current glarea we can setup the additional button for getting the current view direction.
1028 {
1029 getPoint3Button = new QPushButton("Get",this);
1030 getPoint3Button->setMaximumWidth(getPoint3Button->sizeHint().width()/2);
1031
1032 getPoint3Button->setFlat(true);
1033 getPoint3Button->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
1034
1035 hlay->addWidget(getPoint3Button);
1036 QStringList names;
1037 names << "View Dir.";
1038 names << "View Pos.";
1039 names << "Surf. Pos.";
1040 names << "Raster Camera Pos.";
1041 names << "Trackball Center";
1042
1043 getPoint3Combo = new QComboBox(this);
1044 getPoint3Combo->addItems(names);
1045 //getPoint3Combo->setMinimumWidth(getPoint3Combo->sizeHint().width());
1046 //this->addWidget(getPoint3Combo,0,Qt::AlignHCenter);
1047 hlay->addWidget(getPoint3Combo);
1048 hlay->addWidget(perstb, 0, Qt::AlignVCenter);
1049
1050 connect(getPoint3Button,SIGNAL(clicked()),this,SLOT(getPoint()));
1051 connect(getPoint3Combo,SIGNAL(currentIndexChanged(int)),this,SLOT(getPoint()));
1052 connect(curr_gla,SIGNAL(transmitViewDir(QString,vcg::Point3f)),this,SLOT(setPoint(QString,vcg::Point3f)));
1053 connect(curr_gla,SIGNAL(transmitShot(QString,vcg::Shotf)),this,SLOT(setShot(QString,vcg::Shotf)));
1054 connect(curr_gla,SIGNAL(transmitSurfacePos(QString,vcg::Point3f)),this,SLOT(setPoint(QString,vcg::Point3f)));
1055 connect(curr_gla,SIGNAL(transmitCameraPos(QString, Point3m)),this,SLOT(setValue(QString, Point3m)));
1056 connect(curr_gla,SIGNAL(transmitTrackballPos(QString, Point3m)),this,SLOT(setValue(QString, Point3m)));
1057 connect(this,SIGNAL(askViewDir(QString)),curr_gla,SLOT(sendViewDir(QString)));
1058 connect(this,SIGNAL(askViewPos(QString)),curr_gla,SLOT(sendViewerShot(QString)));
1059 connect(this,SIGNAL(askSurfacePos(QString)),curr_gla,SLOT(sendSurfacePos(QString)));
1060 connect(this,SIGNAL(askCameraPos(QString)),curr_gla,SLOT(sendRasterShot(QString)));
1061 connect(this,SIGNAL(askTrackballPos(QString)),curr_gla,SLOT(sendTrackballPos(QString)));
1062 }
1063 //gridLay->addLayout(hlay,row,1,Qt::AlignTop);
1064 }
1065 setVisibility(isImportant);
1066 }
1067
set(const QString & exp)1068 void XMLVec3Widget::set( const QString& exp )
1069 {
1070 vcg::Point3f newVal = env.evalVec3(exp);
1071 for(int ii = 0;ii < 3;++ii)
1072 coordSB[ii]->setText(QString::number(newVal[ii],'g',4));
1073 }
1074
updateVisibility(const bool vis)1075 void XMLVec3Widget::updateVisibility( const bool vis )
1076 {
1077 setVisibility(vis);
1078 }
1079
getWidgetExpression()1080 QString XMLVec3Widget::getWidgetExpression()
1081 {
1082 return QString("[" + coordSB[0]->text() + "," + coordSB[1]->text() + "," + coordSB[2]->text() + "]");
1083 }
1084
1085 //void XMLVec3Widget::setExp(const QString& name,const QString& exp )
1086 //{
1087 // QRegExp pointRegExp("\[\d+(\.\d)*,\d+(\.\d)*,\d+(\.\d)*\]");
1088 // if ((name==paramName) && (pointRegExp.exactMatch(exp)))
1089 // {
1090 // for(int i =0;i<3;++i)
1091 // coordSB[i]->setText(QString::number(val[i],'g',4));
1092 // }
1093 //}
1094
getPoint()1095 void XMLVec3Widget::getPoint()
1096 {
1097 int index = getPoint3Combo->currentIndex();
1098 qDebug("Got signal %i",index);
1099 switch(index)
1100 {
1101 case 0 : emit askViewDir(paramName); break;
1102 case 1 : emit askViewPos(paramName); break;
1103 case 2 : emit askSurfacePos(paramName); break;
1104 case 3 : emit askCameraPos(paramName); break;
1105 case 4 : emit askTrackballPos(paramName); break;
1106 default : assert(0);
1107 }
1108 }
1109
setShot(const QString & name,const vcg::Shotf & shot)1110 void XMLVec3Widget::setShot(const QString& name,const vcg::Shotf& shot )
1111 {
1112 vcg::Point3f p = shot.GetViewPoint();
1113 setPoint(name,p);
1114 }
1115
setPoint(const QString & name,const vcg::Point3f & p)1116 void XMLVec3Widget::setPoint( const QString& name,const vcg::Point3f& p )
1117 {
1118 if (name == paramName)
1119 {
1120 QString exp("[" + QString::number(p[0]) + "," + QString::number(p[1]) + "," + QString::number(p[2]) + "]");
1121 set(exp);
1122 }
1123 }
1124
~XMLVec3Widget()1125 XMLVec3Widget::~XMLVec3Widget()
1126 {
1127
1128 }
1129
setVisibility(const bool vis)1130 void XMLVec3Widget::setVisibility( const bool vis )
1131 {
1132 for(int ii = 0;ii < 3;++ii)
1133 coordSB[ii]->setVisible(vis);
1134 getPoint3Button->setVisible(vis);
1135 getPoint3Combo->setVisible(vis);
1136 descLab->setVisible(vis);
1137 }
1138
addWidgetToGridLayout(QGridLayout * lay,const int r)1139 void XMLVec3Widget::addWidgetToGridLayout( QGridLayout* lay,const int r )
1140 {
1141 if (lay != NULL)
1142 {
1143 lay->addWidget(descLab,r,0);
1144 lay->addLayout(hlay,r,1);
1145 }
1146 XMLMeshLabWidget::addWidgetToGridLayout(lay,r);
1147 }
1148
XMLColorWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * p)1149 XMLColorWidget::XMLColorWidget( const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p )
1150 :XMLMeshLabWidget(xmlWidgetTag,envir,p)
1151 {
1152 colorLabel = new QLabel(this);
1153 QString paramName = xmlWidgetTag[MLXMLElNames::paramName];
1154 descLabel = new QLabel(xmlWidgetTag[MLXMLElNames::guiLabel],this);
1155 colorButton = new QPushButton(this);
1156 colorButton->setAutoFillBackground(true);
1157 colorButton->setFlat(true);
1158 colorButton->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
1159 //const QColor cl = rp->pd->defVal->getColor();
1160 //resetWidgetValue();
1161 QColor cl = envir.evalColor(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
1162 pickcol = cl;
1163 updateColorInfo(cl);
1164 //int row = gridLay->rowCount() - 1;
1165 //gridLay->addWidget(descLabel,row,0,Qt::AlignTop);
1166
1167 hlay = new QHBoxLayout();
1168 QFontMetrics met(colorLabel->font());
1169 QColor black(Qt::black);
1170 QString blackname = "(" + black.name() + ")";
1171 QSize sz = met.size(Qt::TextSingleLine,blackname);
1172 colorLabel->setMaximumWidth(sz.width());
1173 colorLabel->setMinimumWidth(sz.width());
1174 hlay->addWidget(colorLabel,0,Qt::AlignRight);
1175 hlay->addWidget(colorButton);
1176 hlay->addWidget(perstb,0,Qt::AlignVCenter);
1177
1178 //gridLay->addLayout(lay,row,1,Qt::AlignTop);
1179 connect(colorButton,SIGNAL(clicked()),this,SLOT(pickColor()));
1180 connect(this,SIGNAL(dialogParamChanged()),p,SIGNAL(parameterChanged()));
1181 setVisibility(isImportant);
1182 }
1183
~XMLColorWidget()1184 XMLColorWidget::~XMLColorWidget()
1185 {
1186
1187 }
1188
updateVisibility(const bool vis)1189 void XMLColorWidget::updateVisibility( const bool vis )
1190 {
1191 setVisibility(vis);
1192 }
1193
set(const QString & nwExpStr)1194 void XMLColorWidget::set( const QString& nwExpStr )
1195 {
1196 QColor col = env.evalColor(nwExpStr);
1197 updateColorInfo(col);
1198 }
1199
getWidgetExpression()1200 QString XMLColorWidget::getWidgetExpression()
1201 {
1202 return QString("[" + QString::number(pickcol.red()) + "," + QString::number(pickcol.green()) + "," + QString::number(pickcol.blue()) + "," + QString::number(pickcol.alpha()) + "]");
1203 }
1204
updateColorInfo(const QColor & col)1205 void XMLColorWidget::updateColorInfo( const QColor& col )
1206 {
1207 colorLabel->setText("("+col.name()+")");
1208 QPalette palette(col);
1209 colorButton->setPalette(palette);
1210 }
1211
pickColor()1212 void XMLColorWidget::pickColor()
1213 {
1214 pickcol =QColorDialog::getColor(pickcol);
1215 if(pickcol.isValid())
1216 updateColorInfo(pickcol);
1217 emit dialogParamChanged();
1218 }
1219
setVisibility(const bool vis)1220 void XMLColorWidget::setVisibility( const bool vis )
1221 {
1222 colorLabel->setVisible(vis);
1223 descLabel->setVisible(vis);
1224 colorButton->setVisible(vis);
1225 }
1226
addWidgetToGridLayout(QGridLayout * lay,const int r)1227 void XMLColorWidget::addWidgetToGridLayout( QGridLayout* lay,const int r )
1228 {
1229 if (lay != NULL)
1230 {
1231 lay->addWidget(descLabel,r,0,Qt::AlignTop);
1232 lay->addLayout(hlay,r,1,Qt::AlignTop);
1233 }
1234 XMLMeshLabWidget::addWidgetToGridLayout(lay,r);
1235 }
1236
XMLSliderWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * p)1237 XMLSliderWidget::XMLSliderWidget( const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p )
1238 :XMLMeshLabWidget(xmlWidgetTag,envir,p)
1239 {
1240 minVal = env.evalFloat(xmlWidgetTag[MLXMLElNames::guiMinExpr]);
1241 maxVal = env.evalFloat(xmlWidgetTag[MLXMLElNames::guiMaxExpr]);
1242 valueLE = new QLineEdit(this);
1243 valueLE->setAlignment(Qt::AlignRight);
1244 valueSlider = new QSlider(Qt::Horizontal,this);
1245 valueSlider->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
1246 fieldDesc = new QLabel(xmlWidgetTag[MLXMLElNames::guiLabel],this);
1247 valueSlider->setMinimum(0);
1248 valueSlider->setMaximum(100);
1249 float fval = env.evalFloat(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
1250 valueSlider->setValue(floatToInt( fval));
1251 valueLE->setValidator(new QDoubleValidator (minVal,maxVal, 5, valueLE));
1252 valueLE->setText(QString::number(fval));
1253
1254
1255 //int row = gridLay->rowCount() - 1;
1256 //gridLay->addWidget(fieldDesc,row,0,Qt::AlignTop);
1257
1258 hlay = new QHBoxLayout();
1259 hlay->addWidget(valueLE,0,Qt::AlignHCenter);
1260 //lay->addWidget(valueSlider,0,Qt::AlignJustify);
1261 hlay->addWidget(valueSlider,0);
1262 hlay->addWidget(perstb, 0, Qt::AlignVCenter);
1263 //gridLay->addLayout(hlay,row,1,Qt::AlignTop);
1264
1265 connect(valueLE,SIGNAL(textChanged(const QString &)),this,SLOT(setValue()));
1266 connect(valueSlider,SIGNAL(valueChanged(int)),this,SLOT(setValue(int)));
1267 connect(this,SIGNAL(dialogParamChanged()),p,SIGNAL(parameterChanged()));
1268 setVisibility(isImportant);
1269 }
1270
~XMLSliderWidget()1271 XMLSliderWidget::~XMLSliderWidget()
1272 {
1273
1274 }
1275
set(const QString & nwExpStr)1276 void XMLSliderWidget::set( const QString& nwExpStr )
1277 {
1278 float fval = env.evalFloat(nwExpStr);
1279 valueSlider->setValue(floatToInt(fval));
1280 }
1281
updateVisibility(const bool)1282 void XMLSliderWidget::updateVisibility( const bool /*vis*/ )
1283 {
1284 setVisibility(isImportant);
1285 }
1286
getWidgetExpression()1287 QString XMLSliderWidget::getWidgetExpression()
1288 {
1289 return valueLE->text();
1290 }
1291
setValue(int newv)1292 void XMLSliderWidget::setValue( int newv )
1293 {
1294 if( QString::number(intToFloat(newv)) != valueLE->text())
1295 valueLE->setText(QString::number(intToFloat(newv)));
1296 }
1297
setValue(float newValue)1298 void XMLSliderWidget::setValue( float newValue )
1299 {
1300 if(floatToInt(float(valueLE->text().toDouble())) != newValue)
1301 valueLE->setText(QString::number(intToFloat(newValue)));
1302 }
1303
setValue()1304 void XMLSliderWidget::setValue()
1305 {
1306 float newValLE=float(valueLE->text().toDouble());
1307 valueSlider->setValue(floatToInt(newValLE));
1308 emit dialogParamChanged();
1309 }
1310
intToFloat(int val)1311 float XMLSliderWidget::intToFloat( int val )
1312 {
1313 return minVal+float(val)/100.0f*(maxVal-minVal);
1314 }
1315
floatToInt(float val)1316 int XMLSliderWidget::floatToInt( float val )
1317 {
1318 return int (100.0f*(val-minVal)/(maxVal-minVal));
1319 }
1320
setVisibility(const bool vis)1321 void XMLSliderWidget::setVisibility( const bool vis )
1322 {
1323 valueLE->setVisible(vis);
1324 valueSlider->setVisible(vis);
1325 fieldDesc->setVisible(vis);
1326 }
1327
addWidgetToGridLayout(QGridLayout * lay,const int r)1328 void XMLSliderWidget::addWidgetToGridLayout( QGridLayout* lay,const int r )
1329 {
1330 if (lay != NULL)
1331 {
1332 lay->addWidget(fieldDesc,r,0);
1333 lay->addLayout(hlay,r,1);
1334 }
1335 XMLMeshLabWidget::addWidgetToGridLayout(lay,r);
1336 }
1337
XMLComboWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * p)1338 XMLComboWidget::XMLComboWidget( const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p )
1339 :XMLMeshLabWidget(xmlWidgetTag,envir,p)
1340 {
1341 enumLabel = new QLabel(this);
1342 enumLabel->setText(xmlWidgetTag[MLXMLElNames::guiLabel]);
1343 enumCombo = new QComboBox(this);
1344 enumCombo->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
1345
1346 hlay = new QHBoxLayout();
1347 hlay->addWidget(enumCombo);
1348 hlay->addWidget(perstb);
1349
1350 int def;
1351 try
1352 {
1353 def = envir.evalInt(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
1354 }
1355 catch (ExpressionHasNotThisTypeException& /*ex*/)
1356 {
1357 def = 0;
1358 }
1359 enumCombo->setCurrentIndex(def);
1360 //int row = gridLay->rowCount() - 1;
1361 //gridLay->addWidget(enumLabel,row,0,Qt::AlignTop);
1362 //gridLay->addWidget(enumCombo,row,1,Qt::AlignTop);
1363 connect(enumCombo,SIGNAL(activated(int)),this,SIGNAL(dialogParamChanged()));
1364 connect(this,SIGNAL(dialogParamChanged()),p,SIGNAL(parameterChanged()));
1365 setVisibility(isImportant);
1366 }
1367
setVisibility(const bool vis)1368 void XMLComboWidget::setVisibility( const bool vis )
1369 {
1370 enumLabel->setVisible(vis);
1371 enumCombo->setVisible(vis);
1372 }
1373
updateVisibility(const bool vis)1374 void XMLComboWidget::updateVisibility( const bool vis )
1375 {
1376 setVisibility(vis);
1377 }
1378
getWidgetExpression()1379 QString XMLComboWidget::getWidgetExpression()
1380 {
1381 return enumCombo->currentText();
1382 }
1383
~XMLComboWidget()1384 XMLComboWidget::~XMLComboWidget()
1385 {
1386
1387 }
1388
addWidgetToGridLayout(QGridLayout * lay,const int r)1389 void XMLComboWidget::addWidgetToGridLayout( QGridLayout* lay,const int r )
1390 {
1391 if (lay != nullptr)
1392 {
1393 lay->addWidget(enumLabel, r, 0);
1394 lay->addLayout(hlay, r, 1);
1395 }
1396 XMLMeshLabWidget::addWidgetToGridLayout(lay,r);
1397 }
1398
XMLEnumWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * p)1399 XMLEnumWidget::XMLEnumWidget( const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p )
1400 :XMLComboWidget(xmlWidgetTag,envir,p)
1401 {
1402 QString typ = xmlWidgetTag[MLXMLElNames::paramType];
1403 bool rr = MLXMLUtilityFunctions::getEnumNamesValuesFromString(typ,mp);
1404 if (rr)
1405 {
1406 for(QMap<int,QString>::iterator it = mp.begin();it != mp.end();++it)
1407 enumCombo->addItem(it.value(),QVariant(it.key()));
1408 enumCombo->setCurrentIndex(env.evalInt(xmlWidgetTag[MLXMLElNames::paramDefExpr]));
1409 }
1410 }
1411
getWidgetExpression()1412 QString XMLEnumWidget::getWidgetExpression()
1413 {
1414 return enumCombo->itemData(enumCombo->currentIndex()).toString();
1415 }
1416
1417
set(const QString & ind)1418 void XMLEnumWidget::set(const QString& ind)
1419 {
1420 int index = ind.toInt();
1421 auto it = mp.find(index);
1422 if (it != mp.end())
1423 enumCombo->setCurrentIndex(index);
1424 }
1425
XMLMeshWidget(MeshDocument * mdoc,const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * p)1426 XMLMeshWidget::XMLMeshWidget( MeshDocument* mdoc,const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p )
1427 :XMLEnumWidget(xmlWidgetTag,envir,p)
1428 {
1429 foreach(MeshModel* mm,mdoc->meshList)
1430 enumCombo->addItem(mm->shortName(),mm->id());
1431 int def = env.evalInt(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
1432 if (mdoc->getMesh(def))
1433 enumCombo->setCurrentIndex(def);
1434 }
1435
1436
XMLShotWidget(const MLXMLPluginInfo::XMLMap & xmlWidgetTag,EnvWrap & envir,QWidget * p)1437 XMLShotWidget::XMLShotWidget( const MLXMLPluginInfo::XMLMap& xmlWidgetTag,EnvWrap& envir,QWidget* p )
1438 :XMLMeshLabWidget(xmlWidgetTag,envir,p)
1439 {
1440 XMLStdParFrame* par = qobject_cast<XMLStdParFrame*>(p);
1441 if (par == NULL)
1442 throw MLException("Critical Error: A widget must have an instance of XMLStdParFrame as parent.");
1443 gla_curr = par->curr_gla;
1444 //int row = gridLay->rowCount() - 1;
1445 this->setShotValue(paramName,Shotm());
1446 paramName = xmlWidgetTag[MLXMLElNames::paramName];
1447 descLab = new QLabel(xmlWidgetTag[MLXMLElNames::guiLabel],this);
1448 //gridLay->addWidget(descLab,row,0,Qt::AlignTop);
1449 hlay = new QHBoxLayout();
1450 getShotButton = new QPushButton("Get Shot",this);
1451
1452 getShotButton->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
1453 getShotCombo = new QComboBox(this);
1454 int def;
1455 try
1456 {
1457 def = envir.evalInt(xmlWidgetTag[MLXMLElNames::paramDefExpr]);
1458 }
1459 catch (ExpressionHasNotThisTypeException& /*ex*/)
1460 {
1461 def = 0;
1462 }
1463 getShotCombo->setCurrentIndex(def);
1464 //int row = gridLay->rowCount() - 1;
1465 QStringList names;
1466 if(gla_curr) // if we have a connection to the current glarea we can setup the additional button for getting the current view direction.
1467 {
1468 names << "Current Trackball";
1469 names << "Current Mesh";
1470 names << "Current Raster";
1471 connect(gla_curr,SIGNAL(transmitShot(QString,Shotm)),this,SLOT(setShotValue(QString,Shotm)));
1472 connect(this,SIGNAL(askViewerShot(QString)),gla_curr,SLOT(sendViewerShot(QString)));
1473 connect(this,SIGNAL(askMeshShot(QString)), gla_curr,SLOT(sendMeshShot(QString)));
1474 connect(this,SIGNAL(askRasterShot(QString)),gla_curr,SLOT(sendRasterShot(QString)));
1475 }
1476 names << "From File";
1477 getShotCombo->addItems(names);
1478 hlay->addWidget(getShotCombo);
1479 hlay->addWidget(getShotButton);
1480
1481 connect(getShotCombo,SIGNAL(activated(int)),this,SIGNAL(dialogParamChanged()));
1482 connect(this,SIGNAL(dialogParamChanged()),p,SIGNAL(parameterChanged()));
1483 connect(getShotCombo,SIGNAL(currentIndexChanged(int)),this,SLOT(getShot()));
1484 connect(getShotButton,SIGNAL(clicked()),this,SLOT(getShot()));
1485 //gridLay->addLayout(hlay,row,1,Qt::AlignTop);
1486 setVisibility(isImportant);
1487 }
1488
getWidgetExpression()1489 QString XMLShotWidget::getWidgetExpression()
1490 {
1491 Matrix44m m = curShot.Extrinsics.Rot();
1492 Point3m t = curShot.Extrinsics.Tra();
1493 Scalarm foc = curShot.Intrinsics.FocalMm;
1494 Point2m pxs = curShot.Intrinsics.PixelSizeMm;
1495 Point2m cp = curShot.Intrinsics.CenterPx;
1496 vcg::Point2i vw = curShot.Intrinsics.ViewportPx;
1497 Point2m dist = curShot.Intrinsics.DistorCenterPx;
1498 Scalarm* k = curShot.Intrinsics.k;
1499 QString ms = "new " + MLXMLElNames::shotType + "([";
1500 for(int ii = 0;ii < 4;++ii)
1501 for(int jj = 0;jj < 4;++jj)
1502 ms = ms + QString::number(m[ii][jj]) + ",";
1503 ms += "],[";
1504 for(int ii = 0;ii < 3;++ii)
1505 ms = ms + QString::number(t[ii]) + ",";
1506 ms += "]," + QString::number(foc) + ",[";
1507 for(int ii = 0;ii < 2;++ii)
1508 ms = ms + QString::number(pxs[ii]) + ",";
1509 ms += "],[";
1510 for(int ii = 0;ii < 2;++ii)
1511 ms = ms + QString::number(cp[ii]) + ",";
1512 ms += "],[";
1513 for(int ii = 0;ii < 2;++ii)
1514 ms = ms + QString::number(vw[ii]) + ",";
1515 ms += "],[";
1516 for(int ii = 0;ii < 2;++ii)
1517 ms = ms + QString::number(dist[ii]) + ",";
1518 ms += "],[";
1519 for(int ii = 0;ii < 4;++ii)
1520 ms = ms + QString::number(k[ii]) + ",";
1521 ms += "])";
1522 //no ; it will be added by the addExpressionBinding
1523 return ms;
1524 }
1525
1526 //expr == new CameraShot(rotmat[0],....,rotmat[15],travec[0],..,travec[2],foc,pxs[0],pxs[1],centpxs[0],centpxs[1],viewpxs[0],viewpxs[1],distcent[0],distcent[1],k[0],...,k[3])
set(const QString & expr)1527 void XMLShotWidget::set( const QString & expr )
1528 {
1529 QString regexpstr = "(new\\s+" + MLXMLElNames::shotType + "\\(|\\)|\\[|\\])";
1530 QRegExp openexp(regexpstr);
1531 QString tmp(expr);
1532 tmp.remove(openexp);
1533 QStringList numbs = tmp.split(",",QString::SkipEmptyParts);
1534 if (numbs.size() != 32)
1535 {
1536 QString err = "Something bad happened in XMLShotWidget::set function: expected expression should match the following format : new " + MLXMLElNames::shotType + "(rotmat[0],....,rotmat[15],travec[0],..,travec[2],foc,pxs[0],pxs[1],centpxs[0],centpxs[1],viewpxs[0],viewpxs[1],distcent[0],distcent[1],k[0],...,k[3])";
1537 throw MLException(err);
1538 }
1539 int offset = 0;
1540 Matrix44m rot;
1541 int ii = 0;
1542 for(ii = 0;ii < 16;++ii)
1543 {
1544 bool ok = false;
1545 rot[ii / 4][ii % 4] = Scalarm(numbs[ii].toDouble(&ok));
1546 if (!ok)
1547 {
1548 QString err = "Something bad happened in XMLShotWidget::set function: bad value conversion to float.";
1549 throw MLException(err);
1550 }
1551 }
1552 offset += ii;
1553 curShot.Extrinsics.SetRot(rot);
1554 Point3m tra;
1555 for(ii = 0; ii < 3;++ii)
1556 {
1557 bool ok = false;
1558 tra[ii] = numbs[ii + offset].toFloat(&ok);
1559 if (!ok)
1560 {
1561 QString err = "Something bad happened in XMLShotWidget::set function: bad value conversion to float.";
1562 throw MLException(err);
1563 }
1564 }
1565 offset += ii;
1566 curShot.Extrinsics.SetTra(tra);
1567 bool ok = false;
1568 curShot.Intrinsics.FocalMm = numbs[offset].toFloat(&ok);
1569 if (!ok)
1570 {
1571 QString err = "Something bad happened in XMLShotWidget::set function: bad value conversion to float.";
1572 throw MLException(err);
1573 }
1574 ++offset;
1575 Point2m tmp2vcf;
1576 for(ii = 0; ii < 2;++ii)
1577 {
1578 bool ok = false;
1579 tmp2vcf[ii] = numbs[ii + offset].toFloat(&ok);
1580 if (!ok)
1581 {
1582 QString err = "Something bad happened in XMLShotWidget::set function: bad value conversion to float.";
1583 throw MLException(err);
1584 }
1585 }
1586 offset += ii;
1587 curShot.Intrinsics.PixelSizeMm = tmp2vcf;
1588 for(ii = 0; ii < 2;++ii)
1589 {
1590 bool ok = false;
1591 tmp2vcf[ii] = numbs[ii + offset].toFloat(&ok);
1592 if (!ok)
1593 {
1594 QString err = "Something bad happened in XMLShotWidget::set function: bad value conversion to float.";
1595 throw MLException(err);
1596 }
1597 }
1598 offset += ii;
1599 curShot.Intrinsics.CenterPx = tmp2vcf;
1600 vcg::Point2i tmp2vci;
1601 for(ii = 0; ii < 2;++ii)
1602 {
1603 bool ok = false;
1604 tmp2vci[ii] = numbs[ii + offset].toInt(&ok);
1605 if (!ok)
1606 {
1607 QString err = "Something bad happened in XMLShotWidget::set function: bad value conversion to float.";
1608 throw MLException(err);
1609 }
1610 }
1611 offset += ii;
1612 curShot.Intrinsics.ViewportPx = tmp2vci;
1613 for(ii = 0; ii < 2;++ii)
1614 {
1615 bool ok = false;
1616 tmp2vcf[ii] = numbs[ii + offset].toFloat(&ok);
1617 if (!ok)
1618 {
1619 QString err = "Something bad happened in XMLShotWidget::set function: bad value conversion to float.";
1620 throw MLException(err);
1621 }
1622 }
1623 offset += ii;
1624 curShot.Intrinsics.DistorCenterPx = tmp2vcf;
1625 for(ii = 0; ii < 4;++ii)
1626 {
1627 bool ok = false;
1628 curShot.Intrinsics.k[ii] = numbs[ii + offset].toFloat(&ok);
1629 if (!ok)
1630 {
1631 QString err = "Something bad happened in XMLShotWidget::set function: bad value conversion to float.";
1632 throw MLException(err);
1633 }
1634 }
1635 offset += ii;
1636 }
1637
getShot()1638 void XMLShotWidget::getShot()
1639 {
1640 int index = getShotCombo->currentIndex();
1641 switch(index) {
1642 case 0 : emit askViewerShot(paramName); break;
1643 case 1 : emit askMeshShot(paramName); break;
1644 case 2 : emit askRasterShot(paramName); break;
1645 case 3:
1646 {
1647 QString filename = QFileDialog::getOpenFileName(this, tr("Load xml camera"), "./", tr("Xml Files (*.xml)"));
1648 QFile qf(filename);
1649 QFileInfo qfInfo(filename);
1650
1651 if( !qf.open(QIODevice::ReadOnly ) )
1652 return ;
1653
1654 QDomDocument doc("XmlDocument"); //It represents the XML document
1655 if(!doc.setContent( &qf )) return;
1656 qf.close();
1657
1658 QString type = doc.doctype().name();
1659
1660 //TextAlign file project
1661 //if(type == "RegProjectML") loadShotFromTextAlignFile(doc);
1662 //View State file
1663 //else if(type == "ViewState") loadViewFromViewStateFile(doc);
1664
1665 //qDebug("End file reading");
1666
1667
1668 // return true;
1669 }
1670 default : assert(0);
1671 }
1672 }
1673
setShotValue(QString name,Shotm newVal)1674 void XMLShotWidget::setShotValue(QString name,Shotm newVal)
1675 {
1676 if(name==paramName)
1677 {
1678 curShot=newVal;
1679 }
1680 }
1681
updateVisibility(const bool vis)1682 void XMLShotWidget::updateVisibility( const bool vis )
1683 {
1684 setVisibility(vis);
1685 }
1686
setVisibility(const bool vis)1687 void XMLShotWidget::setVisibility( const bool vis )
1688 {
1689 descLab->setVisible(vis);
1690 getShotCombo->setVisible(vis);
1691 getShotButton->setVisible(vis);
1692 }
1693
addWidgetToGridLayout(QGridLayout * lay,const int r)1694 void XMLShotWidget::addWidgetToGridLayout( QGridLayout* lay,const int r )
1695 {
1696 if (lay != NULL)
1697 {
1698 lay->addWidget(descLab,r,0);
1699 lay->addLayout(hlay,r,1);
1700 }
1701 XMLMeshLabWidget::addWidgetToGridLayout(lay,r);
1702 }
1703
1704
1705
OldScriptingSystemXMLParamDialog(QMap<QString,QString> & currparamvalues,MeshLabXMLFilterContainer & mfc,PluginManager & pm,MeshDocument * md,MainWindowInterface * mwi,QWidget * p,QWidget * gla)1706 OldScriptingSystemXMLParamDialog::OldScriptingSystemXMLParamDialog(QMap<QString,QString>& currparamvalues,MeshLabXMLFilterContainer& mfc, PluginManager& pm, MeshDocument * md, MainWindowInterface *mwi, QWidget* p, QWidget *gla)
1707 : QDialog(p),_env(),_paramvalues(currparamvalues),_stdparframe(NULL),_mfc(mfc),_pm(pm),_meshdocument(md),_mwi(mwi),_gla(gla),_showhelp(false)
1708 {
1709 createFrame();
1710 if (mfc.act != NULL)
1711 setWindowTitle(mfc.act->text());
1712 }
1713
~OldScriptingSystemXMLParamDialog()1714 OldScriptingSystemXMLParamDialog::~OldScriptingSystemXMLParamDialog()
1715 {
1716 delete _stdparframe;
1717 }
1718
1719 // update the values of the widgets with the values in the paramlist;
resetValues()1720 void OldScriptingSystemXMLParamDialog::resetValues()
1721 {
1722 if ((_mfc.act != NULL) && (_mfc.xmlInfo != NULL))
1723 {
1724 QString fname(_mfc.act->text());
1725 MLXMLPluginInfo::XMLMapList mplist = _mfc.xmlInfo->filterParametersExtendedInfo(fname);
1726 for (int ii = 0; ii < mplist.size(); ++ii)
1727 {
1728 if (mplist[ii][MLXMLElNames::paramIsPersistent] != QString("true"))
1729 {
1730 if (!_stdparframe->setValue(mplist[ii][MLXMLElNames::paramName], mplist[ii][MLXMLElNames::paramDefExpr]))
1731 {
1732 QString err = QString("MeshLabXMLStdDialog: the widget corresponding to the parameter ") + mplist[ii][MLXMLElNames::paramName] + " has not been found!";
1733 throw MLException(err.toLocal8Bit());
1734 }
1735 }
1736 }
1737 }
1738 }
1739
1740
createFrame()1741 void OldScriptingSystemXMLParamDialog::createFrame()
1742 {
1743 //if ((_mfc.act != NULL) && (_mfc.xmlInfo != NULL))
1744 //{
1745 // QString fname(_mfc.act->text());
1746 // MLXMLPluginInfo::XMLMapList mplist = _mfc.xmlInfo->filterParametersExtendedInfo(fname);
1747 // if (mplist.size() != _paramvalues.size())
1748 // MLException("OldScriptingSystemXMLParamDialog::createFrame() : Something really bad happened. The mplist and _paramvalues MUST have the same number of items.");
1749
1750 // QVBoxLayout *vboxLayout = new QVBoxLayout(this);
1751 // setLayout(vboxLayout);
1752
1753 // GLArea* tmpgl = qobject_cast<GLArea*>(_gla);
1754
1755 // if (tmpgl != NULL)
1756 // _env.loadMLScriptEnv(*_meshdocument,_pm,tmpgl->mw()->currentGlobalPars());
1757 // else
1758 // _env.loadMLScriptEnv(*_meshdocument,_pm);
1759
1760 // EnvWrap envwrap(_env);
1761 // _stdparframe = new XMLStdParFrame(this);
1762 // _stdparframe->loadFrameContent(mplist, envwrap,_meshdocument);
1763 // for(int ii = 0;ii < mplist.size();++ii)
1764 // {
1765 // QMap<QString,QString>::iterator it = _paramvalues.find(mplist[ii][MLXMLElNames::paramName]);
1766 // if (it == _paramvalues.end())
1767 // {
1768 // QString err = "OldScriptingSystemXMLParamDialog::createFrame() : Something really bad happened. Param " + mplist[ii][MLXMLElNames::paramName] + " has not been found in the _paramvalues map.";
1769 // throw MLException(err);
1770 // }
1771 // _stdparframe->xmlfieldwidgets[ii]->set(it.value());
1772 // //in this dialog we will not make distinction between important/not-important parameters
1773 // _stdparframe->xmlfieldwidgets[ii]->setVisibility(true);
1774
1775 // }
1776 // layout()->addWidget(_stdparframe);
1777
1778 // QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Help | QDialogButtonBox::Ok | QDialogButtonBox::Cancel );
1779 // //add the reset button so we can get its signals
1780 // QPushButton *resetButton = buttonBox->addButton(QDialogButtonBox::Reset);
1781 // layout()->addWidget(buttonBox);
1782
1783 // connect(buttonBox, SIGNAL(accepted()), this, SLOT(getAccept()));
1784 // connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
1785 // connect(buttonBox, SIGNAL(helpRequested()), this, SLOT(toggleHelp()));
1786 // connect(resetButton, SIGNAL(clicked()), this, SLOT(resetValues()));
1787
1788 // setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
1789
1790 // //set the minimum size so it will shrink down to the right size after the help is toggled
1791 // this->setMinimumSize(_stdparframe->sizeHint());
1792 // this->showNormal();
1793 // this->adjustSize();
1794 //}
1795 }
1796
1797
getAccept()1798 void OldScriptingSystemXMLParamDialog::getAccept()
1799 {
1800 /*if ((_mfc.act != NULL) && (_mfc.xmlInfo != NULL))
1801 {
1802 QString fname(_mfc.act->text());
1803 MLXMLPluginInfo::XMLMapList mplist = _mfc.xmlInfo->filterParametersExtendedInfo(fname);
1804 if (_stdparframe->xmlfieldwidgets.size() != _paramvalues.size())
1805 MLException("OldScriptingSystemXMLParamDialog::getAccept() : Something really bad happened. The _stdparframe->xmlfieldwidgets and _paramvalues MUST have the same number of items.");
1806 for(int ii = 0;ii < mplist.size();++ii)
1807 {
1808 QMap<QString,QString>::iterator it = _paramvalues.find(mplist[ii][MLXMLElNames::paramName]);
1809 if (it == _paramvalues.end())
1810 {
1811 QString err = "OldScriptingSystemXMLParamDialog::createFrame() : Something really bad happened. Param " + mplist[ii][MLXMLElNames::paramName] + " has not been found in the _paramvalues map.";
1812 throw MLException(err);
1813 }
1814 it.value() = _stdparframe->xmlfieldwidgets[ii]->getWidgetExpression();
1815 }
1816 accept();
1817 }
1818 reject();*/
1819 }
1820
toggleHelp()1821 void OldScriptingSystemXMLParamDialog::toggleHelp()
1822 {
1823 _showhelp = !_showhelp;
1824 _stdparframe->toggleHelp(_showhelp);
1825 updateGeometry();
1826 adjustSize();
1827 }
1828
XMLPersistenToolbox(QWidget * parent)1829 XMLPersistenToolbox::XMLPersistenToolbox(QWidget* parent)
1830 :QFrame(parent)
1831 {
1832 //setStyleSheet("QFrame {margin-top:0;margin-bottom:0;margin-right:0;margin-left:0;shape:box}");
1833 QMargins m(0, 0, 0, 0);
1834 setContentsMargins(m);
1835 QVBoxLayout* layout = new QVBoxLayout();
1836 layout->setSpacing(0);
1837 QFont f;
1838 int pointsize = 5;
1839 int widsize = pointsize * 3;
1840 f.setPointSize(pointsize);
1841 QPushButton* savebutton = new QPushButton(tr("S"), this);
1842 savebutton->setFont(f);
1843 savebutton->setToolTipDuration(0);
1844 savebutton->setToolTip(tr("Save"));
1845 savebutton->setFixedSize(widsize, widsize);
1846 connect(savebutton, SIGNAL(clicked()), this, SLOT(saveClicked()));
1847 QPushButton* loadbutton = new QPushButton(tr("L"), this);
1848 loadbutton->setFont(f);
1849 loadbutton->setToolTip(tr("Load"));
1850 loadbutton->setFixedSize(widsize, widsize);
1851 connect(loadbutton, SIGNAL(clicked()), this, SLOT(loadClicked()));
1852
1853 layout->addWidget(savebutton);
1854 layout->addWidget(loadbutton);
1855 layout->setContentsMargins(m);
1856
1857 setLayout(layout);
1858 }
1859
saveClicked()1860 void XMLPersistenToolbox::saveClicked()
1861 {
1862 emit saveRequested();
1863 }
1864
loadClicked()1865 void XMLPersistenToolbox::loadClicked()
1866 {
1867 emit loadRequested();
1868 }
1869