|
|
@@ -0,0 +1,505 @@
|
|
|
+/*=========================================================================
|
|
|
+
|
|
|
+ Library: CTK
|
|
|
+
|
|
|
+ Copyright (c) Kitware Inc.
|
|
|
+ All rights reserved.
|
|
|
+ Distributed under a BSD License. See LICENSE.txt file.
|
|
|
+
|
|
|
+ This software is distributed "AS IS" WITHOUT ANY WARRANTY; without even
|
|
|
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
+ See the above copyright notice for more information.
|
|
|
+
|
|
|
+=========================================================================*/
|
|
|
+/*=========================================================================
|
|
|
+
|
|
|
+ Program: ParaView
|
|
|
+ Module: $RCSfile: vtkCommandOptions.h,v $
|
|
|
+
|
|
|
+ Copyright (c) Kitware, Inc.
|
|
|
+ All rights reserved.
|
|
|
+ See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
|
|
|
+
|
|
|
+ This software is distributed WITHOUT ANY WARRANTY; without even
|
|
|
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
|
+ PURPOSE. See the above copyright notice for more information.
|
|
|
+
|
|
|
+=========================================================================*/
|
|
|
+
|
|
|
+// Qt includes
|
|
|
+#include <QDebug>
|
|
|
+#include <QString>
|
|
|
+#include <QLatin1String>
|
|
|
+#include <QSettings>
|
|
|
+#include <QHash>
|
|
|
+#include <QList>
|
|
|
+#include <QPointer>
|
|
|
+#include <QStringList>
|
|
|
+
|
|
|
+// CTK includes
|
|
|
+#include <ctkUtils.h>
|
|
|
+#include "ctkVTKCommandOptions.h"
|
|
|
+
|
|
|
+// VTKSYS includes
|
|
|
+#include <vtksys/CommandLineArguments.hxx>
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+class ctkVTKCommandOptionsPrivate: public ctkPrivate<ctkVTKCommandOptions>
|
|
|
+{
|
|
|
+public:
|
|
|
+ typedef ctkVTKCommandOptionsPrivate Self;
|
|
|
+ ctkVTKCommandOptionsPrivate();
|
|
|
+ ~ctkVTKCommandOptionsPrivate();
|
|
|
+
|
|
|
+ void cleanArgcArgv();
|
|
|
+
|
|
|
+ /// Callback executed when an unknown arguments is parsed
|
|
|
+ static int unknownArgumentHandler(const char* argument, void* call_data);
|
|
|
+
|
|
|
+ /// If case the --ignore-rest flag has been specified, this method will
|
|
|
+ /// catch the first argument parsed and add it to the ignoredArguments list.
|
|
|
+ /// If not, it will call the virtual method 'wrongArgument(const char* argument)'
|
|
|
+ bool checkForIgnoreRestFlag(const char* argument);
|
|
|
+
|
|
|
+ /// Callback executed when a deprecated arguments is parsed
|
|
|
+ static int deprecatedArgumentHandler(const char* argument, const char* value, void* call_data);
|
|
|
+
|
|
|
+ /// Since vtksys::CommandLineArguments will only update char*, returns
|
|
|
+ /// a valid char* pointer that it could use.
|
|
|
+ char** mapQStringPtrToCharPtr(QString* qStringPtr);
|
|
|
+
|
|
|
+ /// Since vtksys::CommandLineArguments will only update std::vector<std::string>*, returns
|
|
|
+ /// a valid std::vector<std::string>* pointer that it could use.
|
|
|
+ std::vector<std::string>* mapQStringListPtrToStringVectorPtr(QStringList* qStringListPtr);
|
|
|
+
|
|
|
+ /// If required, sync the updated char* with the corresponding QString*
|
|
|
+ void syncQStringPtrWithCharPtr();
|
|
|
+
|
|
|
+ /// If required, sync the updated std::vector<std::string> with the corresponding QStringList*
|
|
|
+ void syncQStringListPtrWithStringVectorPtr();
|
|
|
+
|
|
|
+ vtksys::CommandLineArguments CMD;
|
|
|
+ QString UnknownArgument;
|
|
|
+ QString ErrorMessage;
|
|
|
+ bool HelpSelected;
|
|
|
+ bool DisableSettings;
|
|
|
+ bool IgnoreRest;
|
|
|
+ QStringList IgnoredArguments;
|
|
|
+ int Argc;
|
|
|
+ char** Argv;
|
|
|
+ QPointer<QSettings> Settings;
|
|
|
+ int ProcessType; // GUI, Batch, Daemon, ...
|
|
|
+
|
|
|
+ QHash<QString*, char**> QStringPointerToCharPointerMap;
|
|
|
+ QHash<QStringList*, std::vector<std::string>*> QStringListPointerToStringVectorPointerMap;
|
|
|
+};
|
|
|
+
|
|
|
+//-----------------------------------------------------------------------------
|
|
|
+// ctkVTKCommandOptionsPrivate methods
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+ctkVTKCommandOptionsPrivate::ctkVTKCommandOptionsPrivate()
|
|
|
+{
|
|
|
+ this->CMD.SetUnknownArgumentCallback(ctkVTKCommandOptionsPrivate::unknownArgumentHandler);
|
|
|
+ this->CMD.SetClientData(this);
|
|
|
+
|
|
|
+ this->Argc = 0;
|
|
|
+ this->Argv = 0;
|
|
|
+ this->HelpSelected = false;
|
|
|
+ this->DisableSettings = false;
|
|
|
+ this->IgnoreRest = false;
|
|
|
+}
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+ctkVTKCommandOptionsPrivate::~ctkVTKCommandOptionsPrivate()
|
|
|
+{
|
|
|
+ this->cleanArgcArgv();
|
|
|
+ foreach (QString* qStringPtr, this->QStringPointerToCharPointerMap.keys())
|
|
|
+ {
|
|
|
+ delete this->QStringPointerToCharPointerMap[qStringPtr];
|
|
|
+ }
|
|
|
+ foreach (QStringList* qStringListPtr, this->QStringListPointerToStringVectorPointerMap.keys())
|
|
|
+ {
|
|
|
+ delete this->QStringListPointerToStringVectorPointerMap[qStringListPtr];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptionsPrivate::cleanArgcArgv()
|
|
|
+{
|
|
|
+ int cc;
|
|
|
+ if (this->Argv)
|
|
|
+ {
|
|
|
+ for (cc = 0; cc < this->Argc; cc++)
|
|
|
+ {
|
|
|
+ delete [] this->Argv[cc];
|
|
|
+ }
|
|
|
+ delete [] this->Argv;
|
|
|
+ this->Argv = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+int ctkVTKCommandOptionsPrivate::unknownArgumentHandler(const char* argument,
|
|
|
+ void* call_data)
|
|
|
+{
|
|
|
+ ctkVTKCommandOptionsPrivate* self =
|
|
|
+ static_cast<ctkVTKCommandOptionsPrivate*>(call_data);
|
|
|
+ if (self)
|
|
|
+ {
|
|
|
+ self->UnknownArgument = QString::fromLatin1(argument);
|
|
|
+ return self->checkForIgnoreRestFlag(argument);
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+bool ctkVTKCommandOptionsPrivate::checkForIgnoreRestFlag(const char* argument)
|
|
|
+{
|
|
|
+ CTK_P(ctkVTKCommandOptions);
|
|
|
+ if (this->IgnoreRest)
|
|
|
+ {
|
|
|
+ this->IgnoredArguments << QLatin1String(argument);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ return p->wrongArgument(argument);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+int ctkVTKCommandOptionsPrivate::deprecatedArgumentHandler(const char* argument,
|
|
|
+ const char* , void* call_data)
|
|
|
+{
|
|
|
+ //qDebug() << "UnknownArgumentHandler: " << argument;
|
|
|
+ ctkVTKCommandOptionsPrivate* self = static_cast<ctkVTKCommandOptionsPrivate*>(call_data);
|
|
|
+ if (self)
|
|
|
+ {
|
|
|
+ return self->ctk_p()->deprecatedArgument(argument);
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+char** ctkVTKCommandOptionsPrivate::mapQStringPtrToCharPtr(QString* qStringPtr)
|
|
|
+{
|
|
|
+ Q_ASSERT(!this->QStringPointerToCharPointerMap.contains(qStringPtr));
|
|
|
+ char** charPtr = new char*; // Create a new pointer
|
|
|
+ *charPtr = 0; // Initialize to 0
|
|
|
+ this->QStringPointerToCharPointerMap[qStringPtr] = charPtr;
|
|
|
+ return charPtr;
|
|
|
+}
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+std::vector<std::string>*
|
|
|
+ctkVTKCommandOptionsPrivate::mapQStringListPtrToStringVectorPtr(QStringList* qStringListPtr)
|
|
|
+{
|
|
|
+ Q_ASSERT(!this->QStringListPointerToStringVectorPointerMap.contains(qStringListPtr));
|
|
|
+ std::vector<std::string>* vectorPtr = new std::vector<std::string>(); // Create a new vector
|
|
|
+ this->QStringListPointerToStringVectorPointerMap[qStringListPtr] = vectorPtr;
|
|
|
+ return vectorPtr;
|
|
|
+}
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptionsPrivate::syncQStringPtrWithCharPtr()
|
|
|
+{
|
|
|
+ foreach(QString* qStringPtr, this->QStringPointerToCharPointerMap.keys())
|
|
|
+ {
|
|
|
+ char** charPtr = this->QStringPointerToCharPointerMap[qStringPtr];
|
|
|
+ Q_ASSERT(charPtr);
|
|
|
+ // Update QString only if the content pointed by charPtr is valid
|
|
|
+ if (*charPtr)
|
|
|
+ {
|
|
|
+ qStringPtr->clear();
|
|
|
+ qStringPtr->append(QLatin1String(*charPtr));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptionsPrivate::syncQStringListPtrWithStringVectorPtr()
|
|
|
+{
|
|
|
+ foreach(QStringList* qStringListPtr, this->QStringListPointerToStringVectorPointerMap.keys())
|
|
|
+ {
|
|
|
+ std::vector<std::string>* vectorPtr =
|
|
|
+ this->QStringListPointerToStringVectorPointerMap[qStringListPtr];
|
|
|
+ Q_ASSERT(vectorPtr);
|
|
|
+ // Update QString only if vectorPtr is not empty
|
|
|
+ if (vectorPtr->size() > 0)
|
|
|
+ {
|
|
|
+ qStringListPtr->clear();
|
|
|
+ QStringList convertedVector;
|
|
|
+ ctkUtils::stlVectorToQList(*vectorPtr, convertedVector);
|
|
|
+ qStringListPtr->append(convertedVector);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//-----------------------------------------------------------------------------
|
|
|
+// ctkVTKCommandOptions methods
|
|
|
+
|
|
|
+// --------------------------------------------------------------------------
|
|
|
+ctkVTKCommandOptions::ctkVTKCommandOptions(QSettings* _settings)
|
|
|
+{
|
|
|
+ CTK_INIT_PRIVATE(ctkVTKCommandOptions);
|
|
|
+ Q_ASSERT(_settings);
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ d->Settings = _settings;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+ctkVTKCommandOptions::~ctkVTKCommandOptions()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptions::printAdditionalInfo()
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ qDebug() << "ctkVTKCommandOptions:" << this << endl
|
|
|
+ << " HelpSelected:" << this->helpSelected() << endl
|
|
|
+ << " DisableSettings:" << d->DisableSettings << endl
|
|
|
+ << " IgnoreRest:" << d->IgnoreRest << endl
|
|
|
+ << " IgnoredArguments:" << d->IgnoredArguments;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+CTK_GET_CXX(ctkVTKCommandOptions, QString, errorMessage, ErrorMessage);
|
|
|
+CTK_GET_CXX(ctkVTKCommandOptions, QString, unknownArgument, UnknownArgument);
|
|
|
+CTK_GET_CXX(ctkVTKCommandOptions, bool, helpSelected, HelpSelected);
|
|
|
+CTK_GET_CXX(ctkVTKCommandOptions, bool, disableSettings, DisableSettings);
|
|
|
+CTK_GET_CXX(ctkVTKCommandOptions, QSettings*, settings, Settings);
|
|
|
+CTK_GET_CXX(ctkVTKCommandOptions, bool, ignoreRest, IgnoreRest);
|
|
|
+CTK_GET_CXX(ctkVTKCommandOptions, QStringList, ignoredArguments, IgnoredArguments);
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+CTK_GET_CXX(ctkVTKCommandOptions, int, processType, ProcessType);
|
|
|
+CTK_SET_CXX(ctkVTKCommandOptions, int, setProcessType, ProcessType);
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptions::initialize()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+QString ctkVTKCommandOptions::help()
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ d->CMD.SetLineLength(300);
|
|
|
+ return QLatin1String(d->CMD.GetHelp());
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+bool ctkVTKCommandOptions::postProcess(int, const char* const*)
|
|
|
+{
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+bool ctkVTKCommandOptions::parse(int argc, const char* const argv[])
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ d->CMD.Initialize(argc, argv);
|
|
|
+ this->initialize();
|
|
|
+ this->addBooleanArgument("--help", "/?", &d->HelpSelected,
|
|
|
+ "Displays available command line arguments.");
|
|
|
+
|
|
|
+ this->addBooleanArgument("--disable-settings", 0, &d->DisableSettings,
|
|
|
+ "Start application ignoring user settings.");
|
|
|
+
|
|
|
+
|
|
|
+ this->addBooleanArgument("--ignore-rest", "--", &d->IgnoreRest,
|
|
|
+ "Ignores the rest of the labeled arguments following this flag.");
|
|
|
+
|
|
|
+ // Get options from the command line
|
|
|
+ bool res1 = d->CMD.Parse();
|
|
|
+ bool res2 = this->postProcess(argc, argv);
|
|
|
+ //qDebug() << "Res1:" << res1 << ", Res2:" << res2;
|
|
|
+ d->cleanArgcArgv();
|
|
|
+ d->CMD.GetRemainingArguments(&d->Argc, &d->Argv);
|
|
|
+
|
|
|
+ if (d->DisableSettings)
|
|
|
+ {
|
|
|
+ this->disableCurrentSettings();
|
|
|
+ }
|
|
|
+
|
|
|
+ d->syncQStringPtrWithCharPtr();
|
|
|
+ d->syncQStringListPtrWithStringVectorPtr();
|
|
|
+
|
|
|
+ // Since CommandLineArguments include arg0 in the list
|
|
|
+ // of remaining arguments, let's create a temporary list and remove it.
|
|
|
+ QStringList _remaingingArguments = this->remainingArguments();
|
|
|
+ _remaingingArguments.removeFirst();
|
|
|
+
|
|
|
+ // Update ignored arguments list
|
|
|
+ d->IgnoredArguments << _remaingingArguments;
|
|
|
+
|
|
|
+ return res1 && res2;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+QStringList ctkVTKCommandOptions::remainingArguments()
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ QStringList tmp;
|
|
|
+ for(int i=0; i < d->Argc; ++i)
|
|
|
+ {
|
|
|
+ tmp << d->Argv[i];
|
|
|
+ }
|
|
|
+ return tmp;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptions::remainingArguments(int* argc, char*** argv)
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ *argc = d->Argc;
|
|
|
+ *argv = d->Argv;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptions::addDeprecatedArgument(const char* longarg, const char* shortarg,
|
|
|
+ const char* arghelp, int type)
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+
|
|
|
+ // If it is for settings or not for the current process do nothing
|
|
|
+ if((type & ctkVTKCommandOptions::QSETTINGS_ONLY) ||
|
|
|
+ !(type & d->ProcessType || type == ctkVTKCommandOptions::ALL))
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Add a callback for the deprecated argument handling
|
|
|
+ d->CMD.AddCallback(longarg, vtksys::CommandLineArguments::NO_ARGUMENT,
|
|
|
+ ctkVTKCommandOptionsPrivate::deprecatedArgumentHandler, this, arghelp);
|
|
|
+ if(shortarg)
|
|
|
+ {
|
|
|
+ d->CMD.AddCallback(shortarg, vtksys::CommandLineArguments::NO_ARGUMENT,
|
|
|
+ ctkVTKCommandOptionsPrivate::deprecatedArgumentHandler, this, arghelp);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+bool ctkVTKCommandOptions::deprecatedArgument(const char* argument)
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ d->ErrorMessage = QString(" %1").arg(d->CMD.GetHelp(argument));
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+bool ctkVTKCommandOptions::wrongArgument(const char* argument)
|
|
|
+{
|
|
|
+ Q_UNUSED(argument);
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptions::addBooleanArgument(const char* longarg, const char* shortarg,
|
|
|
+ bool* var, const char* arghelp,
|
|
|
+ bool defaultValue, int type)
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+
|
|
|
+ // Attempt to read from settings only if longarg is different from '--disable-settings'.
|
|
|
+ if (QLatin1String(longarg) != "--disable-settings")
|
|
|
+ {
|
|
|
+ *var = d->Settings->value(QLatin1String(longarg+2), defaultValue).toBool();
|
|
|
+
|
|
|
+ if(type & ctkVTKCommandOptions::QSETTINGS_ONLY)
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // If the process type matches then add the argument to the command line
|
|
|
+ if(type & d->ProcessType || type == ctkVTKCommandOptions::ALL)
|
|
|
+ {
|
|
|
+ d->CMD.AddBooleanArgument(longarg, var, arghelp);
|
|
|
+ if (shortarg)
|
|
|
+ {
|
|
|
+ d->CMD.AddBooleanArgument(shortarg, var, longarg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptions::addArgument(const char* longarg, const char* shortarg, QString* var,
|
|
|
+ const char* arghelp, const QString& defaultValue, int type)
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ *var = d->Settings->value(QLatin1String(longarg+2), defaultValue).toString();
|
|
|
+
|
|
|
+ if(type & ctkVTKCommandOptions::QSETTINGS_ONLY)
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(type & d->ProcessType || type == ctkVTKCommandOptions::ALL)
|
|
|
+ {
|
|
|
+ char ** charstar = d->mapQStringPtrToCharPtr(var);
|
|
|
+ typedef vtksys::CommandLineArguments argT;
|
|
|
+ d->CMD.AddArgument(longarg, argT::EQUAL_ARGUMENT, charstar, arghelp);
|
|
|
+ if ( shortarg )
|
|
|
+ {
|
|
|
+ d->CMD.AddArgument(shortarg, argT::EQUAL_ARGUMENT, charstar, longarg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptions::addArgument(const char* longarg, const char* shortarg,
|
|
|
+ QStringList* var, const char* arghelp,
|
|
|
+ const QStringList& defaultValue, int type)
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ *var = d->Settings->value(QLatin1String(longarg+2), defaultValue).toStringList();
|
|
|
+
|
|
|
+ if(type & ctkVTKCommandOptions::QSETTINGS_ONLY)
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(type & d->ProcessType || type == ctkVTKCommandOptions::ALL)
|
|
|
+ {
|
|
|
+ std::vector<std::string>* vectorPtr = d->mapQStringListPtrToStringVectorPtr(var);
|
|
|
+ typedef vtksys::CommandLineArguments argT;
|
|
|
+ d->CMD.AddArgument(longarg, argT::MULTI_ARGUMENT, vectorPtr, arghelp);
|
|
|
+ if (shortarg)
|
|
|
+ {
|
|
|
+ d->CMD.AddArgument(shortarg, argT::MULTI_ARGUMENT, vectorPtr, longarg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void ctkVTKCommandOptions::addArgument(const char* longarg, const char* shortarg, int* var,
|
|
|
+ const char* arghelp, int defaultValue, int type)
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ *var = d->Settings->value(QLatin1String(longarg+2), defaultValue).toInt();
|
|
|
+
|
|
|
+ if(type & ctkVTKCommandOptions::QSETTINGS_ONLY)
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(type & d->ProcessType || type == ctkVTKCommandOptions::ALL)
|
|
|
+ {
|
|
|
+ typedef vtksys::CommandLineArguments argT;
|
|
|
+ d->CMD.AddArgument(longarg, argT::EQUAL_ARGUMENT, var, arghelp);
|
|
|
+ if (shortarg)
|
|
|
+ {
|
|
|
+ d->CMD.AddArgument(shortarg, argT::EQUAL_ARGUMENT, var, longarg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+int ctkVTKCommandOptions::indexOfLastParsedArgument()
|
|
|
+{
|
|
|
+ CTK_D(ctkVTKCommandOptions);
|
|
|
+ return d->CMD.GetLastArgument();
|
|
|
+}
|
Jean-Christophe Fillion-Robin