detailedapplicationview.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of ArmarX.
3  *
4  * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
5  *
6  * ArmarX is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * ArmarX is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  *
18  * @package ArmarXCore::core
19  * @author Cedric Seehausen (usdnr at kit dot edu)
20  * @date 2016
21  * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
22  * GNU General Public License
23  */
24 
25 #include "detailedapplicationview.h"
26 #include <ArmarXGui/gui-plugins/ScenarioManager/gui/ui_detailedapplicationview.h>
27 
28 #include <QMenu>
29 #include <QToolButton>
30 #include <ArmarXCore/core/logging/Logging.h>
31 #include <ArmarXCore/core/util/algorithm.h>
32 #include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
33 #include <ArmarXCore/core/application/properties/PropertyDefinitionHelpFormatter.h>
34 #include <ArmarXCore/util/ScenarioManagerCommon/parser/XMLScenarioParser.h>
35 #include <ArmarXCore/util/ScenarioManagerCommon/parser/PackageBuilder.h>
36 
37 #define UPDATE_TIMER_INTERVAL 500
38 
39 using namespace ScenarioManager;
40 using namespace Data_Structure;
41 
42 // Returns {package, scenario}
43 std::pair<std::string, std::string> scenarioInfoFromLink(const std::filesystem::path& linkpath)
44 {
45  auto instancePath = std::filesystem::canonical(linkpath);
46  auto scenarioFolder = instancePath.parent_path().parent_path();
47  std::string scenarioName = scenarioFolder.filename();
48  auto scenarioScx = scenarioFolder / (scenarioName + ".scx");
49  if (!std::filesystem::exists(scenarioScx))
50  {
51  return {"unknown", "unknown"};
52  }
53  auto packageName = ScenarioManager::Parser::XMLScenarioParser().getPackageNameFromScx(scenarioScx);
54 
55  if (packageName.empty())
56  {
57  return {"unknown", scenarioName};
58  }
59 
60  return {packageName, scenarioName};
61 }
62 
63 DetailedApplicationView::DetailedApplicationView(QWidget* parent) :
64  QWidget(parent),
65  ui(new Ui::DetailedApplicationView),
66  variantManager(nullptr),
67  variantFactory(nullptr),
68  statusUpdateRelevant(false),
69  lastScenarioItem(nullptr),
70  neadsUpdate(false)
71 {
72  updateTimer.setSingleShot(true);
73  QObject::connect(&updateTimer, SIGNAL(timeout()), this, SLOT(on_fileUpdate()));
74 }
75 
76 DetailedApplicationView::~DetailedApplicationView()
77 {
78  delete ui;
79 }
80 
81 void DetailedApplicationView::init()
82 {
83  ui->setupUi(this);
84  variantManager = std::shared_ptr<OptionalVariantManager>(new OptionalVariantManager());
85  variantFactory = std::shared_ptr<OptionalVariantFactory>(new OptionalVariantFactory());
86 
87  ui->propertyBrowser->setFactoryForManager(variantManager.get(), variantFactory.get());
88 
89  ui->propertyBrowser->setAlternatingRowColors(true);
90  ui->propertyBrowser->setResizeMode(QtTreePropertyBrowser::ResizeMode::Interactive);
91  ui->propertyBrowser->setSplitterPosition(200);
92 
93  QObject::connect(variantManager.get(), SIGNAL(valueChanged(QtProperty*, const QVariant&)),
94  this, SLOT(itemChanged(QtProperty*, const QVariant&)));
95 
96  QObject::connect(variantManager.get(), SIGNAL(attributeChanged(QtProperty*, const QString&, const QVariant&)),
97  this, SLOT(itemAttributeChanged(QtProperty*, const QString&, const QVariant&)));
98 
99 
100  void attributeChanged(QtProperty * property,
101  const QString & attribute, const QVariant & val);
102 
103  ui->linkedInfoLabel->setVisible(false);
104  ui->makeLocalButton->setVisible(false);
105  ui->addParameterButton->setEnabled(false);
106  //QObject::connect(variantManager.get(), SIGNAL())
107 }
108 
109 void DetailedApplicationView::showApplication(ScenarioManager::Data_Structure::ApplicationPtr application)
110 {
111  if (application.get() == nullptr)
112  {
113  return;
114  }
115  if (variantManager.get() == nullptr || variantFactory.get() == nullptr)
116  {
117  init();
118  }
119 
120  ui->dataLabel->setText(QString::fromStdString(application->getName()));
121 
122  lastAppInstance = ApplicationInstancePtr();
123  lastScenario = ScenarioPtr();
124  lastScenarioItem = nullptr;
125  statusUpdateRelevant = false;
126 
127  ui->stateLabel->setStyleSheet("QLabel { color : black; }");
128  ui->stateLabel->setText("No Status");
129 
130  ui->startButton->setEnabled(false);
131  ui->stopButton->setEnabled(false);
132  ui->restartButton->setEnabled(false);
133  ui->addParameterButton->setEnabled(false);
134  ui->addParameterButton->setMenu(nullptr);
135 
136  ui->toolButton->setEnabled(false);
137 
138  //build propertybrowser items
139  variantManager->clear();
140  static_cast<OptionalVariantFactory*>(variantFactory.get())->setElementName(QString::fromStdString(application->getName()));
141  ui->propertyBrowser->clear();
142 
143  QtProperty* appTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
144  QLatin1String("Application"));
145 
146  appTopItem->setEnabled(false);
147 
148  QtVariantProperty* nameItem = variantManager->addProperty(QVariant::String, QString("Name"));
149  nameItem->setValue(QString::fromStdString(application->getName()));
150  appTopItem->addSubProperty(nameItem);
151 
152  QtVariantProperty* execPathItem = variantManager->addProperty(QVariant::String, QString("Executable Path"));
153  execPathItem->setValue(QString::fromStdString(application->getPathToExecutable()));
154  appTopItem->addSubProperty(execPathItem);
155 
156  QtProperty* appPropertyTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
157  QLatin1String("Default Properties"));
158  appTopItem->addSubProperty(appPropertyTopItem);
159 
160  armarx::PropertyDefinitionsPtr props = application->getProperties();
161 
162  Ice::PropertyDict dict = props->getProperties()->getPropertiesForPrefix("");
163 
164  for (auto const& property : dict)
165  {
166  QStringList valueList;
167  if (props->hasDefinition(property.first))
168  {
169  armarx::PropertyDefinition<std::string> propDef = props->getDefintion<std::string>(property.first);
170  auto keys = armarx::getMapKeys(propDef.getValueMap());
171  ARMARX_INFO << VAROUT(keys);
172  for (auto& key : keys)
173  {
174  valueList << QString::fromStdString(key);
175  }
176  }
177  else
178  {
179  ARMARX_WARNING << "Could not find definition: " << property.first;
180  }
181 
182 
183  QtVariantProperty* appPropertyItem = variantManager->addProperty(QVariant::String, QString::fromStdString(property.first));
184 
185  appPropertyItem->setAttribute("PossibleValues", valueList);
186 
187  appPropertyItem->setValue(QString::fromStdString(property.second));
188  appPropertyItem->setStatusTip(QString::fromStdString(props->getDescription()));
189  if (property.second.compare("<set value!>") == 0 || property.second.compare("::_NOT_SET_::") == 0)
190  {
191  //There is currently no way to change colors of any sort in qtproperty browser but if you later want to add this do it here
192  }
193  appPropertyTopItem->addSubProperty(appPropertyItem);
194  }
195 
196  ui->propertyBrowser->addProperty(appTopItem);
197  ui->propertyBrowser->setRootIsDecorated(false);
198 }
199 
200 void DetailedApplicationView::showApplicationInstance(ApplicationInstancePtr appInstance, ScenarioItem* item)
201 {
202  if (appInstance.get() == nullptr)
203  {
204  showPackage(PackagePtr());
205  return;
206  }
207 
208  if (variantManager.get() == nullptr || variantFactory.get() == nullptr)
209  {
210  init();
211  }
212 
213  if (appInstance->getStatus() == "Running")
214  {
215  ui->stateLabel->setStyleSheet("QLabel { color : green; }");
216  //stateLabelPallet.setColor(QPalette::WindowText, Qt::blue);
217  }
218  else if (appInstance->getStatus().compare("Stopped") == 0)
219  {
220  ui->stateLabel->setStyleSheet("QLabel { color : red; }");
221  }
222  else if (appInstance->getStatus().compare("Inactive") == 0)
223  {
224  ui->stateLabel->setStyleSheet("QLabel { color : gray; }");
225  }
226  else
227  {
228  ui->stateLabel->setStyleSheet("QLabel { color : black; }");
229  }
230 
231  bool readOnly = appInstance->isReadOnly();
232  ui->linkedInfoLabel->setVisible(readOnly);
233  ui->linkedInfoLabel->setText("Linked Application - read only");
234  ui->linkedInfoLabel->setToolTip(
235  "The application's config file is a link to another file, making it read only");
236  ui->makeLocalButton->setVisible(readOnly);
237  ui->makeLocalButton->setToolTip("Replace the linked application with a local copy");
238  ui->addParameterButton->setEnabled(!readOnly);
239 
240  std::string label = appInstance->getName();
241  if (readOnly)
242  {
243  auto [package, scenario] = scenarioInfoFromLink(appInstance->getConfigPath());
244  label += " -> " + scenario;
245  std::string tooltip;
246  if (package == "unknown")
247  {
248  tooltip = "Could not determine original scenario for config '" +
249  std::string(std::filesystem::canonical(appInstance->getConfigPath())) + "'";
250  }
251  else
252  {
253  tooltip = "Original is in " +
254  (package == "unknown" ? "unknown package" : "package " + package) +
255  ", scenario " + scenario;
256  }
257  ui->dataLabel->setToolTip(QString::fromStdString(tooltip));
258  }
259  ui->dataLabel->setText(QString::fromStdString(label));
260 
261  statusUpdateRelevant = true;
262  lastAppInstance = appInstance;
263  lastScenario = ScenarioPtr(nullptr);
264  if (item != nullptr)
265  {
266  lastScenarioItem = item;
267  }
268 
269  if (lastAppInstance->getEnabled())
270  {
271  ui->startButton->setEnabled(true);
272  ui->stopButton->setEnabled(true);
273  ui->restartButton->setEnabled(true);
274  }
275  else
276  {
277  ui->startButton->setEnabled(false);
278  ui->stopButton->setEnabled(false);
279  ui->restartButton->setEnabled(false);
280  }
281 
282  ui->addParameterButton->setMenu(nullptr);
283  ui->toolButton->setEnabled(true);
284 
285  //build propertybrowser items
286  variantManager->clear();
287  static_cast<OptionalVariantFactory*>(variantFactory.get())->setElementName(QString::fromStdString(appInstance->getName()));
288  ui->propertyBrowser->clear();
289 
290  QtProperty* appInstanceTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
291  QLatin1String("ApplicationInstance"));
292 
293  if (!appInstance->isConfigWritable())
294  {
295  appInstanceTopItem->setEnabled(false);
296  }
297 
298  QtVariantProperty* nameItem = variantManager->addProperty(QVariant::String, QString("Name"));
299 
300  nameItem->setValue(QString::fromStdString(appInstance->getName()));
301  appInstanceTopItem->addSubProperty(nameItem);
302 
303  QtVariantProperty* execPathItem = variantManager->addProperty(QVariant::String, QString("Executable Path"));
304  execPathItem->setValue(QString::fromStdString(appInstance->getPathToExecutable()));
305  appInstanceTopItem->addSubProperty(execPathItem);
306 
307  QtVariantProperty* instanceNameItem = variantManager->addProperty(QVariant::String, QString("Instance Name"));
308  instanceNameItem->setValue(QString::fromStdString(appInstance->getInstanceName()));
309  appInstanceTopItem->addSubProperty(instanceNameItem);
310 
311  QtVariantProperty* configPathItem = variantManager->addProperty(QVariant::String, QString("Config Path"));
312  configPathItem->setValue(QString::fromStdString(appInstance->getConfigPath()));
313  appInstanceTopItem->addSubProperty(configPathItem);
314 
315  QtVariantProperty* pidItem = variantManager->addProperty(QVariant::Int, QString("Pid (Stopped = -1)"));
316  pidItem->setValue(appInstance->getPid());
317  pidItem->setEnabled(false);
318  appInstanceTopItem->addSubProperty(pidItem);
319 
320  QtVariantProperty* enabledItem = variantManager->addProperty(QVariant::Bool, QString("Enabled"));
321  enabledItem->setValue(appInstance->getEnabled());
322  appInstanceTopItem->addSubProperty(enabledItem);
323 
324  QtProperty* appPropertyTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
325  QLatin1String("Properties"));
326  appInstanceTopItem->addSubProperty(appPropertyTopItem);
327 
328  armarx::PropertyDefinitionsPtr props = appInstance->getProperties();
329 
330  Ice::PropertyDict dict = props->getProperties()->getPropertiesForPrefix("");
331 
332  for (auto const& property : dict)
333  {
334  if (property.first != "Ice.Config")
335  {
336  QStringList valueList;
337  if (props->hasDefinition(property.first))
338  {
339  armarx::PropertyDefinition<std::string> propDef = props->getDefintion<std::string>(property.first);
340  auto keys = armarx::getMapKeys(propDef.getValueMap());
341  for (auto& key : keys)
342  {
343  valueList << QString::fromStdString(key);
344  }
345  }
346  else
347  {
348  ARMARX_WARNING << "Could not find definition: " << property.first;
349  }
350 
351 
352 
353 
354 
355 
356  QtVariantProperty* appPropertyItem;
357  if (appInstance->isDefaultProperty(property.first))
358  {
359  appPropertyItem = variantManager->addProperty(OptionalVariantManager::optionalProprtyTypeId(), QString::fromStdString(property.first));
360 
361  appPropertyItem->setAttribute(QLatin1String("enabled"), QVariant(appInstance->isDefaultPropertyEnabled(property.first)));
362  }
363  else
364  {
365  appPropertyItem = variantManager->addProperty(QVariant::String, QString::fromStdString(property.first));
366  }
367  appPropertyItem->setValue(QString::fromStdString(property.second));
368  appPropertyItem->setAttribute(QLatin1String("PossibleValues"), QVariant(valueList));
369 
370  try
371  {
372  armarx::PropertyDefinitionHelpFormatter formatter;
373  auto helpString = props->getDefintion<std::string>(property.first).toString(formatter, props->getValue(property.first));
374 
375  QString result = QString::fromStdString("Current value: " + property.second + "\n\n" + helpString);
376  appPropertyItem->setToolTip(result);
377  }
378  catch (armarx::LocalException&)
379  {
380  //nothing to do
381  }
382 
383  appPropertyItem->setAttribute(QLatin1String("readOnly"), QVariant(appInstance->isReadOnly()));
384 
385  appPropertyTopItem->addSubProperty(appPropertyItem);
386  }
387  }
388 
389  QtProperty* appIcePropertyTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
390  QLatin1String("Ice Deployment Properties"));
391  appInstanceTopItem->addSubProperty(appIcePropertyTopItem);
392 
393  QtVariantProperty* nodePropertyItem = variantManager->addProperty(QVariant::String, "Node Name");
394  nodePropertyItem->setValue(QString::fromStdString(appInstance->getNodeName()));
395  nodePropertyItem->setToolTip("Describes on which Node the current Application should be deployed on");
396  nodePropertyItem->setAttribute(QLatin1String("readOnly"), QVariant(appInstance->isReadOnly()));
397  appIcePropertyTopItem->addSubProperty(nodePropertyItem);
398 
399  QtVariantProperty* iceAutoRestartItem = variantManager->addProperty(QVariant::Bool, "Ice Auto Restart");
400  iceAutoRestartItem->setValue(appInstance->getIceAutoRestart());
401  iceAutoRestartItem->setToolTip("Describes if Ice should automatically restart this Application");
402  iceAutoRestartItem->setAttribute("enabled", QVariant(appInstance->isReadOnly()));
403  appIcePropertyTopItem->addSubProperty(iceAutoRestartItem);
404 
405  ui->propertyBrowser->addProperty(appInstanceTopItem);
406  ui->propertyBrowser->setRootIsDecorated(false);
407 }
408 
409 void DetailedApplicationView::showScenario(ScenarioPtr scenario)
410 {
411  if (scenario.get() == nullptr)
412  {
413  showPackage(PackagePtr());
414  return;
415  }
416 
417  if (variantManager.get() == nullptr || variantFactory.get() == nullptr)
418  {
419  init();
420  }
421 
422 
423  ui->dataLabel->setText(QString::fromStdString(scenario->getName()));
424  statusUpdateRelevant = true;
425  lastScenario = scenario;
426  lastAppInstance = ApplicationInstancePtr(nullptr);
427  lastScenarioItem = nullptr;
428 
429  QAction* addVariableToScenarioAction = new QAction(this);
430  QIcon icon;
431  icon.addFile(QString::fromUtf8(":/icons/images/add.png"), QSize(), QIcon::Normal, QIcon::Off);
432  addVariableToScenarioAction->setIcon(icon);
433  addVariableToScenarioAction->setIconVisibleInMenu(true);
434  addVariableToScenarioAction->setText("Add Scenario Variable");
435  addVariableToScenarioAction->setToolTip("Add an Variable to the Scenario");
436  connect(addVariableToScenarioAction, SIGNAL(triggered()), this, SLOT(on_addParameterButton_clicked()));
437 
438  QAction* addVariableToIceAction = new QAction(this);
439  addVariableToIceAction->setIcon(icon);
440  addVariableToIceAction->setIconVisibleInMenu(true);
441  addVariableToIceAction->setText("Add Ice Enviroment Variable");
442  addVariableToIceAction->setToolTip("Add an Ice Enviroment Variable to the Scenario");
443  connect(addVariableToIceAction, SIGNAL(triggered()), this, SLOT(on_addIceEnvButton_clicked()));
444 
445  QMenu* subMenu = new QMenu(this);
446  subMenu->addAction(addVariableToScenarioAction);
447  subMenu->addAction(addVariableToIceAction);
448 
449 
450  bool readOnly = scenario->isReadOnly();
451  ui->linkedInfoLabel->setVisible(readOnly);
452  ui->linkedInfoLabel->setText("Linked Scenario config - read only");
453  ui->linkedInfoLabel->setToolTip(
454  "The Secnario's global configuration is a link to another file, making it read only");
455  ui->makeLocalButton->setVisible(readOnly);
456  ui->makeLocalButton->setToolTip("Replace the linked global scenario configuration with a local copy. Does not alter any applications.");
457  ui->addParameterButton->setEnabled(!readOnly);
458 
459  std::string label = scenario->getName();
460  if (readOnly)
461  {
462  auto [package, origScenario] = scenarioInfoFromLink(scenario->getGlobalConfigPath());
463  label += " -> " + origScenario;
464  std::string tooltip;
465  if (package == "unknown")
466  {
467  tooltip = "Could not determine original scenario for config '" +
468  std::string(std::filesystem::canonical(scenario->getGlobalConfigPath())) + "'";
469  }
470  else
471  {
472  tooltip = "Original is in " +
473  (package == "unknown" ? "unknown package" : "package " + package) +
474  ", scenario " + origScenario;
475  }
476  ui->dataLabel->setToolTip(QString::fromStdString(tooltip));
477  }
478  ui->dataLabel->setText(QString::fromStdString(label));
479 
480  //ui->addParameterButton->setPopupMode(QToolButton::InstantPopup);
481  ui->addParameterButton->setMenu(subMenu);
482 
483 
484  if (scenario->getStatus().compare("Running") == 0)
485  {
486  ui->stateLabel->setStyleSheet("QLabel { color : green; }");
487  //stateLabelPallet.setColor(QPalette::WindowText, Qt::blue);
488  }
489  else if (scenario->getStatus().compare("Stopped") == 0)
490  {
491  ui->stateLabel->setStyleSheet("QLabel { color : red; }");
492  }
493  else if (scenario->getStatus().compare("Inactive") == 0)
494  {
495  ui->stateLabel->setStyleSheet("QLabel { color : gray; }");
496  }
497  else if (scenario->getStatus().compare("Mixed") == 0)
498  {
499  ui->stateLabel->setStyleSheet("QLabel { color : darkYellow; }");
500  }
501  else
502  {
503  ui->stateLabel->setStyleSheet("QLabel { color : black; }");
504  }
505 
506 
507  ui->stateLabel->setText(QString::fromStdString(scenario->getStatus()));
508 
509  ui->startButton->setEnabled(true);
510  ui->restartButton->setEnabled(true);
511  ui->stopButton->setEnabled(true);
512  ui->toolButton->setEnabled(true);
513 
514  //build propertybrowser items
515  variantManager->clear();
516  static_cast<OptionalVariantFactory*>(variantFactory.get())->setElementName(QString::fromStdString(scenario->getName()));
517  ui->propertyBrowser->clear();
518 
519  QtProperty* scenarioTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
520  QLatin1String("Scenario"));
521  if (!scenario->isScenarioFileWriteable())
522  {
523  scenarioTopItem->setEnabled(false);
524  }
525 
526  QtVariantProperty* nameItem = variantManager->addProperty(QVariant::String, QString("Name"));
527  nameItem->setValue(QString::fromStdString(scenario->getName()));
528  scenarioTopItem->addSubProperty(nameItem);
529 
530  QtVariantProperty* scenarioPathItem = variantManager->addProperty(QVariant::String, QString("Scenario Path"));
531  scenarioPathItem->setValue(QString::fromStdString(scenario->getPath()));
532  scenarioTopItem->addSubProperty(scenarioPathItem);
533 
534  QtVariantProperty* createdAtItem = variantManager->addProperty(QVariant::String, QString("Created At"));
535  createdAtItem->setValue(QString::fromStdString(scenario->getCreationTime()));
536  scenarioTopItem->addSubProperty(createdAtItem);
537 
538  QtVariantProperty* lastChangeItem = variantManager->addProperty(QVariant::String, QString("Last Change At"));
539  lastChangeItem->setValue(QString::fromStdString(scenario->getLastChangedTime()));
540  scenarioTopItem->addSubProperty(lastChangeItem);
541 
542  QtProperty* scenarioPropertyTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
543  QLatin1String("Scenario Properties"));
544  scenarioTopItem->addSubProperty(scenarioPropertyTopItem);
545  if (!scenario->isGlobalConfigWritable())
546  {
547  scenarioPropertyTopItem->setEnabled(false);
548  }
549 
550  armarx::PropertyDefinitionsPtr props = scenario->getGlobalConfig();
551 
552  Ice::PropertyDict dict = props->getProperties()->getPropertiesForPrefix("");
553 
554  for (auto const& property : dict)
555  {
556  if (property.first != "Ice.Config")
557  {
558  QtVariantProperty* scenarioPropertyItem = variantManager->addProperty(QVariant::String, QString::fromStdString(property.first));
559  scenarioPropertyItem->setValue(QString::fromStdString(property.second));
560  try
561  {
562  scenarioPropertyItem->setToolTip(QString::fromStdString(props->getDefintion<std::string>(property.first).getDescription()));
563  }
564  catch (armarx::LocalException&)
565  {
566  //nothing to do
567  }
568 
569  scenarioPropertyItem->setAttribute(QLatin1String("readOnly"), QVariant(scenario->isReadOnly()));
570  scenarioPropertyTopItem->addSubProperty(scenarioPropertyItem);
571  }
572  }
573 
574  QtProperty* scenarioIcePropertyTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
575  QLatin1String("Scenario Ice Deployment Properties"));
576  scenarioTopItem->addSubProperty(scenarioIcePropertyTopItem);
577 
578  QtVariantProperty* scenarioDeploymentTypeItem = nullptr;
579  if (readOnly)
580  {
581  scenarioDeploymentTypeItem = variantManager->addProperty(
582  QVariant::String,
583  QString::fromStdString("Deployment Type"));
584  scenarioDeploymentTypeItem->setValue(
585  scenario->getScenarioDeploymentType() == ScenarioDeploymentType::Local ? "Local" : "Remote");
586  scenarioDeploymentTypeItem->setAttribute(QLatin1String("readOnly"), QVariant(true));
587  }
588  else
589  {
590  scenarioDeploymentTypeItem = variantManager->addProperty(
591  QtVariantPropertyManager::enumTypeId(),
592  QString::fromStdString("Deployment Type"));
593  scenarioDeploymentTypeItem->setAttribute("enumNames", scenario->getScenarioDeploymentType() == ScenarioDeploymentType::Local ? QStringList({"Local", "Remote"}) : QStringList({"Remote", "Local"}));
594  }
595  scenarioDeploymentTypeItem->setToolTip("Describes if the Scenario should either use the Local build for Ice deployment or an Remote sync directory");
596  scenarioIcePropertyTopItem->addSubProperty(scenarioDeploymentTypeItem);
597 
598  QtVariantProperty* nodePropertyItem = variantManager->addProperty(QVariant::String, "Node Name");
599  nodePropertyItem->setValue(QString::fromStdString(scenario->getNodeName()));
600  nodePropertyItem->setToolTip("Describes on which Node the currently applications of the current scenario should be deployed on. Can be overwritten for each application.");
601  nodePropertyItem->setAttribute(QLatin1String("readOnly"), QVariant(scenario->isReadOnly()));
602  scenarioIcePropertyTopItem->addSubProperty(nodePropertyItem);
603 
604 
605  QtProperty* scenarioIceEnvVarsTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
606  QLatin1String("Ice Enviroment Variables"));
607  scenarioIcePropertyTopItem->addSubProperty(scenarioIceEnvVarsTopItem);
608 
609  for (const auto& envVar : scenario->getIceEnviromentVariables())
610  {
611  QtVariantProperty* iceEnvVarItem = variantManager->addProperty(QVariant::String, QString::fromStdString(envVar.first));
612  iceEnvVarItem->setValue(QString::fromStdString(envVar.second));
613  iceEnvVarItem->setAttribute(QLatin1String("readOnly"), QVariant(scenario->isReadOnly()));
614  scenarioIceEnvVarsTopItem->addSubProperty(iceEnvVarItem);
615  }
616 
617 
618  ui->propertyBrowser->addProperty(scenarioTopItem);
619  ui->propertyBrowser->setRootIsDecorated(false);
620 }
621 
622 void DetailedApplicationView::showPackage(PackagePtr package)
623 {
624  if (variantManager.get() == nullptr || variantFactory.get() == nullptr)
625  {
626  init();
627  }
628  if (package == nullptr)
629  {
630  //build propertybrowser items
631  variantManager->clear();
632  ui->propertyBrowser->clear();
633 
634  ui->startButton->setEnabled(false);
635  ui->stopButton->setEnabled(false);
636  ui->restartButton->setEnabled(false);
637  ui->addParameterButton->setEnabled(false);
638  ui->toolButton->setEnabled(false);
639  ui->linkedInfoLabel->setVisible(false);
640  ui->makeLocalButton->setVisible(false);
641 
642  lastAppInstance = ApplicationInstancePtr(nullptr);
643  lastScenario = ScenarioPtr(nullptr);
644  statusUpdateRelevant = false;
645 
646  return;
647  }
648 
649 
650  ui->dataLabel->setText(QString::fromStdString(package->getName()));
651 
652  lastAppInstance = ApplicationInstancePtr();
653  lastScenario = ScenarioPtr();
654  lastScenarioItem = nullptr;
655 
656  statusUpdateRelevant = false;
657 
658  ui->stateLabel->setStyleSheet("QLabel { color : black; }");
659  ui->stateLabel->setText("No Status");
660 
661  ui->startButton->setEnabled(false);
662  ui->stopButton->setEnabled(false);
663  ui->restartButton->setEnabled(false);
664  ui->addParameterButton->setEnabled(false);
665  ui->addParameterButton->setMenu(nullptr);
666 
667  ui->toolButton->setEnabled(false);
668 
669  //build propertybrowser items
670  variantManager->clear();
671  static_cast<OptionalVariantFactory*>(variantFactory.get())->setElementName(QString::fromStdString(package->getName()));
672  ui->propertyBrowser->clear();
673 
674  QtProperty* packageTopItem = variantManager->addProperty(QtVariantPropertyManager::groupTypeId(),
675  QLatin1String("Package"));
676 
677  packageTopItem->setEnabled(false);
678 
679  QtVariantProperty* nameItem = variantManager->addProperty(QVariant::String, QString("Name"));
680  nameItem->setValue(QString::fromStdString(package->getName()));
681  packageTopItem->addSubProperty(nameItem);
682 
683  QtVariantProperty* packagePathItem = variantManager->addProperty(QVariant::String, QString("Package Path"));
684  packagePathItem->setValue(QString::fromStdString(package->getPath()));
685  packageTopItem->addSubProperty(packagePathItem);
686 
687  ui->propertyBrowser->addProperty(packageTopItem);
688  ui->propertyBrowser->setRootIsDecorated(false);
689 }
690 
691 void DetailedApplicationView::show_or_hide_property(QtProperty* prop, bool visible)
692 {
693  for (auto& item : ui->propertyBrowser->items(prop))
694  {
695  ui->propertyBrowser->setItemVisible(item, visible);
696  }
697 }
698 
699 bool DetailedApplicationView::show_or_hide_subproperties(QtProperty* parent_prop, const QString& text)
700 {
701  if (parent_prop == nullptr)
702  {
703  return false;
704  }
705 
706  bool active_subproperty = false;
707  for (auto prop : parent_prop->subProperties())
708  {
709  if (prop->hasValue())
710  {
711  if (!ui->showInactiveProperties->isChecked())
712  {
713  QtVariantProperty* vprop = static_cast<QtVariantProperty*>(prop);
714  if (vprop->propertyType() == OptionalVariantManager::optionalProprtyTypeId() && !vprop->attributeValue(QLatin1String("enabled")).toBool())
715  {
716  this->show_or_hide_property(prop, false);
717  /*active_subproperty = active_subproperty || false;*/
718  continue;
719  }
720  }
721  if (prop->propertyName().contains(text, Qt::CaseInsensitive) || prop->valueText().contains(text, Qt::CaseInsensitive) || text == "")
722  {
723  this->show_or_hide_property(prop, true);
724  active_subproperty = /*active_subproperty || */true;
725  }
726  else
727  {
728  this->show_or_hide_property(prop, false);
729  /*active_subproperty = active_subproperty || false;*/
730  }
731  }
732  else
733  {
734  // Assuming that a property with value cannot have subproperties
735  active_subproperty = this->show_or_hide_subproperties(prop, text) || active_subproperty;
736  }
737  }
738  if (active_subproperty)
739  {
740  this->show_or_hide_property(parent_prop, true);
741  }
742  else
743  {
744  this->show_or_hide_property(parent_prop, false);
745  }
746  return active_subproperty;
747 }
748 
749 void DetailedApplicationView::on_searchBar_textEdited(const QString& text)
750 {
751  for (auto prop : ui->propertyBrowser->properties())
752  {
753  this->show_or_hide_subproperties(prop, text);
754  }
755 }
756 
757 void DetailedApplicationView::on_showInactiveProperties_stateChanged(int)
758 {
759  ARMARX_INFO << "Checkbox Statechanged with text " << ui->searchBar->text().toStdString();
760  this->on_searchBar_textEdited(ui->searchBar->text());
761 }
762 
763 void DetailedApplicationView::on_startButton_clicked()
764 {
765  emit startButtonClicked();
766 }
767 
768 void DetailedApplicationView::on_stopButton_clicked()
769 {
770  emit stopButtonClicked();
771 }
772 
773 void DetailedApplicationView::on_restartButton_clicked()
774 {
775  emit restartButtonClicked();
776 }
777 
778 void DetailedApplicationView::on_addParameterButton_clicked()
779 {
780  emit addParameterButtonClicked();
781 }
782 
783 void DetailedApplicationView::on_addIceEnvButton_clicked()
784 {
785  ARMARX_INFO << "on_addIceEnvButton_clicked";
786  emit addIceEnvButtonClicked();
787 }
788 
789 void DetailedApplicationView::on_toolButton_clicked()
790 {
791  emit toolButtonClicked();
792 }
793 
794 
795 
796 void DetailedApplicationView::updateStatus()
797 {
798  if (statusUpdateRelevant)
799  {
800  QPalette stateLabelPallet;
801  if (lastAppInstance.get() != nullptr)
802  {
803  ui->stateLabel->setText(QString::fromStdString(lastAppInstance->getStatus()));
804 
805  if (lastAppInstance->getStatus().compare("Running") == 0)
806  {
807  ui->stateLabel->setStyleSheet("QLabel { color : green; }");
808  //stateLabelPallet.setColor(QPalette::WindowText, Qt::blue);
809  }
810  else if (lastAppInstance->getStatus().compare("Stopped") == 0)
811  {
812  ui->stateLabel->setStyleSheet("QLabel { color : red; }");
813  }
814  else
815  {
816  ui->stateLabel->setStyleSheet("QLabel { color : black; }");
817  }
818  }
819  else if (lastScenario.get() != nullptr)
820  {
821  ui->stateLabel->setText(QString::fromStdString(lastScenario->getStatus()));
822 
823  if (lastScenario->getStatus().compare("Running") == 0)
824  {
825  ui->stateLabel->setStyleSheet("QLabel { color : green; }");
826  //stateLabelPallet.setColor(QPalette::WindowText, Qt::blue);
827  }
828  else if (lastScenario->getStatus().compare("Stopped") == 0)
829  {
830  ui->stateLabel->setStyleSheet("QLabel { color : red; }");
831  }
832  else if (lastScenario->getStatus().compare("Mixed") == 0)
833  {
834  ui->stateLabel->setStyleSheet("QLabel { color : darkYellow; }");
835  }
836  else
837  {
838  ui->stateLabel->setStyleSheet("QLabel { color : black; }");
839  }
840  }
841  ui->stateLabel->setAutoFillBackground(true);
842  ui->stateLabel->setPalette(stateLabelPallet);
843  }
844 }
845 
846 void DetailedApplicationView::itemChanged(QtProperty* property, const QVariant& value)
847 {
848  if (statusUpdateRelevant)
849  {
850  if (lastAppInstance.get() != nullptr)
851  {
852  armarx::PropertyDefinitionsPtr props = lastAppInstance->getProperties();
853 
854  Ice::PropertiesPtr properties = props->getProperties()->clone();
855 
856  if (property->propertyName().compare("Name") == 0 ||
857  property->propertyName().compare("Executable Path") == 0 ||
858  property->propertyName().compare("Config Path") == 0 ||
859  property->propertyName().compare("Pid (Stopped = -1)") == 0 ||
860  property->propertyName().compare("Scenario Path") == 0 ||
861  property->propertyName().compare("Created At") == 0 ||
862  property->propertyName().compare("Package Path") == 0 ||
863  property->propertyName().compare("Last Change At") == 0 ||
864  property->propertyName().compare("Default Properties") == 0)
865  {
866  return;
867  }
868 
869  if (property->propertyName().compare("Instance Name") == 0 && lastAppInstance->getInstanceName().compare(value.toString().toStdString()))
870  {
871  lastAppInstance->setInstanceName(value.toString().toStdString());
872 
873  updateTimer.start(UPDATE_TIMER_INTERVAL);
874  }
875  else if (property->propertyName().compare("Instance Name") && property->propertyName() == "Enabled")
876  {
877  if (property->valueText() == "True")
878  {
879  lastAppInstance->setEnabled(true);
880  ui->startButton->setEnabled(true);
881  ui->stopButton->setEnabled(true);
882  ui->restartButton->setEnabled(true);
883  if (lastScenarioItem != nullptr)
884  {
885  lastScenarioItem->setEnabled(true);
886  }
887  }
888  else
889  {
890  lastAppInstance->setEnabled(false);
891  ui->startButton->setEnabled(false);
892  ui->stopButton->setEnabled(false);
893  ui->restartButton->setEnabled(false);
894  if (lastScenarioItem != nullptr)
895  {
896  lastScenarioItem->setEnabled(false);
897  }
898  }
899  updateTimer.start(UPDATE_TIMER_INTERVAL);
900  }
901  else if (property->propertyName() == "Node Name")
902  {
903  ARMARX_INFO << "Setting node name to " << property->valueText().toStdString();
904  lastAppInstance->setNodeName(property->valueText().toStdString());
905  updateTimer.start(UPDATE_TIMER_INTERVAL);
906  }
907  else if (property->propertyName() == "Ice Auto Restart")
908  {
909  lastAppInstance->setIceAutoRestart(property->valueText() == "True");
910  updateTimer.start(UPDATE_TIMER_INTERVAL);
911  }
912  else if (property->propertyName().compare("Instance Name") && properties->getProperty(property->propertyName().toStdString()).compare(value.toString().toStdString()))
913  {
914  lastAppInstance->modifyProperty(property->propertyName().toStdString(), property->valueText().toStdString());
915  if (value.toString().compare("<set value!>")
916  && value.toString().compare("::NOT_DEFINED::")
917  && value.toString().compare("::_NOT_SET_::"))
918  {
919  lastAppInstance->setDefaultPropertyEnabled(property->propertyName().toStdString(), true);
920  variantManager->setAttribute(property, QLatin1String("enabled"), true);
921  }
922  updateTimer.start(UPDATE_TIMER_INTERVAL);
923  }
924  //showApplicationInstance(lastAppInstance);
925  }
926  else if (lastScenario.get() != nullptr)
927  {
928  armarx::PropertyDefinitionsPtr props = lastScenario->getGlobalConfig();
929 
930  Ice::PropertiesPtr properties = props->getProperties()->clone();
931 
932  if (property->propertyName().compare("Name") == 0 ||
933  property->propertyName().compare("Scenario Path") == 0 ||
934  property->propertyName().compare("Created At") == 0 ||
935  property->propertyName().compare("Package Path") == 0 ||
936  property->propertyName().compare("Last Change At") == 0 ||
937  property->propertyName().compare("Default Properties") == 0)
938  {
939  return;
940  }
941  else if (property->propertyName() == "Deployment Type")
942  {
943  if (property->valueText() == "Local")
944  {
945  lastScenario->setScenarioDeploymentType(ScenarioDeploymentType::Local);
946  }
947  else if (property->valueText() == "Remote")
948  {
949  lastScenario->setScenarioDeploymentType(ScenarioDeploymentType::Remote);
950  }
951 
952  updateTimer.start(UPDATE_TIMER_INTERVAL);
953  }
954  else if (property->propertyName() == "Node Name")
955  {
956  lastScenario->setNodeName(property->valueText().toStdString());
957  }
958  else if (properties->getProperty(property->propertyName().toStdString()) != ""
959  && properties->getProperty(property->propertyName().toStdString()).compare(value.toString().toStdString()))
960  {
961  lastScenario->getGlobalConfig()->defineOptionalProperty<std::string>(property->propertyName().toStdString(), "::NOT_DEFINED::", "Custom Property");
962  lastScenario->getGlobalConfig()->getProperties()->setProperty(property->propertyName().toStdString(), property->valueText().toStdString());
963 
964  updateTimer.start(UPDATE_TIMER_INTERVAL);
965  }
966  else if (lastScenario->getIceEnviromentVariables()[property->propertyName().toStdString()] != ""
967  && lastScenario->getIceEnviromentVariables()[property->propertyName().toStdString()] != value.toString().toStdString())
968  {
969  lastScenario->addIceEnviromentVariable(property->propertyName().toStdString(), value.toString().toStdString());
970  updateTimer.start(UPDATE_TIMER_INTERVAL);
971  }
972  }
973  }
974 }
975 
976 void DetailedApplicationView::itemAttributeChanged(QtProperty* property, const QString& attribute, const QVariant& val)
977 {
978  if (statusUpdateRelevant)
979  {
980  if (lastAppInstance.get() != nullptr && attribute.compare(QLatin1String("enabled")) == 0)
981  {
982  lastAppInstance->setDefaultPropertyEnabled(property->propertyName().toStdString(), val.toBool());
983 
984  if (!val.toBool())
985  {
986  OptionalVariantManager* internalManager = static_cast<OptionalVariantManager*>(property->propertyManager());
987  armarx::PropertyDefinitionsPtr properties = lastAppInstance->getProperties();
988  armarx::PropertyDefinition<std::string> definition = properties->getDefintion<std::string>(property->propertyName().toStdString());
989 
990  if (definition.isRequired())
991  {
992  properties->getProperties()->setProperty(property->propertyName().toStdString(), "::_NOT_SET_::");
993  internalManager->setValue(property, "::_NOT_SET_::");
994  }
995  else
996  {
997  properties->getProperties()->setProperty(property->propertyName().toStdString(), definition.getDefaultValue());
998  internalManager->setValue(property, QString::fromStdString(definition.getDefaultValue()));
999  }
1000  }
1001 
1002  updateTimer.start(UPDATE_TIMER_INTERVAL);
1003  }
1004  }
1005 }
1006 
1007 void DetailedApplicationView::on_fileUpdate()
1008 {
1009  if (lastAppInstance.get() != nullptr)
1010  {
1011 
1012  //DANGER delets old config
1013  if (lastAppInstance->isConfigWritable())
1014  {
1015  lastAppInstance->resetConfigPath();
1016  lastAppInstance->save();
1017  }
1018 
1019  emit saveScenario(lastAppInstance);
1020  }
1021  else if (lastScenario.get() != nullptr)
1022  {
1023  if (lastScenario->isScenarioFileWriteable())
1024  {
1025  lastScenario->save();
1026  }
1027  }
1028 }
1029 
1030 void DetailedApplicationView::on_reloadButton_clicked()
1031 {
1032  if (statusUpdateRelevant)
1033  {
1034  if (lastAppInstance.get() != nullptr)
1035  {
1036  lastAppInstance->load();
1037  showApplicationInstance(lastAppInstance, nullptr);
1038  }
1039  else if (lastScenario.get() != nullptr)
1040  {
1041  lastScenario->reloadGlobalConf();
1042  showScenario(lastScenario);
1043  }
1044  }
1045 }
1046 
1047 void DetailedApplicationView::on_makeLocalButton_clicked()
1048 {
1049  if (lastAppInstance)
1050  {
1051  lastAppInstance->makeLocal();
1052  showApplicationInstance(lastAppInstance, nullptr);
1053  }
1054  else if (lastScenario)
1055  {
1056  lastScenario->makeLocalGlobalConfig();
1057  showScenario(lastScenario);
1058  }
1059 }
1060 
ScenarioItem
TreeItem representing data contained in a Scenario or an Application.
Definition: scenarioitem.h:38
ScenarioManager::Parser::XMLScenarioParser::getPackageNameFromScx
static std::string getPackageNameFromScx(const std::string &path)
Definition: XMLScenarioParser.cpp:405
algorithm.h
armarx::PropertyDefinitionBase::isRequired
bool isRequired() const
Definition: PropertyDefinitionInterface.h:75
detailedapplicationview.h
ScenarioManager::Data_Structure::ScenarioPtr
std::shared_ptr< Scenario > ScenarioPtr
Definition: Scenario.h:36
armarx::PropertyDefinition::getValueMap
PropertyValuesMap & getValueMap()
Definition: PropertyDefinition.hpp:313
DetailedApplicationView::addIceEnvButtonClicked
void addIceEnvButtonClicked()
QtProperty::hasValue
bool hasValue() const
Definition: qtpropertybrowser.cpp:277
DetailedApplicationView::saveScenario
void saveScenario(ScenarioManager::Data_Structure::ApplicationInstancePtr application)
QtProperty::setStatusTip
void setStatusTip(const QString &text)
Definition: qtpropertybrowser.cpp:342
ScenarioManager::Data_Structure::ApplicationPtr
std::shared_ptr< Application > ApplicationPtr
Definition: Application.h:119
DetailedApplicationView::showApplication
void showApplication(ScenarioManager::Data_Structure::ApplicationPtr application)
Show an Application.
Definition: detailedapplicationview.cpp:109
DetailedApplicationView::startButtonClicked
void startButtonClicked()
DetailedApplicationView::restartButtonClicked
void restartButtonClicked()
DetailedApplicationView::toolButtonClicked
void toolButtonClicked()
ScenarioManager::Parser::XMLScenarioParser
This class provides different methods to parse and save scenario data in XML-Files....
Definition: XMLScenarioParser.h:56
armarx::VariantType::Bool
const VariantTypeId Bool
Definition: Variant.h:915
QtProperty::valueText
QString valueText() const
Definition: qtpropertybrowser.cpp:303
UPDATE_TIMER_INTERVAL
#define UPDATE_TIMER_INTERVAL
Definition: detailedapplicationview.cpp:37
QtProperty
The QtProperty class encapsulates an instance of a property.
Definition: qtpropertybrowser.h:71
ApplicationInstancePtr
std::shared_ptr< ScenarioManager::Data_Structure::ApplicationInstance > ApplicationInstancePtr
Definition: StopStrategy.h:7
PropertyDefinitionHelpFormatter.h
OptionalVariantManager
Definition: OptionalPropertyManager.h:29
IceInternal::Handle< ::Ice::Properties >
QtVariantProperty
The QtVariantProperty class is a convenience class handling QVariant based properties.
Definition: qtvariantproperty.h:55
armarx::PropertyDefinitionHelpFormatter
PropertyDefinitionHelpFormatter.
Definition: PropertyDefinitionHelpFormatter.h:40
QtProperty::propertyName
QString propertyName() const
Definition: qtpropertybrowser.cpp:247
DetailedApplicationView::updateStatus
void updateStatus()
Updates the status of the displayed item.
Definition: detailedapplicationview.cpp:796
PackageBuilder.h
cxxopts::value
std::shared_ptr< Value > value()
Definition: cxxopts.hpp:926
scenarioInfoFromLink
std::pair< std::string, std::string > scenarioInfoFromLink(const std::filesystem::path &linkpath)
Definition: detailedapplicationview.cpp:43
Ui
ArmarX Headers.
Definition: ArmarXMainWindow.h:58
ScenarioManager::Data_Structure::PackagePtr
std::shared_ptr< Package > PackagePtr
Definition: Package.h:121
OptionalVariantFactory
Definition: OptionalPropertyFactory.h:29
DetailedApplicationView::~DetailedApplicationView
~DetailedApplicationView() override
Destructor.
Definition: detailedapplicationview.cpp:76
TreeItem::setEnabled
void setEnabled(bool enabled)
Definition: treeitem.cpp:84
QtVariantProperty::attributeValue
QVariant attributeValue(const QString &attribute) const
Definition: qtvariantproperty.cpp:232
XMLScenarioParser.h
QtVariantPropertyManager::groupTypeId
static int groupTypeId()
Definition: qtvariantproperty.cpp:115
DetailedApplicationView::showScenario
void showScenario(ScenarioManager::Data_Structure::ScenarioPtr scenario)
Show a Scenario.
Definition: detailedapplicationview.cpp:409
ScenarioManager::Data_Structure::Local
@ Local
Definition: Scenario.h:53
QtVariantProperty::setValue
void setValue(const QVariant &value)
Definition: qtvariantproperty.cpp:272
DetailedApplicationView::addParameterButtonClicked
void addParameterButtonClicked()
armarx::PropertyDefinition::getDefaultValue
PropertyType getDefaultValue()
Definition: PropertyDefinition.hpp:321
QtProperty::setToolTip
void setToolTip(const QString &text)
Definition: qtpropertybrowser.cpp:326
QtProperty::subProperties
QList< QtProperty * > subProperties() const
Definition: qtpropertybrowser.cpp:199
GfxTL::Off
OnOff< false > Off
Definition: OnOff.h:11
DetailedApplicationView::DetailedApplicationView
DetailedApplicationView(QWidget *parent=0)
Constructor that sets up the ui.
Definition: detailedapplicationview.cpp:63
DetailedApplicationView::showApplicationInstance
void showApplicationInstance(ScenarioManager::Data_Structure::ApplicationInstancePtr appInstance, ScenarioItem *item)
Show an ApplicationInstance.
Definition: detailedapplicationview.cpp:200
ScenarioManager
Definition: Application.cpp:166
ARMARX_INFO
#define ARMARX_INFO
Definition: Logging.h:174
PropertyDefinitionContainer.h
VAROUT
#define VAROUT(x)
Definition: StringHelpers.h:182
QtProperty::setEnabled
void setEnabled(bool enable)
Definition: qtpropertybrowser.cpp:392
ScenarioManager::Data_Structure::Remote
@ Remote
Definition: Scenario.h:54
IceUtil::Handle< class PropertyDefinitionContainer >
QtProperty::addSubProperty
void addSubProperty(QtProperty *property)
Definition: qtpropertybrowser.cpp:427
DetailedApplicationView::showPackage
void showPackage(ScenarioManager::Data_Structure::PackagePtr package)
Show a Package.
Definition: detailedapplicationview.cpp:622
armarx::viz::toString
const char * toString(InteractionFeedbackType type)
Definition: Interaction.h:27
armarx::VariantType::Int
const VariantTypeId Int
Definition: Variant.h:916
cxxopts::String
std::string String
Definition: cxxopts.hpp:209
Logging.h
OptionalVariantManager::optionalProprtyTypeId
static int optionalProprtyTypeId()
Definition: OptionalPropertyManager.cpp:72
ARMARX_WARNING
#define ARMARX_WARNING
Definition: Logging.h:186
OptionalVariantManager::setValue
void setValue(QtProperty *property, const QVariant &val) override
Definition: OptionalPropertyManager.cpp:162
QtVariantProperty::setAttribute
void setAttribute(const QString &attribute, const QVariant &value)
Definition: qtvariantproperty.cpp:286
QtVariantPropertyManager::enumTypeId
static int enumTypeId()
Definition: qtvariantproperty.cpp:87
QtVariantProperty::propertyType
int propertyType() const
Definition: qtvariantproperty.cpp:257
DetailedApplicationView
View that shows detailed information about a Scenario, Package or Application. Shows status and param...
Definition: detailedapplicationview.h:49
armarx::PropertyDefinition
PropertyDefinition defines a property that will be available within the PropertyUser.
Definition: PropertyDefinition.h:107
DetailedApplicationView::stopButtonClicked
void stopButtonClicked()
armarx::getMapKeys
void getMapKeys(const MapType &map, OutputIteratorType it)
Definition: algorithm.h:157