TDE
/
universal-indent-gui-tqt
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/universal-indent-gui-tqt
0
0
Fork 0
Code Issues Releases Wiki Activity

Format code using uncrustify

Browse Source 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/3/head
Michele Calgaro 3 years ago
parent d833de5bbe
commit 430373ae38
57 changed files with 10985 additions and 9791 deletions
Show Stats Download Patch File Download Diff File

53
src/AboutDialog.cpp
Unescape Escape View File

@ -37,18 +37,19 @@
\brief The constructor calls the setup function for the ui created by uic and adds
the GPL text to the text edit.
*/
AboutDialog::AboutDialog(TQWidget *parent, TQt::WindowFlags flags) : TQDialog(parent, flags)
, _dialogForm(NULL)
, _timer(NULL)
{
AboutDialog::AboutDialog(TQWidget *parent, TQt::WindowFlags flags) :
TQDialog(parent, flags), _dialogForm(NULL), _timer(NULL)
{
_dialogForm = new Ui::AboutDialog();
_dialogForm->setupUi(this);
_dialogForm->authorTextBrowser->setOpenExternalLinks( true );
_dialogForm->creditsTextBrowser->setOpenExternalLinks( true );
_dialogForm->authorTextBrowser->setOpenExternalLinks(true);
_dialogForm->creditsTextBrowser->setOpenExternalLinks(true);
TQString versionString = _dialogForm->versionTextBrowser->toHtml();
versionString = versionString.arg(PROGRAM_VERSION_STRING).arg( UiGuiVersion::getBuildRevision() ).arg( UiGuiVersion::getBuildDate() );
versionString =
versionString.arg(PROGRAM_VERSION_STRING).arg(UiGuiVersion::getBuildRevision()).arg(
UiGuiVersion::getBuildDate());
_dialogForm->versionTextBrowser->setHtml(versionString);
_dialogForm->creditsTextBrowser->setHtml("<html><head></head><body>"
@ -94,54 +95,60 @@ AboutDialog::AboutDialog(TQWidget *parent, TQt::WindowFlags flags) : TQDialog(pa
_scrollDirection = 1;
_scrollSpeed = 100;
_timer = new TQTimer(this);
connect( _timer, SIGNAL(timeout()), this, SLOT(scroll()) );
connect( this, SIGNAL(accepted()), _timer, SLOT(stop()) );
connect(_timer, SIGNAL(timeout()), this, SLOT(scroll()));
connect(this, SIGNAL(accepted()), _timer, SLOT(stop()));
}
/*!
\brief Catches language change events and retranslates all needed widgets.
*/
void AboutDialog::changeEvent(TQEvent *event) {
if (event->type() == TQEvent::LanguageChange) {
void AboutDialog::changeEvent(TQEvent *event)
{
if (event->type() == TQEvent::LanguageChange)
{
_dialogForm->retranslateUi(this);
TQString versionString = _dialogForm->versionTextBrowser->toHtml();
versionString = versionString.arg(PROGRAM_VERSION_STRING).arg( UiGuiVersion::getBuildRevision() ).arg( UiGuiVersion::getBuildDate() );
versionString =
versionString.arg(PROGRAM_VERSION_STRING).arg(UiGuiVersion::getBuildRevision()).arg(
UiGuiVersion::getBuildDate());
_dialogForm->versionTextBrowser->setHtml(versionString);
}
else {
else
{
TQWidget::changeEvent(event);
}
}
/*!
\brief Reimplements the dialog execution function to init the credits scroller.
*/
int AboutDialog::exec() {
int AboutDialog::exec()
{
//creditsTextBrowser->verticalScrollBar()->setValue(0);
_timer->start(_scrollSpeed);
return TQDialog::exec();
}
/*!
\brief This slot is called each _timer timeout to scroll the credits textbrowser.
Also changes the scroll direction and speed when reaching the start or end.
*/
void AboutDialog::scroll() {
void AboutDialog::scroll()
{
TQScrollBar *scrollBar = _dialogForm->creditsTextBrowser->verticalScrollBar();
scrollBar->setValue( scrollBar->value()+_scrollDirection );
scrollBar->setValue(scrollBar->value() + _scrollDirection);
if ( scrollBar->value() == scrollBar->maximum() ) {
if (scrollBar->value() == scrollBar->maximum())
{
// Toggle scroll direction and change scroll speed;
_scrollDirection = -1;
_scrollSpeed = 5;
_timer->stop();
_timer->start(_scrollSpeed);
}
else if ( scrollBar->value() == scrollBar->minimum() ) {
else if (scrollBar->value() == scrollBar->minimum())
{
// Toggle scroll direction and change scroll speed;
_scrollDirection = 1;
_scrollSpeed = 100;
@ -152,11 +159,11 @@ void AboutDialog::scroll() {
_dialogForm->creditsTextBrowser->update();
}
/*!
\brief Shows the about dialog and also starts the credits scroller.
*/
void AboutDialog::show() {
void AboutDialog::show()
{
_timer->start(_scrollSpeed);
TQDialog::show();
}

13
src/AboutDialog.h
Unescape Escape View File

@ -22,7 +22,8 @@
#include <tntqdialog.h>
namespace Ui {
namespace Ui
{
class AboutDialog;
}
@ -31,20 +32,20 @@ class AboutDialog : public TQDialog
{
Q_OBJECT
public:
public:
AboutDialog(TQWidget *parent = NULL, TQt::WindowFlags flags = 0);
public slots:
public slots:
int exec();
void show();
private slots:
private slots:
void scroll();
private:
private:
void changeEvent(TQEvent *event);
Ui::AboutDialog* _dialogForm;
Ui::AboutDialog *_dialogForm;
int _scrollDirection;
int _scrollSpeed;
TQTimer *_timer;

104
src/AboutDialogGraphicsView.cpp
Unescape Escape View File

@ -39,23 +39,23 @@
/*!
\brief The constructor initializes everything needed for the 3D animation.
*/
AboutDialogGraphicsView::AboutDialogGraphicsView(AboutDialog *aboutDialog, TQWidget *parentWindow) : TQGraphicsView(parentWindow)
, _aboutDialog(NULL)
, _graphicsProxyWidget(NULL)
, _parentWindow(NULL)
, _timeLine(NULL)
, _aboutDialogAsSplashScreen(NULL)
AboutDialogGraphicsView::AboutDialogGraphicsView(AboutDialog *aboutDialog, TQWidget *parentWindow) :
TQGraphicsView(parentWindow), _aboutDialog(NULL), _graphicsProxyWidget(NULL),
_parentWindow(NULL), _timeLine(NULL), _aboutDialogAsSplashScreen(NULL)
{
_parentWindow = parentWindow;
setWindowFlags(TQt::SplashScreen);
#ifdef Q_OS_LINUX
TQRect availableGeometry = TQApplication::desktop()->availableGeometry();
TQRect newGeometry = TQRect( availableGeometry.x(), availableGeometry.y(), availableGeometry.width(), availableGeometry.height() );
TQRect newGeometry = TQRect(availableGeometry.x(),
availableGeometry.y(), availableGeometry.width(), availableGeometry.height());
#else
TQRect newGeometry = TQRect( -1,-1, TQApplication::desktop()->rect().width()+2, TQApplication::desktop()->rect().height()+2 );
TQRect newGeometry = TQRect(-1, -1,
TQApplication::desktop()->rect().width() + 2,
TQApplication::desktop()->rect().height() + 2);
#endif
setGeometry( newGeometry );
setGeometry(newGeometry);
_aboutDialog = aboutDialog;
@ -63,12 +63,12 @@ AboutDialogGraphicsView::AboutDialogGraphicsView(AboutDialog *aboutDialog, TQWid
_windowPosOffset = 0;
TQGraphicsScene *scene = new TQGraphicsScene(this);
setSceneRect( newGeometry );
setSceneRect(newGeometry);
_aboutDialogAsSplashScreen = new TQSplashScreen(this);
_graphicsProxyWidget = scene->addWidget(_aboutDialogAsSplashScreen);
_graphicsProxyWidget->setWindowFlags( TQt::ToolTip );
_graphicsProxyWidget->setWindowFlags(TQt::ToolTip);
setScene( scene );
setScene(scene);
setRenderHint(TQPainter::Antialiasing);
setCacheMode(TQGraphicsView::CacheBackground);
@ -89,30 +89,41 @@ AboutDialogGraphicsView::AboutDialogGraphicsView(AboutDialog *aboutDialog, TQWid
connect(_timeLine, SIGNAL(frameChanged(int)), this, SLOT(updateStep(int)));
}
AboutDialogGraphicsView::~AboutDialogGraphicsView(void) {
AboutDialogGraphicsView::~AboutDialogGraphicsView(void)
{
}
/*!
\brief Grabs a screenshot of the full desktop and shows that as background. Above that background the
AboutDialog 3D animation is shown. Also grabs the content of the AboutDialog itself.
*/
void AboutDialogGraphicsView::show() {
// Because on X11 system the window decoration is only available after a widget has been shown once,
void AboutDialogGraphicsView::show()
{
// Because on X11 system the window decoration is only available after a widget has been shown
// once,
// we can detect _windowTitleBarWidth here for the first time.
_windowTitleBarWidth = _parentWindow->geometry().y() - _parentWindow->y();
// If the _windowTitleBarWidth could not be determined, try it a second way. Even the chances are low to get good results.
if ( _windowTitleBarWidth == 0 )
_windowTitleBarWidth = _parentWindow->frameGeometry().height() - _parentWindow->geometry().height();
// If the _windowTitleBarWidth could not be determined, try it a second way. Even the chances are
// low to get good results.
if (_windowTitleBarWidth == 0)
{
_windowTitleBarWidth = _parentWindow->frameGeometry().height() -
_parentWindow->geometry().height();
}
#ifdef Q_OS_LINUX
if ( _windowTitleBarWidth == 0 ) {
//TODO: 27 pixel is a fix value for the Ubuntu 10.4 default window theme and so just a workaround for that specific case.
if (_windowTitleBarWidth == 0)
{
//TODO: 27 pixel is a fix value for the Ubuntu 10.4 default window theme and so just a
// workaround for that specific case.
_windowPosOffset = 27;
_windowTitleBarWidth = 27;
}
#endif
TQPixmap originalPixmap = TQPixmap::grabWindow(TQApplication::desktop()->winId(), TQApplication::desktop()->availableGeometry().x(), TQApplication::desktop()->availableGeometry().y(), geometry().width(), geometry().height() );
TQPixmap originalPixmap = TQPixmap::grabWindow(
TQApplication::desktop()->winId(),
TQApplication::desktop()->availableGeometry().x(),
TQApplication::desktop()->availableGeometry().y(), geometry().width(),
geometry().height());
TQBrush brush(originalPixmap);
TQTransform transform;
transform.translate(0, TQApplication::desktop()->availableGeometry().y());
@ -120,15 +131,16 @@ void AboutDialogGraphicsView::show() {
setBackgroundBrush(brush);
_aboutDialogAsSplashScreen->setPixmap( TQPixmap::grabWidget(_aboutDialog) );
_graphicsProxyWidget->setGeometry( _aboutDialog->geometry() );
_aboutDialogAsSplashScreen->setPixmap(TQPixmap::grabWidget(_aboutDialog));
_graphicsProxyWidget->setGeometry(_aboutDialog->geometry());
_aboutDialog->hide();
_graphicsProxyWidget->setPos( _parentWindow->geometry().x()+(_parentWindow->geometry().width()-_graphicsProxyWidget->geometry().width()) / 2, _parentWindow->y()+_windowTitleBarWidth-_windowPosOffset);
_graphicsProxyWidget->setPos(_parentWindow->geometry().x() +
(_parentWindow->geometry().width() - _graphicsProxyWidget->geometry().width()) / 2,
_parentWindow->y() + _windowTitleBarWidth - _windowPosOffset);
TQRectF r = _graphicsProxyWidget->boundingRect();
_graphicsProxyWidget->setTransform(TQTransform()
.translate(r.width() / 2, -_windowTitleBarWidth)
.rotate(270, TQt::XAxis)
_graphicsProxyWidget->setTransform(TQTransform().translate(
r.width() / 2, -_windowTitleBarWidth).rotate(270, TQt::XAxis)
//.rotate(90, TQt::YAxis)
//.rotate(5, TQt::ZAxis)
//.scale(1 + 1.5 * step, 1 + 1.5 * step)
@ -143,15 +155,14 @@ void AboutDialogGraphicsView::show() {
_timeLine->start();
}
/*!
\brief Does the next calculation/transformation step.
*/
void AboutDialogGraphicsView::updateStep(int step) {
void AboutDialogGraphicsView::updateStep(int step)
{
TQRectF r = _graphicsProxyWidget->boundingRect();
_graphicsProxyWidget->setTransform(TQTransform()
.translate(r.width() / 2, -_windowTitleBarWidth)
.rotate(step, TQt::XAxis)
_graphicsProxyWidget->setTransform(TQTransform().translate(
r.width() / 2, -_windowTitleBarWidth).rotate(step, TQt::XAxis)
//.rotate(step, TQt::YAxis)
//.rotate(step * 5, TQt::ZAxis)
//.scale(1 + 1.5 * step, 1 + 1.5 * step)
@ -159,28 +170,31 @@ void AboutDialogGraphicsView::updateStep(int step) {
//update();
}
/*!
\brief Stops the 3D animation, moves the AboutDialog to the correct place and really shows it.
*/
void AboutDialogGraphicsView::showAboutDialog() {
void AboutDialogGraphicsView::showAboutDialog()
{
//hide();
disconnect(_timeLine, SIGNAL(finished()), this, SLOT(showAboutDialog()));
_aboutDialog->move( int(_parentWindow->geometry().x()+(_parentWindow->geometry().width()-_graphicsProxyWidget->geometry().width()) / 2), _parentWindow->y()+_windowTitleBarWidth-_windowPosOffset );
_aboutDialog->move(int(_parentWindow->geometry().x() +
(_parentWindow->geometry().width() - _graphicsProxyWidget->geometry().width()) / 2),
_parentWindow->y() + _windowTitleBarWidth - _windowPosOffset);
_aboutDialog->exec();
}
/*!
\brief Does not directly hide the AboutDialog but instead starts the "fade out" 3D animation.
*/
void AboutDialogGraphicsView::hide() {
_graphicsProxyWidget->setPos( _parentWindow->geometry().x()+(_parentWindow->geometry().width()-_graphicsProxyWidget->geometry().width()) / 2, _parentWindow->y()+_windowTitleBarWidth-_windowPosOffset);
void AboutDialogGraphicsView::hide()
{
_graphicsProxyWidget->setPos(_parentWindow->geometry().x() +
(_parentWindow->geometry().width() - _graphicsProxyWidget->geometry().width()) / 2,
_parentWindow->y() + _windowTitleBarWidth - _windowPosOffset);
TQRectF r = _graphicsProxyWidget->boundingRect();
_graphicsProxyWidget->setTransform(TQTransform()
.translate(r.width() / 2, -_windowTitleBarWidth)
.rotate(0, TQt::XAxis)
_graphicsProxyWidget->setTransform(TQTransform().translate(
r.width() / 2, -_windowTitleBarWidth).rotate(0, TQt::XAxis)
//.rotate(90, TQt::YAxis)
//.rotate(5, TQt::ZAxis)
//.scale(1 + 1.5 * step, 1 + 1.5 * step)
@ -195,11 +209,11 @@ void AboutDialogGraphicsView::hide() {
_timeLine->start();
}
/*!
\brief This slot really hides this AboutDialog container.
*/
void AboutDialogGraphicsView::hideReally() {
void AboutDialogGraphicsView::hideReally()
{
disconnect(_timeLine, SIGNAL(finished()), this, SLOT(hideReally()));
TQGraphicsView::hide();
_parentWindow->activateWindow();

9
src/AboutDialogGraphicsView.h
Unescape Escape View File

@ -30,20 +30,21 @@ class TQSplashScreen;
class AboutDialogGraphicsView : public TQGraphicsView
{
Q_OBJECT
public:
public:
AboutDialogGraphicsView(AboutDialog *aboutDialog, TQWidget *parentWindow = NULL);
~AboutDialogGraphicsView(void);
public slots:
public slots:
void show();
void hide();
private slots:
private slots:
void updateStep(int step);
void showAboutDialog();
void hideReally();
private:
private:
AboutDialog *_aboutDialog;
TQGraphicsProxyWidget *_graphicsProxyWidget;
TQWidget *_parentWindow;

1364
src/IndentHandler.cpp
View File

File diff suppressed because it is too large Load Diff

50
src/IndentHandler.h
Unescape Escape View File

@ -40,7 +40,7 @@ class IndentHandler : public TQWidget
{
Q_OBJECT
public:
public:
IndentHandler(int indenterID, TQWidget *mainWindow = NULL, TQWidget *parent = NULL);
~IndentHandler();
@ -57,21 +57,21 @@ public:
TQString getCurrentIndenterName();
TQMenu* getIndenterMenu();
TQList<TQAction*> getIndenterMenuActions();
void contextMenuEvent( TQContextMenuEvent *event );
void setParameterChangedCallback( void(*paramChangedCallback)(void) );
void setWindowClosedCallback( void(*winClosedCallback)(void) );
void contextMenuEvent(TQContextMenuEvent *event);
void setParameterChangedCallback(void (*paramChangedCallback)(void));
void setWindowClosedCallback(void (*winClosedCallback)(void));
int getIndenterId();
signals:
signals:
void indenterSettingsChanged();
void selectedIndenterIndexChanged(int index);
protected:
bool event( TQEvent *event );
protected:
bool event(TQEvent *event);
void closeEvent(TQCloseEvent *event);
void wheelEvent( TQWheelEvent *event );
void wheelEvent(TQWheelEvent *event);
private slots:
private slots:
void setIndenter(int indenterID);
void showIndenterManual();
void openConfigFileDialog();
@ -81,7 +81,7 @@ private slots:
void handleChangedIndenterSettings();
void updateDrawing();
private:
private:
TQString callExecutableIndenter(TQString sourceCode, TQString inputFileExtension);
TQString callJavaScriptIndenter(TQString sourceCode);
void saveConfigFile(TQString filePathName, TQString parameterString);
@ -89,44 +89,55 @@ private:
bool createIndenterCallString();
void initIndenterMenu();
//! Holds a reference to all created pages of the parameter categories toolbox and the pages boxlayout
struct IndenterParameterCategoryPage {
//! Holds a reference to all created pages of the parameter categories toolbox and the pages
// boxlayout
struct IndenterParameterCategoryPage
{
TQWidget *widget;
TQVBoxLayout *vboxLayout;
};
TQVector<IndenterParameterCategoryPage> _indenterParameterCategoryPages;
//! Holds a reference to all checkboxes needed for boolean parameter setting and the parameters name
struct ParamBoolean {
//! Holds a reference to all checkboxes needed for boolean parameter setting and the parameters
// name
struct ParamBoolean
{
TQString paramName;
TQString trueString;
TQString falseString;
TQCheckBox *checkBox;
};
TQVector<ParamBoolean> _paramBooleans;
//! Holds a reference to all line edits needed for parameter setting and the parameters name
struct ParamString {
struct ParamString
{
TQString paramName;
TQString paramCallName;
TQCheckBox *valueEnabledChkBox;
TQLineEdit *lineEdit;
TQLabel *label;
};
TQVector<ParamString> _paramStrings;
//! Hold a reference to all spin boxes needed for parameter setting and the parameters name
struct ParamNumeric {
struct ParamNumeric
{
TQString paramName;
TQString paramCallName;
TQCheckBox *valueEnabledChkBox;
TQSpinBox *spinBox;
TQLabel *label;
};
TQVector<ParamNumeric> _paramNumerics;
//! Hold a reference to all combo boxes needed for parameter setting and the parameters name
struct ParamMultiple {
struct ParamMultiple
{
TQString paramName;
TQString paramCallName;
TQCheckBox *valueEnabledChkBox;
@ -134,6 +145,7 @@ private:
TQStringList choicesStrings;
TQStringList choicesStringsReadable;
};
TQVector<ParamMultiple> _paramMultiples;
TQComboBox *_indenterSelectionCombobox;
@ -172,9 +184,9 @@ private:
TQAction *_actionCreateShellScript;
TQAction *_actionResetIndenterParameters;
//! Needed for the NPP plugin.
void(*_parameterChangedCallback)(void);
void (*_parameterChangedCallback)(void);
//! Needed for the NPP plugin.
void(*_windowClosedCallback)(void);
void (*_windowClosedCallback)(void);
//TODO: This function should go into a string helper/tool class/file.
TQString encodeToHTML(const TQString &text);

949
src/MainWindow.cpp
View File

File diff suppressed because it is too large Load Diff

19
src/MainWindow.h
Unescape Escape View File

@ -30,7 +30,8 @@ class AboutDialogGraphicsView;
class UiGuiHighlighter;
class IndentHandler;
class UpdateCheckDialog;
namespace Ui {
namespace Ui
{
class ToolBarWidget;
class MainWindowUi;
}
@ -47,18 +48,20 @@ class MainWindow : public TQMainWindow
{
Q_OBJECT
public:
public:
//! Constructor
MainWindow(TQString file2OpenOnStart = "", TQWidget *parent = NULL);
~MainWindow() {
~MainWindow()
{
_settings.clear();
}
protected:
void closeEvent( TQCloseEvent *event );
protected:
void closeEvent(TQCloseEvent *event);
bool eventFilter(TQObject *obj, TQEvent *event);
private slots:
private slots:
void openSourceFileDialog(TQString fileName = "");
bool saveasSourceFileDialog(TQAction *chosenEncodingAction = NULL);
void saveAsOtherEncoding(TQAction *chosenEncodingAction);
@ -77,12 +80,12 @@ private slots:
void encodingChanged(TQAction *encodingAction);
void numberOfLinesChanged();
void updateRecentlyOpenedList();
void openFileFromRecentlyOpenedList(TQAction* recentlyOpenedAction);
void openFileFromRecentlyOpenedList(TQAction *recentlyOpenedAction);
void clearRecentlyOpenedList();
void showAboutDialog();
void setStatusBarCursorPosInfo(int line, int column);
private:
private:
Ui::MainWindowUi *_mainWindowForm;
TQString loadFile(TQString filePath);

166
src/SettingsPaths.cpp
Unescape Escape View File

@ -45,7 +45,6 @@ TQString SettingsPaths::_indenterPath = "";
TQString SettingsPaths::_tempPath = "";
bool SettingsPaths::_portableMode = false;
/*!
\brief Initializes all available information about the paths.
@ -56,7 +55,8 @@ bool SettingsPaths::_portableMode = false;
Means also that the directory "indenters" has to be there.
In not portable mode (multiuser mode) only users home directory is used for writing config data.
*/
void SettingsPaths::init() {
void SettingsPaths::init()
{
_alreadyInitialized = true;
tqDebug() << __LINE__ << " " << __FUNCTION__ << ": Initializing application paths.";
@ -64,7 +64,8 @@ void SettingsPaths::init() {
// Get the applications binary path, with respect to MacOSXs use of the .app folder.
_applicationBinaryPath = TQCoreApplication::applicationDirPath();
// Remove any trailing slashes
while ( _applicationBinaryPath.right(1) == "/" ) {
while (_applicationBinaryPath.right(1) == "/")
{
_applicationBinaryPath.chop(1);
}
@ -76,200 +77,233 @@ void SettingsPaths::init() {
// Because on Mac universal binaries are used, the binary path is not equal
// to the applications (.app) path. So get the .apps path here.
int indexOfDotApp = _applicationBinaryPath.indexOf(".app");
if ( indexOfDotApp != -1 ) {
if (indexOfDotApp != -1)
{
// Cut off after the dot of ".app".
_applicationBinaryPath = _applicationBinaryPath.left( indexOfDotApp-1 );
// Cut off after the first slash that was in front of ".app" (normally this is the word "UniversalIndentGUI")
_applicationBinaryPath = _applicationBinaryPath.left( _applicationBinaryPath.lastIndexOf("/") );
_applicationBinaryPath = _applicationBinaryPath.left(indexOfDotApp - 1);
// Cut off after the first slash that was in front of ".app" (normally this is the word
// "UniversalIndentGUI")
_applicationBinaryPath = _applicationBinaryPath.left(_applicationBinaryPath.lastIndexOf("/"));
}
#endif
// If the "config" directory is a subdir of the applications binary path, use this one (portable mode)
// If the "config" directory is a subdir of the applications binary path, use this one (portable
// mode)
_settingsPath = _applicationBinaryPath + "/config";
if ( TQFile::exists( _settingsPath ) ) {
if (TQFile::exists(_settingsPath))
{
_portableMode = true;
TQDir dirCreator;
_globalFilesPath = _applicationBinaryPath;
_indenterPath = _applicationBinaryPath + "/indenters";
dirCreator.mkpath( _settingsPath );
dirCreator.mkpath(_settingsPath);
_tempPath = _applicationBinaryPath + "/temp";
//TODO: If the portable drive has write protection, use local temp path and clean it up on exit.
dirCreator.mkpath( _tempPath );
dirCreator.mkpath(_tempPath);
}
// ... otherwise use the system specific global application data path.
else {
else
{
_portableMode = false;
TQDir dirCreator;
#ifdef Q_OS_WIN
// Get the local users application settings directory.
// Remove any trailing slashes.
_settingsPath = TQDir::fromNativeSeparators( qgetenv("APPDATA") );
while ( _settingsPath.right(1) == "/" ) {
_settingsPath = TQDir::fromNativeSeparators(qgetenv("APPDATA"));
while (_settingsPath.right(1) == "/")
{
_settingsPath.chop(1);
}
_settingsPath = _settingsPath + "/UniversalIndentGUI";
// On windows systems the directories "indenters", "translations" are subdirs of the _applicationBinaryPath.
// On windows systems the directories "indenters", "translations" are subdirs of the
// _applicationBinaryPath.
_globalFilesPath = _applicationBinaryPath;
#else
// Remove any trailing slashes.
_settingsPath = TQDir::homePath();
while ( _settingsPath.right(1) == "/" ) {
while (_settingsPath.right(1) == "/")
{
_settingsPath.chop(1);
}
_settingsPath = _settingsPath + "/.universalindentgui";
_globalFilesPath = "/usr/share/universalindentgui";
#endif
dirCreator.mkpath( _settingsPath );
dirCreator.mkpath(_settingsPath);
// If a highlighter config file does not exist in the users home config dir
// copy the default config file over there.
if ( !TQFile::exists(_settingsPath+"/UiGuiSyntaxHighlightConfig.ini") ) {
TQFile::copy( _globalFilesPath+"/config/UiGuiSyntaxHighlightConfig.ini", _settingsPath+"/UiGuiSyntaxHighlightConfig.ini" );
if (!TQFile::exists(_settingsPath + "/UiGuiSyntaxHighlightConfig.ini"))
{
TQFile::copy(_globalFilesPath + "/config/UiGuiSyntaxHighlightConfig.ini",
_settingsPath + "/UiGuiSyntaxHighlightConfig.ini");
}
_indenterPath = _globalFilesPath + "/indenters";
// On different systems it may be that "TQDir::tempPath()" ends with a "/" or not. So check this.
// On different systems it may be that "TQDir::tempPath()" ends with a "/" or not. So check
// this.
// Remove any trailing slashes.
_tempPath = TQDir::tempPath();
while ( _tempPath.right(1) == "/" ) {
while (_tempPath.right(1) == "/")
{
_tempPath.chop(1);
}
_tempPath = _tempPath + "/UniversalIndentGUI";
#if defined(Q_OS_WIN32)
dirCreator.mkpath( _tempPath );
#if defined (Q_OS_WIN32)
dirCreator.mkpath(_tempPath);
#else
// On Unix based systems create a random temporary directory for security
// reasons. Otherwise an evil human being could create a symbolic link
// to an important existing file which gets overwritten when UiGUI writes
// into this normally temporary but linked file.
char *pathTemplate = new char[_tempPath.length()+8];
char *pathTemplate = new char[_tempPath.length() + 8];
TQByteArray pathTemplateTQBA = TQString(_tempPath + "-XXXXXX").toAscii();
delete [] pathTemplate;
delete[] pathTemplate;
pathTemplate = pathTemplateTQBA.data();
pathTemplate = mkdtemp( pathTemplate );
pathTemplate = mkdtemp(pathTemplate);
_tempPath = pathTemplate;
#endif
}
tqDebug() << __LINE__ << " " << __FUNCTION__ << ": Paths are:" \
"<ul><li>_applicationBinaryPath=" << _applicationBinaryPath \
<< "</li><li>_settingsPath=" << _settingsPath \
<< "</li><li>_globalFilesPath=" << _globalFilesPath \
<< "</li><li>_indenterPath=" << _indenterPath \
<< "</li><li>_tempPath=" << _tempPath \
<< "</li><li>Running in portable mode=" << _portableMode << "</li></ul>";
"<ul><li>_applicationBinaryPath=" <<
_applicationBinaryPath << "</li><li>_settingsPath=" << _settingsPath <<
"</li><li>_globalFilesPath=" << _globalFilesPath << "</li><li>_indenterPath=" <<
_indenterPath << "</li><li>_tempPath=" << _tempPath <<
"</li><li>Running in portable mode=" << _portableMode << "</li></ul>";
}
/*!
\brief Returns the path of the applications executable.
*/
const TQString SettingsPaths::getApplicationBinaryPath() {
if ( !_alreadyInitialized ) {
const TQString SettingsPaths::getApplicationBinaryPath()
{
if (!_alreadyInitialized)
{
SettingsPaths::init();
}
return _applicationBinaryPath;
}
/*!
\brief Returns the path where all settings are being/should be written to.
*/
const TQString SettingsPaths::getSettingsPath() {
if ( !_alreadyInitialized ) {
const TQString SettingsPaths::getSettingsPath()
{
if (!_alreadyInitialized)
{
SettingsPaths::init();
}
return _settingsPath;
}
/*!
\brief Returns the path where the files concerning all users reside. For example translations.
*/
const TQString SettingsPaths::getGlobalFilesPath() {
if ( !_alreadyInitialized ) {
const TQString SettingsPaths::getGlobalFilesPath()
{
if (!_alreadyInitialized)
{
SettingsPaths::init();
}
return _globalFilesPath;
}
/*!
\brief Returns the path where the indenter executables reside.
*/
const TQString SettingsPaths::getIndenterPath() {
if ( !_alreadyInitialized ) {
const TQString SettingsPaths::getIndenterPath()
{
if (!_alreadyInitialized)
{
SettingsPaths::init();
}
return _indenterPath;
}
/*!
\brief Returns the path where the where all temporary data should be written to.
*/
const TQString SettingsPaths::getTempPath() {
if ( !_alreadyInitialized ) {
const TQString SettingsPaths::getTempPath()
{
if (!_alreadyInitialized)
{
SettingsPaths::init();
}
return _tempPath;
}
/*!
\brief Returns true if portable mode shall be used.
*/
bool SettingsPaths::getPortableMode() {
if ( !_alreadyInitialized ) {
bool SettingsPaths::getPortableMode()
{
if (!_alreadyInitialized)
{
SettingsPaths::init();
}
return _portableMode;
}
/*!
\brief Completely deletes the created temporary directory with all of its content.
*/
void SettingsPaths::cleanAndRemoveTempDir() {
void SettingsPaths::cleanAndRemoveTempDir()
{
TQDirIterator dirIterator(_tempPath, TQDirIterator::Subdirectories);
TQStack<TQString> directoryStack;
bool noErrorsOccurred = true;
while ( dirIterator.hasNext() ) {
while (dirIterator.hasNext())
{
TQString currentDirOrFile = dirIterator.next();
// If this dummy call isn't done here, calling "dirIterator.fileInfo().isDir()" later somehow fails.
// If this dummy call isn't done here, calling "dirIterator.fileInfo().isDir()" later somehow
// fails.
dirIterator.fileInfo();
if ( !currentDirOrFile.isEmpty() && dirIterator.fileName() != "." && dirIterator.fileName() != ".." ) {
if (!currentDirOrFile.isEmpty() && dirIterator.fileName() != "." &&
dirIterator.fileName() != "..")
{
// There is a path on the stack but the current path doesn't start with that path.
// So we changed into another parent directory and the one on the stack can be deleted
// since it must be empty.
if ( !directoryStack.isEmpty() && !currentDirOrFile.startsWith(directoryStack.top()) ) {
if (!directoryStack.isEmpty() && !currentDirOrFile.startsWith(directoryStack.top()))
{
TQString dirToBeRemoved = directoryStack.pop();
bool couldRemoveDir = TQDir(dirToBeRemoved).rmdir(dirToBeRemoved);
noErrorsOccurred &= couldRemoveDir;
if ( couldRemoveDir == false )
tqWarning() << __LINE__ << " " << __FUNCTION__ << "Could not remove the directory: " << dirToBeRemoved;
if (couldRemoveDir == false)
{
tqWarning() << __LINE__ << " " << __FUNCTION__ << "Could not remove the directory: " <<
dirToBeRemoved;
}
//tqDebug() << "Removing Dir " << directoryStack.pop();
}
// If the iterator currently points to a directory push it onto the stack.
if ( dirIterator.fileInfo().isDir() ) {
directoryStack.push( currentDirOrFile );
if (dirIterator.fileInfo().isDir())
{
directoryStack.push(currentDirOrFile);
//tqDebug() << "Pushing onto Stack " << currentDirOrFile;
}
// otherwise it must be a file, so delete it.
else {
bool couldRemoveFile = TQFile::remove( currentDirOrFile );
else
{
bool couldRemoveFile = TQFile::remove(currentDirOrFile);
noErrorsOccurred &= couldRemoveFile;
if ( couldRemoveFile == false )
tqWarning() << __LINE__ << " " << __FUNCTION__ << "Could not remove the file: " << currentDirOrFile;
if (couldRemoveFile == false)
{
tqWarning() << __LINE__ << " " << __FUNCTION__ << "Could not remove the file: " <<
currentDirOrFile;
}
//tqDebug() << "Removing File " << currentDirOrFile;
}
}
}
noErrorsOccurred &= TQDir(_tempPath).rmdir(_tempPath);
if ( noErrorsOccurred == false )
tqWarning() << __LINE__ << " " << __FUNCTION__ << "While cleaning up the temp dir an error occurred.";
if (noErrorsOccurred == false)
{
tqWarning() << __LINE__ << " " << __FUNCTION__ <<
"While cleaning up the temp dir an error occurred.";
}
}

4
src/SettingsPaths.h
Unescape Escape View File

@ -25,7 +25,7 @@ class TQString;
class SettingsPaths
{
public:
public:
static void init();
static const TQString getApplicationBinaryPath();
static const TQString getSettingsPath();
@ -35,7 +35,7 @@ public:
static bool getPortableMode();
static void cleanAndRemoveTempDir();
private:
private:
SettingsPaths();
static bool _alreadyInitialized;

8
src/TemplateBatchScript.cpp
Unescape Escape View File

@ -33,9 +33,10 @@
"__INDENTERCALLSTRING2__" the call string for indenting only one file.
And "__INDENTERCALLSTRINGSCRIPTNAME__" which is only the shown name of the indenter.
*/
const char* TemplateBatchScript::getTemplateBatchScript() {
static const char* templateBatchScript =
#if defined(Q_OS_WIN32)
const char* TemplateBatchScript::getTemplateBatchScript()
{
static const char *templateBatchScript =
#if defined (Q_OS_WIN32)
"@echo off\n"
"\n"
"IF (%1)==() GOTO error\n"
@ -121,7 +122,6 @@ const char* TemplateBatchScript::getTemplateBatchScript() {
return templateBatchScript;
}
/* Here comes the original batch script without the c++ markup
@echo off

5
src/TemplateBatchScript.h
Unescape Escape View File

@ -22,9 +22,10 @@
class TemplateBatchScript
{
private:
private:
TemplateBatchScript();
public:
public:
static const char* getTemplateBatchScript();
};

40
src/UiGuiErrorMessage.cpp
Unescape Escape View File

@ -36,20 +36,21 @@
Retrieves the object pointer to the \a _showAgainCheckBox check box, sets the dialogs
modality and for a working translation sets the check box text.
*/
UiGuiErrorMessage::UiGuiErrorMessage(TQWidget *parent) : TQErrorMessage(parent) {
_showAgainCheckBox = findChild<TQCheckBox *>();
setWindowModality( TQt::ApplicationModal );
_showAgainCheckBox->setText( tr("Show this message again") );
UiGuiErrorMessage::UiGuiErrorMessage(TQWidget *parent) :
TQErrorMessage(parent)
{
_showAgainCheckBox = findChild<TQCheckBox*>();
setWindowModality(TQt::ApplicationModal);
_showAgainCheckBox->setText(tr("Show this message again"));
}
/*!
\brief Just a lazy nothin doin destructive destructor.
*/
UiGuiErrorMessage::~UiGuiErrorMessage(void) {
UiGuiErrorMessage::~UiGuiErrorMessage(void)
{
}
/*!
\brief Shows an error \a message in a dialog box with \a title.
@ -57,31 +58,36 @@ UiGuiErrorMessage::~UiGuiErrorMessage(void) {
already in that list and "Show this message again" is not checked, that
message will not be shown.
*/
void UiGuiErrorMessage::showMessage( const TQString &title, const TQString &message ) {
void UiGuiErrorMessage::showMessage(const TQString &title, const TQString &message)
{
bool showAgain = true;
if ( _showAgainCheckBox != 0 ) {
if (_showAgainCheckBox != 0)
{
showAgain = _showAgainCheckBox->isChecked();
}
setWindowTitle(title);
if ( !_errorMessageList.contains(message) ) {
if (!_errorMessageList.contains(message))
{
_errorMessageList << message;
if ( _showAgainCheckBox != 0 ) {
if (_showAgainCheckBox != 0)
{
_showAgainCheckBox->setChecked(true);
}
TQErrorMessage::showMessage( message );
TQErrorMessage::showMessage(message);
}
else if ( showAgain ) {
TQErrorMessage::showMessage( message );
else if (showAgain)
{
TQErrorMessage::showMessage(message);
}
}
/*!
\brief For convinience, for showing a dialog box with the default title "UniversalIndentGUI".
*/
void UiGuiErrorMessage::showMessage( const TQString &message ) {
showMessage( "UniversalIndentGUI", message );
void UiGuiErrorMessage::showMessage(const TQString &message)
{
showMessage("UniversalIndentGUI", message);
}

9
src/UiGuiErrorMessage.h
Unescape Escape View File

@ -29,13 +29,14 @@ class UiGuiErrorMessage : public TQErrorMessage
{
Q_OBJECT
public:
public:
UiGuiErrorMessage(TQWidget *parent = 0);
~UiGuiErrorMessage(void);
void showMessage( const TQString &message );
void showMessage( const TQString &title, const TQString &message );
private:
void showMessage(const TQString &message);
void showMessage(const TQString &title, const TQString &message);
private:
TQCheckBox *_showAgainCheckBox;
TQStringList _errorMessageList;
};

326
src/UiGuiHighlighter.cpp
Unescape Escape View File

@ -36,9 +36,9 @@
#include <Qsci/qscilexercss.h>
#include <Qsci/qscilexerd.h>
#include <Qsci/qscilexerdiff.h>
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#include <Qsci/qscilexerfortran.h>
#include <Qsci/qscilexerfortran77.h>
#if (TQSCINTILLA_VERSION >= 0x020300)
#include <Qsci/qscilexerfortran.h>
#include <Qsci/qscilexerfortran77.h>
#endif
#include <Qsci/qscilexerhtml.h>
#include <Qsci/qscilexeridl.h>
@ -46,32 +46,32 @@
#include <Qsci/qscilexerjavascript.h>
#include <Qsci/qscilexerlua.h>
#include <Qsci/qscilexermakefile.h>
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#include <Qsci/qscilexerpascal.h>
#if (TQSCINTILLA_VERSION >= 0x020300)
#include <Qsci/qscilexerpascal.h>
#endif
#include <Qsci/qscilexerperl.h>
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#include <Qsci/qscilexerpostscript.h>
#if (TQSCINTILLA_VERSION >= 0x020300)
#include <Qsci/qscilexerpostscript.h>
#endif
#include <Qsci/qscilexerpov.h>
#include <Qsci/qscilexerproperties.h>
#include <Qsci/qscilexerpython.h>
#include <Qsci/qscilexerruby.h>
#if ( TQSCINTILLA_VERSION >= 0x020400 )
#include <Qsci/qscilexerspice.h>
#if (TQSCINTILLA_VERSION >= 0x020400)
#include <Qsci/qscilexerspice.h>
#endif
#include <Qsci/qscilexersql.h>
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#include <Qsci/qscilexertcl.h>
#if (TQSCINTILLA_VERSION >= 0x020300)
#include <Qsci/qscilexertcl.h>
#endif
#include <Qsci/qscilexertex.h>
#if ( TQSCINTILLA_VERSION >= 0x020400 )
#include <Qsci/qscilexerverilog.h>
#if (TQSCINTILLA_VERSION >= 0x020400)
#include <Qsci/qscilexerverilog.h>
#endif
#include <Qsci/qscilexervhdl.h>
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#include <Qsci/qscilexerxml.h>
#include <Qsci/qscilexeryaml.h>
#if (TQSCINTILLA_VERSION >= 0x020300)
#include <Qsci/qscilexerxml.h>
#include <Qsci/qscilexeryaml.h>
#endif
//! \defgroup grp_EditorComponent All concerning editor widget.
@ -85,23 +85,28 @@
/*!
\brief The constructor initializes some regular expressions and keywords to identify cpp tokens
*/
UiGuiHighlighter::UiGuiHighlighter(QsciScintilla *parent) : TQObject(parent) {
UiGuiHighlighter::UiGuiHighlighter(QsciScintilla *parent) :
TQObject(parent)
{
_qsciEditorParent = parent;
// Create the highlighter _settings object from the UiGuiSyntaxHighlightConfig.ini file.
_settings = new TQSettings(SettingsPaths::getSettingsPath() + "/UiGuiSyntaxHighlightConfig.ini", TQSettings::IniFormat, this);
_settings = new TQSettings(
SettingsPaths::getSettingsPath() + "/UiGuiSyntaxHighlightConfig.ini", TQSettings::IniFormat,
this);
_highlightningIsOn = true;
_mapHighlighternameToExtension["Bash"] = TQStringList() << "sh";
_mapHighlighternameToExtension["Batch"] = TQStringList() << "bat";
_mapHighlighternameToExtension["CMake"] = TQStringList() << "cmake";
_mapHighlighternameToExtension["C++"] = TQStringList() << "c" << "h" << "cpp" << "hpp" << "cxx" << "hxx";
_mapHighlighternameToExtension["C++"] = TQStringList() << "c" << "h" << "cpp" << "hpp" <<
"cxx" << "hxx";
_mapHighlighternameToExtension["C#"] = TQStringList() << "cs";
_mapHighlighternameToExtension["CSS"] = TQStringList() << "css";
_mapHighlighternameToExtension["D"] = TQStringList() << "d";
_mapHighlighternameToExtension["Diff"] = TQStringList() << "diff";
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#if (TQSCINTILLA_VERSION >= 0x020300)
_mapHighlighternameToExtension["Fortran"] = TQStringList() << "f" << "for" << "f90";
_mapHighlighternameToExtension["Fortran77"] = TQStringList() << "f77";
#endif
@ -111,32 +116,33 @@ UiGuiHighlighter::UiGuiHighlighter(QsciScintilla *parent) : TQObject(parent) {
_mapHighlighternameToExtension["JavaScript"] = TQStringList() << "js";
_mapHighlighternameToExtension["LUA"] = TQStringList() << "lua";
_mapHighlighternameToExtension["Makefile"] = TQStringList() << "makefile";
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#if (TQSCINTILLA_VERSION >= 0x020300)
_mapHighlighternameToExtension["Pascal"] = TQStringList() << "pas";
#endif
_mapHighlighternameToExtension["Perl"] = TQStringList() << "perl" << "pl" << "pm";
_mapHighlighternameToExtension["PHP"] = TQStringList() << "php";
#if ( TQSCINTILLA_VERSION >= 0x020300 )
_mapHighlighternameToExtension["PostScript"] = TQStringList() << "ps" << "eps" << "pdf" << "ai" << "fh";
#if (TQSCINTILLA_VERSION >= 0x020300)
_mapHighlighternameToExtension["PostScript"] = TQStringList() << "ps" << "eps" << "pdf" << "ai" <<
"fh";
#endif
_mapHighlighternameToExtension["POV"] = TQStringList() << "pov";
_mapHighlighternameToExtension["Ini"] = TQStringList() << "ini";
_mapHighlighternameToExtension["Python"] = TQStringList() << "py";
_mapHighlighternameToExtension["Ruby"] = TQStringList() << "rub" << "rb";
#if ( TQSCINTILLA_VERSION >= 0x020400 )
#if (TQSCINTILLA_VERSION >= 0x020400)
_mapHighlighternameToExtension["Spice"] = TQStringList() << "cir";
#endif
_mapHighlighternameToExtension["SQL"] = TQStringList() << "sql";
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#if (TQSCINTILLA_VERSION >= 0x020300)
_mapHighlighternameToExtension["TCL"] = TQStringList() << "tcl";
#endif
_mapHighlighternameToExtension["TeX"] = TQStringList() << "tex";
#if ( TQSCINTILLA_VERSION >= 0x020400 )
#if (TQSCINTILLA_VERSION >= 0x020400)
_mapHighlighternameToExtension["Verilog"] = TQStringList() << "v" << "vh";
#endif
_mapHighlighternameToExtension["VHDL"] = TQStringList() << "vhdl";
_mapHighlighternameToExtension["XML"] = TQStringList() << "xml";
#if ( TQSCINTILLA_VERSION >= 0x020300 )
#if (TQSCINTILLA_VERSION >= 0x020300)
_mapHighlighternameToExtension["YAML"] = TQStringList() << "yaml";
#endif
@ -150,36 +156,37 @@ UiGuiHighlighter::UiGuiHighlighter(QsciScintilla *parent) : TQObject(parent) {
*/
// Set default highlighter to C++ highlighter.
setLexerForExtension( "cpp" );
setLexerForExtension("cpp");
}
/*!
\brief Returns the available highlighters as TQStringList.
*/
TQStringList UiGuiHighlighter::getAvailableHighlighters() {
TQStringList UiGuiHighlighter::getAvailableHighlighters()
{
return _mapHighlighternameToExtension.keys();
}
/*!
\brief This slot handles signals coming from selecting another syntax highlighter.
*/
void UiGuiHighlighter::setHighlighterByAction(TQAction* highlighterAction) {
void UiGuiHighlighter::setHighlighterByAction(TQAction *highlighterAction)
{
TQString highlighterName = highlighterAction->text();
setLexerForExtension( _mapHighlighternameToExtension[highlighterName].first() );
setLexerForExtension(_mapHighlighternameToExtension[highlighterName].first());
//TODO: This is really no nice way. How do it better?
// Need to do this "text update" to update the syntax highlighting. Otherwise highlighting is wrong.
// Need to do this "text update" to update the syntax highlighting. Otherwise highlighting is
// wrong.
int scrollPos = _qsciEditorParent->verticalScrollBar()->value();
_qsciEditorParent->setText( _qsciEditorParent->text() );
_qsciEditorParent->setText(_qsciEditorParent->text());
_qsciEditorParent->verticalScrollBar()->setValue(scrollPos);
}
/*!
\brief Turns the syntax parser on.
*/
void UiGuiHighlighter::turnHighlightOn() {
void UiGuiHighlighter::turnHighlightOn()
{
_highlightningIsOn = true;
_qsciEditorParent->setLexer(_lexer);
readCurrentSettings("");
@ -188,24 +195,26 @@ void UiGuiHighlighter::turnHighlightOn() {
/*!
\brief Turns the syntax parser off.
*/
void UiGuiHighlighter::turnHighlightOff() {
void UiGuiHighlighter::turnHighlightOff()
{
_highlightningIsOn = false;
_qsciEditorParent->setLexer();
#if defined(Q_OS_WIN) || defined(Q_OS_MAC)
_qsciEditorParent->setFont( TQFont("Courier", 10, TQFont::Normal) );
_qsciEditorParent->setMarginsFont( TQFont("Courier", 10, TQFont::Normal) );
#if defined (Q_OS_WIN) || defined (Q_OS_MAC)
_qsciEditorParent->setFont(TQFont("Courier", 10, TQFont::Normal));
_qsciEditorParent->setMarginsFont(TQFont("Courier", 10, TQFont::Normal));
#else
_qsciEditorParent->setFont( TQFont("Monospace", 10, TQFont::Normal) );
_qsciEditorParent->setMarginsFont( TQFont("Monospace", 10, TQFont::Normal) );
_qsciEditorParent->setFont(TQFont("Monospace", 10, TQFont::Normal));
_qsciEditorParent->setMarginsFont(TQFont("Monospace", 10, TQFont::Normal));
#endif
}
/*!
\brief Read the settings for the current lexer from the settings file.
*/
//TODO: Refactor this function so that the coding style and variable names suit better.
bool UiGuiHighlighter::readCurrentSettings( const char *prefix ) {
bool UiGuiHighlighter::readCurrentSettings(const char *prefix)
{
bool ok, flag, rc = true;
int num;
TQString key;
@ -215,12 +224,15 @@ bool UiGuiHighlighter::readCurrentSettings( const char *prefix ) {
_colorForStyles.clear();
// Read the styles.
for (int i = 0; i < 128; ++i) {
for (int i = 0; i < 128; ++i)
{
// Ignore invalid styles.
if ( _lexer->description(i).isEmpty() )
if (_lexer->description(i).isEmpty())
{
continue;
}
key.sprintf( "%s/%s/style%d/", prefix, _lexer->language(), i );
key.sprintf("%s/%s/style%d/", prefix, _lexer->language(), i);
key.replace("+", "p");
// Read the foreground color.
@ -228,18 +240,26 @@ bool UiGuiHighlighter::readCurrentSettings( const char *prefix ) {
num = _settings->value(key + "color", 0).toInt();
if (ok)
setColor( TQColor((num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff), i );
{
setColor(TQColor((num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff), i);
}
else
{
rc = false;
}
// Read the end-of-line fill.
ok = _settings->contains(key + "eolfill");
flag = _settings->value(key + "eolfill", false).toBool();
if (ok)
_lexer->setEolFill( flag, i );
{
_lexer->setEolFill(flag, i);
}
else
{
rc = false;
}
// Read the font
TQStringList fdesc;
@ -247,16 +267,21 @@ bool UiGuiHighlighter::readCurrentSettings( const char *prefix ) {
ok = _settings->contains(key + "font");
fdesc = _settings->value(key + "font").toStringList();
if (ok && fdesc.count() == 5) {
if (ok && fdesc.count() == 5)
{
TQFont f;
#if defined(Q_OS_WIN) || defined(Q_OS_MAC)
#if defined (Q_OS_WIN) || defined (Q_OS_MAC)
f.setFamily(fdesc[0]);
#else
if ( fdesc[0].contains("courier", TQt::CaseInsensitive) )
if (fdesc[0].contains("courier", TQt::CaseInsensitive))
{
f.setFamily("Monospace");
}
else
{
f.setFamily(fdesc[0]);
}
#endif
f.setPointSize(fdesc[1].toInt());
f.setBold(fdesc[2].toInt());
@ -266,53 +291,64 @@ bool UiGuiHighlighter::readCurrentSettings( const char *prefix ) {
setFont(f, i);
}
else
{
rc = false;
}
// Read the background color.
ok = _settings->contains(key + "paper");
num = _settings->value(key + "paper", 0).toInt();
if (ok)
_lexer->setPaper( TQColor((num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff), i );
{
_lexer->setPaper(TQColor((num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff), i);
}
else
{
rc = false;
}
}
// Read the properties.
key.sprintf( "%s/%s/properties/", prefix, _lexer->language() );
key.sprintf("%s/%s/properties/", prefix, _lexer->language());
_lexer->refreshProperties();
return rc;
}
/*!
\brief Write the settings for the current lexer to the settings file.
*/
void UiGuiHighlighter::writeCurrentSettings( const char *prefix ) {
void UiGuiHighlighter::writeCurrentSettings(const char *prefix)
{
TQString key;
// Write the styles.
for (int i = 0; i < 128; ++i) {
for (int i = 0; i < 128; ++i)
{
// Ignore invalid styles.
if ( _lexer->description(i).isEmpty() )
if (_lexer->description(i).isEmpty())
{
continue;
}
int num;
TQColor c;
key.sprintf( "%s/%s/style%d/", prefix, _lexer->language(), i );
key.sprintf("%s/%s/style%d/", prefix, _lexer->language(), i);
key.replace("+", "p");
// Write style name
_settings->setValue( key + "", _lexer->description(i) );
_settings->setValue(key + "", _lexer->description(i));
// Write the foreground color.
if ( _colorForStyles.contains(i) ) {
if (_colorForStyles.contains(i))
{
c = _colorForStyles[i];
}
else {
else
{
c = _lexer->color(i);
}
num = (c.red() << 16) | (c.green() << 8) | c.blue();
@ -320,27 +356,29 @@ void UiGuiHighlighter::writeCurrentSettings( const char *prefix ) {
_settings->setValue(key + "color", num);
// Write the end-of-line fill.
_settings->setValue( key + "eolfill", _lexer->eolFill(i) );
_settings->setValue(key + "eolfill", _lexer->eolFill(i));
// Write the font
TQStringList fdesc;
TQString fmt("%1");
TQFont f;
if ( _fontForStyles.contains(i) ) {
if (_fontForStyles.contains(i))
{
f = _fontForStyles[i];
}
else {
else
{
f = _lexer->font(i);
}
fdesc += f.family();
fdesc += fmt.arg( f.pointSize() );
fdesc += fmt.arg(f.pointSize());
// The casts are for Borland.
fdesc += fmt.arg( (int)f.bold() );
fdesc += fmt.arg( (int)f.italic() );
fdesc += fmt.arg( (int)f.underline() );
fdesc += fmt.arg((int)f.bold());
fdesc += fmt.arg((int)f.italic());
fdesc += fmt.arg((int)f.underline());
_settings->setValue(key + "font", fdesc);
@ -352,172 +390,210 @@ void UiGuiHighlighter::writeCurrentSettings( const char *prefix ) {
}
}
/*!
\brief Sets the \a color for the given \a style.
*/
void UiGuiHighlighter::setColor(const TQColor &color, int style) {
void UiGuiHighlighter::setColor(const TQColor &color, int style)
{
_colorForStyles[style] = color;
_lexer->setColor( color, style );
_lexer->setColor(color, style);
}
/*!
\brief Sets the \a font for the given \a style.
*/
void UiGuiHighlighter::setFont(const TQFont &font, int style) {
void UiGuiHighlighter::setFont(const TQFont &font, int style)
{
_fontForStyles[style] = font;
_lexer->setFont( font, style );
_lexer->setFont(font, style);
}
/*!
\brief Sets the to be used lexer by giving his name.
*/
void UiGuiHighlighter::setLexerByName( TQString lexerName ) {
setLexerForExtension( _mapHighlighternameToExtension[lexerName].first() );
void UiGuiHighlighter::setLexerByName(TQString lexerName)
{
setLexerForExtension(_mapHighlighternameToExtension[lexerName].first());
}
/*!
\brief Sets the proper highlighter / lexer for the given file \a extension. Returns the index of the used lexer in the list.
*/
int UiGuiHighlighter::setLexerForExtension( TQString extension ) {
int UiGuiHighlighter::setLexerForExtension(TQString extension)
{
int indexOfHighlighter = 0;
extension = extension.toLower();
if ( _lexer != NULL ) {
if (_lexer != NULL)
{
writeCurrentSettings("");
delete _lexer;
}
if ( extension == "cpp" || extension == "hpp" || extension == "c" || extension == "h" || extension == "cxx" || extension == "hxx" ) {
if (extension == "cpp" || extension == "hpp" || extension == "c" || extension == "h" ||
extension == "cxx" || extension == "hxx")
{
_lexer = new QsciLexerCPP();
}
else if ( extension == "sh" ) {
else if (extension == "sh")
{
_lexer = new QsciLexerBash();
}
else if ( extension == "bat" ) {
else if (extension == "bat")
{
_lexer = new QsciLexerBatch();
}
else if ( extension == "cmake" ) {
else if (extension == "cmake")
{
_lexer = new QsciLexerCMake();
}
else if ( extension == "cs" ) {
else if (extension == "cs")
{
_lexer = new QsciLexerCSharp();
}
else if ( extension == "css" ) {
else if (extension == "css")
{
_lexer = new QsciLexerCSS();
}
else if ( extension == "d" ) {
else if (extension == "d")
{
_lexer = new QsciLexerD();
}
else if ( extension == "diff" ) {
else if (extension == "diff")
{
_lexer = new QsciLexerDiff();
}
#if ( TQSCINTILLA_VERSION >= 0x020300 )
else if ( extension == "f" || extension == "for" || extension == "f90" ) {
#if (TQSCINTILLA_VERSION >= 0x020300)
else if (extension == "f" || extension == "for" || extension == "f90")
{
_lexer = new QsciLexerFortran();
}
else if ( extension == "f77" ) {
else if (extension == "f77")
{
_lexer = new QsciLexerFortran77();
}
#endif
else if ( extension == "html" || extension == "htm" ) {
else if (extension == "html" || extension == "htm")
{
_lexer = new QsciLexerHTML();
}
else if ( extension == "idl" ) {
else if (extension == "idl")
{
_lexer = new QsciLexerIDL();
}
else if ( extension == "java" ) {
else if (extension == "java")
{
_lexer = new QsciLexerJava();
}
else if ( extension == "js" ) {
else if (extension == "js")
{
_lexer = new QsciLexerJavaScript();
}
else if ( extension == "lua" ) {
else if (extension == "lua")
{
_lexer = new QsciLexerLua();
}
else if ( extension == "makefile" ) {
else if (extension == "makefile")
{
_lexer = new QsciLexerMakefile();
}
#if ( TQSCINTILLA_VERSION >= 0x020300 )
else if ( extension == "pas" ) {
#if (TQSCINTILLA_VERSION >= 0x020300)
else if (extension == "pas")
{
_lexer = new QsciLexerPascal();
}
#endif
else if ( extension == "perl" || extension == "pl" || extension == "pm" ) {
else if (extension == "perl" || extension == "pl" || extension == "pm")
{
_lexer = new QsciLexerPerl();
}
else if ( extension == "php" ) {
else if (extension == "php")
{
_lexer = new QsciLexerHTML();
}
#if ( TQSCINTILLA_VERSION >= 0x020300 )
else if ( extension == "ps" || extension == "eps" || extension == "pdf" || extension == "ai" || extension == "fh") {
#if (TQSCINTILLA_VERSION >= 0x020300)
else if (extension == "ps" || extension == "eps" || extension == "pdf" || extension == "ai" ||
extension == "fh")
{
_lexer = new QsciLexerPostScript();
}
#endif
else if ( extension == "pov" ) {
else if (extension == "pov")
{
_lexer = new QsciLexerPOV();
}
else if ( extension == "ini" ) {
else if (extension == "ini")
{
_lexer = new QsciLexerProperties();
}
else if ( extension == "py" ) {
else if (extension == "py")
{
_lexer = new QsciLexerPython();
}
else if ( extension == "rub" || extension == "rb" ) {
else if (extension == "rub" || extension == "rb")
{
_lexer = new QsciLexerRuby();
}
#if ( TQSCINTILLA_VERSION >= 0x020400 )
else if ( extension == "spice?" ) {
#if (TQSCINTILLA_VERSION >= 0x020400)
else if (extension == "spice?")
{
_lexer = new QsciLexerSpice();
}
#endif
else if ( extension == "sql" ) {
else if (extension == "sql")
{
_lexer = new QsciLexerSQL();
}
#if ( TQSCINTILLA_VERSION >= 0x020300 )
else if ( extension == "tcl" ) {
#if (TQSCINTILLA_VERSION >= 0x020300)
else if (extension == "tcl")
{
_lexer = new QsciLexerTCL();
}
#endif
else if ( extension == "tex" ) {
else if (extension == "tex")
{
_lexer = new QsciLexerTeX();
}
#if ( TQSCINTILLA_VERSION >= 0x020400 )
else if ( extension == "vlog?" ) {
#if (TQSCINTILLA_VERSION >= 0x020400)
else if (extension == "vlog?")
{
_lexer = new QsciLexerVerilog();
}
#endif
else if ( extension == "vhdl" ) {
else if (extension == "vhdl")
{
_lexer = new QsciLexerVHDL();
}
else if ( extension == "xml" ) {
#if ( TQSCINTILLA_VERSION >= 0x020300 )
else if (extension == "xml")
{
#if (TQSCINTILLA_VERSION >= 0x020300)
_lexer = new QsciLexerXML();
#else
_lexer = new QsciLexerHTML();
#endif
}
#if ( TQSCINTILLA_VERSION >= 0x020300 )
else if ( extension == "yaml" ) {
#if (TQSCINTILLA_VERSION >= 0x020300)
else if (extension == "yaml")
{
_lexer = new QsciLexerYAML();
}
#endif
else {
else
{
_lexer = new QsciLexerCPP();
extension = "cpp";
}
// Find the index of the selected _lexer.
indexOfHighlighter = 0;
while ( !_mapHighlighternameToExtension.values().at(indexOfHighlighter).contains(extension) ) {
while (!_mapHighlighternameToExtension.values().at(indexOfHighlighter).contains(extension))
{
indexOfHighlighter++;
}
// Set the _lexer for the TQScintilla widget.
if ( _highlightningIsOn ) {
if (_highlightningIsOn)
{
_qsciEditorParent->setLexer(_lexer);
}

15
src/UiGuiHighlighter.h
Unescape Escape View File

@ -36,8 +36,9 @@ class UiGuiHighlighter : public TQObject
{
Q_OBJECT
public:
public:
UiGuiHighlighter(QsciScintilla *parent);
void turnHighlightOff();
void turnHighlightOn();
@ -45,7 +46,7 @@ public:
void writeCurrentSettings(const char *prefix);
TQStringList getAvailableHighlighters();
public slots:
public slots:
//! The foreground color for style number \a style is set to \a color. If
//! \a style is -1 then the color is set for all styles.
void setColor(const TQColor &color, int style = -1);
@ -55,18 +56,18 @@ public slots:
void setFont(const TQFont &font, int style = -1);
//! Sets the lexer that is responsible for the given \a extension.
int setLexerForExtension( TQString extension );
int setLexerForExtension(TQString extension);
void setLexerByName( TQString lexerName );
void setLexerByName(TQString lexerName);
void setHighlighterByAction(TQAction* highlighterAction);
void setHighlighterByAction(TQAction *highlighterAction);
private:
private:
bool _highlightningIsOn;
QsciScintilla *_qsciEditorParent;
TQMap<int, TQFont> _fontForStyles;
TQMap<int, TQColor> _colorForStyles;
QsciLexer* _lexer;
QsciLexer *_lexer;
TQSettings *_settings;
TQMap<TQString, TQStringList> _mapHighlighternameToExtension;
};

89
src/UiGuiIndentServer.cpp
Unescape Escape View File

@ -43,37 +43,44 @@
matter for which application the plugin/client is developed.
*/
UiGuiIndentServer::UiGuiIndentServer(void) : TQObject() {
UiGuiIndentServer::UiGuiIndentServer(void) :
TQObject()
{
_tcpServer = NULL;
_currentClientConnection = NULL;
_readyForHandleRequest = false;
}
UiGuiIndentServer::~UiGuiIndentServer(void) {
UiGuiIndentServer::~UiGuiIndentServer(void)
{
}
void UiGuiIndentServer::startServer() {
if ( _tcpServer == NULL ) {
void UiGuiIndentServer::startServer()
{
if (_tcpServer == NULL)
{
_tcpServer = new TQTcpServer(this);
}
if ( !_tcpServer->isListening() ) {
if ( !_tcpServer->listen(TQHostAddress::Any, tquint16(84484)) ) {
TQMessageBox::critical( NULL, tr("UiGUI Server"), tr("Unable to start the server: %1.").arg(_tcpServer->errorString()) );
if (!_tcpServer->isListening())
{
if (!_tcpServer->listen(TQHostAddress::Any, tquint16(84484)))
{
TQMessageBox::critical(NULL, tr("UiGUI Server"),
tr("Unable to start the server: %1.").arg(_tcpServer->errorString()));
return;
}
}
connect( _tcpServer, SIGNAL(newConnection()), this, SLOT(handleNewConnection()) );
connect(_tcpServer, SIGNAL(newConnection()), this, SLOT(handleNewConnection()));
_readyForHandleRequest = true;
_blockSize = 0;
}
void UiGuiIndentServer::stopServer() {
if ( _tcpServer != NULL ) {
void UiGuiIndentServer::stopServer()
{
if (_tcpServer != NULL)
{
_tcpServer->close();
delete _tcpServer;
_tcpServer = NULL;
@ -82,36 +89,43 @@ void UiGuiIndentServer::stopServer() {
_readyForHandleRequest = false;
}
void UiGuiIndentServer::handleNewConnection() {
void UiGuiIndentServer::handleNewConnection()
{
TQTcpSocket *clientConnection = _tcpServer->nextPendingConnection();
connect( clientConnection, SIGNAL(disconnected()), clientConnection, SLOT(deleteLater()) );
connect(clientConnection, SIGNAL(disconnected()), clientConnection, SLOT(deleteLater()));
connect( clientConnection, SIGNAL(readyRead()), this, SLOT(handleReceivedData()) );
connect(clientConnection, SIGNAL(readyRead()), this, SLOT(handleReceivedData()));
}
void UiGuiIndentServer::handleReceivedData() {
if ( !_readyForHandleRequest ) {
void UiGuiIndentServer::handleReceivedData()
{
if (!_readyForHandleRequest)
{
return;
}
_currentClientConnection = qobject_cast<TQTcpSocket*>( sender() );
_currentClientConnection = qobject_cast<TQTcpSocket*>(sender());
TQString receivedData = "";
if ( _currentClientConnection != NULL ) {
if (_currentClientConnection != NULL)
{
TQDataStream in(_currentClientConnection);
in.setVersion(TQDataStream::TQt_4_0);
if ( _blockSize == 0 ) {
if ( _currentClientConnection->bytesAvailable() < (int)sizeof(tquint32) )
if (_blockSize == 0)
{
if (_currentClientConnection->bytesAvailable() < (int)sizeof(tquint32))
{
return;
}
in >> _blockSize;
}
if ( _currentClientConnection->bytesAvailable() < _blockSize )
if (_currentClientConnection->bytesAvailable() < _blockSize)
{
return;
}
TQString receivedMessage;
in >> receivedMessage;
@ -120,17 +134,19 @@ void UiGuiIndentServer::handleReceivedData() {
tqDebug() << "receivedMessage: " << receivedMessage;
if ( receivedMessage == "ts" ) {
if (receivedMessage == "ts")
{
sendMessage("Toll");
}
else {
else
{
sendMessage("irgendwas");
}
}
}
void UiGuiIndentServer::sendMessage( const TQString &message ) {
void UiGuiIndentServer::sendMessage(const TQString &message)
{
_readyForHandleRequest = false;
_dataToSend = "";
@ -141,16 +157,19 @@ void UiGuiIndentServer::sendMessage( const TQString &message ) {
out.device()->seek(0);
out << (tquint32)(_dataToSend.size() - sizeof(tquint32));
connect(_currentClientConnection, SIGNAL(bytesWritten(qint64)), this, SLOT(checkIfReadyForHandleRequest()));
connect(_currentClientConnection, SIGNAL(bytesWritten(qint64)), this,
SLOT(checkIfReadyForHandleRequest()));
_currentClientConnection->write(_dataToSend);
}
void UiGuiIndentServer::checkIfReadyForHandleRequest() {
if ( _currentClientConnection->bytesToWrite() == 0 ) {
TQString dataToSendStr = _dataToSend.right( _dataToSend.size() - sizeof(tquint32) );
void UiGuiIndentServer::checkIfReadyForHandleRequest()
{
if (_currentClientConnection->bytesToWrite() == 0)
{
TQString dataToSendStr = _dataToSend.right(_dataToSend.size() - sizeof(tquint32));
tqDebug() << "checkIfReadyForHandleRequest _dataToSend was: " << dataToSendStr;
disconnect(_currentClientConnection, SIGNAL(bytesWritten(qint64)), this, SLOT(checkIfReadyForHandleRequest()));
disconnect(_currentClientConnection, SIGNAL(bytesWritten(qint64)), this,
SLOT(checkIfReadyForHandleRequest()));
_readyForHandleRequest = true;
}
}

8
src/UiGuiIndentServer.h
Unescape Escape View File

@ -30,21 +30,21 @@ class UiGuiIndentServer : public TQObject
{
Q_OBJECT
public:
public:
UiGuiIndentServer(void);
~UiGuiIndentServer(void);
public slots:
public slots:
void startServer();
void stopServer();
private slots:
private slots:
void handleNewConnection();
void handleReceivedData();
void sendMessage(const TQString &message);
void checkIfReadyForHandleRequest();
private:
private:
TQTcpServer *_tcpServer;
TQByteArray _dataToSend;
bool _readyForHandleRequest;

61
src/UiGuiIniFileParser.cpp
Unescape Escape View File

@ -43,46 +43,47 @@
/*!
\brief Init and empty all needed lists and strings.
*/
UiGuiIniFileParser::UiGuiIniFileParser(void) {
UiGuiIniFileParser::UiGuiIniFileParser(void)
{
init();
}
/*!
\brief Directly loads and parses the file with name \a iniFileName.
*/
UiGuiIniFileParser::UiGuiIniFileParser(const TQString &iniFileName) {
UiGuiIniFileParser::UiGuiIniFileParser(const TQString &iniFileName)
{
init();
_iniFileName = iniFileName;
parseIniFile();
}
void UiGuiIniFileParser::init() {
void UiGuiIniFileParser::init()
{
_sections.clear();
_keyValueMap.clear();
_iniFileName = "";
}
UiGuiIniFileParser::~UiGuiIniFileParser(void) {
UiGuiIniFileParser::~UiGuiIniFileParser(void)
{
}
/*!
\brief Returns the group/section names in the same order as they occurr in the ini file as TQStringList.
*/
TQStringList UiGuiIniFileParser::childGroups() {
TQStringList UiGuiIniFileParser::childGroups()
{
TQStringList sectionsStringList;
for( unsigned int i = 0; i < _sections.size(); i++ ) {
for (unsigned int i = 0; i < _sections.size(); i++)
{
sectionsStringList << _sections[i];
}
return sectionsStringList;
}
/*!
\brief Returns the value of the defined \a keyName as TQVariant.
@ -91,59 +92,67 @@ TQStringList UiGuiIniFileParser::childGroups() {
<code>[NiceSection]</br>niceKeyName=2</code> you would have to call
value("NiceSection/niceKeyName").
*/
TQVariant UiGuiIniFileParser::value(const TQString &keyName, const TQString &defaultValue) {
return _keyValueMap.value( keyName, defaultValue );
TQVariant UiGuiIniFileParser::value(const TQString &keyName, const TQString &defaultValue)
{
return _keyValueMap.value(keyName, defaultValue);
}
/*!
\brief Parses the ini file and stores the key value pairs in the internal vectors \a keys and \a values.
*/
void UiGuiIniFileParser::parseIniFile() {
void UiGuiIniFileParser::parseIniFile()
{
TQFile iniFile(_iniFileName);
if ( iniFile.open(TQFile::ReadOnly) ) {
if (iniFile.open(TQFile::ReadOnly))
{
// Clear the vectors holding the keys and values.
_sections.clear();
_keyValueMap.clear();
TQTextStream iniFileStream( &iniFile );
TQTextStream iniFileStream(&iniFile);
TQString line;
TQString currentSectionName = "";
TQString keyName = "";
TQString valueAsString = "";
while ( !iniFileStream.atEnd() ) {
while (!iniFileStream.atEnd())
{
line = iniFileStream.readLine().trimmed();
// Test if the read line is a section name and if so remeber it.
if ( line.startsWith("[") && line.endsWith("]") ) {
if (line.startsWith("[") && line.endsWith("]"))
{
currentSectionName = line.remove(0, 1);
currentSectionName.chop(1);
// Store the section name.
_sections.push_back( currentSectionName );
_sections.push_back(currentSectionName);
}
// Otherwise test whether the line has a assign char
else if ( line.contains("=") ) {
else if (line.contains("="))
{
int indexOfFirstAssign = line.indexOf("=");
keyName = line.left(indexOfFirstAssign);
if ( !keyName.isEmpty() ) {
valueAsString = line.remove(0, indexOfFirstAssign+1);
if (!keyName.isEmpty())
{
valueAsString = line.remove(0, indexOfFirstAssign + 1);
// Remove any existing double quotes from the value.
if ( valueAsString.startsWith("\"") && valueAsString.endsWith("\"") ) {
if (valueAsString.startsWith("\"") && valueAsString.endsWith("\""))
{
valueAsString = valueAsString.remove(0, 1);
valueAsString.chop(1);
}
// Prepend an eventually section name to the key name.
if ( !currentSectionName.isEmpty() ) {
if (!currentSectionName.isEmpty())
{
keyName = currentSectionName + "/" + keyName;
}
// Store the key and value in the map.
_keyValueMap.insert(keyName, valueAsString );
_keyValueMap.insert(keyName, valueAsString);
}
}
}

7
src/UiGuiIniFileParser.h
Unescape Escape View File

@ -31,17 +31,18 @@ class TQVariant;
class UiGuiIniFileParser
{
public:
public:
UiGuiIniFileParser(void);
UiGuiIniFileParser(const TQString &iniFileName);
~UiGuiIniFileParser(void);
TQVariant value(const TQString &keyName, const TQString &defaultValue = "");
TQStringList childGroups();
protected:
protected:
void init();
private:
private:
void parseIniFile();
TQString _iniFileName;

699
src/UiGuiSettings.cpp
View File

File diff suppressed because it is too large Load Diff

38
src/UiGuiSettings.h
Unescape Escape View File

@ -31,38 +31,49 @@ class TQSettings;
class UiGuiSettings : public TQObject
{
Q_OBJECT
private:
private:
UiGuiSettings();
static TQWeakPointer<UiGuiSettings> _instance;
public:
public:
static TQSharedPointer<UiGuiSettings> getInstance();
~UiGuiSettings();
bool registerObjectProperty(TQObject *obj, const TQString &propertyName, const TQString &settingName);
bool registerObjectProperty(TQObject *obj, const TQString &propertyName,
const TQString &settingName);
bool registerObjectPropertyRecursive(TQObject *obj);
bool setObjectPropertyToSettingValue(TQObject *obj, const TQString &propertyName, const TQString &settingName);
bool setObjectPropertyToSettingValue(TQObject *obj, const TQString &propertyName,
const TQString &settingName);
bool setObjectPropertyToSettingValueRecursive(TQObject *obj);
bool setSettingToObjectPropertyValue(TQObject *obj, const TQString &propertyName, const TQString &settingName);
bool setSettingToObjectPropertyValue(TQObject *obj, const TQString &propertyName,
const TQString &settingName);
bool setSettingToObjectPropertyValueRecursive(TQObject *obj);
bool registerObjectSlot(TQObject *obj, const TQString &slotName, const TQString &settingName);
bool registerObjectSlot(TQObject *obj, const TQString &slotName,
const TQString &settingName);
TQVariant getValueByName(TQString settingName);
TQStringList getAvailableTranslations();
public slots:
public slots:
void setValueByName(const TQString &settingName, const TQVariant &value);
void unregisterObjectProperty(TQObject *obj);
void unregisterObjectSlot(TQObject *obj, const TQString &slotName = "", const TQString &settingName = "");
void unregisterObjectSlot(TQObject *obj, const TQString &slotName = "",
const TQString &settingName = "");
protected:
protected:
bool initSettings();
bool invokeMethodWithValue(TQObject *obj, TQMetaMethod mMethod, TQVariant value);
bool checkCustomPropertiesAndCallFunction(TQObject *obj, bool (UiGuiSettings::*callBackFunc)(TQObject *obj, const TQString &propertyName, const TQString &settingName));
private slots:
bool checkCustomPropertiesAndCallFunction(TQObject * obj,
bool (UiGuiSettings::*callBackFunc)(TQObject *obj, const TQString &propertyName,
const TQString &settingName));
private slots:
void handleObjectPropertyChange();
private:
private:
void readAvailableTranslations();
//! Stores the mnemonics of the available translations.
@ -71,7 +82,8 @@ private:
//! The settings file.
TQSettings *_qsettings;
//! Maps an TQObject to a string list containing the property name and the associated setting name.
//! Maps an TQObject to a string list containing the property name and the associated setting
// name.
TQMap<TQObject*, TQStringList> _registeredObjectProperties;
//! Maps TQObjects to a string list containing the method name and the associated setting name.

150
src/UiGuiSettingsDialog.cpp
Unescape Escape View File

@ -31,7 +31,10 @@
/*!
\brief The constructor calls the setup function for the ui created by uic.
*/
UiGuiSettingsDialog::UiGuiSettingsDialog(TQWidget* parent, TQSharedPointer<UiGuiSettings> settings) : TQDialog(parent) {
UiGuiSettingsDialog::UiGuiSettingsDialog(TQWidget *parent,
TQSharedPointer<UiGuiSettings> settings) :
TQDialog(parent)
{
// Remember pointer to the UiGuiSettings object.
_settings = settings;
@ -41,64 +44,82 @@ UiGuiSettingsDialog::UiGuiSettingsDialog(TQWidget* parent, TQSharedPointer<UiGui
//TODO: This call has to be removed when the properties for the highlighters can be set
// with the settings dialog.
_settingsDialogForm->groupBoxSyntaxHighlighterProperties->setToolTip( "(Will be implemented soon)" + _settingsDialogForm->groupBoxSyntaxHighlighterProperties->toolTip() );
_settingsDialogForm->groupBoxSyntaxHighlighterProperties->setToolTip(
"(Will be implemented soon)" +
_settingsDialogForm->groupBoxSyntaxHighlighterProperties->toolTip());
// Connect the accepted signal to own function, to write values back to the UiGuiSettings object.
connect(this, SIGNAL(accepted()), this, SLOT(writeWidgetValuesToSettings()) );
connect(this, SIGNAL(accepted()), this, SLOT(writeWidgetValuesToSettings()));
// Init the language selection combobox.
initTranslationSelection();
}
/*!
\brief By calling this function the combobox for selecting the application language will
be initialized.
Also the translation itself will be reinitialized.
*/
void UiGuiSettingsDialog::initTranslationSelection() {
void UiGuiSettingsDialog::initTranslationSelection()
{
// First empty the combo box.
_settingsDialogForm->languageSelectionComboBox->clear();
// Now add an entry into the box for every language short.
foreach (TQString languageShort, _settings->getAvailableTranslations() ) {
foreach(TQString languageShort, _settings->getAvailableTranslations())
{
// Identify the language mnemonic and set the full name.
if ( languageShort == "en" ) {
_settingsDialogForm->languageSelectionComboBox->addItem( TQIcon(TQString(":/language/language-"+languageShort+".png")), tr("English") );
}
else if ( languageShort == "fr" ) {
_settingsDialogForm->languageSelectionComboBox->addItem( TQIcon(TQString(":/language/language-"+languageShort+".png")), tr("French") );
}
else if ( languageShort == "de" ) {
_settingsDialogForm->languageSelectionComboBox->addItem( TQIcon(TQString(":/language/language-"+languageShort+".png")), tr("German") );
}
else if ( languageShort == "zh_TW" ) {
_settingsDialogForm->languageSelectionComboBox->addItem( TQIcon(TQString(":/language/language-"+languageShort+".png")), tr("Chinese (Taiwan)") );
}
else if ( languageShort == "ja" ) {
_settingsDialogForm->languageSelectionComboBox->addItem( TQIcon(TQString(":/language/language-"+languageShort+".png")), tr("Japanese") );
}
else if ( languageShort == "ru" ) {
_settingsDialogForm->languageSelectionComboBox->addItem( TQIcon(TQString(":/language/language-"+languageShort+".png")), tr("Russian") );
}
else if ( languageShort == "uk" ) {
_settingsDialogForm->languageSelectionComboBox->addItem( TQIcon(TQString(":/language/language-"+languageShort+".png")), tr("Ukrainian") );
}
else {
_settingsDialogForm->languageSelectionComboBox->addItem( tr("Unknown language mnemonic ") + languageShort );
if (languageShort == "en")
{
_settingsDialogForm->languageSelectionComboBox->addItem(TQIcon(TQString(":/language/language-"
+ languageShort + ".png")), tr("English"));
}
else if (languageShort == "fr")
{
_settingsDialogForm->languageSelectionComboBox->addItem(TQIcon(TQString(":/language/language-"
+ languageShort + ".png")), tr("French"));
}
else if (languageShort == "de")
{
_settingsDialogForm->languageSelectionComboBox->addItem(TQIcon(TQString(":/language/language-"
+ languageShort + ".png")), tr("German"));
}
else if (languageShort == "zh_TW")
{
_settingsDialogForm->languageSelectionComboBox->addItem(TQIcon(TQString(":/language/language-"
+ languageShort + ".png")), tr("Chinese (Taiwan)"));
}
else if (languageShort == "ja")
{
_settingsDialogForm->languageSelectionComboBox->addItem(TQIcon(TQString(":/language/language-"
+ languageShort + ".png")), tr("Japanese"));
}
else if (languageShort == "ru")
{
_settingsDialogForm->languageSelectionComboBox->addItem(TQIcon(TQString(":/language/language-"
+ languageShort + ".png")), tr("Russian"));
}
else if (languageShort == "uk")
{
_settingsDialogForm->languageSelectionComboBox->addItem(TQIcon(TQString(":/language/language-"
+ languageShort + ".png")), tr("Ukrainian"));
}
else
{
_settingsDialogForm->languageSelectionComboBox->addItem(tr(
"Unknown language mnemonic ") + languageShort);
}
}
}
/*!
\brief Displays the dialog by calling the dialogs exec function.
Before it gets all the values needed from the UiGuiSettings object.
*/
int UiGuiSettingsDialog::showDialog() {
int UiGuiSettingsDialog::showDialog()
{
// Init all settings dialog objects with values from settings.
_settings->setObjectPropertyToSettingValueRecursive(this);
@ -106,64 +127,79 @@ int UiGuiSettingsDialog::showDialog() {
return exec();
}
/*!
\brief This slot is called when the dialog box is closed by pressing the Ok button.
Writes all settings to the UiGuiSettings object.
*/
void UiGuiSettingsDialog::writeWidgetValuesToSettings() {
void UiGuiSettingsDialog::writeWidgetValuesToSettings()
{
// Write settings dialog object values to settings.
_settings->setSettingToObjectPropertyValueRecursive(this);
}
/*!
\brief Catches language change events and retranslates all needed widgets.
*/
void UiGuiSettingsDialog::changeEvent(TQEvent *event) {
if (event->type() == TQEvent::LanguageChange) {
void UiGuiSettingsDialog::changeEvent(TQEvent *event)
{
if (event->type() == TQEvent::LanguageChange)
{
_settingsDialogForm->retranslateUi(this);
// If this is not explicit set here, TQt < 4.3.0 does not translate the buttons.
_settingsDialogForm->buttonBox->setStandardButtons(TQDialogButtonBox::Cancel | TQDialogButtonBox::NoButton|TQDialogButtonBox::Ok);
_settingsDialogForm->buttonBox->setStandardButtons(
TQDialogButtonBox::Cancel | TQDialogButtonBox::NoButton | TQDialogButtonBox::Ok);
//TODO: This has to be removed when the properties for the highlighters can be set.
_settingsDialogForm->groupBoxSyntaxHighlighterProperties->setToolTip( "(Will be implemented soon)" + _settingsDialogForm->groupBoxSyntaxHighlighterProperties->toolTip() );
_settingsDialogForm->groupBoxSyntaxHighlighterProperties->setToolTip(
"(Will be implemented soon)" +
_settingsDialogForm->groupBoxSyntaxHighlighterProperties->toolTip());
TQStringList languageShortList = _settings->getAvailableTranslations();
// Now retranslate every entry in the language selection box.
for (int i = 0; i < languageShortList.size(); i++ ) {
for (int i = 0; i < languageShortList.size(); i++)
{
TQString languageShort = languageShortList.at(i);
// Identify the language mnemonic and set the full name.
if ( languageShort == "en" ) {
_settingsDialogForm->languageSelectionComboBox->setItemText( i, tr("English") );
if (languageShort == "en")
{
_settingsDialogForm->languageSelectionComboBox->setItemText(i, tr("English"));
}
else if ( languageShort == "fr" ) {
_settingsDialogForm->languageSelectionComboBox->setItemText( i, tr("French") );
else if (languageShort == "fr")
{
_settingsDialogForm->languageSelectionComboBox->setItemText(i, tr("French"));
}
else if ( languageShort == "de" ) {
_settingsDialogForm->languageSelectionComboBox->setItemText( i, tr("German") );
else if (languageShort == "de")
{
_settingsDialogForm->languageSelectionComboBox->setItemText(i, tr("German"));
}
else if ( languageShort == "zh_TW" ) {
_settingsDialogForm->languageSelectionComboBox->setItemText( i, tr("Chinese (Taiwan)") );
else if (languageShort == "zh_TW")
{
_settingsDialogForm->languageSelectionComboBox->setItemText(i, tr("Chinese (Taiwan)"));
}
else if ( languageShort == "ja" ) {
_settingsDialogForm->languageSelectionComboBox->setItemText( i, tr("Japanese") );
else if (languageShort == "ja")
{
_settingsDialogForm->languageSelectionComboBox->setItemText(i, tr("Japanese"));
}
else if ( languageShort == "ru" ) {
_settingsDialogForm->languageSelectionComboBox->setItemText( i, tr("Russian") );
else if (languageShort == "ru")
{
_settingsDialogForm->languageSelectionComboBox->setItemText(i, tr("Russian"));
}
else if ( languageShort == "uk" ) {
_settingsDialogForm->languageSelectionComboBox->setItemText( i, tr("Ukrainian") );
else if (languageShort == "uk")
{
_settingsDialogForm->languageSelectionComboBox->setItemText(i, tr("Ukrainian"));
}
else {
_settingsDialogForm->languageSelectionComboBox->setItemText( i, tr("Unknown language mnemonic ") + languageShort );
else
{
_settingsDialogForm->languageSelectionComboBox->setItemText(i,
tr("Unknown language mnemonic ") + languageShort);
}
}
}
else {
else
{
TQWidget::changeEvent(event);
}
}

13
src/UiGuiSettingsDialog.h
Unescape Escape View File

@ -24,7 +24,8 @@
#include "UiGuiSettings.h"
namespace Ui {
namespace Ui
{
class SettingsDialog;
}
@ -33,16 +34,16 @@ class UiGuiSettingsDialog : public TQDialog
{
Q_OBJECT
public:
UiGuiSettingsDialog(TQWidget* parent, TQSharedPointer<UiGuiSettings> settings);
public:
UiGuiSettingsDialog(TQWidget *parent, TQSharedPointer<UiGuiSettings> settings);
public slots:
public slots:
int showDialog();
private slots:
private slots:
void writeWidgetValuesToSettings();
private:
private:
Ui::SettingsDialog *_settingsDialogForm;
void changeEvent(TQEvent *event);

184
src/UiGuiSystemInfo.cpp
Unescape Escape View File

@ -24,101 +24,179 @@
#include <tntqprocess.h>
#include <tntqfile.h>
UiGuiSystemInfo::UiGuiSystemInfo() {
UiGuiSystemInfo::UiGuiSystemInfo()
{
}
/*!
\brief Returns the operating system UiGUI is currently running on as one string.
The String contains name and version of the os. E.g. Linux Ubuntu 9.04.
*/
TQString UiGuiSystemInfo::getOperatingSystem() {
TQString UiGuiSystemInfo::getOperatingSystem()
{
TQString operatingSystemString = "";
#if defined(Q_WS_WIN)
switch ( TQSysInfo::WindowsVersion ) {
case TQSysInfo::WV_32s :
#if defined (Q_WS_WIN)
switch (TQSysInfo::WindowsVersion)
{
case TQSysInfo::WV_32s:
{
operatingSystemString = "Windows 3.1 with Win 32s";
break;
case TQSysInfo::WV_95 :
}
case TQSysInfo::WV_95:
{
operatingSystemString = "Windows 95";
break;
case TQSysInfo::WV_98 :
}
case TQSysInfo::WV_98:
{
operatingSystemString = "Windows 98";
break;
case TQSysInfo::WV_Me :
}
case TQSysInfo::WV_Me:
{
operatingSystemString = "Windows Me";
break;
case TQSysInfo::WV_NT :
}
case TQSysInfo::WV_NT:
{
operatingSystemString = "Windows NT (operating system version 4.0)";
break;
case TQSysInfo::WV_2000 :
}
case TQSysInfo::WV_2000:
{
operatingSystemString = "Windows 2000 (operating system version 5.0)";
break;
case TQSysInfo::WV_XP :
}
case TQSysInfo::WV_XP:
{
operatingSystemString = "Windows XP (operating system version 5.1)";
break;
case TQSysInfo::WV_2003 :
operatingSystemString = "Windows Server 2003, Windows Server 2003 R2, Windows Home Server, Windows XP Professional x64 Edition (operating system version 5.2)";
}
case TQSysInfo::WV_2003:
{
operatingSystemString =
"Windows Server 2003, Windows Server 2003 R2, Windows Home Server, Windows XP Professional x64 Edition (operating system version 5.2)";
break;
case TQSysInfo::WV_VISTA :
}
case TQSysInfo::WV_VISTA:
{
operatingSystemString = "Windows Vista, Windows Server 2008 (operating system version 6.0)";
break;
case TQSysInfo::WV_WINDOWS7 :
}
case TQSysInfo::WV_WINDOWS7:
{
operatingSystemString = "Windows 7 (operating system version 6.1)";
break;
case TQSysInfo::WV_CE :
}
case TQSysInfo::WV_CE:
{
operatingSystemString = "Windows CE";
break;
case TQSysInfo::WV_CENET :
}
case TQSysInfo::WV_CENET:
{
operatingSystemString = "Windows CE .NET";
break;
case TQSysInfo::WV_CE_5 :
}
case TQSysInfo::WV_CE_5:
{
operatingSystemString = "Windows CE 5.x";
break;
case TQSysInfo::WV_CE_6 :
}
case TQSysInfo::WV_CE_6:
{
operatingSystemString = "Windows CE 6.x";
break;
default :
}
default:
{
operatingSystemString = "Unknown Windows operating system.";
break;
}
#elif defined(Q_WS_MAC)
switch ( TQSysInfo::MacintoshVersion ) {
case TQSysInfo::MV_9 :
}
#elif defined (Q_WS_MAC)
switch (TQSysInfo::MacintoshVersion)
{
case TQSysInfo::MV_9:
{
operatingSystemString = "Mac OS 9 (unsupported)";
break;
case TQSysInfo::MV_10_0 :
}
case TQSysInfo::MV_10_0:
{
operatingSystemString = "Mac OS X 10.0 Cheetah (unsupported)";
break;
case TQSysInfo::MV_10_1 :
}
case TQSysInfo::MV_10_1:
{
operatingSystemString = "Mac OS X 10.1 Puma (unsupported)";
break;
case TQSysInfo::MV_10_2 :
}
case TQSysInfo::MV_10_2:
{
operatingSystemString = "Mac OS X 10.2 Jaguar (unsupported)";
break;
case TQSysInfo::MV_10_3 :
}
case TQSysInfo::MV_10_3:
{
operatingSystemString = "Mac OS X 10.3 Panther";
break;
case TQSysInfo::MV_10_4 :
}
case TQSysInfo::MV_10_4:
{
operatingSystemString = "Mac OS X 10.4 Tiger";
break;
case TQSysInfo::MV_10_5 :
}
case TQSysInfo::MV_10_5:
{
operatingSystemString = "Mac OS X 10.5 Leopard";
break;
case TQSysInfo::MV_10_6 :
}
case TQSysInfo::MV_10_6:
{
operatingSystemString = "Mac OS X 10.6 Snow Leopard";
break;
case TQSysInfo::MV_Unknown :
}
case TQSysInfo::MV_Unknown:
{
operatingSystemString = "An unknown and currently unsupported platform";
break;
default :
}
default:
{
operatingSystemString = "Unknown Mac operating system.";
break;
}
}
#else
//TODO: Detect Unix, Linux etc. distro as described on http://www.novell.com/coolsolutions/feature/11251.html
//TODO: Detect Unix, Linux etc. distro as described on
// http://www.novell.com/coolsolutions/feature/11251.html
operatingSystemString = "Linux";
TQProcess process;
@ -134,7 +212,8 @@ TQString UiGuiSystemInfo::getOperatingSystem() {
result = process.waitForFinished(1000);
TQString mach = process.readAllStandardOutput().trimmed();
if ( os == "SunOS" ) {
if (os == "SunOS")
{
os = "Solaris";
process.start("uname -p");
@ -147,19 +226,22 @@ TQString UiGuiSystemInfo::getOperatingSystem() {
operatingSystemString = os + " " + rev + " (" + arch + " " + timestamp + ")";
}
else if ( os == "AIX" ) {
else if (os == "AIX")
{
process.start("oslevel -r");
result = process.waitForFinished(1000);
TQString oslevel = process.readAllStandardOutput().trimmed();
operatingSystemString = os + "oslevel " + oslevel;
}
else if ( os == "Linux" ) {
else if (os == "Linux")
{
TQString dist;
TQString pseudoname;
TQString kernel = rev;
if ( TQFile::exists("/etc/redhat-release") ) {
if (TQFile::exists("/etc/redhat-release"))
{
dist = "RedHat";
process.start("sh -c \"cat /etc/redhat-release | sed s/.*\\(// | sed s/\\)//\"");
@ -170,7 +252,8 @@ TQString UiGuiSystemInfo::getOperatingSystem() {
result = process.waitForFinished(1000);
rev = process.readAllStandardOutput().trimmed();
}
else if ( TQFile::exists("/etc/SUSE-release") ) {
else if (TQFile::exists("/etc/SUSE-release"))
{
process.start("sh -c \"cat /etc/SUSE-release | tr '\\n' ' '| sed s/VERSION.*//\"");
result = process.waitForFinished(1000);
dist = process.readAllStandardOutput().trimmed();
@ -179,7 +262,8 @@ TQString UiGuiSystemInfo::getOperatingSystem() {
result = process.waitForFinished(1000);
rev = process.readAllStandardOutput().trimmed();
}
else if ( TQFile::exists("/etc/mandrake-release") ) {
else if (TQFile::exists("/etc/mandrake-release"))
{
dist = "Mandrake";
process.start("sh -c \"cat /etc/mandrake-release | sed s/.*\\(// | sed s/\\)//\"");
@ -190,20 +274,24 @@ TQString UiGuiSystemInfo::getOperatingSystem() {
result = process.waitForFinished(1000);
rev = process.readAllStandardOutput().trimmed();
}
else if ( TQFile::exists("/etc/lsb-release") ) {
else if (TQFile::exists("/etc/lsb-release"))
{
dist = "Ubuntu";
TQString processCall = "sh -c \"cat /etc/lsb-release | tr '\\n' ' ' | sed s/.*DISTRIB_RELEASE=// | sed s/\\ .*//\"";
process.start( processCall );
TQString processCall =
"sh -c \"cat /etc/lsb-release | tr '\\n' ' ' | sed s/.*DISTRIB_RELEASE=// | sed s/\\ .*//\"";
process.start(processCall);
result = process.waitForFinished(1000);
rev = process.readAllStandardOutput().trimmed();
TQString errorStr = process.readAllStandardError();
process.start("sh -c \"cat /etc/lsb-release | tr '\\n' ' ' | sed s/.*DISTRIB_CODENAME=// | sed s/\\ .*//\"");
process.start(
"sh -c \"cat /etc/lsb-release | tr '\\n' ' ' | sed s/.*DISTRIB_CODENAME=// | sed s/\\ .*//\"");
result = process.waitForFinished(1000);
pseudoname = process.readAllStandardOutput().trimmed();
}
else if ( TQFile::exists("/etc/debian_version") ) {
else if (TQFile::exists("/etc/debian_version"))
{
dist = "Debian";
process.start("cat /etc/debian_version");
@ -213,13 +301,15 @@ TQString UiGuiSystemInfo::getOperatingSystem() {
rev = "";
}
if ( TQFile::exists("/etc/UnitedLinux-release") ) {
if (TQFile::exists("/etc/UnitedLinux-release"))
{
process.start("sh -c \"cat /etc/UnitedLinux-release | tr '\\n' ' ' | sed s/VERSION.*//\"");
result = process.waitForFinished(1000);
dist += process.readAllStandardOutput().trimmed();
}
operatingSystemString = os + " " + dist + " " + rev + " (" + pseudoname + " " + kernel + " " + mach + ")";
operatingSystemString = os + " " + dist + " " + rev + " (" + pseudoname + " " + kernel + " " +
mach + ")";
}
#endif

4
src/UiGuiSystemInfo.h
Unescape Escape View File

@ -25,10 +25,10 @@ class TQString;
class UiGuiSystemInfo
{
public:
public:
static TQString getOperatingSystem();
private:
private:
UiGuiSystemInfo();
};

35
src/UiGuiVersion.cpp
Unescape Escape View File

@ -23,39 +23,48 @@
#include <tntqstringlist.h>
#include <tqdate.h>
namespace UiGuiVersion {
/*!
namespace UiGuiVersion
{
/*!
\brief Returns the build date as a localized string, e.g. "9. Februar 2009". If
there was some kind of error, the returned string is empty.
*/
TQString getBuildDate() {
TQString getBuildDate()
{
TQStringList monthNames;
TQString buildDateString = "";
monthNames << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dez";
TQStringList buildDateStringList = TQString(__DATE__).simplified().split(' '); // __DATE__ returns eg "Feb 4 2009"
monthNames << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun" << "Jul" << "Aug" << "Sep" <<
"Oct" << "Nov" << "Dez";
TQStringList buildDateStringList = TQString(__DATE__).simplified().split(' '); // __DATE__
// returns eg
// "Feb 4 2009"
if ( buildDateStringList.count() == 3 ) {
TQDate buildDate(buildDateStringList.last().toInt(), monthNames.indexOf( buildDateStringList.first() )+1, buildDateStringList.at(1).toInt());
if (buildDateStringList.count() == 3)
{
TQDate buildDate(buildDateStringList.last().toInt(),
monthNames.indexOf(buildDateStringList.first()) + 1,
buildDateStringList.at(1).toInt());
buildDateString = buildDate.toString("d. MMMM yyyy");
}
return buildDateString;
}
}
/*!
/*!
\brief Returns the revision number, that the current build is based on, as string. If
there was some kind of error, the returned string is empty.
*/
TQString getBuildRevision() {
TQString getBuildRevision()
{
TQString buildRevision = "";
TQStringList buildRevisionStringList = TQString(PROGRAM_REVISION).simplified().split(' ');
if ( buildRevisionStringList.count() == 3 ) {
if (buildRevisionStringList.count() == 3)
{
buildRevision = buildRevisionStringList.at(1); // PROGRAM_REVISION is eg "$Revision: 907 $"
}
return buildRevision;
}
}
} // namespace UiGuiVersion

9
src/UiGuiVersion.h
Unescape Escape View File

@ -23,17 +23,16 @@
class TQString;
// Define the version number here. Update this as the last file before a release.
#define PROGRAM_VERSION 1.2.0
#define PROGRAM_VERSION 1.2 .0
#define PROGRAM_VERSION_STRING "1.2.0"
#define RESOURCE_VERSION 1,2,0,0
#define RESOURCE_VERSION 1, 2, 0, 0
#define RESOURCE_VERSION_STRING "1,2,0,0\0"
#define PROGRAM_REVISION "$Revision: 1070 $"
namespace UiGuiVersion {
namespace UiGuiVersion
{
TQString getBuildDate();
TQString getBuildRevision();
}
#endif // UIGUIVERSION_H

164
src/UpdateCheckDialog.cpp
Unescape Escape View File

@ -44,9 +44,8 @@
/*!
\brief Initializes member variables and stores the version of UiGui and a pointer to the _settings object.
*/
UpdateCheckDialog::UpdateCheckDialog(TQSharedPointer<UiGuiSettings> settings, TQWidget *parent) : TQDialog(parent),
_manualUpdateRequested(false),
_currentNetworkReply(NULL),
UpdateCheckDialog::UpdateCheckDialog(TQSharedPointer<UiGuiSettings> settings, TQWidget *parent) :
TQDialog(parent), _manualUpdateRequested(false), _currentNetworkReply(NULL),
_roleOfClickedButton(TQDialogButtonBox::InvalidRole)
{
_updateCheckDialogForm = new Ui::UpdateCheckDialog();
@ -54,16 +53,18 @@ UpdateCheckDialog::UpdateCheckDialog(TQSharedPointer<UiGuiSettings> settings, TQ
// Create object for _networkAccessManager request and connect it with the request return handler.
_networkAccessManager = new TQNetworkAccessManager(this);
connect( _networkAccessManager, SIGNAL(finished(TQNetworkReply*)), this, SLOT(checkResultsOfFetchedPadXMLFile(TQNetworkReply*)) );
connect(_networkAccessManager, SIGNAL(finished(TQNetworkReply*)), this,
SLOT(checkResultsOfFetchedPadXMLFile(TQNetworkReply*)));
// Create a timer object used for the progress bar.
_updateCheckProgressTimer = new TQTimer(this);
_updateCheckProgressTimer->setInterval(5);
connect( _updateCheckProgressTimer, SIGNAL(timeout()), this, SLOT(updateUpdateCheckProgressBar()) );
connect(_updateCheckProgressTimer, SIGNAL(timeout()), this, SLOT(updateUpdateCheckProgressBar()));
_updateCheckProgressCounter = 0;
// Connect the dialogs buttonbox with a button click handler.
connect( _updateCheckDialogForm->buttonBox, SIGNAL(clicked(TQAbstractButton*)), this, SLOT(handleUpdateCheckDialogButtonClicked(TQAbstractButton*)) );
connect(_updateCheckDialogForm->buttonBox, SIGNAL(clicked(TQAbstractButton*)), this,
SLOT(handleUpdateCheckDialogButtonClicked(TQAbstractButton*)));
settings->registerObjectSlot(this, "initProxySettings()", "ProxyEnabled");
settings->registerObjectSlot(this, "initProxySettings()", "ProxyHostName");
@ -79,52 +80,55 @@ UpdateCheckDialog::UpdateCheckDialog(TQSharedPointer<UiGuiSettings> settings, TQ
setModal(true);
}
/*!
\brief On destroy cancels any currently running network request.
*/
UpdateCheckDialog::~UpdateCheckDialog() {
disconnect( _networkAccessManager, SIGNAL(finished(TQNetworkReply*)), this, SLOT(checkResultsOfFetchedPadXMLFile(TQNetworkReply*)) );
UpdateCheckDialog::~UpdateCheckDialog()
{
disconnect(_networkAccessManager, SIGNAL(finished(TQNetworkReply*)), this,
SLOT(checkResultsOfFetchedPadXMLFile(TQNetworkReply*)));
if (_currentNetworkReply != NULL)
{
_currentNetworkReply->abort();
}
}
/*!
\brief This slot should be called, if an update check is manually invoked.
In difference to the automatic update check, during manual update check request
a modal progress indicator dialog will be shown.
*/
void UpdateCheckDialog::checkForUpdateAndShowDialog() {
void UpdateCheckDialog::checkForUpdateAndShowDialog()
{
_manualUpdateRequested = true;
getPadXMLFile();
showCheckingForUpdateDialog();
}
/*!
\brief This slot should be called, if an update check is automatically invoked.
An automatic invoked update check should run in background, so the user
gets not interrupted by a dialog box.
*/
void UpdateCheckDialog::checkForUpdate() {
void UpdateCheckDialog::checkForUpdate()
{
_manualUpdateRequested = false;
getPadXMLFile();
}
/*!
\brief This function tries to download the UniversalIndentGui pad file from the SourceForge server.
*/
void UpdateCheckDialog::getPadXMLFile() {
void UpdateCheckDialog::getPadXMLFile()
{
//_networkAccessManager->setHost("universalindent.sourceforge.net");
//_networkAccessManager->get("/universalindentgui_pad.xml");
_currentNetworkReply = _networkAccessManager->get(TQNetworkRequest(TQUrl("http://universalindent.sourceforge.net/universalindentgui_pad.xml")));
_currentNetworkReply = _networkAccessManager->get(TQNetworkRequest(TQUrl(
"http://universalindent.sourceforge.net/universalindentgui_pad.xml")));
}
/*!
\brief This slot is called after the update check has returned, either by successfully
retrieving the pad file, or on any kind of network error.
@ -133,51 +137,67 @@ void UpdateCheckDialog::getPadXMLFile() {
download page if a newer version exists. In case of an error during update
check, a message box with the error will be displayed.
*/
void UpdateCheckDialog::checkResultsOfFetchedPadXMLFile(TQNetworkReply *networkReply) {
void UpdateCheckDialog::checkResultsOfFetchedPadXMLFile(TQNetworkReply *networkReply)
{
Q_ASSERT(_currentNetworkReply == networkReply);
// Stop the progress bar timer.
_updateCheckProgressTimer->stop();
if ( networkReply->error() == TQNetworkReply::NoError ) {
if (networkReply->error() == TQNetworkReply::NoError)
{
// Try to find the version string.
TQString returnedString = networkReply->readAll();
int leftPosition = returnedString.indexOf("<Program_Version>");
int rightPosition = returnedString.indexOf("</Program_Version>");
// If the version string could be found in the returned string, show an update dialog and set last update check date.
if ( leftPosition != -1 && rightPosition != -1 ) {
// If the version string could be found in the returned string, show an update dialog and set
// last update check date.
if (leftPosition != -1 && rightPosition != -1)
{
// Get the pure version string from returned string.
returnedString = returnedString.mid( leftPosition+17, rightPosition-(leftPosition+17) );
returnedString = returnedString.mid(leftPosition + 17, rightPosition - (leftPosition + 17));
// Create integer values from the version strings.
int versionOnServerInt = convertVersionStringToNumber( returnedString );
int currentVersionInt = convertVersionStringToNumber( PROGRAM_VERSION_STRING );
// Only show update dialog, if the current version number is lower than the one received from the server.
if ( versionOnServerInt > currentVersionInt && currentVersionInt >= 0 && versionOnServerInt >= 0 ) {
int versionOnServerInt = convertVersionStringToNumber(returnedString);
int currentVersionInt = convertVersionStringToNumber(PROGRAM_VERSION_STRING);
// Only show update dialog, if the current version number is lower than the one received from
// the server.
if (versionOnServerInt > currentVersionInt && currentVersionInt >= 0 &&
versionOnServerInt >= 0)
{
// Show message box whether to download the new version.
showNewVersionAvailableDialog(returnedString);
// If yes clicked, open the download url in the default browser.
if ( _roleOfClickedButton == TQDialogButtonBox::YesRole ) {
TQDesktopServices::openUrl( TQUrl("_networkAccessManager://sourceforge.net/project/showfiles.php?group_id=167482") );
if (_roleOfClickedButton == TQDialogButtonBox::YesRole)
{
TQDesktopServices::openUrl(TQUrl(
"_networkAccessManager://sourceforge.net/project/showfiles.php?group_id=167482"));
}
}
else if ( _manualUpdateRequested ) {
else if (_manualUpdateRequested)
{
showNoNewVersionAvailableDialog();
}
// Set last update check date.
_settings->setValueByName("LastUpdateCheck", TQDate::currentDate());
}
// In the returned string, the version string could not be found.
else {
TQMessageBox::warning(this, tr("Update check error"), tr("There was an error while trying to check for an update! The retrieved file did not contain expected content.") );
else
{
TQMessageBox::warning(this, tr("Update check error"), tr(
"There was an error while trying to check for an update! The retrieved file did not contain expected content."));
}
}
// If there was some error while trying to retrieve the update info from server and not cancel was pressed.
else if ( _roleOfClickedButton != TQDialogButtonBox::RejectRole ) {
TQMessageBox::warning(this, tr("Update check error"), tr("There was an error while trying to check for an update! Error was : %1").arg(networkReply->errorString()) );
// If there was some error while trying to retrieve the update info from server and not cancel was
// pressed.
else if (_roleOfClickedButton != TQDialogButtonBox::RejectRole)
{
TQMessageBox::warning(this, tr("Update check error"),
tr("There was an error while trying to check for an update! Error was : %1").arg(
networkReply->errorString()));
hide();
}
_manualUpdateRequested = false;
@ -185,7 +205,6 @@ void UpdateCheckDialog::checkResultsOfFetchedPadXMLFile(TQNetworkReply *networkR
_currentNetworkReply = NULL;
}
/*!
\brief Displays the progress bar during update check.
@ -193,45 +212,49 @@ void UpdateCheckDialog::checkResultsOfFetchedPadXMLFile(TQNetworkReply *networkR
updated the progress bar. The user can press a cancel button to
stop the update check.
*/
void UpdateCheckDialog::showCheckingForUpdateDialog() {
void UpdateCheckDialog::showCheckingForUpdateDialog()
{
// Reset the progress bar.
_updateCheckProgressCounter = 0;
_updateCheckDialogForm->progressBar->setValue(_updateCheckProgressCounter);
_updateCheckDialogForm->progressBar->setInvertedAppearance( false );
_updateCheckDialogForm->progressBar->setInvertedAppearance(false);
_updateCheckProgressTimer->start();
_updateCheckDialogForm->progressBar->show();
setWindowTitle( tr("Checking for update...") );
_updateCheckDialogForm->label->setText( tr("Checking whether a newer version is available") );
setWindowTitle(tr("Checking for update..."));
_updateCheckDialogForm->label->setText(tr("Checking whether a newer version is available"));
_updateCheckDialogForm->buttonBox->setStandardButtons(TQDialogButtonBox::Cancel);
show();
}
/*!
\brief Displays the dialog with info about the new available version.
*/
void UpdateCheckDialog::showNewVersionAvailableDialog(TQString newVersion) {
void UpdateCheckDialog::showNewVersionAvailableDialog(TQString newVersion)
{
_updateCheckDialogForm->progressBar->hide();
setWindowTitle( tr("Update available") );
_updateCheckDialogForm->label->setText( tr("A newer version of UniversalIndentGUI is available.\nYour version is %1. New version is %2.\nDo you want to go to the download website?").arg(PROGRAM_VERSION_STRING).arg(newVersion) );
_updateCheckDialogForm->buttonBox->setStandardButtons(TQDialogButtonBox::No|TQDialogButtonBox::NoButton|TQDialogButtonBox::Yes);
setWindowTitle(tr("Update available"));
_updateCheckDialogForm->label->setText(tr(
"A newer version of UniversalIndentGUI is available.\nYour version is %1. New version is %2.\nDo you want to go to the download website?").arg(
PROGRAM_VERSION_STRING).arg(newVersion));
_updateCheckDialogForm->buttonBox->setStandardButtons(
TQDialogButtonBox::No | TQDialogButtonBox::NoButton | TQDialogButtonBox::Yes);
exec();
}
/*!
\brief Displays the dialog, that no new version is available.
*/
void UpdateCheckDialog::showNoNewVersionAvailableDialog() {
void UpdateCheckDialog::showNoNewVersionAvailableDialog()
{
_updateCheckDialogForm->progressBar->hide();
setWindowTitle( tr("No new update available") );
_updateCheckDialogForm->label->setText( tr("You already have the latest version of UniversalIndentGUI.") );
setWindowTitle(tr("No new update available"));
_updateCheckDialogForm->label->setText(tr(
"You already have the latest version of UniversalIndentGUI."));
_updateCheckDialogForm->buttonBox->setStandardButtons(TQDialogButtonBox::Ok);
exec();
}
/*!
\brief This slot is called, when a button in the dialog is clicked.
@ -241,10 +264,12 @@ void UpdateCheckDialog::showNoNewVersionAvailableDialog() {
In any case if a button is clicked, the dialog box will be closed.
*/
void UpdateCheckDialog::handleUpdateCheckDialogButtonClicked(TQAbstractButton *clickedButton) {
void UpdateCheckDialog::handleUpdateCheckDialogButtonClicked(TQAbstractButton *clickedButton)
{
_roleOfClickedButton = _updateCheckDialogForm->buttonBox->buttonRole(clickedButton);
if ( _roleOfClickedButton == TQDialogButtonBox::RejectRole ) {
if (_roleOfClickedButton == TQDialogButtonBox::RejectRole)
{
// Abort the _networkAccessManager request.
_currentNetworkReply->abort();
// Stop the progress bar timer.
@ -254,29 +279,32 @@ void UpdateCheckDialog::handleUpdateCheckDialogButtonClicked(TQAbstractButton *c
accept();
}
/*!
\brief This slot is responsible for the animation of the update check progress bar.
*/
void UpdateCheckDialog::updateUpdateCheckProgressBar() {
void UpdateCheckDialog::updateUpdateCheckProgressBar()
{
// Depending on the progress bar direction, decrease or increase the progressbar value.
if ( _updateCheckDialogForm->progressBar->invertedAppearance() ) {
if (_updateCheckDialogForm->progressBar->invertedAppearance())
{
_updateCheckProgressCounter--;
}
else {
else
{
_updateCheckProgressCounter++;
}
// If the progress bar reaches 0 or 100 as value, swap the animation direction.
if ( _updateCheckProgressCounter == 0 || _updateCheckProgressCounter == 100 ) {
_updateCheckDialogForm->progressBar->setInvertedAppearance( !_updateCheckDialogForm->progressBar->invertedAppearance() );
if (_updateCheckProgressCounter == 0 || _updateCheckProgressCounter == 100)
{
_updateCheckDialogForm->progressBar->setInvertedAppearance(
!_updateCheckDialogForm->progressBar->invertedAppearance());
}
// Update the progress bar value.
_updateCheckDialogForm->progressBar->setValue(_updateCheckProgressCounter);
}
/*!
\brief Converts the as string given version \a versionString to an integer number.
@ -287,20 +315,23 @@ void UpdateCheckDialog::updateUpdateCheckProgressBar() {
Thus for example 12.5.170 will result in 12005170.
*/
int UpdateCheckDialog::convertVersionStringToNumber(TQString versionString) {
int UpdateCheckDialog::convertVersionStringToNumber(TQString versionString)
{
int versionInteger = 0;
int pos = 0;
TQRegExp regEx("\\d{1,3}.\\d{1,3}.\\d{1,3}");
TQRegExpValidator validator(regEx, NULL);
if ( validator.validate(versionString, pos) == TQValidator::Acceptable ) {
if (validator.validate(versionString, pos) == TQValidator::Acceptable)
{
TQStringList versionNumberStringList = versionString.split(".");
versionInteger = versionNumberStringList.at(0).toInt() * 1000000;
versionInteger += versionNumberStringList.at(1).toInt() * 1000;
versionInteger += versionNumberStringList.at(2).toInt();
}
else {
else
{
versionInteger = -1;
}
@ -309,14 +340,17 @@ int UpdateCheckDialog::convertVersionStringToNumber(TQString versionString) {
void UpdateCheckDialog::initProxySettings()
{
if ( _settings->getValueByName("ProxyEnabled") == true ) {
if (_settings->getValueByName("ProxyEnabled") == true)
{
TQString proxyHostName = _settings->getValueByName("ProxyHostName").toString();
int proxyPort = _settings->getValueByName("ProxyPort").toInt();
TQString proxyUserName = _settings->getValueByName("ProxyUserName").toString();
TQString proxyPassword = _settings->getValueByName("ProxyPassword").toString();
_networkAccessManager->setProxy(TQNetworkProxy(TQNetworkProxy::Socks5Proxy, proxyHostName, proxyPort, proxyUserName, proxyPassword));
_networkAccessManager->setProxy(TQNetworkProxy(TQNetworkProxy::Socks5Proxy, proxyHostName,
proxyPort, proxyUserName, proxyPassword));
}
else {
else
{
_networkAccessManager->setProxy(TQNetworkProxy());
}
}

11
src/UpdateCheckDialog.h
Unescape Escape View File

@ -24,7 +24,8 @@
#include <tqdialogbuttonbox.h>
class UiGuiSettings;
namespace Ui {
namespace Ui
{
class UpdateCheckDialog;
}
@ -38,21 +39,21 @@ class UpdateCheckDialog : public TQDialog
{
Q_OBJECT
public:
public:
UpdateCheckDialog(TQSharedPointer<UiGuiSettings> settings, TQWidget *parent = NULL);
~UpdateCheckDialog();
public slots:
public slots:
void checkForUpdateAndShowDialog();
void checkForUpdate();
private slots:
private slots:
void checkResultsOfFetchedPadXMLFile(TQNetworkReply *networkReply);
void handleUpdateCheckDialogButtonClicked(TQAbstractButton *clickedButton);
void updateUpdateCheckProgressBar();
void initProxySettings();
private:
private:
Ui::UpdateCheckDialog *_updateCheckDialogForm;
void getPadXMLFile();

152
src/debugging/TSLogger.cpp
Unescape Escape View File

@ -35,7 +35,7 @@
using namespace tschweitzer;
using namespace tschweitzer::debugging;
TSLogger* TSLogger::_instance = NULL;
TSLogger*TSLogger::_instance = NULL;
/*!
\class TSLogger
@ -52,18 +52,21 @@ TSLogger* TSLogger::_instance = NULL;
/*!
\brief Returns the only existing instance of TSLogger. If the instance doesn't exist, it will be created.
*/
TSLogger* TSLogger::getInstance(int verboseLevel) {
if ( _instance == NULL )
TSLogger* TSLogger::getInstance(int verboseLevel)
{
if (_instance == NULL)
{
_instance = new TSLogger(verboseLevel);
}
return _instance;
}
/*!
\brief Returns the only existing instance of TSLogger. If the instance doesn't exist, it will be created.
*/
TSLogger* TSLogger::getInstance() {
TSLogger* TSLogger::getInstance()
{
#ifdef _DEBUG
return TSLogger::getInstance(TQtDebugMsg);
#else
@ -71,12 +74,13 @@ TSLogger* TSLogger::getInstance() {
#endif
}
/*!
\brief Initializes the dialog and sets the path to the log file in the systems temporary directory.
Sets the default verbose level to warning level.
*/
TSLogger::TSLogger(int verboseLevel) : TQDialog() {
TSLogger::TSLogger(int verboseLevel) :
TQDialog()
{
_TSLoggerDialogForm = new Ui::TSLoggerDialog();
_TSLoggerDialogForm->setupUi(this);
#ifdef _DEBUG
@ -87,117 +91,149 @@ TSLogger::TSLogger(int verboseLevel) : TQDialog() {
_logFileInitState = NOTINITIALZED;
connect( _TSLoggerDialogForm->openLogFileFolderToolButton, SIGNAL(clicked()), this, SLOT(openLogFileFolder()) );
connect(_TSLoggerDialogForm->openLogFileFolderToolButton, SIGNAL(clicked()), this,
SLOT(openLogFileFolder()));
// Make the main application not to wait for the logging window to close.
setAttribute(TQt::WA_QuitOnClose, false);
}
/*!
\brief Logs all incoming messages \a msg to the dialogs text edit and to the log file.
Only messages whos \a type have a higher priority than the set verbose level are logged.
*/
void TSLogger::messageHandler(TQtMsgType type, const char *msg) {
if ( _instance == NULL )
void TSLogger::messageHandler(TQtMsgType type, const char *msg)
{
if (_instance == NULL)
{
_instance = TSLogger::getInstance();
}
/*
/*
TQMessageBox messageBox;
TQString messageBoxText = TQString::fromUtf8( msg );
messageBox.setText( messageBoxText );
messageBox.setWindowModality( TQt::ApplicationModal );
messageBox.exec();
*/
*/
// Only log messages that have a higher or equal priority than set with the verbose level.
if ( type < _instance->_verboseLevel )
if (type < _instance->_verboseLevel)
{
return;
}
// Init log message with prepended date and time.
TQString message = TQDateTime::currentDateTime().toString();
// Depending on the TQtMsgType prepend a different colored Debug, Warning, Critical or Fatal.
switch (type) {
case TQtDebugMsg :
switch (type)
{
case TQtDebugMsg:
{
message += " <span style=\"font-weight:bold; color:black;\">Debug:</span> ";
break;
case TQtWarningMsg :
}
case TQtWarningMsg:
{
message += " <span style=\"font-weight:bold; color:gold;\">Warning:</span> ";
break;
case TQtCriticalMsg :
}
case TQtCriticalMsg:
{
message += "<span style=\"font-weight:bold; color:red;\">Critical:</span> ";
break;
case TQtFatalMsg :
}
case TQtFatalMsg:
{
message += " <span style=\"font-weight:bold; color:#D60000;\">Fatal:</span> ";
}
// This one is no TQt message type, but can be used to send info messages to the log
// by calling TSLogger::messageHandler() directly.
case TSLoggerInfoMsg :
case TSLoggerInfoMsg:
{
message += " <span style=\"font-weight:bold; color:darkgray;\">Info:</span> ";
break;
}
}
// Append the to UTF-8 back converted message parameter.
message += TQString::fromUtf8( msg ) + "<br/>\n";
message += TQString::fromUtf8(msg) + "<br/>\n";
// Write the message to the log windows text edit.
_instance->_TSLoggerDialogForm->logTextEdit->append( message );
_instance->_TSLoggerDialogForm->logTextEdit->append(message);
// Write/append the log message to the log file.
_instance->writeToLogFile( message );
_instance->writeToLogFile(message);
// In case of a fatal error abort the application.
if ( type == TQtFatalMsg )
if (type == TQtFatalMsg)
{
abort();
}
}
/*!
\brief Calling this the verbose level can be set in a range from 0 to 3
which is equal to debug, warning, critical and fatal priority.
*/
void TSLogger::setVerboseLevel(int level) {
if ( level < 0 )
void TSLogger::setVerboseLevel(int level)
{
if (level < 0)
{
_verboseLevel = TQtDebugMsg;
if ( level > 3 )
}
if (level > 3)
{
_verboseLevel = TQtFatalMsg;
}
else
{
_verboseLevel = TQtMsgType(level);
}
}
/*!
\brief Deletes the existing _instance of TSLogger.
*/
void TSLogger::deleteInstance() {
if ( _instance != NULL ) {
void TSLogger::deleteInstance()
{
if (_instance != NULL)
{
delete _instance;
_instance = NULL;
}
}
/*!
\brief Opens the folder that contains the created log file with the name "UiGUI_log.html".
*/
void TSLogger::openLogFileFolder() {
TQDesktopServices::openUrl( TQFileInfo( _logFile ).absolutePath() );
void TSLogger::openLogFileFolder()
{
TQDesktopServices::openUrl(TQFileInfo(_logFile).absolutePath());
}
/*!
\brief Writes the \a message to the used log file.
*/
void TSLogger::writeToLogFile(const TQString &message) {
void TSLogger::writeToLogFile(const TQString &message)
{
// If the file where all logging messages should go to isn't initilized yet, do that now.
if ( _logFileInitState == NOTINITIALZED ) {
if (_logFileInitState == NOTINITIALZED)
{
_logFileInitState = INITIALIZING;
// On different systems it may be that "TQDir::tempPath()" ends with a "/" or not. So check this.
// On different systems it may be that "TQDir::tempPath()" ends with a "/" or not. So check
// this.
// Remove any trailing slashes.
TQString tempPath = TQFileInfo( SettingsPaths::getTempPath() ).absolutePath();
while ( tempPath.right(1) == "/" ) {
TQString tempPath = TQFileInfo(SettingsPaths::getTempPath()).absolutePath();
while (tempPath.right(1) == "/")
{
tempPath.chop(1);
}
@ -206,28 +242,38 @@ void TSLogger::writeToLogFile(const TQString &message) {
TQString logFileName = "UiGUI_log_" + TQDateTime::currentDateTime().toString("yyyyMMdd");
logFileName += "-" + TQDateTime::currentDateTime().toString("hhmmsszzz");
// By random decide whether to append a number or an upper or lower case character.
qsrand( time(NULL) );
qsrand(time(NULL));
unsigned char randomChar;
switch ( qrand() % 3 ) {
switch (qrand() % 3)
{
// Append a number from 0 to 9.
case 0 :
case 0:
{
randomChar = qrand() % 10 + '0';
break;
}
// Append a upper case characer between A and Z.
case 1 :
case 1:
{
randomChar = qrand() % 26 + 'A';
break;
}
// Append a lower case characer between a and z.
default :
default:
{
randomChar = qrand() % 26 + 'a';
break;
}
}
logFileName += "_" + TQString(randomChar) + ".html";
_logFile.setFileName( tempPath + "/" + logFileName );
_logFile.setFileName(tempPath + "/" + logFileName);
// Set the tooltip of the open log file folder button to show the unique name of the log file.
_TSLoggerDialogForm->openLogFileFolderToolButton->setToolTip( _TSLoggerDialogForm->openLogFileFolderToolButton->toolTip() + " (" + logFileName + ")" );
_TSLoggerDialogForm->openLogFileFolderToolButton->setToolTip(
_TSLoggerDialogForm->openLogFileFolderToolButton->toolTip() + " (" + logFileName + ")");
_logFileInitState = INITIALZED;
}
@ -235,13 +281,17 @@ void TSLogger::writeToLogFile(const TQString &message) {
// Add the message to the message queue.
_messageQueue << message;
// If the logging file is initialzed, write all messages contained in the message queue into the file.
if ( _logFileInitState == INITIALZED ) {
// If the logging file is initialzed, write all messages contained in the message queue into the
// file.
if (_logFileInitState == INITIALZED)
{
// Write/append the log message to the log file.
if ( _logFile.open(TQIODevice::WriteOnly | TQIODevice::Text | TQIODevice::Append) ) {
if (_logFile.open(TQIODevice::WriteOnly | TQIODevice::Text | TQIODevice::Append))
{
TQTextStream out(&_logFile);
while ( !_messageQueue.isEmpty() ) {
while (!_messageQueue.isEmpty())
{
out << _messageQueue.takeFirst() << "\n";
}

35
src/debugging/TSLogger.h
Unescape Escape View File

@ -23,41 +23,50 @@
#include <tntqdialog.h>
#include <tntqfile.h>
namespace Ui {
namespace Ui
{
class TSLoggerDialog;
}
namespace tschweitzer { namespace debugging {
namespace tschweitzer
{
namespace debugging
{
#define TSLoggerInfoMsg TQtMsgType(4)
class TSLogger : public TQDialog
{
class TSLogger : public TQDialog
{
Q_OBJECT
public:
public:
static TSLogger* getInstance(int verboseLevel);
static TSLogger* getInstance();
static void messageHandler(TQtMsgType type, const char *msg);
static void deleteInstance();
void setVerboseLevel(int level);
private slots:
private slots:
void openLogFileFolder();
private:
private:
Ui::TSLoggerDialog *_TSLoggerDialogForm;
enum LogFileInitState { NOTINITIALZED, INITIALIZING, INITIALZED } _logFileInitState;
enum LogFileInitState
{
NOTINITIALZED,
INITIALIZING,
INITIALZED
} _logFileInitState;
TSLogger(int verboseLevel);
void writeToLogFile(const TQString &message);
static TSLogger* _instance;
static TSLogger *_instance;
TQtMsgType _verboseLevel;
TQFile _logFile;
TQStringList _messageQueue;
};
}} // namespace tschweitzer::debugging
};
}
} // namespace tschweitzer::debugging
#endif // TSLogger_H

237
src/main.cpp
Unescape Escape View File

@ -54,118 +54,127 @@
int main(int argc, char *argv[])
{
return 0;
// -- TQString file2OpenOnStart = "";
// -- int verboseLevel = 1;
// -- bool startAsPlugin = false;
// -- bool startAsServer = false;
// -- bool tclapExitExceptionThrown = false;
// -- int returnValue = 0;
// --
// -- // Wrap everything in a try block. Do this every time,
// -- // because exceptions will be thrown for problems.
// -- try {
// -- // Define the command line object.
// -- TCLAP::CmdLine cmd("If -p and -s are set, -p will be used.\nGiving no parameters starts full gui without server.", ' ', "UiGUI version " PROGRAM_VERSION_STRING " " PROGRAM_REVISION);
// -- cmd.setExceptionHandling(false);
// --
// -- // Define a value argument and add it to the command line.
// -- TCLAP::UnlabeledValueArg<std::string> filenameArg("file", "Opens the by filename defined file on start" , false, "", "filename");
// -- cmd.add( filenameArg );
// --
// -- // Define a switch and add it to the command line.
// -- TCLAP::SwitchArg pluginSwitch("p", "plugin", "Run as plugin. Server will be started with a simplified gui", false);
// -- cmd.add( pluginSwitch );
// --
// -- // Define a switch and add it to the command line.
// -- TCLAP::SwitchArg serverSwitch("s", "server", "Run as server only without gui", false);
// -- cmd.add( serverSwitch );
// --
// -- // Define a value argument and add it to the command line.
// -- TCLAP::ValueArg<int> verboselevelArg("v", "verbose", "Sets how many info is written to the log. 0 means with debug info, 3 means critical messages only" , false, 1, "int");
// -- cmd.add( verboselevelArg );
// --
// -- // Parse the args.
// -- cmd.parse( argc, argv );
// --
// -- // Get the value parsed by each arg.
// -- file2OpenOnStart = filenameArg.getValue().c_str();
// -- startAsPlugin = pluginSwitch.getValue();
// -- startAsServer = serverSwitch.getValue();
// -- verboseLevel = verboselevelArg.getValue();
// -- }
// -- catch (TCLAP::ArgException &e) { // catch arg exceptions
// -- std::cerr << std::endl << "error: " << e.error() << ". " << e.argId() << std::endl;
// -- returnValue = 1;
// -- }
// -- catch (TCLAP::ExitException &e) { // catch exit exceptions
// -- tclapExitExceptionThrown = true;
// -- returnValue = e.getExitStatus();
// -- }
// -- catch (...) { // catch any exceptions
// -- std::cerr << std::endl << "There was an error! Maybe faulty command line arguments set. See --help." << std::endl;
// -- returnValue = 1;
// -- }
// --
// -- if ( returnValue != 0 || tclapExitExceptionThrown ) {
// -- return returnValue;
// -- }
// --
// -- TQApplication app(argc, argv);
// -- UiGuiIndentServer server;
// -- MainWindow *mainWindow = NULL;
// -- IndentHandler *indentHandler = NULL;
// --
// -- // Init and install the logger function.
// -- // Setting UTF-8 as default 8-Bit encoding to ensure that tqDebug does no false string conversion.
// -- TQTextCodec::setCodecForCStrings( TQTextCodec::codecForName("UTF-8") );
// -- TQTextCodec::setCodecForLocale( TQTextCodec::codecForName("UTF-8") );
// -- // Force creation of an TSLogger instance here, to avoid recursion with SettingsPaths init function.
// -- #ifdef _DEBUG
// -- TSLogger::getInstance(0);
// -- #else
// -- TSLogger::getInstance(verboseLevel);
// -- #endif
// -- qInstallMsgHandler( TSLogger::messageHandler );
// -- TSLogger::messageHandler( TSLoggerInfoMsg, TQString("Starting UiGUI Version %1 %2").arg(PROGRAM_VERSION_STRING).arg(PROGRAM_REVISION).toAscii() );
// -- TSLogger::messageHandler( TSLoggerInfoMsg, TQString("Running on %1").arg(UiGuiSystemInfo::getOperatingSystem()).toAscii() );
// --
// -- // Set default values for all by UniversalIndentGUI used settings objects.
// -- TQCoreApplication::setOrganizationName("UniversalIndentGUI");
// -- TQCoreApplication::setOrganizationDomain("universalindent.sf.net");
// -- TQCoreApplication::setApplicationName("UniversalIndentGUI");
// --
// -- // Start normal with full gui and without server.
// -- if ( !startAsPlugin && !startAsServer ) {
// -- mainWindow = new MainWindow(file2OpenOnStart);
// -- mainWindow->show();
// -- }
// -- // Start as plugin with server.
// -- else if ( startAsPlugin ) {
// -- server.startServer();
// -- indentHandler = new IndentHandler(0);
// -- indentHandler->show();
// -- }
// -- // Start as server only without any gui.
// -- else if ( startAsServer ) {
// -- server.startServer();
// -- }
// --
// -- try {
// -- returnValue = app.exec();
// -- }
// -- catch (std::exception &ex) {
// -- qCritical() << __LINE__ << " " << __FUNCTION__ << ": Something went terribly wrong:" << ex.what();
// -- }
// --
// -- if ( startAsPlugin || startAsServer )
// -- server.stopServer();
// --
// -- delete indentHandler;
// -- delete mainWindow;
// --
// -- SettingsPaths::cleanAndRemoveTempDir();
// -- TSLogger::deleteInstance();
// --
// -- return returnValue;
// -- TQString file2OpenOnStart = "";
// -- int verboseLevel = 1;
// -- bool startAsPlugin = false;
// -- bool startAsServer = false;
// -- bool tclapExitExceptionThrown = false;
// -- int returnValue = 0;
// --
// -- // Wrap everything in a try block. Do this every time,
// -- // because exceptions will be thrown for problems.
// -- try {
// -- // Define the command line object.
// -- TCLAP::CmdLine cmd("If -p and -s are set, -p will be used.\nGiving no parameters starts
// full gui without server.", ' ', "UiGUI version " PROGRAM_VERSION_STRING " " PROGRAM_REVISION);
// -- cmd.setExceptionHandling(false);
// --
// -- // Define a value argument and add it to the command line.
// -- TCLAP::UnlabeledValueArg<std::string> filenameArg("file", "Opens the by
// filename defined file on start" , false, "", "filename");
// -- cmd.add( filenameArg );
// --
// -- // Define a switch and add it to the command line.
// -- TCLAP::SwitchArg pluginSwitch("p", "plugin", "Run as plugin. Server will be started with
// a simplified gui", false);
// -- cmd.add( pluginSwitch );
// --
// -- // Define a switch and add it to the command line.
// -- TCLAP::SwitchArg serverSwitch("s", "server", "Run as server only without gui", false);
// -- cmd.add( serverSwitch );
// --
// -- // Define a value argument and add it to the command line.
// -- TCLAP::ValueArg<int> verboselevelArg("v", "verbose", "Sets how many info is written to
// the log. 0 means with debug info, 3 means critical messages only" , false, 1, "int");
// -- cmd.add( verboselevelArg );
// --
// -- // Parse the args.
// -- cmd.parse( argc, argv );
// --
// -- // Get the value parsed by each arg.
// -- file2OpenOnStart = filenameArg.getValue().c_str();
// -- startAsPlugin = pluginSwitch.getValue();
// -- startAsServer = serverSwitch.getValue();
// -- verboseLevel = verboselevelArg.getValue();
// -- }
// -- catch (TCLAP::ArgException &e) { // catch arg exceptions
// -- std::cerr << std::endl << "error: " << e.error() << ". " << e.argId() << std::endl;
// -- returnValue = 1;
// -- }
// -- catch (TCLAP::ExitException &e) { // catch exit exceptions
// -- tclapExitExceptionThrown = true;
// -- returnValue = e.getExitStatus();
// -- }
// -- catch (...) { // catch any exceptions
// -- std::cerr << std::endl << "There was an error! Maybe faulty command line arguments set.
// See --help." << std::endl;
// -- returnValue = 1;
// -- }
// --
// -- if ( returnValue != 0 || tclapExitExceptionThrown ) {
// -- return returnValue;
// -- }
// --
// -- TQApplication app(argc, argv);
// -- UiGuiIndentServer server;
// -- MainWindow *mainWindow = NULL;
// -- IndentHandler *indentHandler = NULL;
// --
// -- // Init and install the logger function.
// -- // Setting UTF-8 as default 8-Bit encoding to ensure that tqDebug does no false string
// conversion.
// -- TQTextCodec::setCodecForCStrings( TQTextCodec::codecForName("UTF-8") );
// -- TQTextCodec::setCodecForLocale( TQTextCodec::codecForName("UTF-8") );
// -- // Force creation of an TSLogger instance here, to avoid recursion with SettingsPaths
// init function.
// -- #ifdef _DEBUG
// -- TSLogger::getInstance(0);
// -- #else
// -- TSLogger::getInstance(verboseLevel);
// -- #endif
// -- qInstallMsgHandler( TSLogger::messageHandler );
// -- TSLogger::messageHandler( TSLoggerInfoMsg, TQString("Starting UiGUI Version %1
// %2").arg(PROGRAM_VERSION_STRING).arg(PROGRAM_REVISION).toAscii() );
// -- TSLogger::messageHandler( TSLoggerInfoMsg, TQString("Running on
// %1").arg(UiGuiSystemInfo::getOperatingSystem()).toAscii() );
// --
// -- // Set default values for all by UniversalIndentGUI used settings objects.
// -- TQCoreApplication::setOrganizationName("UniversalIndentGUI");
// -- TQCoreApplication::setOrganizationDomain("universalindent.sf.net");
// -- TQCoreApplication::setApplicationName("UniversalIndentGUI");
// --
// -- // Start normal with full gui and without server.
// -- if ( !startAsPlugin && !startAsServer ) {
// -- mainWindow = new MainWindow(file2OpenOnStart);
// -- mainWindow->show();
// -- }
// -- // Start as plugin with server.
// -- else if ( startAsPlugin ) {
// -- server.startServer();
// -- indentHandler = new IndentHandler(0);
// -- indentHandler->show();
// -- }
// -- // Start as server only without any gui.
// -- else if ( startAsServer ) {
// -- server.startServer();
// -- }
// --
// -- try {
// -- returnValue = app.exec();
// -- }
// -- catch (std::exception &ex) {
// -- qCritical() << __LINE__ << " " << __FUNCTION__ << ": Something went terribly wrong:"
// << ex.what();
// -- }
// --
// -- if ( startAsPlugin || startAsServer )
// -- server.stopServer();
// --
// -- delete indentHandler;
// -- delete mainWindow;
// --
// -- SettingsPaths::cleanAndRemoveTempDir();
// -- TSLogger::deleteInstance();
// --
// -- return returnValue;
}

477
src/tclap/Arg.h
Unescape Escape View File

@ -26,9 +26,9 @@
#define TCLAP_ARGUMENT_H
#ifdef HAVE_CONFIG_H
#include <config.h>
#include <config.h>
#else
#define HAVE_SSTREAM
#define HAVE_SSTREAM
#endif
#include <string>
@ -38,14 +38,14 @@
#include <iomanip>
#include <cstdio>
#if defined(HAVE_SSTREAM)
#include <sstream>
#if defined (HAVE_SSTREAM)
#include <sstream>
typedef std::istringstream istringstream;
#elif defined(HAVE_STRSTREAM)
#include <strstream>
#elif defined (HAVE_STRSTREAM)
#include <strstream>
typedef std::istrstream istringstream;
#else
#error "Need a stringstream (sstream or strstream) to compile!"
#error "Need a stringstream (sstream or strstream) to compile!"
#endif
#include <tclap/ArgException.h>
@ -54,30 +54,37 @@ typedef std::istrstream istringstream;
#include <tclap/ArgTraits.h>
#include <tclap/StandardTraits.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A virtual base class that defines the essential data for all arguments.
* This class, or one of its existing children, must be subclassed to do
* anything.
*/
class Arg
{
class Arg
{
private:
/**
* Indicates whether the rest of the arguments should be ignored.
*/
static bool& ignoreRestRef() { static bool ign = false; return ign; }
static bool& ignoreRestRef()
{
static bool ign = false;
return ign;
}
/**
* The delimiter that separates an argument flag/name from the
* value.
*/
static char& delimiterRef() { static char delim = ' '; return delim; }
static char& delimiterRef()
{
static char delim = ' ';
return delim;
}
protected:
/**
* The single char flag used to identify the argument.
* This value (preceded by a dash {-}), can be used to identify
@ -133,7 +140,7 @@ class Arg
* argument is matched. This defaults to NULL and should not
* be used unless absolutely necessary.
*/
Visitor* _visitor;
Visitor *_visitor;
/**
* Whether this argument can be ignored, if desired.
@ -166,12 +173,8 @@ class Arg
* \param valreq - Whether the a value is required for the argument.
* \param v - The visitor checked by the argument. Defaults to NULL.
*/
Arg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
bool valreq,
Visitor* v = NULL );
Arg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
bool valreq, Visitor *v = NULL);
public:
/**
@ -183,57 +186,84 @@ class Arg
* Adds this to the specified list of Args.
* \param argList - The list to add this to.
*/
virtual void addToList( std::list<Arg*>& argList ) const;
virtual void addToList(std::list<Arg*> &argList) const;
/**
* Begin ignoring arguments since the "--" argument was specified.
*/
static void beginIgnoring() { ignoreRestRef() = true; }
static void beginIgnoring()
{
ignoreRestRef() = true;
}
/**
* Whether to ignore the rest.
*/
static bool ignoreRest() { return ignoreRestRef(); }
static bool ignoreRest()
{
return ignoreRestRef();
}
/**
* The delimiter that separates an argument flag/name from the
* value.
*/
static char delimiter() { return delimiterRef(); }
static char delimiter()
{
return delimiterRef();
}
/**
* The char used as a place holder when SwitchArgs are combined.
* Currently set to the bell char (ASCII 7).
*/
static char blankChar() { return (char)7; }
static char blankChar()
{
return (char)7;
}
/**
* The char that indicates the beginning of a flag. Currently '-'.
*/
static char flagStartChar() { return '-'; }
static char flagStartChar()
{
return '-';
}
/**
* The sting that indicates the beginning of a flag. Currently "-".
* Should be identical to flagStartChar.
*/
static const std::string flagStartString() { return "-"; }
static const std::string flagStartString()
{
return "-";
}
/**
* The sting that indicates the beginning of a name. Currently "--".
* Should be flagStartChar twice.
*/
static const std::string nameStartString() { return "--"; }
static const std::string nameStartString()
{
return "--";
}
/**
* The name used to identify the ignore rest argument.
*/
static const std::string ignoreNameString() { return "ignore_rest"; }
static const std::string ignoreNameString()
{
return "ignore_rest";
}
/**
* Sets the delimiter for all arguments.
* \param c - The character that delimits flags/names from values.
*/
static void setDelimiter( char c ) { delimiterRef() = c; }
static void setDelimiter(char c)
{
delimiterRef() = c;
}
/**
* Pure virtual method meant to handle the parsing and value assignment
@ -242,14 +272,14 @@ class Arg
* \param args - Mutable list of strings. What is
* passed in from main.
*/
virtual bool processArg(int *i, std::vector<std::string>& args) = 0;
virtual bool processArg(int *i, std::vector<std::string> &args) = 0;
/**
* Operator ==.
* Equality operator. Must be virtual to handle unlabeled args.
* \param a - The Arg to be compared to this.
*/
virtual bool operator==(const Arg& a) const;
virtual bool operator==(const Arg &a) const;
/**
* Returns the argument flag.
@ -307,7 +337,7 @@ class Arg
* \param s - The string to be compared to the flag/name to determine
* whether the arg matches.
*/
virtual bool argMatches( const std::string& s ) const;
virtual bool argMatches(const std::string &s) const;
/**
* Returns a simple string representation of the argument.
@ -319,13 +349,13 @@ class Arg
* Returns a short ID for the usage.
* \param valueId - The value used in the id.
*/
virtual std::string shortID( const std::string& valueId = "val" ) const;
virtual std::string shortID(const std::string &valueId = "val") const;
/**
* Returns a long ID for the usage.
* \param valueId - The value used in the id.
*/
virtual std::string longID( const std::string& valueId = "val" ) const;
virtual std::string longID(const std::string &valueId = "val") const;
/**
* Trims a value off of the flag.
@ -334,7 +364,7 @@ class Arg
* \param value - Where the value trimmed from the string will
* be stored.
*/
virtual void trimFlag( std::string& flag, std::string& value ) const;
virtual void trimFlag(std::string &flag, std::string &value) const;
/**
* Checks whether a given string has blank chars, indicating that
@ -342,14 +372,14 @@ class Arg
* false.
* \param s - string to be checked.
*/
bool _hasBlanks( const std::string& s ) const;
bool _hasBlanks(const std::string &s) const;
/**
* Sets the requireLabel. Used by XorHandler. You shouldn't ever
* use this.
* \param s - Set the requireLabel to this value.
*/
void setRequireLabel( const std::string& s );
void setRequireLabel(const std::string &s);
/**
* Used for MultiArgs and XorHandler to determine whether args
@ -368,305 +398,352 @@ class Arg
* command lines.
*/
virtual void reset();
};
};
/**
/**
* Typedef of an Arg list iterator.
*/
typedef std::list<Arg*>::iterator ArgListIterator;
typedef std::list<Arg*>::iterator ArgListIterator;
/**
/**
* Typedef of an Arg vector iterator.
*/
typedef std::vector<Arg*>::iterator ArgVectorIterator;
typedef std::vector<Arg*>::iterator ArgVectorIterator;
/**
/**
* Typedef of a Visitor list iterator.
*/
typedef std::list<Visitor*>::iterator VisitorListIterator;
typedef std::list<Visitor*>::iterator VisitorListIterator;
/*
/*
* Extract a value of type T from it's string representation contained
* in strVal. The ValueLike parameter used to select the correct
* specialization of ExtractValue depending on the value traits of T.
* ValueLike traits use operator>> to assign the value from strVal.
*/
template<typename T> void
ExtractValue(T &destVal, const std::string& strVal, ValueLike vl)
{
template<typename T>
void ExtractValue(T &destVal, const std::string &strVal, ValueLike vl)
{
static_cast<void>(vl); // Avoid warning about unused vl
std::istringstream is(strVal);
int valuesRead = 0;
while ( is.good() ) {
if ( is.peek() != EOF )
while (is.good())
{
if (is.peek() != EOF)
#ifdef TCLAP_SETBASE_ZERO
{
is >> std::setbase(0) >> destVal;
}
#else
{
is >> destVal;
}
#endif
else
{
break;
}
valuesRead++;
}
if ( is.fail() )
throw( ArgParseException("Couldn't read argument value "
if (is.fail())
{
throw (ArgParseException("Couldn't read argument value "
"from string '" + strVal + "'"));
}
if ( valuesRead > 1 )
throw( ArgParseException("More than one valid value parsed from "
if (valuesRead > 1)
{
throw (ArgParseException("More than one valid value parsed from "
"string '" + strVal + "'"));
}
}
}
/*
/*
* Extract a value of type T from it's string representation contained
* in strVal. The ValueLike parameter used to select the correct
* specialization of ExtractValue depending on the value traits of T.
* StringLike uses assignment (operator=) to assign from strVal.
*/
template<typename T> void
ExtractValue(T &destVal, const std::string& strVal, StringLike sl)
{
template<typename T>
void ExtractValue(T &destVal, const std::string &strVal, StringLike sl)
{
static_cast<void>(sl); // Avoid warning about unused sl
SetString(destVal, strVal);
}
//////////////////////////////////////////////////////////////////////
//BEGIN Arg.cpp
//////////////////////////////////////////////////////////////////////
inline Arg::Arg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
bool valreq,
Visitor* v) :
_flag(flag),
_name(name),
_description(desc),
_required(req),
_requireLabel("required"),
_valueRequired(valreq),
_alreadySet(false),
_visitor( v ),
_ignoreable(true),
_xorSet(false),
_acceptsMultipleValues(false)
{
if ( _flag.length() > 1 )
throw(SpecificationException(
"Argument flag can only be one character long", toString() ) );
}
if ( _name != ignoreNameString() &&
( _flag == Arg::flagStartString() ||
_flag == Arg::nameStartString() ||
_flag == " " ) )
throw(SpecificationException("Argument flag cannot be either '" +
Arg::flagStartString() + "' or '" +
Arg::nameStartString() + "' or a space.",
toString() ) );
//////////////////////////////////////////////////////////////////////
//BEGIN Arg.cpp
//////////////////////////////////////////////////////////////////////
if ( ( _name.substr( 0, Arg::flagStartString().length() ) == Arg::flagStartString() ) ||
( _name.substr( 0, Arg::nameStartString().length() ) == Arg::nameStartString() ) ||
( _name.find( " ", 0 ) != std::string::npos ) )
throw(SpecificationException("Argument name begin with either '" +
Arg::flagStartString() + "' or '" +
Arg::nameStartString() + "' or space.",
toString() ) );
inline Arg::Arg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, bool valreq, Visitor *v) :
_flag(flag), _name(name), _description(desc), _required(req), _requireLabel("required"),
_valueRequired(valreq), _alreadySet(false), _visitor(v), _ignoreable(true),
_xorSet(false), _acceptsMultipleValues(false)
{
if (_flag.length() > 1)
{
throw (SpecificationException(
"Argument flag can only be one character long", toString()));
}
}
if (_name != ignoreNameString() &&
(_flag == Arg::flagStartString() ||
_flag == Arg::nameStartString() ||
_flag == " "))
{
throw (SpecificationException("Argument flag cannot be either '" + Arg::flagStartString() +
"' or '" + Arg::nameStartString() + "' or a space.", toString()));
}
inline Arg::~Arg() { }
if ((_name.substr(0, Arg::flagStartString().length()) == Arg::flagStartString()) ||
(_name.substr(0, Arg::nameStartString().length()) == Arg::nameStartString()) ||
(_name.find(" ", 0) != std::string::npos))
{
throw (SpecificationException("Argument name begin with either '" + Arg::flagStartString() +
"' or '" + Arg::nameStartString() + "' or space.", toString()));
}
}
inline std::string Arg::shortID( const std::string& valueId ) const
{
inline Arg::~Arg()
{
}
inline std::string Arg::shortID(const std::string &valueId) const
{
std::string id = "";
if ( _flag != "" )
if (_flag != "")
{
id = Arg::flagStartString() + _flag;
}
else
{
id = Arg::nameStartString() + _name;
}
if ( _valueRequired )
id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
if (_valueRequired)
{
id += std::string(1, Arg::delimiter()) + "<" + valueId + ">";
}
if ( !_required )
if (!_required)
{
id = "[" + id + "]";
}
return id;
}
}
inline std::string Arg::longID( const std::string& valueId ) const
{
inline std::string Arg::longID(const std::string &valueId) const
{
std::string id = "";
if ( _flag != "" )
if (_flag != "")
{
id += Arg::flagStartString() + _flag;
if ( _valueRequired )
id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
if (_valueRequired)
{
id += std::string(1, Arg::delimiter()) + "<" + valueId + ">";
}
id += ", ";
}
id += Arg::nameStartString() + _name;
if ( _valueRequired )
id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
if (_valueRequired)
{
id += std::string(1, Arg::delimiter()) + "<" + valueId + ">";
}
return id;
}
}
inline bool Arg::operator==(const Arg& a) const
{
if ( ( _flag != "" && _flag == a._flag ) || _name == a._name)
inline bool Arg::operator==(const Arg &a) const
{
if ((_flag != "" && _flag == a._flag) || _name == a._name)
{
return true;
}
else
{
return false;
}
}
}
inline std::string Arg::getDescription() const
{
inline std::string Arg::getDescription() const
{
std::string desc = "";
if ( _required )
if (_required)
{
desc = "(" + _requireLabel + ") ";
}
// if ( _valueRequired )
// desc += "(value required) ";
// if ( _valueRequired )
// desc += "(value required) ";
desc += _description;
return desc;
}
}
inline const std::string& Arg::getFlag() const { return _flag; }
inline const std::string& Arg::getFlag() const
{
return _flag;
}
inline const std::string& Arg::getName() const { return _name; }
inline const std::string& Arg::getName() const
{
return _name;
}
inline bool Arg::isRequired() const { return _required; }
inline bool Arg::isRequired() const
{
return _required;
}
inline bool Arg::isValueRequired() const { return _valueRequired; }
inline bool Arg::isValueRequired() const
{
return _valueRequired;
}
inline bool Arg::isSet() const
{
if ( _alreadySet && !_xorSet )
inline bool Arg::isSet() const
{
if (_alreadySet && !_xorSet)
{
return true;
}
else
{
return false;
}
}
}
inline bool Arg::isIgnoreable() const { return _ignoreable; }
inline bool Arg::isIgnoreable() const
{
return _ignoreable;
}
inline void Arg::setRequireLabel( const std::string& s)
{
inline void Arg::setRequireLabel(const std::string &s)
{
_requireLabel = s;
}
}
inline bool Arg::argMatches( const std::string& argFlag ) const
{
if ( ( argFlag == Arg::flagStartString() + _flag && _flag != "" ) ||
argFlag == Arg::nameStartString() + _name )
inline bool Arg::argMatches(const std::string &argFlag) const
{
if ((argFlag == Arg::flagStartString() + _flag && _flag != "") ||
argFlag == Arg::nameStartString() + _name)
{
return true;
}
else
{
return false;
}
}
}
inline std::string Arg::toString() const
{
inline std::string Arg::toString() const
{
std::string s = "";
if ( _flag != "" )
if (_flag != "")
{
s += Arg::flagStartString() + _flag + " ";
}
s += "(" + Arg::nameStartString() + _name + ")";
return s;
}
}
inline void Arg::_checkWithVisitor() const
{
if ( _visitor != NULL )
inline void Arg::_checkWithVisitor() const
{
if (_visitor != NULL)
{
_visitor->visit();
}
}
}
/**
/**
* Implementation of trimFlag.
*/
inline void Arg::trimFlag(std::string& flag, std::string& value) const
{
inline void Arg::trimFlag(std::string &flag, std::string &value) const
{
int stop = 0;
for ( int i = 0; static_cast<unsigned int>(i) < flag.length(); i++ )
if ( flag[i] == Arg::delimiter() )
for (int i = 0; static_cast<unsigned int>(i) < flag.length(); i++)
{
if (flag[i] == Arg::delimiter())
{
stop = i;
break;
}
}
if ( stop > 1 )
if (stop > 1)
{
value = flag.substr(stop+1);
flag = flag.substr(0,stop);
value = flag.substr(stop + 1);
flag = flag.substr(0, stop);
}
}
}
/**
/**
* Implementation of _hasBlanks.
*/
inline bool Arg::_hasBlanks( const std::string& s ) const
{
for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
if ( s[i] == Arg::blankChar() )
inline bool Arg::_hasBlanks(const std::string &s) const
{
for (int i = 1; static_cast<unsigned int>(i) < s.length(); i++)
{
if (s[i] == Arg::blankChar())
{
return true;
}
}
return false;
}
}
inline void Arg::forceRequired()
{
inline void Arg::forceRequired()
{
_required = true;
}
}
inline void Arg::xorSet()
{
inline void Arg::xorSet()
{
_alreadySet = true;
_xorSet = true;
}
}
/**
/**
* Overridden by Args that need to added to the end of the list.
*/
inline void Arg::addToList( std::list<Arg*>& argList ) const
{
argList.push_front( const_cast<Arg*>(this) );
}
inline void Arg::addToList(std::list<Arg*> &argList) const
{
argList.push_front(const_cast<Arg*>(this));
}
inline bool Arg::allowMore()
{
inline bool Arg::allowMore()
{
return false;
}
}
inline bool Arg::acceptsMultipleValues()
{
inline bool Arg::acceptsMultipleValues()
{
return _acceptsMultipleValues;
}
}
inline void Arg::reset()
{
inline void Arg::reset()
{
_xorSet = false;
_alreadySet = false;
}
//////////////////////////////////////////////////////////////////////
//END Arg.cpp
//////////////////////////////////////////////////////////////////////
}
//////////////////////////////////////////////////////////////////////
//END Arg.cpp
//////////////////////////////////////////////////////////////////////
} //namespace TCLAP
#endif

140
src/tclap/ArgException.h
Unescape Escape View File

@ -27,16 +27,15 @@
#include <string>
#include <exception>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A simple class that defines and argument exception. Should be caught
* whenever a CmdLine is created and parsed.
*/
class ArgException : public std::exception
{
class ArgException : public std::exception
{
public:
/**
* Constructor.
* \param text - The text of the exception.
@ -44,40 +43,47 @@ class ArgException : public std::exception
* \param td - Text describing the type of ArgException it is.
* of the exception.
*/
ArgException( const std::string& text = "undefined exception",
const std::string& id = "undefined",
const std::string& td = "Generic ArgException")
: std::exception(),
_errorText(text),
_argId( id ),
_typeDescription(td)
{ }
ArgException(const std::string &text = "undefined exception",
const std::string &id = "undefined",
const std::string &td = "Generic ArgException") :
std::exception(), _errorText(text), _argId(id), _typeDescription(td)
{
}
/**
* Destructor.
*/
virtual ~ArgException() throw() { }
virtual ~ArgException() throw ()
{
}
/**
* Returns the error text.
*/
std::string error() const { return ( _errorText ); }
std::string error() const
{
return _errorText;
}
/**
* Returns the argument id.
*/
std::string argId() const
{
if ( _argId == "undefined" )
if (_argId == "undefined")
{
return " ";
}
else
return ( "Argument: " + _argId );
{
return "Argument: " + _argId;
}
}
/**
* Returns the arg id and error text.
*/
const char* what() const throw()
const char* what() const throw ()
{
static std::string ex;
ex = _argId + " -- " + _errorText;
@ -93,9 +99,7 @@ class ArgException : public std::exception
return _typeDescription;
}
private:
/**
* The text of the exception message.
*/
@ -111,15 +115,14 @@ class ArgException : public std::exception
* between different child exceptions.
*/
std::string _typeDescription;
};
};
/**
/**
* Thrown from within the child Arg classes when it fails to properly
* parse the argument it has been passed.
*/
class ArgParseException : public ArgException
{
class ArgParseException : public ArgException
{
public:
/**
* Constructor.
@ -127,21 +130,22 @@ class ArgParseException : public ArgException
* \param id - The text identifying the argument source
* of the exception.
*/
ArgParseException( const std::string& text = "undefined exception",
const std::string& id = "undefined" )
: ArgException( text,
ArgParseException(const std::string &text = "undefined exception",
const std::string &id = "undefined") :
ArgException(text,
id,
std::string( "Exception found while parsing " ) +
std::string( "the value the Arg has been passed." ))
{ }
};
std::string("Exception found while parsing ") +
std::string("the value the Arg has been passed."))
{
}
};
/**
/**
* Thrown from CmdLine when the arguments on the command line are not
* properly specified, e.g. too many arguments, required argument missing, etc.
*/
class CmdLineParseException : public ArgException
{
class CmdLineParseException : public ArgException
{
public:
/**
* Constructor.
@ -149,23 +153,23 @@ class CmdLineParseException : public ArgException
* \param id - The text identifying the argument source
* of the exception.
*/
CmdLineParseException( const std::string& text = "undefined exception",
const std::string& id = "undefined" )
: ArgException( text,
CmdLineParseException(const std::string &text = "undefined exception",
const std::string &id = "undefined") :
ArgException(text,
id,
std::string( "Exception found when the values ") +
std::string( "on the command line do not meet ") +
std::string( "the requirements of the defined ") +
std::string( "Args." ))
{ }
};
/**
std::string("Exception found when the values ") +
std::string("on the command line do not meet ") +
std::string("the requirements of the defined ") + std::string("Args."))
{
}
};
/**
* Thrown from Arg and CmdLine when an Arg is improperly specified, e.g.
* same flag as another Arg, same name, etc.
*/
class SpecificationException : public ArgException
{
class SpecificationException : public ArgException
{
public:
/**
* Constructor.
@ -173,28 +177,32 @@ class SpecificationException : public ArgException
* \param id - The text identifying the argument source
* of the exception.
*/
SpecificationException( const std::string& text = "undefined exception",
const std::string& id = "undefined" )
: ArgException( text,
SpecificationException(const std::string &text = "undefined exception",
const std::string &id = "undefined") :
ArgException(text,
id,
std::string("Exception found when an Arg object ")+
std::string("is improperly defined by the ") +
std::string("developer." ))
{ }
};
std::string("Exception found when an Arg object ") +
std::string("is improperly defined by the ") + std::string("developer."))
{
}
};
class ExitException {
public:
ExitException(int estat) : _estat(estat) {}
class ExitException
{
public:
ExitException(int estat) :
_estat(estat)
{
}
int getExitStatus() const { return _estat; }
int getExitStatus() const
{
return _estat;
}
private:
private:
int _estat;
};
};
} // namespace TCLAP
#endif

46
src/tclap/ArgTraits.h
Unescape Escape View File

@ -24,58 +24,62 @@
// include this directly
#ifndef TCLAP_ARGTRAITS_H
#define TCLAP_ARGTRAITS_H
#define TCLAP_ARGTRAITS_H
namespace TCLAP {
namespace TCLAP
{
// We use two empty structs to get compile type specialization
// function to work
// We use two empty structs to get compile type specialization
// function to work
/**
/**
* A value like argument value type is a value that can be set using
* operator>>. This is the default value type.
*/
struct ValueLike {
struct ValueLike
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* A string like argument value type is a value that can be set using
* operator=(string). Usefull if the value type contains spaces which
* will be broken up into individual tokens by operator>>.
*/
struct StringLike {};
struct StringLike
{};
/**
/**
* A class can inherit from this object to make it have string like
* traits. This is a compile time thing and does not add any overhead
* to the inherenting class.
*/
struct StringLikeTrait {
struct StringLikeTrait
{
typedef StringLike ValueCategory;
};
};
/**
/**
* A class can inherit from this object to make it have value like
* traits. This is a compile time thing and does not add any overhead
* to the inherenting class.
*/
struct ValueLikeTrait {
struct ValueLikeTrait
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* Arg traits are used to get compile type specialization when parsing
* argument values. Using an ArgTraits you can specify the way that
* values gets assigned to any particular type during parsing. The two
* supported types are string like and value like.
*/
template<typename T>
struct ArgTraits {
template<typename T>
struct ArgTraits
{
typedef typename T::ValueCategory ValueCategory;
//typedef ValueLike ValueCategory;
};
};
#endif
} // namespace

400
src/tclap/CmdLine.h
Unescape Escape View File

@ -48,29 +48,29 @@
#include <algorithm>
#include <stdlib.h> // Needed for exit(), which isn't defined in some envs.
namespace TCLAP {
template<typename T> void DelPtr(T ptr)
namespace TCLAP
{
template<typename T>
void DelPtr(T ptr)
{
delete ptr;
}
}
template<typename C> void ClearContainer(C &c)
{
template<typename C>
void ClearContainer(C &c)
{
typedef typename C::value_type value_type;
std::for_each(c.begin(), c.end(), DelPtr<value_type>);
c.clear();
}
}
/**
/**
* The base class that manages the command line definition and passes
* along the parsing to the appropriate Arg classes.
*/
class CmdLine : public CmdLineInterface
{
class CmdLine : public CmdLineInterface
{
protected:
/**
* The list of arguments that will be tested against the
* command line.
@ -127,7 +127,7 @@ class CmdLine : public CmdLineInterface
/**
* Object that handles all output for the CmdLine.
*/
CmdLineOutput* _output;
CmdLineOutput *_output;
/**
* Should CmdLine handle parsing exceptions internally?
@ -145,20 +145,19 @@ class CmdLine : public CmdLineInterface
* into a single argument.
* \param s - The message to be used in the usage.
*/
bool _emptyCombined(const std::string& s);
bool _emptyCombined(const std::string &s);
/**
* Perform a delete ptr; operation on ptr when this object is deleted.
*/
void deleteOnExit(Arg* ptr);
void deleteOnExit(Arg *ptr);
/**
* Perform a delete ptr; operation on ptr when this object is deleted.
*/
void deleteOnExit(Visitor* ptr);
private:
void deleteOnExit(Visitor *ptr);
private:
/**
* Encapsulates the code common to the constructors
* (which is all of it).
@ -178,7 +177,6 @@ private:
bool _helpAndVersion;
public:
/**
* Command line constructor. Defines how the arguments will be
* parsed.
@ -191,10 +189,8 @@ private:
* \param helpAndVersion - Whether or not to create the Help and
* Version switches. Defaults to true.
*/
CmdLine(const std::string& message,
const char delimiter = ' ',
const std::string& version = "none",
bool helpAndVersion = true);
CmdLine(const std::string &message, const char delimiter = ' ',
const std::string &version = "none", bool helpAndVersion = true);
/**
* Deletes any resources allocated by a CmdLine object.
@ -205,13 +201,13 @@ private:
* Adds an argument to the list of arguments to be parsed.
* \param a - Argument to be added.
*/
void add( Arg& a );
void add(Arg &a);
/**
* An alternative add. Functionally identical.
* \param a - Argument to be added.
*/
void add( Arg* a );
void add(Arg *a);
/**
* Add two Args that will be xor'd. If this method is used, add does
@ -219,28 +215,28 @@ private:
* \param a - Argument to be added and xor'd.
* \param b - Argument to be added and xor'd.
*/
void xorAdd( Arg& a, Arg& b );
void xorAdd(Arg &a, Arg &b);
/**
* Add a list of Args that will be xor'd. If this method is used,
* add does not need to be called.
* \param xors - List of Args to be added and xor'd.
*/
void xorAdd( std::vector<Arg*>& xors );
void xorAdd(std::vector<Arg*> &xors);
/**
* Parses the command line.
* \param argc - Number of arguments.
* \param argv - Array of arguments.
*/
void parse(int argc, const char * const * argv);
void parse(int argc, const char*const *argv);
/**
* Parses the command line.
* \param args - A vector of strings representing the args.
* args[0] is still the program name.
*/
void parse(std::vector<std::string>& args);
void parse(std::vector<std::string> &args);
/**
*
@ -250,7 +246,7 @@ private:
/**
*
*/
void setOutput(CmdLineOutput* co);
void setOutput(CmdLineOutput *co);
/**
*
@ -306,148 +302,145 @@ private:
* Allows the CmdLine object to be reused.
*/
void reset();
};
};
///////////////////////////////////////////////////////////////////////////////
//Begin CmdLine.cpp
///////////////////////////////////////////////////////////////////////////////
inline CmdLine::CmdLine(const std::string& m,
char delim,
const std::string& v,
bool help )
: _progName("not_set_yet"),
_message(m),
_version(v),
_numRequired(0),
_delimiter(delim),
_handleExceptions(true),
_userSetOutput(false),
_helpAndVersion(help)
{
///////////////////////////////////////////////////////////////////////////////
//Begin CmdLine.cpp
///////////////////////////////////////////////////////////////////////////////
inline CmdLine::CmdLine(const std::string &m, char delim, const std::string &v, bool help) :
_progName("not_set_yet"), _message(m), _version(v), _numRequired(0), _delimiter(delim),
_handleExceptions(true), _userSetOutput(false), _helpAndVersion(help)
{
_constructor();
}
}
inline CmdLine::~CmdLine()
{
inline CmdLine::~CmdLine()
{
ClearContainer(_argDeleteOnExitList);
ClearContainer(_visitorDeleteOnExitList);
if ( !_userSetOutput ) {
if (!_userSetOutput)
{
delete _output;
_output = 0;
}
}
}
inline void CmdLine::_constructor()
{
inline void CmdLine::_constructor()
{
_output = new StdOutput;
Arg::setDelimiter( _delimiter );
Arg::setDelimiter(_delimiter);
Visitor* v;
Visitor *v;
if ( _helpAndVersion )
if (_helpAndVersion)
{
v = new HelpVisitor( this, &_output );
SwitchArg* help = new SwitchArg("h","help",
"Displays usage information and exits.",
false, v);
add( help );
v = new HelpVisitor(this, &_output);
SwitchArg *help =
new SwitchArg("h", "help", "Displays usage information and exits.", false, v);
add(help);
deleteOnExit(help);
deleteOnExit(v);
v = new VersionVisitor( this, &_output );
SwitchArg* vers = new SwitchArg("","version",
"Displays version information and exits.",
v = new VersionVisitor(this, &_output);
SwitchArg *vers = new SwitchArg("", "version", "Displays version information and exits.",
false, v);
add( vers );
add(vers);
deleteOnExit(vers);
deleteOnExit(v);
}
v = new IgnoreRestVisitor();
SwitchArg* ignore = new SwitchArg(Arg::flagStartString(),
Arg::ignoreNameString(),
"Ignores the rest of the labeled arguments following this flag.",
false, v);
add( ignore );
SwitchArg *ignore = new SwitchArg(Arg::flagStartString(),
Arg::ignoreNameString(), "Ignores the rest of the labeled arguments following this flag.", false,
v);
add(ignore);
deleteOnExit(ignore);
deleteOnExit(v);
}
}
inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
{
_xorHandler.add( ors );
inline void CmdLine::xorAdd(std::vector<Arg*> &ors)
{
_xorHandler.add(ors);
for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
{
(*it)->forceRequired();
(*it)->setRequireLabel( "OR required" );
(*it)->setRequireLabel("OR required");
add( *it );
add(*it);
}
}
}
inline void CmdLine::xorAdd( Arg& a, Arg& b )
{
inline void CmdLine::xorAdd(Arg &a, Arg &b)
{
std::vector<Arg*> ors;
ors.push_back( &a );
ors.push_back( &b );
xorAdd( ors );
}
ors.push_back(&a);
ors.push_back(&b);
xorAdd(ors);
}
inline void CmdLine::add( Arg& a )
{
add( &a );
}
inline void CmdLine::add(Arg &a)
{
add(&a);
}
inline void CmdLine::add( Arg* a )
{
for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
if ( *a == *(*it) )
throw( SpecificationException(
"Argument with same flag/name already exists!",
a->longID() ) );
inline void CmdLine::add(Arg *a)
{
for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
{
if (*a == *(*it))
{
throw (SpecificationException(
"Argument with same flag/name already exists!", a->longID()));
}
}
a->addToList( _argList );
a->addToList(_argList);
if ( a->isRequired() )
if (a->isRequired())
{
_numRequired++;
}
}
}
inline void CmdLine::parse(int argc, const char * const * argv)
{
inline void CmdLine::parse(int argc, const char*const *argv)
{
// this step is necessary so that we have easy access to
// mutable strings.
std::vector<std::string> args;
for (int i = 0; i < argc; i++)
{
args.push_back(argv[i]);
}
parse(args);
}
}
inline void CmdLine::parse(std::vector<std::string>& args)
{
inline void CmdLine::parse(std::vector<std::string> &args)
{
bool shouldExit = false;
int estat = 0;
try {
try
{
_progName = args.front();
args.erase(args.begin());
int requiredCount = 0;
for (int i = 0; static_cast<unsigned int>(i) < args.size(); i++) {
for (int i = 0; static_cast<unsigned int>(i) < args.size(); i++)
{
bool matched = false;
for (ArgListIterator it = _argList.begin();
it != _argList.end(); it++) {
if ( (*it)->processArg( &i, args ) )
it != _argList.end(); it++)
{
if ((*it)->processArg(&i, args))
{
requiredCount += _xorHandler.check( *it );
requiredCount += _xorHandler.check(*it);
matched = true;
break;
}
@ -455,36 +448,51 @@ inline void CmdLine::parse(std::vector<std::string>& args)
// checks to see if the argument is an empty combined
// switch and if so, then we've actually matched it
if ( !matched && _emptyCombined( args[i] ) )
if (!matched && _emptyCombined(args[i]))
{
matched = true;
}
if ( !matched && !Arg::ignoreRest() )
throw(CmdLineParseException("Couldn't find match "
"for argument",
args[i]));
if (!matched && !Arg::ignoreRest())
{
throw (CmdLineParseException("Couldn't find match "
"for argument", args[i]));
}
}
if ( requiredCount < _numRequired )
if (requiredCount < _numRequired)
{
missingArgsException();
}
if ( requiredCount > _numRequired )
throw(CmdLineParseException("Too many arguments!"));
} catch ( ArgException& e ) {
if (requiredCount > _numRequired)
{
throw (CmdLineParseException("Too many arguments!"));
}
}
catch (ArgException &e)
{
// If we're not handling the exceptions, rethrow.
if ( !_handleExceptions) {
if (!_handleExceptions)
{
throw;
}
try {
_output->failure(*this,e);
} catch ( ExitException &ee ) {
try
{
_output->failure(*this, e);
}
catch (ExitException &ee)
{
estat = ee.getExitStatus();
shouldExit = true;
}
} catch (ExitException &ee) {
}
catch (ExitException &ee)
{
// If we're not handling the exceptions, rethrow.
if ( !_handleExceptions) {
if (!_handleExceptions)
{
throw;
}
@ -493,129 +501,139 @@ inline void CmdLine::parse(std::vector<std::string>& args)
}
if (shouldExit)
{
exit(estat);
}
}
}
inline bool CmdLine::_emptyCombined(const std::string& s)
{
if ( s.length() > 0 && s[0] != Arg::flagStartChar() )
inline bool CmdLine::_emptyCombined(const std::string &s)
{
if (s.length() > 0 && s[0] != Arg::flagStartChar())
{
return false;
}
for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
if ( s[i] != Arg::blankChar() )
for (int i = 1; static_cast<unsigned int>(i) < s.length(); i++)
{
if (s[i] != Arg::blankChar())
{
return false;
}
}
return true;
}
}
inline void CmdLine::missingArgsException()
{
inline void CmdLine::missingArgsException()
{
int count = 0;
std::string missingArgList;
for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
{
if ( (*it)->isRequired() && !(*it)->isSet() )
if ((*it)->isRequired() && !(*it)->isSet())
{
missingArgList += (*it)->getName();
missingArgList += ", ";
count++;
}
}
missingArgList = missingArgList.substr(0,missingArgList.length()-2);
missingArgList = missingArgList.substr(0, missingArgList.length() - 2);
std::string msg;
if ( count > 1 )
if (count > 1)
{
msg = "Required arguments missing: ";
}
else
{
msg = "Required argument missing: ";
}
msg += missingArgList;
throw(CmdLineParseException(msg));
}
throw (CmdLineParseException(msg));
}
inline void CmdLine::deleteOnExit(Arg* ptr)
{
inline void CmdLine::deleteOnExit(Arg *ptr)
{
_argDeleteOnExitList.push_back(ptr);
}
}
inline void CmdLine::deleteOnExit(Visitor* ptr)
{
inline void CmdLine::deleteOnExit(Visitor *ptr)
{
_visitorDeleteOnExitList.push_back(ptr);
}
}
inline CmdLineOutput* CmdLine::getOutput()
{
inline CmdLineOutput* CmdLine::getOutput()
{
return _output;
}
}
inline void CmdLine::setOutput(CmdLineOutput* co)
{
inline void CmdLine::setOutput(CmdLineOutput *co)
{
_userSetOutput = true;
_output = co;
}
}
inline std::string& CmdLine::getVersion()
{
inline std::string& CmdLine::getVersion()
{
return _version;
}
}
inline std::string& CmdLine::getProgramName()
{
inline std::string& CmdLine::getProgramName()
{
return _progName;
}
}
inline std::list<Arg*>& CmdLine::getArgList()
{
inline std::list<Arg*>& CmdLine::getArgList()
{
return _argList;
}
}
inline XorHandler& CmdLine::getXorHandler()
{
inline XorHandler& CmdLine::getXorHandler()
{
return _xorHandler;
}
}
inline char CmdLine::getDelimiter()
{
inline char CmdLine::getDelimiter()
{
return _delimiter;
}
}
inline std::string& CmdLine::getMessage()
{
inline std::string& CmdLine::getMessage()
{
return _message;
}
}
inline bool CmdLine::hasHelpAndVersion()
{
inline bool CmdLine::hasHelpAndVersion()
{
return _helpAndVersion;
}
}
inline void CmdLine::setExceptionHandling(const bool state)
{
inline void CmdLine::setExceptionHandling(const bool state)
{
_handleExceptions = state;
}
}
inline bool CmdLine::getExceptionHandling() const
{
inline bool CmdLine::getExceptionHandling() const
{
return _handleExceptions;
}
}
inline void CmdLine::reset()
{
for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
inline void CmdLine::reset()
{
for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
{
(*it)->reset();
}
_progName.clear();
}
///////////////////////////////////////////////////////////////////////////////
//End CmdLine.cpp
///////////////////////////////////////////////////////////////////////////////
}
///////////////////////////////////////////////////////////////////////////////
//End CmdLine.cpp
///////////////////////////////////////////////////////////////////////////////
} //namespace TCLAP
#endif

57
src/tclap/CmdLineInterface.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: CmdLineInterface.h
@ -30,36 +29,37 @@
#include <algorithm>
namespace TCLAP {
class Arg;
class CmdLineOutput;
class XorHandler;
namespace TCLAP
{
class Arg;
class CmdLineOutput;
class XorHandler;
/**
/**
* The base class that manages the command line definition and passes
* along the parsing to the appropriate Arg classes.
*/
class CmdLineInterface
{
class CmdLineInterface
{
public:
/**
* Destructor
*/
virtual ~CmdLineInterface() {}
virtual ~CmdLineInterface()
{
}
/**
* Adds an argument to the list of arguments to be parsed.
* \param a - Argument to be added.
*/
virtual void add( Arg& a )=0;
virtual void add(Arg &a) = 0;
/**
* An alternative add. Functionally identical.
* \param a - Argument to be added.
*/
virtual void add( Arg* a )=0;
virtual void add(Arg *a) = 0;
/**
* Add two Args that will be xor'd.
@ -68,82 +68,81 @@ class CmdLineInterface
* \param a - Argument to be added and xor'd.
* \param b - Argument to be added and xor'd.
*/
virtual void xorAdd( Arg& a, Arg& b )=0;
virtual void xorAdd(Arg &a, Arg &b) = 0;
/**
* Add a list of Args that will be xor'd. If this method is used,
* add does not need to be called.
* \param xors - List of Args to be added and xor'd.
*/
virtual void xorAdd( std::vector<Arg*>& xors )=0;
virtual void xorAdd(std::vector<Arg*> &xors) = 0;
/**
* Parses the command line.
* \param argc - Number of arguments.
* \param argv - Array of arguments.
*/
virtual void parse(int argc, const char * const * argv)=0;
virtual void parse(int argc, const char*const *argv) = 0;
/**
* Parses the command line.
* \param args - A vector of strings representing the args.
* args[0] is still the program name.
*/
void parse(std::vector<std::string>& args);
void parse(std::vector<std::string> &args);
/**
* Returns the CmdLineOutput object.
*/
virtual CmdLineOutput* getOutput()=0;
virtual CmdLineOutput* getOutput() = 0;
/**
* \param co - CmdLineOutput object that we want to use instead.
*/
virtual void setOutput(CmdLineOutput* co)=0;
virtual void setOutput(CmdLineOutput *co) = 0;
/**
* Returns the version string.
*/
virtual std::string& getVersion()=0;
virtual std::string& getVersion() = 0;
/**
* Returns the program name string.
*/
virtual std::string& getProgramName()=0;
virtual std::string& getProgramName() = 0;
/**
* Returns the argList.
*/
virtual std::list<Arg*>& getArgList()=0;
virtual std::list<Arg*>& getArgList() = 0;
/**
* Returns the XorHandler.
*/
virtual XorHandler& getXorHandler()=0;
virtual XorHandler& getXorHandler() = 0;
/**
* Returns the delimiter string.
*/
virtual char getDelimiter()=0;
virtual char getDelimiter() = 0;
/**
* Returns the message string.
*/
virtual std::string& getMessage()=0;
virtual std::string& getMessage() = 0;
/**
* Indicates whether or not the help and version switches were created
* automatically.
*/
virtual bool hasHelpAndVersion()=0;
virtual bool hasHelpAndVersion() = 0;
/**
* Resets the instance as if it had just been constructed so that the
* instance can be reused.
*/
virtual void reset()=0;
};
virtual void reset() = 0;
};
} //namespace

34
src/tclap/CmdLineOutput.h
Unescape Escape View File

@ -1,5 +1,3 @@
/******************************************************************************
*
* file: CmdLineOutput.h
@ -30,45 +28,43 @@
#include <iomanip>
#include <algorithm>
namespace TCLAP {
class CmdLineInterface;
class ArgException;
namespace TCLAP
{
class CmdLineInterface;
class ArgException;
/**
/**
* The interface that any output object must implement.
*/
class CmdLineOutput
{
class CmdLineOutput
{
public:
/**
* Virtual destructor.
*/
virtual ~CmdLineOutput() {}
virtual ~CmdLineOutput()
{
}
/**
* Generates some sort of output for the USAGE.
* \param c - The CmdLine object the output is generated for.
*/
virtual void usage(CmdLineInterface& c)=0;
virtual void usage(CmdLineInterface &c) = 0;
/**
* Generates some sort of output for the version.
* \param c - The CmdLine object the output is generated for.
*/
virtual void version(CmdLineInterface& c)=0;
virtual void version(CmdLineInterface &c) = 0;
/**
* Generates some sort of output for a failure.
* \param c - The CmdLine object the output is generated for.
* \param e - The ArgException that caused the failure.
*/
virtual void failure( CmdLineInterface& c,
ArgException& e )=0;
};
virtual void failure(CmdLineInterface &c, ArgException &e) = 0;
};
} //namespace TCLAP
#endif

28
src/tclap/Constraint.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: Constraint.h
@ -29,40 +28,41 @@
#include <iomanip>
#include <algorithm>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* The interface that defines the interaction between the Arg and Constraint.
*/
template<class T>
class Constraint
{
template<class T>
class Constraint
{
public:
/**
* Returns a description of the Constraint.
*/
virtual std::string description() const =0;
virtual std::string description() const = 0;
/**
* Returns the short ID for the Constraint.
*/
virtual std::string shortID() const =0;
virtual std::string shortID() const = 0;
/**
* The method used to verify that the value parsed from the command
* line meets the constraint.
* \param value - The value that will be checked.
*/
virtual bool check(const T& value) const =0;
virtual bool check(const T &value) const = 0;
/**
* Destructor.
* Silences warnings about Constraint being a base class with virtual
* functions but without a virtual destructor.
*/
virtual ~Constraint() { ; }
};
virtual ~Constraint()
{
}
};
} //namespace TCLAP
#endif

170
src/tclap/DocBookOutput.h
Unescape Escape View File

@ -34,30 +34,28 @@
#include <tclap/XorHandler.h>
#include <tclap/Arg.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A class that generates DocBook output for usage() method for the
* given CmdLine and its Args.
*/
class DocBookOutput : public CmdLineOutput
{
class DocBookOutput : public CmdLineOutput
{
public:
/**
* Prints the usage to stdout. Can be overridden to
* produce alternative behavior.
* \param c - The CmdLine object the output is generated for.
*/
virtual void usage(CmdLineInterface& c);
virtual void usage(CmdLineInterface &c);
/**
* Prints the version to stdout. Can be overridden
* to produce alternative behavior.
* \param c - The CmdLine object the output is generated for.
*/
virtual void version(CmdLineInterface& c);
virtual void version(CmdLineInterface &c);
/**
* Prints (to stderr) an error message, short usage
@ -65,46 +63,44 @@ class DocBookOutput : public CmdLineOutput
* \param c - The CmdLine object the output is generated for.
* \param e - The ArgException that caused the failure.
*/
virtual void failure(CmdLineInterface& c,
ArgException& e );
virtual void failure(CmdLineInterface &c, ArgException &e);
protected:
/**
* Substitutes the char r for string x in string s.
* \param s - The string to operate on.
* \param r - The char to replace.
* \param x - What to replace r with.
*/
void substituteSpecialChars( std::string& s, char r, std::string& x );
void removeChar( std::string& s, char r);
void basename( std::string& s );
void substituteSpecialChars(std::string &s, char r, std::string &x);
void removeChar(std::string &s, char r);
void basename(std::string &s);
void printShortArg(Arg* it);
void printLongArg(Arg* it);
void printShortArg(Arg *it);
void printLongArg(Arg *it);
char theDelimiter;
};
};
inline void DocBookOutput::version(CmdLineInterface& _cmd)
{
inline void DocBookOutput::version(CmdLineInterface &_cmd)
{
std::cout << _cmd.getVersion() << std::endl;
}
}
inline void DocBookOutput::usage(CmdLineInterface& _cmd )
{
inline void DocBookOutput::usage(CmdLineInterface &_cmd)
{
std::list<Arg*> argList = _cmd.getArgList();
std::string progName = _cmd.getProgramName();
std::string version = _cmd.getVersion();
theDelimiter = _cmd.getDelimiter();
XorHandler xorHandler = _cmd.getXorHandler();
std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
std::vector<std::vector<Arg*>> xorList = xorHandler.getXorList();
basename(progName);
std::cout << "<?xml version='1.0'?>" << std::endl;
std::cout << "<!DOCTYPE refentry PUBLIC \"-//OASIS//DTD DocBook XML V4.2//EN\"" << std::endl;
std::cout << "\t\"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd\">" << std::endl << std::endl;
std::cout << "\t\"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd\">" << std::endl <<
std::endl;
std::cout << "<refentry>" << std::endl;
@ -124,20 +120,26 @@ inline void DocBookOutput::usage(CmdLineInterface& _cmd )
std::cout << "<command>" << progName << "</command>" << std::endl;
// xor
for ( int i = 0; (unsigned int)i < xorList.size(); i++ )
for (int i = 0; (unsigned int)i < xorList.size(); i++)
{
std::cout << "<group choice='req'>" << std::endl;
for ( ArgVectorIterator it = xorList[i].begin();
it != xorList[i].end(); it++ )
for (ArgVectorIterator it = xorList[i].begin();
it != xorList[i].end(); it++)
{
printShortArg((*it));
}
std::cout << "</group>" << std::endl;
}
// rest of args
for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
if ( !xorHandler.contains( (*it) ) )
{
if (!xorHandler.contains((*it)))
{
printShortArg((*it));
}
}
std::cout << "</cmdsynopsis>" << std::endl;
std::cout << "</refsynopsisdiv>" << std::endl;
@ -155,7 +157,9 @@ inline void DocBookOutput::usage(CmdLineInterface& _cmd )
std::cout << "<variablelist>" << std::endl;
for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
{
printLongArg((*it));
}
std::cout << "</variablelist>" << std::endl;
std::cout << "</refsect1>" << std::endl;
@ -168,99 +172,101 @@ inline void DocBookOutput::usage(CmdLineInterface& _cmd )
std::cout << "</refsect1>" << std::endl;
std::cout << "</refentry>" << std::endl;
}
}
inline void DocBookOutput::failure( CmdLineInterface& _cmd,
ArgException& e )
{
inline void DocBookOutput::failure(CmdLineInterface &_cmd, ArgException &e)
{
static_cast<void>(_cmd); // unused
std::cout << e.what() << std::endl;
throw ExitException(1);
}
}
inline void DocBookOutput::substituteSpecialChars( std::string& s,
char r,
std::string& x )
{
inline void DocBookOutput::substituteSpecialChars(std::string &s, char r, std::string &x)
{
size_t p;
while ( (p = s.find_first_of(r)) != std::string::npos )
while ((p = s.find_first_of(r)) != std::string::npos)
{
s.erase(p,1);
s.insert(p,x);
s.erase(p, 1);
s.insert(p, x);
}
}
}
inline void DocBookOutput::removeChar( std::string& s, char r)
{
inline void DocBookOutput::removeChar(std::string &s, char r)
{
size_t p;
while ( (p = s.find_first_of(r)) != std::string::npos )
while ((p = s.find_first_of(r)) != std::string::npos)
{
s.erase(p,1);
s.erase(p, 1);
}
}
}
inline void DocBookOutput::basename( std::string& s )
{
inline void DocBookOutput::basename(std::string &s)
{
size_t p = s.find_last_of('/');
if ( p != std::string::npos )
if (p != std::string::npos)
{
s.erase(0, p + 1);
}
}
}
inline void DocBookOutput::printShortArg(Arg* a)
{
inline void DocBookOutput::printShortArg(Arg *a)
{
std::string lt = "&lt;";
std::string gt = "&gt;";
std::string id = a->shortID();
substituteSpecialChars(id,'<',lt);
substituteSpecialChars(id,'>',gt);
removeChar(id,'[');
removeChar(id,']');
substituteSpecialChars(id, '<', lt);
substituteSpecialChars(id, '>', gt);
removeChar(id, '[');
removeChar(id, ']');
std::string choice = "opt";
if ( a->isRequired() )
if (a->isRequired())
{
choice = "plain";
}
std::cout << "<arg choice='" << choice << '\'';
if ( a->acceptsMultipleValues() )
if (a->acceptsMultipleValues())
{
std::cout << " rep='repeat'";
}
std::cout << '>';
if ( !a->getFlag().empty() )
if (!a->getFlag().empty())
{
std::cout << a->flagStartChar() << a->getFlag();
}
else
{
std::cout << a->nameStartString() << a->getName();
if ( a->isValueRequired() )
}
if (a->isValueRequired())
{
std::string arg = a->shortID();
removeChar(arg,'[');
removeChar(arg,']');
removeChar(arg,'<');
removeChar(arg,'>');
removeChar(arg, '[');
removeChar(arg, ']');
removeChar(arg, '<');
removeChar(arg, '>');
arg.erase(0, arg.find_last_of(theDelimiter) + 1);
std::cout << theDelimiter;
std::cout << "<replaceable>" << arg << "</replaceable>";
}
std::cout << "</arg>" << std::endl;
}
}
inline void DocBookOutput::printLongArg(Arg* a)
{
inline void DocBookOutput::printLongArg(Arg *a)
{
std::string lt = "&lt;";
std::string gt = "&gt;";
std::string desc = a->getDescription();
substituteSpecialChars(desc,'<',lt);
substituteSpecialChars(desc,'>',gt);
substituteSpecialChars(desc, '<', lt);
substituteSpecialChars(desc, '>', gt);
std::cout << "<varlistentry>" << std::endl;
if ( !a->getFlag().empty() )
if (!a->getFlag().empty())
{
std::cout << "<term>" << std::endl;
std::cout << "<option>";
@ -272,13 +278,13 @@ inline void DocBookOutput::printLongArg(Arg* a)
std::cout << "<term>" << std::endl;
std::cout << "<option>";
std::cout << a->nameStartString() << a->getName();
if ( a->isValueRequired() )
if (a->isValueRequired())
{
std::string arg = a->shortID();
removeChar(arg,'[');
removeChar(arg,']');
removeChar(arg,'<');
removeChar(arg,'>');
removeChar(arg, '[');
removeChar(arg, ']');
removeChar(arg, '<');
removeChar(arg, '>');
arg.erase(0, arg.find_last_of(theDelimiter) + 1);
std::cout << theDelimiter;
std::cout << "<replaceable>" << arg << "</replaceable>";
@ -293,7 +299,7 @@ inline void DocBookOutput::printLongArg(Arg* a)
std::cout << "</listitem>" << std::endl;
std::cout << "</varlistentry>" << std::endl;
}
}
} //namespace TCLAP
#endif

33
src/tclap/HelpVisitor.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: HelpVisitor.h
@ -26,44 +25,46 @@
#include <tclap/CmdLineOutput.h>
#include <tclap/Visitor.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A Visitor object that calls the usage method of the given CmdLineOutput
* object for the specified CmdLine object.
*/
class HelpVisitor: public Visitor
{
class HelpVisitor : public Visitor
{
protected:
/**
* The CmdLine the output will be generated for.
*/
CmdLineInterface* _cmd;
CmdLineInterface *_cmd;
/**
* The output object.
*/
CmdLineOutput** _out;
CmdLineOutput **_out;
public:
/**
* Constructor.
* \param cmd - The CmdLine the output will be generated for.
* \param out - The type of output.
*/
HelpVisitor(CmdLineInterface* cmd, CmdLineOutput** out)
: Visitor(), _cmd( cmd ), _out( out ) { }
HelpVisitor(CmdLineInterface *cmd, CmdLineOutput **out) :
Visitor(), _cmd(cmd), _out(out)
{
}
/**
* Calls the usage method of the CmdLineOutput for the
* specified CmdLine.
*/
void visit() { (*_out)->usage(*_cmd); throw ExitException(0); }
};
void visit()
{
(*_out)->usage(*_cmd);
throw ExitException(0);
}
};
}
#endif

25
src/tclap/IgnoreRestVisitor.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: IgnoreRestVisitor.h
@ -26,27 +25,31 @@
#include <tclap/Visitor.h>
#include <tclap/Arg.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A Vistor that tells the CmdLine to begin ignoring arguments after
* this one is parsed.
*/
class IgnoreRestVisitor: public Visitor
{
class IgnoreRestVisitor : public Visitor
{
public:
/**
* Constructor.
*/
IgnoreRestVisitor() : Visitor() {}
IgnoreRestVisitor() :
Visitor()
{
}
/**
* Sets Arg::_ignoreRest.
*/
void visit() { Arg::beginIgnoring(); }
};
void visit()
{
Arg::beginIgnoring();
}
};
}
#endif

309
src/tclap/MultiArg.h
Unescape Escape View File

@ -29,22 +29,22 @@
#include <tclap/Arg.h>
#include <tclap/Constraint.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* An argument that allows multiple values of type T to be specified. Very
* similar to a ValueArg, except a vector of values will be returned
* instead of just one.
*/
template<class T>
class MultiArg : public Arg
{
public:
template<class T>
class MultiArg : public Arg
{
public:
typedef std::vector<T> container_type;
typedef typename container_type::iterator iterator;
typedef typename container_type::const_iterator const_iterator;
protected:
protected:
/**
* The list of values parsed from the CmdLine.
*/
@ -58,7 +58,7 @@ protected:
/**
* A list of constraint on this Arg.
*/
Constraint<T>* _constraint;
Constraint<T> *_constraint;
/**
* Extracts the value from the string.
@ -66,15 +66,14 @@ protected:
* is thrown.
* \param val - The string to be read.
*/
void _extractValue( const std::string& val );
void _extractValue(const std::string &val);
/**
* Used by XorHandler to decide whether to keep parsing for this arg.
*/
bool _allowMore;
public:
public:
/**
* Constructor.
* \param flag - The one character flag that identifies this
@ -92,12 +91,8 @@ public:
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
MultiArg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
const std::string& typeDesc,
Visitor* v = NULL);
MultiArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
const std::string &typeDesc, Visitor *v = NULL);
/**
* Constructor.
@ -117,13 +112,8 @@ public:
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
MultiArg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
const std::string& typeDesc,
CmdLineInterface& parser,
Visitor* v = NULL );
MultiArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
const std::string &typeDesc, CmdLineInterface &parser, Visitor *v = NULL);
/**
* Constructor.
@ -140,12 +130,8 @@ public:
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
MultiArg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
Constraint<T>* constraint,
Visitor* v = NULL );
MultiArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
Constraint<T> *constraint, Visitor *v = NULL);
/**
* Constructor.
@ -163,13 +149,8 @@ public:
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
MultiArg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
Constraint<T>* constraint,
CmdLineInterface& parser,
Visitor* v = NULL );
MultiArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
Constraint<T> *constraint, CmdLineInterface &parser, Visitor *v = NULL);
/**
* Handles the processing of the argument.
@ -179,7 +160,7 @@ public:
* \param i - Pointer the the current argument in the list.
* \param args - Mutable list of strings. Passed from main().
*/
virtual bool processArg(int* i, std::vector<std::string>& args);
virtual bool processArg(int *i, std::vector<std::string> &args);
/**
* Returns a vector of type T containing the values parsed from
@ -191,25 +172,31 @@ public:
* Returns an iterator over the values parsed from the command
* line.
*/
const_iterator begin() const { return _values.begin(); }
const_iterator begin() const
{
return _values.begin();
}
/**
* Returns the end of the values parsed from the command
* line.
*/
const_iterator end() const { return _values.end(); }
const_iterator end() const
{
return _values.end();
}
/**
* Returns the a short id string. Used in the usage.
* \param val - value to be used.
*/
virtual std::string shortID(const std::string& val="val") const;
virtual std::string shortID(const std::string &val = "val") const;
/**
* Returns the a long id string. Used in the usage.
* \param val - value to be used.
*/
virtual std::string longID(const std::string& val="val") const;
virtual std::string longID(const std::string &val = "val") const;
/**
* Once we've matched the first value, then the arg is no longer
@ -220,112 +207,97 @@ public:
virtual bool allowMore();
virtual void reset();
};
};
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
const std::string& typeDesc,
Visitor* v)
: Arg( flag, name, desc, req, true, v ),
_typeDesc( typeDesc ),
_constraint( NULL ),
_allowMore(false)
{
template<class T>
MultiArg<T>::MultiArg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, const std::string &typeDesc, Visitor *v) :
Arg(flag, name, desc, req, true, v), _typeDesc(typeDesc), _constraint(NULL), _allowMore(false)
{
_acceptsMultipleValues = true;
}
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
const std::string& typeDesc,
CmdLineInterface& parser,
Visitor* v)
: Arg( flag, name, desc, req, true, v ),
_typeDesc( typeDesc ),
_constraint( NULL ),
_allowMore(false)
{
parser.add( this );
}
template<class T>
MultiArg<T>::MultiArg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, const std::string &typeDesc, CmdLineInterface &parser,
Visitor *v) :
Arg(flag, name, desc, req, true, v), _typeDesc(typeDesc), _constraint(NULL), _allowMore(false)
{
parser.add(this);
_acceptsMultipleValues = true;
}
}
/**
/**
*
*/
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
Constraint<T>* constraint,
Visitor* v)
: Arg( flag, name, desc, req, true, v ),
_typeDesc( constraint->shortID() ),
_constraint( constraint ),
_allowMore(false)
{
template<class T>
MultiArg<T>::MultiArg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, Constraint<T> *constraint, Visitor *v) :
Arg(flag, name, desc, req, true, v), _typeDesc(constraint->shortID()),
_constraint(constraint), _allowMore(false)
{
_acceptsMultipleValues = true;
}
template<class T>
MultiArg<T>::MultiArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
Constraint<T>* constraint,
CmdLineInterface& parser,
Visitor* v)
: Arg( flag, name, desc, req, true, v ),
_typeDesc( constraint->shortID() ),
_constraint( constraint ),
_allowMore(false)
{
parser.add( this );
}
template<class T>
MultiArg<T>::MultiArg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, Constraint<T> *constraint, CmdLineInterface &parser, Visitor *v) :
Arg(flag, name, desc, req, true, v), _typeDesc(constraint->shortID()),
_constraint(constraint), _allowMore(false)
{
parser.add(this);
_acceptsMultipleValues = true;
}
}
template<class T>
const std::vector<T>& MultiArg<T>::getValue() { return _values; }
template<class T>
const std::vector<T>& MultiArg<T>::getValue()
{
return _values;
}
template<class T>
bool MultiArg<T>::processArg(int *i, std::vector<std::string>& args)
{
if ( _ignoreable && Arg::ignoreRest() )
template<class T>
bool MultiArg<T>::processArg(int *i, std::vector<std::string> &args)
{
if (_ignoreable && Arg::ignoreRest())
{
return false;
}
if ( _hasBlanks( args[*i] ) )
if (_hasBlanks(args[*i]))
{
return false;
}
std::string flag = args[*i];
std::string value = "";
trimFlag( flag, value );
trimFlag(flag, value);
if ( argMatches( flag ) )
if (argMatches(flag))
{
if ( Arg::delimiter() != ' ' && value == "" )
throw( ArgParseException(
"Couldn't find delimiter for this argument!",
toString() ) );
if (Arg::delimiter() != ' ' && value == "")
{
throw (ArgParseException(
"Couldn't find delimiter for this argument!", toString()));
}
// always take the first one, regardless of start string
if ( value == "" )
if (value == "")
{
(*i)++;
if ( static_cast<unsigned int>(*i) < args.size() )
_extractValue( args[*i] );
if (static_cast<unsigned int>(*i) < args.size())
{
_extractValue(args[*i]);
}
else
throw( ArgParseException("Missing a value for this argument!",
toString() ) );
{
throw (ArgParseException("Missing a value for this argument!", toString()));
}
}
else
_extractValue( value );
{
_extractValue(value);
}
/*
// continuing taking the args until we hit one with a start string
@ -341,82 +313,93 @@ bool MultiArg<T>::processArg(int *i, std::vector<std::string>& args)
return true;
}
else
{
return false;
}
}
}
/**
/**
*
*/
template<class T>
std::string MultiArg<T>::shortID(const std::string& val) const
{
template<class T>
std::string MultiArg<T>::shortID(const std::string &val) const
{
static_cast<void>(val); // Ignore input, don't warn
return Arg::shortID(_typeDesc) + " ... ";
}
}
/**
/**
*
*/
template<class T>
std::string MultiArg<T>::longID(const std::string& val) const
{
template<class T>
std::string MultiArg<T>::longID(const std::string &val) const
{
static_cast<void>(val); // Ignore input, don't warn
return Arg::longID(_typeDesc) + " (accepted multiple times)";
}
}
/**
/**
* Once we've matched the first value, then the arg is no longer
* required.
*/
template<class T>
bool MultiArg<T>::isRequired() const
{
if ( _required )
template<class T>
bool MultiArg<T>::isRequired() const
{
if (_required)
{
if (_values.size() > 1)
{
if ( _values.size() > 1 )
return false;
}
else
{
return true;
}
}
else
{
return false;
}
}
}
template<class T>
void MultiArg<T>::_extractValue( const std::string& val )
{
try {
template<class T>
void MultiArg<T>::_extractValue(const std::string &val)
{
try
{
T tmp;
ExtractValue(tmp, val, typename ArgTraits<T>::ValueCategory());
_values.push_back(tmp);
} catch( ArgParseException &e) {
}
catch (ArgParseException &e)
{
throw ArgParseException(e.error(), toString());
}
if ( _constraint != NULL )
if ( ! _constraint->check( _values.back() ) )
throw( CmdLineParseException( "Value '" + val +
"' does not meet constraint: " +
_constraint->description(),
toString() ) );
}
if (_constraint != NULL)
{
if (!_constraint->check(_values.back()))
{
throw (CmdLineParseException("Value '" + val + "' does not meet constraint: " +
_constraint->description(), toString()));
}
}
}
template<class T>
bool MultiArg<T>::allowMore()
{
template<class T>
bool MultiArg<T>::allowMore()
{
bool am = _allowMore;
_allowMore = true;
return am;
}
}
template<class T>
void MultiArg<T>::reset()
{
template<class T>
void MultiArg<T>::reset()
{
Arg::reset();
_values.clear();
}
}
} // namespace TCLAP
#endif

135
src/tclap/MultiSwitchArg.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: MultiSwitchArg.h
@ -30,16 +29,15 @@
#include <tclap/SwitchArg.h>
namespace TCLAP {
/**
* A multiple switch argument. If the switch is set on the command line, then
* the getValue method will return the number of times the switch appears.
*/
class MultiSwitchArg : public SwitchArg
namespace TCLAP
{
/**
* A multiple switch argument. If the switch is set on the command line, then
* the getValue method will return the number of times the switch appears.
*/
class MultiSwitchArg : public SwitchArg
{
protected:
/**
* The value of the switch.
*/
@ -52,7 +50,6 @@ class MultiSwitchArg : public SwitchArg
int _default;
public:
/**
* MultiSwitchArg constructor.
* \param flag - The one character flag that identifies this
@ -66,11 +63,8 @@ class MultiSwitchArg : public SwitchArg
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
MultiSwitchArg(const std::string& flag,
const std::string& name,
const std::string& desc,
int init = 0,
Visitor* v = NULL);
MultiSwitchArg(const std::string &flag, const std::string &name, const std::string &desc,
int init = 0, Visitor *v = NULL);
/**
@ -87,12 +81,8 @@ class MultiSwitchArg : public SwitchArg
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
MultiSwitchArg(const std::string& flag,
const std::string& name,
const std::string& desc,
CmdLineInterface& parser,
int init = 0,
Visitor* v = NULL);
MultiSwitchArg(const std::string &flag, const std::string &name, const std::string &desc,
CmdLineInterface &parser, int init = 0, Visitor *v = NULL);
/**
@ -103,7 +93,7 @@ class MultiSwitchArg : public SwitchArg
* \param args - Mutable list of strings. Passed
* in from main().
*/
virtual bool processArg(int* i, std::vector<std::string>& args);
virtual bool processArg(int *i, std::vector<std::string> &args);
/**
* Returns int, the number of times the switch has been set.
@ -113,51 +103,46 @@ class MultiSwitchArg : public SwitchArg
/**
* Returns the shortID for this Arg.
*/
std::string shortID(const std::string& val) const;
std::string shortID(const std::string &val) const;
/**
* Returns the longID for this Arg.
*/
std::string longID(const std::string& val) const;
std::string longID(const std::string &val) const;
void reset();
};
//////////////////////////////////////////////////////////////////////
//BEGIN MultiSwitchArg.cpp
//////////////////////////////////////////////////////////////////////
inline MultiSwitchArg::MultiSwitchArg(const std::string &flag, const std::string &name,
const std::string &desc, int init, Visitor *v) :
SwitchArg(flag, name, desc, false, v), _value(init), _default(init)
{
}
};
//////////////////////////////////////////////////////////////////////
//BEGIN MultiSwitchArg.cpp
//////////////////////////////////////////////////////////////////////
inline MultiSwitchArg::MultiSwitchArg(const std::string& flag,
const std::string& name,
const std::string& desc,
int init,
Visitor* v )
: SwitchArg(flag, name, desc, false, v),
_value( init ),
_default( init )
{ }
inline MultiSwitchArg::MultiSwitchArg(const std::string& flag,
const std::string& name,
const std::string& desc,
CmdLineInterface& parser,
int init,
Visitor* v )
: SwitchArg(flag, name, desc, false, v),
_value( init ),
_default( init )
{
parser.add( this );
}
inline MultiSwitchArg::MultiSwitchArg(const std::string &flag, const std::string &name,
const std::string &desc, CmdLineInterface &parser, int init,
Visitor *v) :
SwitchArg(flag, name, desc, false, v), _value(init), _default(init)
{
parser.add(this);
}
inline int MultiSwitchArg::getValue() { return _value; }
inline int MultiSwitchArg::getValue()
{
return _value;
}
inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string>& args)
{
if ( _ignoreable && Arg::ignoreRest() )
inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string> &args)
{
if (_ignoreable && Arg::ignoreRest())
{
return false;
}
if ( argMatches( args[*i] ))
if (argMatches(args[*i]))
{
// so the isSet() method will work
_alreadySet = true;
@ -169,7 +154,7 @@ inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string>& args)
return true;
}
else if ( combinedSwitchesMatch( args[*i] ) )
else if (combinedSwitchesMatch(args[*i]))
{
// so the isSet() method will work
_alreadySet = true;
@ -178,39 +163,39 @@ inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string>& args)
++_value;
// Check for more in argument and increment value.
while ( combinedSwitchesMatch( args[*i] ) )
while (combinedSwitchesMatch(args[*i]))
{
++_value;
}
_checkWithVisitor();
return false;
}
else
{
return false;
}
}
}
inline std::string
MultiSwitchArg::shortID(const std::string& val) const
{
inline std::string MultiSwitchArg::shortID(const std::string &val) const
{
return Arg::shortID(val) + " ... ";
}
}
inline std::string
MultiSwitchArg::longID(const std::string& val) const
{
inline std::string MultiSwitchArg::longID(const std::string &val) const
{
return Arg::longID(val) + " (accepted multiple times)";
}
}
inline void
MultiSwitchArg::reset()
{
inline void MultiSwitchArg::reset()
{
MultiSwitchArg::_value = MultiSwitchArg::_default;
}
//////////////////////////////////////////////////////////////////////
//END MultiSwitchArg.cpp
//////////////////////////////////////////////////////////////////////
}
//////////////////////////////////////////////////////////////////////
//END MultiSwitchArg.cpp
//////////////////////////////////////////////////////////////////////
} //namespace TCLAP
#endif

56
src/tclap/OptionalUnlabeledTracker.h
Unescape Escape View File

@ -1,5 +1,3 @@
/******************************************************************************
*
* file: OptionalUnlabeledTracker.h
@ -26,37 +24,45 @@
#include <string>
namespace TCLAP {
class OptionalUnlabeledTracker
namespace TCLAP
{
class OptionalUnlabeledTracker
{
public:
static void check(bool req, const std::string &argName);
static void check( bool req, const std::string& argName );
static void gotOptional()
{
alreadyOptionalRef() = true;
}
static void gotOptional() { alreadyOptionalRef() = true; }
static bool& alreadyOptional() { return alreadyOptionalRef(); }
static bool& alreadyOptional()
{
return alreadyOptionalRef();
}
private:
static bool& alreadyOptionalRef() { static bool ct = false; return ct; }
};
inline void OptionalUnlabeledTracker::check( bool req, const std::string& argName )
{
if ( OptionalUnlabeledTracker::alreadyOptional() )
throw( SpecificationException(
"You can't specify ANY Unlabeled Arg following an optional Unlabeled Arg",
argName ) );
if ( !req )
static bool& alreadyOptionalRef()
{
static bool ct = false;
return ct;
}
};
inline void OptionalUnlabeledTracker::check(bool req, const std::string &argName)
{
if (OptionalUnlabeledTracker::alreadyOptional())
{
throw (SpecificationException(
"You can't specify ANY Unlabeled Arg following an optional Unlabeled Arg", argName));
}
if (!req)
{
OptionalUnlabeledTracker::gotOptional();
}
}
}
} // namespace TCLAP
#endif

180
src/tclap/StandardTraits.h
Unescape Escape View File

@ -27,160 +27,174 @@
#define TCLAP_STANDARD_TRAITS_H
#ifdef HAVE_CONFIG_H
#include <config.h> // To check for long long
#include <config.h> // To check for long long
#endif
namespace TCLAP {
// ======================================================================
// Integer types
// ======================================================================
namespace TCLAP
{
// ======================================================================
// Integer types
// ======================================================================
/**
/**
* longs have value-like semantics.
*/
template<>
struct ArgTraits<long> {
template<>
struct ArgTraits<long>
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* ints have value-like semantics.
*/
template<>
struct ArgTraits<int> {
template<>
struct ArgTraits<int>
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* shorts have value-like semantics.
*/
template<>
struct ArgTraits<short> {
template<>
struct ArgTraits<short>
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* chars have value-like semantics.
*/
template<>
struct ArgTraits<char> {
template<>
struct ArgTraits<char>
{
typedef ValueLike ValueCategory;
};
};
#ifdef HAVE_LONG_LONG
/**
/**
* long longs have value-like semantics.
*/
template<>
struct ArgTraits<long long> {
template<>
struct ArgTraits<long long>
{
typedef ValueLike ValueCategory;
};
};
#endif
// ======================================================================
// Unsigned integer types
// ======================================================================
// ======================================================================
// Unsigned integer types
// ======================================================================
/**
/**
* unsigned longs have value-like semantics.
*/
template<>
struct ArgTraits<unsigned long> {
template<>
struct ArgTraits<unsigned long>
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* unsigned ints have value-like semantics.
*/
template<>
struct ArgTraits<unsigned int> {
template<>
struct ArgTraits<unsigned int>
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* unsigned shorts have value-like semantics.
*/
template<>
struct ArgTraits<unsigned short> {
template<>
struct ArgTraits<unsigned short>
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* unsigned chars have value-like semantics.
*/
template<>
struct ArgTraits<unsigned char> {
template<>
struct ArgTraits<unsigned char>
{
typedef ValueLike ValueCategory;
};
};
#ifdef HAVE_LONG_LONG
/**
/**
* unsigned long longs have value-like semantics.
*/
template<>
struct ArgTraits<unsigned long long> {
template<>
struct ArgTraits<unsigned long long>
{
typedef ValueLike ValueCategory;
};
};
#endif
// ======================================================================
// Float types
// ======================================================================
// ======================================================================
// Float types
// ======================================================================
/**
/**
* floats have value-like semantics.
*/
template<>
struct ArgTraits<float> {
template<>
struct ArgTraits<float>
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* doubles have value-like semantics.
*/
template<>
struct ArgTraits<double> {
template<>
struct ArgTraits<double>
{
typedef ValueLike ValueCategory;
};
};
// ======================================================================
// Other types
// ======================================================================
// ======================================================================
// Other types
// ======================================================================
/**
/**
* bools have value-like semantics.
*/
template<>
struct ArgTraits<bool> {
template<>
struct ArgTraits<bool>
{
typedef ValueLike ValueCategory;
};
};
/**
/**
* wchar_ts have value-like semantics.
*/
/*
template<>
struct ArgTraits<wchar_t> {
/*
template<>
struct ArgTraits<wchar_t> {
typedef ValueLike ValueCategory;
};
*/
};
*/
/**
/**
* Strings have string like argument traits.
*/
template<>
struct ArgTraits<std::string> {
template<>
struct ArgTraits<std::string>
{
typedef StringLike ValueCategory;
};
};
template<typename T>
void SetString(T &dst, const std::string &src)
{
template<typename T>
void SetString(T &dst, const std::string &src)
{
dst = src;
}
}
} // namespace
#endif

208
src/tclap/StdOutput.h
Unescape Escape View File

@ -34,30 +34,28 @@
#include <tclap/XorHandler.h>
#include <tclap/Arg.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A class that isolates any output from the CmdLine object so that it
* may be easily modified.
*/
class StdOutput : public CmdLineOutput
{
class StdOutput : public CmdLineOutput
{
public:
/**
* Prints the usage to stdout. Can be overridden to
* produce alternative behavior.
* \param c - The CmdLine object the output is generated for.
*/
virtual void usage(CmdLineInterface& c);
virtual void usage(CmdLineInterface &c);
/**
* Prints the version to stdout. Can be overridden
* to produce alternative behavior.
* \param c - The CmdLine object the output is generated for.
*/
virtual void version(CmdLineInterface& c);
virtual void version(CmdLineInterface &c);
/**
* Prints (to stderr) an error message, short usage
@ -65,17 +63,15 @@ class StdOutput : public CmdLineOutput
* \param c - The CmdLine object the output is generated for.
* \param e - The ArgException that caused the failure.
*/
virtual void failure(CmdLineInterface& c,
ArgException& e );
virtual void failure(CmdLineInterface &c, ArgException &e);
protected:
/**
* Writes a brief usage message with short args.
* \param c - The CmdLine object the output is generated for.
* \param os - The stream to write the message to.
*/
void _shortUsage( CmdLineInterface& c, std::ostream& os ) const;
void _shortUsage(CmdLineInterface &c, std::ostream &os) const;
/**
* Writes a longer usage message with long and short args,
@ -83,7 +79,7 @@ class StdOutput : public CmdLineOutput
* \param c - The CmdLine object the output is generated for.
* \param os - The stream to write the message to.
*/
void _longUsage( CmdLineInterface& c, std::ostream& os ) const;
void _longUsage(CmdLineInterface &c, std::ostream &os) const;
/**
* This function inserts line breaks and indents long strings
@ -96,179 +92,189 @@ class StdOutput : public CmdLineOutput
* \param secondLineOffset - The number of spaces to indent the second
* and all subsequent lines in addition to indentSpaces.
*/
void spacePrint( std::ostream& os,
const std::string& s,
int maxWidth,
int indentSpaces,
int secondLineOffset ) const;
void spacePrint(std::ostream &os, const std::string &s, int maxWidth, int indentSpaces,
int secondLineOffset) const;
};
};
inline void StdOutput::version(CmdLineInterface& _cmd)
{
inline void StdOutput::version(CmdLineInterface &_cmd)
{
std::string progName = _cmd.getProgramName();
std::string version = _cmd.getVersion();
std::cout << std::endl << progName << " version: "
<< version << std::endl << std::endl;
}
std::cout << std::endl << progName << " version: " << version << std::endl << std::endl;
}
inline void StdOutput::usage(CmdLineInterface& _cmd )
{
inline void StdOutput::usage(CmdLineInterface &_cmd)
{
std::cout << std::endl << "USAGE: " << std::endl << std::endl;
_shortUsage( _cmd, std::cout );
_shortUsage(_cmd, std::cout);
std::cout << std::endl << std::endl << "Where: " << std::endl << std::endl;
_longUsage( _cmd, std::cout );
_longUsage(_cmd, std::cout);
std::cout << std::endl;
}
}
inline void StdOutput::failure( CmdLineInterface& _cmd,
ArgException& e )
{
inline void StdOutput::failure(CmdLineInterface &_cmd, ArgException &e)
{
std::string progName = _cmd.getProgramName();
std::cerr << "PARSE ERROR: " << e.argId() << std::endl
<< " " << e.error() << std::endl << std::endl;
std::cerr << "PARSE ERROR: " << e.argId() << std::endl << " " << e.error() <<
std::endl << std::endl;
if ( _cmd.hasHelpAndVersion() )
if (_cmd.hasHelpAndVersion())
{
std::cerr << "Brief USAGE: " << std::endl;
_shortUsage( _cmd, std::cerr );
_shortUsage(_cmd, std::cerr);
std::cerr << std::endl << "For complete USAGE and HELP type: "
<< std::endl << " " << progName << " --help"
<< std::endl << std::endl;
std::cerr << std::endl << "For complete USAGE and HELP type: " << std::endl << " " <<
progName << " --help" << std::endl << std::endl;
}
else
{
usage(_cmd);
}
throw ExitException(1);
}
}
inline void
StdOutput::_shortUsage( CmdLineInterface& _cmd,
std::ostream& os ) const
{
inline void StdOutput::_shortUsage(CmdLineInterface &_cmd, std::ostream &os) const
{
std::list<Arg*> argList = _cmd.getArgList();
std::string progName = _cmd.getProgramName();
XorHandler xorHandler = _cmd.getXorHandler();
std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
std::vector<std::vector<Arg*>> xorList = xorHandler.getXorList();
std::string s = progName + " ";
// first the xor
for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
for (int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++)
{
s += " {";
for ( ArgVectorIterator it = xorList[i].begin();
it != xorList[i].end(); it++ )
for (ArgVectorIterator it = xorList[i].begin();
it != xorList[i].end(); it++)
{
s += (*it)->shortID() + "|";
}
s[s.length()-1] = '}';
s[s.length() - 1] = '}';
}
// then the rest
for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
if ( !xorHandler.contains( (*it) ) )
{
if (!xorHandler.contains((*it)))
{
s += " " + (*it)->shortID();
}
}
// if the program name is too long, then adjust the second line offset
int secondLineOffset = static_cast<int>(progName.length()) + 2;
if ( secondLineOffset > 75/2 )
secondLineOffset = static_cast<int>(75/2);
if (secondLineOffset > 75 / 2)
{
secondLineOffset = static_cast<int>(75 / 2);
}
spacePrint( os, s, 75, 3, secondLineOffset );
}
spacePrint(os, s, 75, 3, secondLineOffset);
}
inline void
StdOutput::_longUsage( CmdLineInterface& _cmd,
std::ostream& os ) const
{
inline void StdOutput::_longUsage(CmdLineInterface &_cmd, std::ostream &os) const
{
std::list<Arg*> argList = _cmd.getArgList();
std::string message = _cmd.getMessage();
XorHandler xorHandler = _cmd.getXorHandler();
std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
std::vector<std::vector<Arg*>> xorList = xorHandler.getXorList();
// first the xor
for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
for (int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++)
{
for ( ArgVectorIterator it = xorList[i].begin();
for (ArgVectorIterator it = xorList[i].begin();
it != xorList[i].end();
it++ )
it++)
{
spacePrint( os, (*it)->longID(), 75, 3, 3 );
spacePrint( os, (*it)->getDescription(), 75, 5, 0 );
spacePrint(os, (*it)->longID(), 75, 3, 3);
spacePrint(os, (*it)->getDescription(), 75, 5, 0);
if ( it+1 != xorList[i].end() )
if (it + 1 != xorList[i].end())
{
spacePrint(os, "-- OR --", 75, 9, 0);
}
}
os << std::endl << std::endl;
}
// then the rest
for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
if ( !xorHandler.contains( (*it) ) )
{
spacePrint( os, (*it)->longID(), 75, 3, 3 );
spacePrint( os, (*it)->getDescription(), 75, 5, 0 );
if (!xorHandler.contains((*it)))
{
spacePrint(os, (*it)->longID(), 75, 3, 3);
spacePrint(os, (*it)->getDescription(), 75, 5, 0);
os << std::endl;
}
}
os << std::endl;
spacePrint( os, message, 75, 3, 0 );
}
spacePrint(os, message, 75, 3, 0);
}
inline void StdOutput::spacePrint( std::ostream& os,
const std::string& s,
int maxWidth,
int indentSpaces,
int secondLineOffset ) const
{
inline void StdOutput::spacePrint(std::ostream &os, const std::string &s, int maxWidth,
int indentSpaces, int secondLineOffset) const
{
int len = static_cast<int>(s.length());
if ( (len + indentSpaces > maxWidth) && maxWidth > 0 )
if ((len + indentSpaces > maxWidth) && maxWidth > 0)
{
int allowedLen = maxWidth - indentSpaces;
int start = 0;
while ( start < len )
while (start < len)
{
// find the substring length
// int stringLen = std::min<int>( len - start, allowedLen );
// doing it this way to support a VisualC++ 2005 bug
using namespace std;
int stringLen = min<int>( len - start, allowedLen );
int stringLen = min<int>(len - start, allowedLen);
// trim the length so it doesn't end in middle of a word
if ( stringLen == allowedLen )
while ( stringLen >= 0 &&
s[stringLen+start] != ' ' &&
s[stringLen+start] != ',' &&
s[stringLen+start] != '|' )
if (stringLen == allowedLen)
{
while (stringLen >= 0 &&
s[stringLen + start] != ' ' &&
s[stringLen + start] != ',' &&
s[stringLen + start] != '|')
{
stringLen--;
}
}
// ok, the word is longer than the line, so just split
// wherever the line ends
if ( stringLen <= 0 )
if (stringLen <= 0)
{
stringLen = allowedLen;
}
// check for newlines
for ( int i = 0; i < stringLen; i++ )
if ( s[start+i] == '\n' )
stringLen = i+1;
for (int i = 0; i < stringLen; i++)
{
if (s[start + i] == '\n')
{
stringLen = i + 1;
}
}
// print the indent
for ( int i = 0; i < indentSpaces; i++ )
for (int i = 0; i < indentSpaces; i++)
{
os << " ";
}
if ( start == 0 )
if (start == 0)
{
// handle second line offsets
indentSpaces += secondLineOffset;
@ -277,22 +283,26 @@ inline void StdOutput::spacePrint( std::ostream& os,
allowedLen -= secondLineOffset;
}
os << s.substr(start,stringLen) << std::endl;
os << s.substr(start, stringLen) << std::endl;
// so we don't start a line with a space
while ( s[stringLen+start] == ' ' && start < len )
while (s[stringLen + start] == ' ' && start < len)
{
start++;
}
start += stringLen;
}
}
else
{
for ( int i = 0; i < indentSpaces; i++ )
for (int i = 0; i < indentSpaces; i++)
{
os << " ";
}
os << s << std::endl;
}
}
}
} //namespace TCLAP
#endif

153
src/tclap/SwitchArg.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: SwitchArg.h
@ -29,17 +28,16 @@
#include <tclap/Arg.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A simple switch argument. If the switch is set on the command line, then
* the getValue method will return the opposite of the default value for the
* switch.
*/
class SwitchArg : public Arg
{
class SwitchArg : public Arg
{
protected:
/**
* The value of the switch.
*/
@ -52,7 +50,6 @@ class SwitchArg : public Arg
bool _default;
public:
/**
* SwitchArg constructor.
* \param flag - The one character flag that identifies this
@ -65,11 +62,8 @@ class SwitchArg : public Arg
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
SwitchArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool def = false,
Visitor* v = NULL);
SwitchArg(const std::string &flag, const std::string &name, const std::string &desc,
bool def = false, Visitor *v = NULL);
/**
@ -85,12 +79,8 @@ class SwitchArg : public Arg
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
SwitchArg(const std::string& flag,
const std::string& name,
const std::string& desc,
CmdLineInterface& parser,
bool def = false,
Visitor* v = NULL);
SwitchArg(const std::string &flag, const std::string &name, const std::string &desc,
CmdLineInterface &parser, bool def = false, Visitor *v = NULL);
/**
@ -101,13 +91,13 @@ class SwitchArg : public Arg
* \param args - Mutable list of strings. Passed
* in from main().
*/
virtual bool processArg(int* i, std::vector<std::string>& args);
virtual bool processArg(int *i, std::vector<std::string> &args);
/**
* Checks a string to see if any of the chars in the string
* match the flag for this Switch.
*/
bool combinedSwitchesMatch(std::string& combined);
bool combinedSwitchesMatch(std::string &combined);
/**
* Returns bool, whether or not the switch has been set.
@ -115,59 +105,58 @@ class SwitchArg : public Arg
bool getValue();
virtual void reset();
};
//////////////////////////////////////////////////////////////////////
//BEGIN SwitchArg.cpp
//////////////////////////////////////////////////////////////////////
inline SwitchArg::SwitchArg(const std::string &flag, const std::string &name,
const std::string &desc, bool default_val, Visitor *v) :
Arg(flag, name, desc, false, false, v), _value(default_val), _default(default_val)
{
}
};
//////////////////////////////////////////////////////////////////////
//BEGIN SwitchArg.cpp
//////////////////////////////////////////////////////////////////////
inline SwitchArg::SwitchArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool default_val,
Visitor* v )
: Arg(flag, name, desc, false, false, v),
_value( default_val ),
_default( default_val )
{ }
inline SwitchArg::SwitchArg(const std::string& flag,
const std::string& name,
const std::string& desc,
CmdLineInterface& parser,
bool default_val,
Visitor* v )
: Arg(flag, name, desc, false, false, v),
_value( default_val ),
_default(default_val)
{
parser.add( this );
}
inline SwitchArg::SwitchArg(const std::string &flag, const std::string &name,
const std::string &desc, CmdLineInterface &parser, bool default_val,
Visitor *v) :
Arg(flag, name, desc, false, false, v), _value(default_val), _default(default_val)
{
parser.add(this);
}
inline bool SwitchArg::getValue() { return _value; }
inline bool SwitchArg::getValue()
{
return _value;
}
inline bool SwitchArg::combinedSwitchesMatch(std::string& combinedSwitches )
{
inline bool SwitchArg::combinedSwitchesMatch(std::string &combinedSwitches)
{
// make sure this is actually a combined switch
if ( combinedSwitches.length() > 0 &&
combinedSwitches[0] != Arg::flagStartString()[0] )
if (combinedSwitches.length() > 0 &&
combinedSwitches[0] != Arg::flagStartString()[0])
{
return false;
}
// make sure it isn't a long name
if ( combinedSwitches.substr( 0, Arg::nameStartString().length() ) ==
Arg::nameStartString() )
if (combinedSwitches.substr(0, Arg::nameStartString().length()) == Arg::nameStartString())
{
return false;
}
// make sure the delimiter isn't in the string
if ( combinedSwitches.find_first_of( Arg::delimiter() ) != std::string::npos )
if (combinedSwitches.find_first_of(Arg::delimiter()) != std::string::npos)
{
return false;
}
// ok, we're not specifying a ValueArg, so we know that we have
// a combined switch list.
for ( unsigned int i = 1; i < combinedSwitches.length(); i++ )
if ( _flag.length() > 0 &&
for (unsigned int i = 1; i < combinedSwitches.length(); i++)
{
if (_flag.length() > 0 &&
combinedSwitches[i] == _flag[0] &&
_flag[0] != Arg::flagStartString()[0] )
_flag[0] != Arg::flagStartString()[0])
{
// update the combined switches so this one is no longer present
// this is necessary so that no unlabeled args are matched
@ -176,53 +165,65 @@ inline bool SwitchArg::combinedSwitchesMatch(std::string& combinedSwitches )
combinedSwitches[i] = Arg::blankChar();
return true;
}
}
// none of the switches passed in the list match.
return false;
}
}
inline bool SwitchArg::processArg(int *i, std::vector<std::string>& args)
{
if ( _ignoreable && Arg::ignoreRest() )
inline bool SwitchArg::processArg(int *i, std::vector<std::string> &args)
{
if (_ignoreable && Arg::ignoreRest())
{
return false;
}
if ( argMatches( args[*i] ) || combinedSwitchesMatch( args[*i] ) )
if (argMatches(args[*i]) || combinedSwitchesMatch(args[*i]))
{
// If we match on a combined switch, then we want to return false
// so that other switches in the combination will also have a
// chance to match.
bool ret = false;
if ( argMatches( args[*i] ) )
if (argMatches(args[*i]))
{
ret = true;
}
if ( _alreadySet || ( !ret && combinedSwitchesMatch( args[*i] ) ) )
throw(CmdLineParseException("Argument already set!", toString()));
if (_alreadySet || (!ret && combinedSwitchesMatch(args[*i])))
{
throw (CmdLineParseException("Argument already set!", toString()));
}
_alreadySet = true;
if ( _value == true )
if (_value == true)
{
_value = false;
}
else
{
_value = true;
}
_checkWithVisitor();
return ret;
}
else
{
return false;
}
}
}
inline void SwitchArg::reset()
{
inline void SwitchArg::reset()
{
Arg::reset();
_value = _default;
}
//////////////////////////////////////////////////////////////////////
//End SwitchArg.cpp
//////////////////////////////////////////////////////////////////////
}
//////////////////////////////////////////////////////////////////////
//End SwitchArg.cpp
//////////////////////////////////////////////////////////////////////
} //namespace TCLAP
#endif

209
src/tclap/UnlabeledMultiArg.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: UnlabeledMultiArg.h
@ -29,17 +28,16 @@
#include <tclap/MultiArg.h>
#include <tclap/OptionalUnlabeledTracker.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* Just like a MultiArg, except that the arguments are unlabeled. Basically,
* this Arg will slurp up everything that hasn't been matched to another
* Arg.
*/
template<class T>
class UnlabeledMultiArg : public MultiArg<T>
{
template<class T>
class UnlabeledMultiArg : public MultiArg<T>
{
// If compiler has two stage name lookup (as gcc >= 3.4 does)
// this is requried to prevent undef. symbols
using MultiArg<T>::_ignoreable;
@ -52,7 +50,6 @@ class UnlabeledMultiArg : public MultiArg<T>
using MultiArg<T>::toString;
public:
/**
* Constructor.
* \param name - The name of the Arg. Note that this is used for
@ -70,12 +67,9 @@ class UnlabeledMultiArg : public MultiArg<T>
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
UnlabeledMultiArg( const std::string& name,
const std::string& desc,
bool req,
const std::string& typeDesc,
bool ignoreable = false,
Visitor* v = NULL );
UnlabeledMultiArg(const std::string &name, const std::string &desc, bool req,
const std::string &typeDesc, bool ignoreable = false, Visitor *v = NULL);
/**
* Constructor.
* \param name - The name of the Arg. Note that this is used for
@ -94,13 +88,9 @@ class UnlabeledMultiArg : public MultiArg<T>
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
UnlabeledMultiArg( const std::string& name,
const std::string& desc,
bool req,
const std::string& typeDesc,
CmdLineInterface& parser,
bool ignoreable = false,
Visitor* v = NULL );
UnlabeledMultiArg(const std::string &name, const std::string &desc, bool req,
const std::string &typeDesc, CmdLineInterface &parser,
bool ignoreable = false, Visitor *v = NULL);
/**
* Constructor.
@ -117,12 +107,8 @@ class UnlabeledMultiArg : public MultiArg<T>
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
UnlabeledMultiArg( const std::string& name,
const std::string& desc,
bool req,
Constraint<T>* constraint,
bool ignoreable = false,
Visitor* v = NULL );
UnlabeledMultiArg(const std::string &name, const std::string &desc, bool req,
Constraint<T> *constraint, bool ignoreable = false, Visitor *v = NULL);
/**
* Constructor.
@ -140,13 +126,9 @@ class UnlabeledMultiArg : public MultiArg<T>
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
UnlabeledMultiArg( const std::string& name,
const std::string& desc,
bool req,
Constraint<T>* constraint,
CmdLineInterface& parser,
bool ignoreable = false,
Visitor* v = NULL );
UnlabeledMultiArg(const std::string &name, const std::string &desc, bool req,
Constraint<T> *constraint, CmdLineInterface &parser,
bool ignoreable = false, Visitor *v = NULL);
/**
* Handles the processing of the argument.
@ -156,103 +138,87 @@ class UnlabeledMultiArg : public MultiArg<T>
* \param i - Pointer the the current argument in the list.
* \param args - Mutable list of strings. Passed from main().
*/
virtual bool processArg(int* i, std::vector<std::string>& args);
virtual bool processArg(int *i, std::vector<std::string> &args);
/**
* Returns the a short id string. Used in the usage.
* \param val - value to be used.
*/
virtual std::string shortID(const std::string& val="val") const;
virtual std::string shortID(const std::string &val = "val") const;
/**
* Returns the a long id string. Used in the usage.
* \param val - value to be used.
*/
virtual std::string longID(const std::string& val="val") const;
virtual std::string longID(const std::string &val = "val") const;
/**
* Opertor ==.
* \param a - The Arg to be compared to this.
*/
virtual bool operator==(const Arg& a) const;
virtual bool operator==(const Arg &a) const;
/**
* Pushes this to back of list rather than front.
* \param argList - The list this should be added to.
*/
virtual void addToList( std::list<Arg*>& argList ) const;
};
template<class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
const std::string& desc,
bool req,
const std::string& typeDesc,
bool ignoreable,
Visitor* v)
: MultiArg<T>("", name, desc, req, typeDesc, v)
{
virtual void addToList(std::list<Arg*> &argList) const;
};
template<class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name, const std::string &desc,
bool req, const std::string &typeDesc, bool ignoreable,
Visitor *v) :
MultiArg<T>("", name, desc, req, typeDesc, v)
{
_ignoreable = ignoreable;
OptionalUnlabeledTracker::check(true, toString());
}
template<class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
const std::string& desc,
bool req,
const std::string& typeDesc,
CmdLineInterface& parser,
bool ignoreable,
Visitor* v)
: MultiArg<T>("", name, desc, req, typeDesc, v)
{
}
template<class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name, const std::string &desc,
bool req, const std::string &typeDesc,
CmdLineInterface &parser, bool ignoreable, Visitor *v) :
MultiArg<T>("", name, desc, req, typeDesc, v)
{
_ignoreable = ignoreable;
OptionalUnlabeledTracker::check(true, toString());
parser.add( this );
}
template<class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
const std::string& desc,
bool req,
Constraint<T>* constraint,
bool ignoreable,
Visitor* v)
: MultiArg<T>("", name, desc, req, constraint, v)
{
parser.add(this);
}
template<class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name, const std::string &desc,
bool req, Constraint<T> *constraint, bool ignoreable,
Visitor *v) :
MultiArg<T>("", name, desc, req, constraint, v)
{
_ignoreable = ignoreable;
OptionalUnlabeledTracker::check(true, toString());
}
template<class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
const std::string& desc,
bool req,
Constraint<T>* constraint,
CmdLineInterface& parser,
bool ignoreable,
Visitor* v)
: MultiArg<T>("", name, desc, req, constraint, v)
{
}
template<class T>
UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string &name, const std::string &desc,
bool req, Constraint<T> *constraint,
CmdLineInterface &parser, bool ignoreable, Visitor *v) :
MultiArg<T>("", name, desc, req, constraint, v)
{
_ignoreable = ignoreable;
OptionalUnlabeledTracker::check(true, toString());
parser.add( this );
}
template<class T>
bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string>& args)
{
if ( _hasBlanks( args[*i] ) )
parser.add(this);
}
template<class T>
bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string> &args)
{
if (_hasBlanks(args[*i]))
{
return false;
}
// never ignore an unlabeled multi arg
// always take the first value, regardless of the start string
_extractValue( args[(*i)] );
_extractValue(args[(*i)]);
/*
// continue taking args until we hit the end or a start string
@ -265,37 +231,40 @@ bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string>& args)
_alreadySet = true;
return true;
}
}
template<class T>
std::string UnlabeledMultiArg<T>::shortID(const std::string& val) const
{
template<class T>
std::string UnlabeledMultiArg<T>::shortID(const std::string &val) const
{
static_cast<void>(val); // Ignore input, don't warn
return std::string("<") + _typeDesc + "> ...";
}
}
template<class T>
std::string UnlabeledMultiArg<T>::longID(const std::string& val) const
{
template<class T>
std::string UnlabeledMultiArg<T>::longID(const std::string &val) const
{
static_cast<void>(val); // Ignore input, don't warn
return std::string("<") + _typeDesc + "> (accepted multiple times)";
}
}
template<class T>
bool UnlabeledMultiArg<T>::operator==(const Arg& a) const
{
if ( _name == a.getName() || _description == a.getDescription() )
template<class T>
bool UnlabeledMultiArg<T>::operator==(const Arg &a) const
{
if (_name == a.getName() || _description == a.getDescription())
{
return true;
}
else
{
return false;
}
template<class T>
void UnlabeledMultiArg<T>::addToList( std::list<Arg*>& argList ) const
{
argList.push_back( const_cast<Arg*>(static_cast<const Arg* const>(this)) );
}
}
}
template<class T>
void UnlabeledMultiArg<T>::addToList(std::list<Arg*> &argList) const
{
argList.push_back(const_cast<Arg*>(static_cast<const Arg*const>(this)));
}
}
#endif

224
src/tclap/UnlabeledValueArg.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: UnlabeledValueArg.h
@ -31,18 +30,17 @@
#include <tclap/OptionalUnlabeledTracker.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* The basic unlabeled argument that parses a value.
* This is a template class, which means the type T defines the type
* that a given object will attempt to parse when an UnlabeledValueArg
* is reached in the list of args that the CmdLine iterates over.
*/
template<class T>
class UnlabeledValueArg : public ValueArg<T>
{
template<class T>
class UnlabeledValueArg : public ValueArg<T>
{
// If compiler has two stage name lookup (as gcc >= 3.4 does)
// this is requried to prevent undef. symbols
using ValueArg<T>::_ignoreable;
@ -55,7 +53,6 @@ class UnlabeledValueArg : public ValueArg<T>
using ValueArg<T>::toString;
public:
/**
* UnlabeledValueArg constructor.
* \param name - A one word name for the argument. Note that this is used for
@ -77,13 +74,8 @@ class UnlabeledValueArg : public ValueArg<T>
* \param v - Optional Vistor. You should leave this blank unless
* you have a very good reason.
*/
UnlabeledValueArg( const std::string& name,
const std::string& desc,
bool req,
T value,
const std::string& typeDesc,
bool ignoreable = false,
Visitor* v = NULL);
UnlabeledValueArg(const std::string &name, const std::string &desc, bool req, T value,
const std::string &typeDesc, bool ignoreable = false, Visitor *v = NULL);
/**
* UnlabeledValueArg constructor.
@ -107,14 +99,9 @@ class UnlabeledValueArg : public ValueArg<T>
* \param v - Optional Vistor. You should leave this blank unless
* you have a very good reason.
*/
UnlabeledValueArg( const std::string& name,
const std::string& desc,
bool req,
T value,
const std::string& typeDesc,
CmdLineInterface& parser,
bool ignoreable = false,
Visitor* v = NULL );
UnlabeledValueArg(const std::string &name, const std::string &desc, bool req, T value,
const std::string &typeDesc, CmdLineInterface &parser,
bool ignoreable = false, Visitor *v = NULL);
/**
* UnlabeledValueArg constructor.
@ -135,13 +122,8 @@ class UnlabeledValueArg : public ValueArg<T>
* \param v - Optional Vistor. You should leave this blank unless
* you have a very good reason.
*/
UnlabeledValueArg( const std::string& name,
const std::string& desc,
bool req,
T value,
Constraint<T>* constraint,
bool ignoreable = false,
Visitor* v = NULL );
UnlabeledValueArg(const std::string &name, const std::string &desc, bool req, T value,
Constraint<T> *constraint, bool ignoreable = false, Visitor *v = NULL);
/**
@ -164,14 +146,9 @@ class UnlabeledValueArg : public ValueArg<T>
* \param v - Optional Vistor. You should leave this blank unless
* you have a very good reason.
*/
UnlabeledValueArg( const std::string& name,
const std::string& desc,
bool req,
T value,
Constraint<T>* constraint,
CmdLineInterface& parser,
bool ignoreable = false,
Visitor* v = NULL);
UnlabeledValueArg(const std::string &name, const std::string &desc, bool req, T value,
Constraint<T> *constraint, CmdLineInterface &parser,
bool ignoreable = false, Visitor *v = NULL);
/**
* Handles the processing of the argument.
@ -181,160 +158,147 @@ class UnlabeledValueArg : public ValueArg<T>
* \param i - Pointer the the current argument in the list.
* \param args - Mutable list of strings.
*/
virtual bool processArg(int* i, std::vector<std::string>& args);
virtual bool processArg(int *i, std::vector<std::string> &args);
/**
* Overrides shortID for specific behavior.
*/
virtual std::string shortID(const std::string& val="val") const;
virtual std::string shortID(const std::string &val = "val") const;
/**
* Overrides longID for specific behavior.
*/
virtual std::string longID(const std::string& val="val") const;
virtual std::string longID(const std::string &val = "val") const;
/**
* Overrides operator== for specific behavior.
*/
virtual bool operator==(const Arg& a ) const;
virtual bool operator==(const Arg &a) const;
/**
* Instead of pushing to the front of list, push to the back.
* \param argList - The list to add this to.
*/
virtual void addToList( std::list<Arg*>& argList ) const;
};
virtual void addToList(std::list<Arg*> &argList) const;
};
/**
/**
* Constructor implemenation.
*/
template<class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name,
const std::string& desc,
bool req,
T val,
const std::string& typeDesc,
bool ignoreable,
Visitor* v)
: ValueArg<T>("", name, desc, req, val, typeDesc, v)
{
template<class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name, const std::string &desc,
bool req, T val, const std::string &typeDesc,
bool ignoreable, Visitor *v) :
ValueArg<T>("", name, desc, req, val, typeDesc, v)
{
_ignoreable = ignoreable;
OptionalUnlabeledTracker::check(req, toString());
}
template<class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name,
const std::string& desc,
bool req,
T val,
const std::string& typeDesc,
CmdLineInterface& parser,
bool ignoreable,
Visitor* v)
: ValueArg<T>("", name, desc, req, val, typeDesc, v)
{
}
template<class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name, const std::string &desc,
bool req, T val, const std::string &typeDesc,
CmdLineInterface &parser, bool ignoreable, Visitor *v) :
ValueArg<T>("", name, desc, req, val, typeDesc, v)
{
_ignoreable = ignoreable;
OptionalUnlabeledTracker::check(req, toString());
parser.add( this );
}
parser.add(this);
}
/**
/**
* Constructor implemenation.
*/
template<class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name,
const std::string& desc,
bool req,
T val,
Constraint<T>* constraint,
bool ignoreable,
Visitor* v)
: ValueArg<T>("", name, desc, req, val, constraint, v)
{
template<class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name, const std::string &desc,
bool req, T val, Constraint<T> *constraint,
bool ignoreable, Visitor *v) :
ValueArg<T>("", name, desc, req, val, constraint, v)
{
_ignoreable = ignoreable;
OptionalUnlabeledTracker::check(req, toString());
}
template<class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name,
const std::string& desc,
bool req,
T val,
Constraint<T>* constraint,
CmdLineInterface& parser,
bool ignoreable,
Visitor* v)
: ValueArg<T>("", name, desc, req, val, constraint, v)
{
}
template<class T>
UnlabeledValueArg<T>::UnlabeledValueArg(const std::string &name, const std::string &desc,
bool req, T val, Constraint<T> *constraint,
CmdLineInterface &parser, bool ignoreable, Visitor *v) :
ValueArg<T>("", name, desc, req, val, constraint, v)
{
_ignoreable = ignoreable;
OptionalUnlabeledTracker::check(req, toString());
parser.add( this );
}
parser.add(this);
}
/**
/**
* Implementation of processArg().
*/
template<class T>
bool UnlabeledValueArg<T>::processArg(int *i, std::vector<std::string>& args)
{
if ( _alreadySet )
template<class T>
bool UnlabeledValueArg<T>::processArg(int *i, std::vector<std::string> &args)
{
if (_alreadySet)
{
return false;
}
if ( _hasBlanks( args[*i] ) )
if (_hasBlanks(args[*i]))
{
return false;
}
// never ignore an unlabeled arg
_extractValue( args[*i] );
_extractValue(args[*i]);
_alreadySet = true;
return true;
}
}
/**
/**
* Overriding shortID for specific output.
*/
template<class T>
std::string UnlabeledValueArg<T>::shortID(const std::string& val) const
{
template<class T>
std::string UnlabeledValueArg<T>::shortID(const std::string &val) const
{
static_cast<void>(val); // Ignore input, don't warn
return std::string("<") + _typeDesc + ">";
}
}
/**
/**
* Overriding longID for specific output.
*/
template<class T>
std::string UnlabeledValueArg<T>::longID(const std::string& val) const
{
template<class T>
std::string UnlabeledValueArg<T>::longID(const std::string &val) const
{
static_cast<void>(val); // Ignore input, don't warn
// Ideally we would like to be able to use RTTI to return the name
// of the type required for this argument. However, g++ at least,
// doesn't appear to return terribly useful "names" of the types.
return std::string("<") + _typeDesc + ">";
}
}
/**
/**
* Overriding operator== for specific behavior.
*/
template<class T>
bool UnlabeledValueArg<T>::operator==(const Arg& a ) const
{
if ( _name == a.getName() || _description == a.getDescription() )
template<class T>
bool UnlabeledValueArg<T>::operator==(const Arg &a) const
{
if (_name == a.getName() || _description == a.getDescription())
{
return true;
}
else
{
return false;
}
}
template<class T>
void UnlabeledValueArg<T>::addToList(std::list<Arg*> &argList) const
{
argList.push_back(const_cast<Arg*>(static_cast<const Arg*const>(this)));
}
}
template<class T>
void UnlabeledValueArg<T>::addToList( std::list<Arg*>& argList ) const
{
argList.push_back( const_cast<Arg*>(static_cast<const Arg* const>(this)) );
}
}
#endif

297
src/tclap/ValueArg.h
Unescape Escape View File

@ -29,9 +29,9 @@
#include <tclap/Arg.h>
#include <tclap/Constraint.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* The basic labeled argument that parses a value.
* This is a template class, which means the type T defines the type
* that a given object will attempt to parse when the flag/name is matched
@ -39,11 +39,10 @@ namespace TCLAP {
* an unflagged ValueArg, it is unwise and would cause significant problems.
* Instead use an UnlabeledValueArg.
*/
template<class T>
class ValueArg : public Arg
{
template<class T>
class ValueArg : public Arg
{
protected:
/**
* The value parsed from the command line.
* Can be of any type, as long as the >> operator for the type
@ -69,7 +68,7 @@ class ValueArg : public Arg
/**
* A Constraint this Arg must conform to.
*/
Constraint<T>* _constraint;
Constraint<T> *_constraint;
/**
* Extracts the value from the string.
@ -77,10 +76,9 @@ class ValueArg : public Arg
* is thrown.
* \param val - value to be parsed.
*/
void _extractValue( const std::string& val );
void _extractValue(const std::string &val);
public:
/**
* Labeled ValueArg constructor.
* You could conceivably call this constructor with a blank flag,
@ -104,13 +102,8 @@ class ValueArg : public Arg
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
ValueArg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T value,
const std::string& typeDesc,
Visitor* v = NULL);
ValueArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
T value, const std::string &typeDesc, Visitor *v = NULL);
/**
@ -137,14 +130,8 @@ class ValueArg : public Arg
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
ValueArg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T value,
const std::string& typeDesc,
CmdLineInterface& parser,
Visitor* v = NULL );
ValueArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
T value, const std::string &typeDesc, CmdLineInterface &parser, Visitor *v = NULL);
/**
* Labeled ValueArg constructor.
@ -168,14 +155,8 @@ class ValueArg : public Arg
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
ValueArg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T value,
Constraint<T>* constraint,
CmdLineInterface& parser,
Visitor* v = NULL );
ValueArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
T value, Constraint<T> *constraint, CmdLineInterface &parser, Visitor *v = NULL);
/**
* Labeled ValueArg constructor.
@ -198,13 +179,8 @@ class ValueArg : public Arg
* \param v - An optional visitor. You probably should not
* use this unless you have a very good reason.
*/
ValueArg( const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T value,
Constraint<T>* constraint,
Visitor* v = NULL );
ValueArg(const std::string &flag, const std::string &name, const std::string &desc, bool req,
T value, Constraint<T> *constraint, Visitor *v = NULL);
/**
* Handles the processing of the argument.
@ -215,197 +191,186 @@ class ValueArg : public Arg
* \param args - Mutable list of strings. Passed
* in from main().
*/
virtual bool processArg(int* i, std::vector<std::string>& args);
virtual bool processArg(int *i, std::vector<std::string> &args);
/**
* Returns the value of the argument.
*/
T& getValue() ;
T& getValue();
/**
* Specialization of shortID.
* \param val - value to be used.
*/
virtual std::string shortID(const std::string& val = "val") const;
virtual std::string shortID(const std::string &val = "val") const;
/**
* Specialization of longID.
* \param val - value to be used.
*/
virtual std::string longID(const std::string& val = "val") const;
virtual std::string longID(const std::string &val = "val") const;
virtual void reset() ;
virtual void reset();
};
};
/**
/**
* Constructor implementation.
*/
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T val,
const std::string& typeDesc,
Visitor* v)
: Arg(flag, name, desc, req, true, v),
_value( val ),
_default( val ),
_typeDesc( typeDesc ),
_constraint( NULL )
{ }
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T val,
const std::string& typeDesc,
CmdLineInterface& parser,
Visitor* v)
: Arg(flag, name, desc, req, true, v),
_value( val ),
_default( val ),
_typeDesc( typeDesc ),
_constraint( NULL )
{
parser.add( this );
}
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T val,
Constraint<T>* constraint,
Visitor* v)
: Arg(flag, name, desc, req, true, v),
_value( val ),
_default( val ),
_typeDesc( constraint->shortID() ),
_constraint( constraint )
{ }
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
const std::string& name,
const std::string& desc,
bool req,
T val,
Constraint<T>* constraint,
CmdLineInterface& parser,
Visitor* v)
: Arg(flag, name, desc, req, true, v),
_value( val ),
_default( val ),
_typeDesc( constraint->shortID() ),
_constraint( constraint )
{
parser.add( this );
}
template<class T>
ValueArg<T>::ValueArg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, T val, const std::string &typeDesc, Visitor *v) :
Arg(flag, name, desc, req, true, v), _value(val), _default(val), _typeDesc(typeDesc),
_constraint(NULL)
{
}
template<class T>
ValueArg<T>::ValueArg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, T val, const std::string &typeDesc, CmdLineInterface &parser,
Visitor *v) :
Arg(flag, name, desc, req, true, v), _value(val), _default(val), _typeDesc(typeDesc),
_constraint(NULL)
{
parser.add(this);
}
/**
template<class T>
ValueArg<T>::ValueArg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, T val, Constraint<T> *constraint, Visitor *v) :
Arg(flag, name, desc, req, true, v), _value(val), _default(val), _typeDesc(
constraint->shortID()), _constraint(constraint)
{
}
template<class T>
ValueArg<T>::ValueArg(const std::string &flag, const std::string &name, const std::string &desc,
bool req, T val, Constraint<T> *constraint, CmdLineInterface &parser,
Visitor *v) :
Arg(flag, name, desc, req, true, v), _value(val), _default(val), _typeDesc(
constraint->shortID()), _constraint(constraint)
{
parser.add(this);
}
/**
* Implementation of getValue().
*/
template<class T>
T& ValueArg<T>::getValue() { return _value; }
template<class T>
T& ValueArg<T>::getValue()
{
return _value;
}
/**
/**
* Implementation of processArg().
*/
template<class T>
bool ValueArg<T>::processArg(int *i, std::vector<std::string>& args)
{
if ( _ignoreable && Arg::ignoreRest() )
template<class T>
bool ValueArg<T>::processArg(int *i, std::vector<std::string> &args)
{
if (_ignoreable && Arg::ignoreRest())
{
return false;
}
if ( _hasBlanks( args[*i] ) )
if (_hasBlanks(args[*i]))
{
return false;
}
std::string flag = args[*i];
std::string value = "";
trimFlag( flag, value );
trimFlag(flag, value);
if ( argMatches( flag ) )
if (argMatches(flag))
{
if ( _alreadySet )
throw( CmdLineParseException("Argument already set!", toString()) );
if (_alreadySet)
{
throw (CmdLineParseException("Argument already set!", toString()));
}
if ( Arg::delimiter() != ' ' && value == "" )
throw( ArgParseException(
"Couldn't find delimiter for this argument!",
toString() ) );
if (Arg::delimiter() != ' ' && value == "")
{
throw (ArgParseException(
"Couldn't find delimiter for this argument!", toString()));
}
if ( value == "" )
if (value == "")
{
(*i)++;
if ( static_cast<unsigned int>(*i) < args.size() )
_extractValue( args[*i] );
if (static_cast<unsigned int>(*i) < args.size())
{
_extractValue(args[*i]);
}
else
throw( ArgParseException("Missing a value for this argument!",
toString() ) );
{
throw (ArgParseException("Missing a value for this argument!", toString()));
}
}
else
_extractValue( value );
{
_extractValue(value);
}
_alreadySet = true;
_checkWithVisitor();
return true;
}
else
{
return false;
}
}
}
/**
/**
* Implementation of shortID.
*/
template<class T>
std::string ValueArg<T>::shortID(const std::string& val) const
{
template<class T>
std::string ValueArg<T>::shortID(const std::string &val) const
{
static_cast<void>(val); // Ignore input, don't warn
return Arg::shortID( _typeDesc );
}
return Arg::shortID(_typeDesc);
}
/**
/**
* Implementation of longID.
*/
template<class T>
std::string ValueArg<T>::longID(const std::string& val) const
{
template<class T>
std::string ValueArg<T>::longID(const std::string &val) const
{
static_cast<void>(val); // Ignore input, don't warn
return Arg::longID( _typeDesc );
}
return Arg::longID(_typeDesc);
}
template<class T>
void ValueArg<T>::_extractValue( const std::string& val )
{
try {
template<class T>
void ValueArg<T>::_extractValue(const std::string &val)
{
try
{
ExtractValue(_value, val, typename ArgTraits<T>::ValueCategory());
} catch( ArgParseException &e) {
}
catch (ArgParseException &e)
{
throw ArgParseException(e.error(), toString());
}
if ( _constraint != NULL )
if ( ! _constraint->check( _value ) )
throw( CmdLineParseException( "Value '" + val +
+ "' does not meet constraint: "
+ _constraint->description(),
toString() ) );
}
if (_constraint != NULL)
{
if (!_constraint->check(_value))
{
throw (CmdLineParseException("Value '" + val + +"' does not meet constraint: " +
_constraint->description(), toString()));
}
}
}
template<class T>
void ValueArg<T>::reset()
{
template<class T>
void ValueArg<T>::reset()
{
Arg::reset();
_value = _default;
}
}
} // namespace TCLAP
#endif

100
src/tclap/ValuesConstraint.h
Unescape Escape View File

@ -1,5 +1,3 @@
/******************************************************************************
*
* file: ValuesConstraint.h
@ -28,41 +26,42 @@
#include <tclap/Constraint.h>
#ifdef HAVE_CONFIG_H
#include <config.h>
#include <config.h>
#else
#define HAVE_SSTREAM
#define HAVE_SSTREAM
#endif
#if defined(HAVE_SSTREAM)
#include <sstream>
#elif defined(HAVE_STRSTREAM)
#include <strstream>
#if defined (HAVE_SSTREAM)
#include <sstream>
#elif defined (HAVE_STRSTREAM)
#include <strstream>
#else
#error "Need a stringstream (sstream or strstream) to compile!"
#error "Need a stringstream (sstream or strstream) to compile!"
#endif
namespace TCLAP {
namespace TCLAP
{
/**
/**
* A Constraint that constrains the Arg to only those values specified
* in the constraint.
*/
template<class T>
class ValuesConstraint : public Constraint<T>
{
template<class T>
class ValuesConstraint : public Constraint<T>
{
public:
/**
* Constructor.
* \param allowed - vector of allowed values.
*/
ValuesConstraint(std::vector<T>& allowed);
ValuesConstraint(std::vector<T> &allowed);
/**
* Virtual destructor.
*/
virtual ~ValuesConstraint() {}
virtual ~ValuesConstraint()
{
}
/**
* Returns a description of the Constraint.
@ -79,10 +78,9 @@ class ValuesConstraint : public Constraint<T>
* line meets the constraint.
* \param value - The value that will be checked.
*/
virtual bool check(const T& value) const;
virtual bool check(const T &value) const;
protected:
/**
* The list of valid values.
*/
@ -92,56 +90,58 @@ class ValuesConstraint : public Constraint<T>
* The string used to describe the allowed values of this constraint.
*/
std::string _typeDesc;
};
};
template<class T>
ValuesConstraint<T>::ValuesConstraint(std::vector<T>& allowed)
: _allowed(allowed)
{
for ( unsigned int i = 0; i < _allowed.size(); i++ )
template<class T>
ValuesConstraint<T>::ValuesConstraint(std::vector<T> &allowed) :
_allowed(allowed)
{
#if defined(HAVE_SSTREAM)
for (unsigned int i = 0; i < _allowed.size(); i++)
{
#if defined (HAVE_SSTREAM)
std::ostringstream os;
#elif defined(HAVE_STRSTREAM)
#elif defined (HAVE_STRSTREAM)
std::ostrstream os;
#else
#error "Need a stringstream (sstream or strstream) to compile!"
#error "Need a stringstream (sstream or strstream) to compile!"
#endif
os << _allowed[i];
std::string temp( os.str() );
std::string temp(os.str());
if ( i > 0 )
if (i > 0)
{
_typeDesc += "|";
}
_typeDesc += temp;
}
}
}
template<class T>
bool ValuesConstraint<T>::check( const T& val ) const
{
if ( std::find(_allowed.begin(),_allowed.end(),val) == _allowed.end() )
template<class T>
bool ValuesConstraint<T>::check(const T &val) const
{
if (std::find(_allowed.begin(), _allowed.end(), val) == _allowed.end())
{
return false;
}
else
{
return true;
}
}
}
template<class T>
std::string ValuesConstraint<T>::shortID() const
{
template<class T>
std::string ValuesConstraint<T>::shortID() const
{
return _typeDesc;
}
}
template<class T>
std::string ValuesConstraint<T>::description() const
{
template<class T>
std::string ValuesConstraint<T>::description() const
{
return _typeDesc;
}
}
} //namespace TCLAP
#endif
#endif

29
src/tclap/VersionVisitor.h
Unescape Escape View File

@ -28,47 +28,46 @@
#include <tclap/CmdLineOutput.h>
#include <tclap/Visitor.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A Vistor that will call the version method of the given CmdLineOutput
* for the specified CmdLine object and then exit.
*/
class VersionVisitor: public Visitor
{
class VersionVisitor : public Visitor
{
protected:
/**
* The CmdLine of interest.
*/
CmdLineInterface* _cmd;
CmdLineInterface *_cmd;
/**
* The output object.
*/
CmdLineOutput** _out;
CmdLineOutput **_out;
public:
/**
* Constructor.
* \param cmd - The CmdLine the output is generated for.
* \param out - The type of output.
*/
VersionVisitor( CmdLineInterface* cmd, CmdLineOutput** out )
: Visitor(), _cmd( cmd ), _out( out ) { }
VersionVisitor(CmdLineInterface *cmd, CmdLineOutput **out) :
Visitor(), _cmd(cmd), _out(out)
{
}
/**
* Calls the version method of the output object using the
* specified CmdLine.
*/
void visit() {
void visit()
{
(*_out)->version(*_cmd);
throw ExitException(0);
}
};
};
}
#endif

27
src/tclap/Visitor.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: Visitor.h
@ -23,31 +22,35 @@
#ifndef TCLAP_VISITOR_H
#define TCLAP_VISITOR_H
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A base class that defines the interface for visitors.
*/
class Visitor
{
class Visitor
{
public:
/**
* Constructor. Does nothing.
*/
Visitor() { }
Visitor()
{
}
/**
* Destructor. Does nothing.
*/
virtual ~Visitor() { }
virtual ~Visitor()
{
}
/**
* Does nothing. Should be overridden by child.
*/
virtual void visit() { }
};
virtual void visit()
{
}
};
}
#endif

116
src/tclap/XorHandler.h
Unescape Escape View File

@ -1,4 +1,3 @@
/******************************************************************************
*
* file: XorHandler.h
@ -29,33 +28,34 @@
#include <algorithm>
#include <iostream>
namespace TCLAP {
namespace TCLAP
{
/**
/**
* This class handles lists of Arg's that are to be XOR'd on the command
* line. This is used by CmdLine and you shouldn't ever use it.
*/
class XorHandler
{
class XorHandler
{
protected:
/**
* The list of of lists of Arg's to be or'd together.
*/
std::vector< std::vector<Arg*> > _orList;
std::vector<std::vector<Arg*>> _orList;
public:
/**
* Constructor. Does nothing.
*/
XorHandler( ) {}
XorHandler()
{
}
/**
* Add a list of Arg*'s that will be orred together.
* \param ors - list of Arg* that will be xor'd.
*/
void add( std::vector<Arg*>& ors );
void add(std::vector<Arg*> &ors);
/**
* Checks whether the specified Arg is in one of the xor lists and
@ -64,7 +64,7 @@ class XorHandler
* the Arg's in the list. You shouldn't use this.
* \param a - The Arg to be checked.
*/
int check( const Arg* a );
int check(const Arg *a);
/**
* Returns the XOR specific short usage.
@ -75,82 +75,94 @@ class XorHandler
* Prints the XOR specific long usage.
* \param os - Stream to print to.
*/
void printLongUsage(std::ostream& os);
void printLongUsage(std::ostream &os);
/**
* Simply checks whether the Arg is contained in one of the arg
* lists.
* \param a - The Arg to be checked.
*/
bool contains( const Arg* a );
std::vector< std::vector<Arg*> >& getXorList();
};
bool contains(const Arg *a);
std::vector<std::vector<Arg*>>& getXorList();
};
//////////////////////////////////////////////////////////////////////
//BEGIN XOR.cpp
//////////////////////////////////////////////////////////////////////
inline void XorHandler::add( std::vector<Arg*>& ors )
{
_orList.push_back( ors );
}
//////////////////////////////////////////////////////////////////////
//BEGIN XOR.cpp
//////////////////////////////////////////////////////////////////////
inline void XorHandler::add(std::vector<Arg*> &ors)
{
_orList.push_back(ors);
}
inline int XorHandler::check( const Arg* a )
{
inline int XorHandler::check(const Arg *a)
{
// iterate over each XOR list
for ( int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++ )
for (int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++)
{
// if the XOR list contains the arg..
ArgVectorIterator ait = std::find( _orList[i].begin(),
_orList[i].end(), a );
if ( ait != _orList[i].end() )
ArgVectorIterator ait = std::find(_orList[i].begin(), _orList[i].end(), a);
if (ait != _orList[i].end())
{
// go through and set each arg that is not a
for ( ArgVectorIterator it = _orList[i].begin();
for (ArgVectorIterator it = _orList[i].begin();
it != _orList[i].end();
it++ )
if ( a != (*it) )
it++)
{
if (a != (*it))
{
(*it)->xorSet();
}
}
// return the number of required args that have now been set
if ( (*ait)->allowMore() )
if ((*ait)->allowMore())
{
return 0;
}
else
{
return static_cast<int>(_orList[i].size());
}
}
}
if ( a->isRequired() )
if (a->isRequired())
{
return 1;
}
else
{
return 0;
}
}
}
inline bool XorHandler::contains( const Arg* a )
{
for ( int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++ )
for ( ArgVectorIterator it = _orList[i].begin();
inline bool XorHandler::contains(const Arg *a)
{
for (int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++)
{
for (ArgVectorIterator it = _orList[i].begin();
it != _orList[i].end();
it++ )
if ( a == (*it) )
it++)
{
if (a == (*it))
{
return true;
}
}
}
return false;
}
}
inline std::vector< std::vector<Arg*> >& XorHandler::getXorList()
{
inline std::vector<std::vector<Arg*>>& XorHandler::getXorList()
{
return _orList;
}
//////////////////////////////////////////////////////////////////////
//END XOR.cpp
//////////////////////////////////////////////////////////////////////
}
//////////////////////////////////////////////////////////////////////
//END XOR.cpp
//////////////////////////////////////////////////////////////////////
} //namespace TCLAP
#endif

185
src/tclap/ZshCompletionOutput.h
Unescape Escape View File

@ -34,17 +34,15 @@
#include <tclap/XorHandler.h>
#include <tclap/Arg.h>
namespace TCLAP {
/**
namespace TCLAP
{
/**
* A class that generates a Zsh completion function as output from the usage()
* method for the given CmdLine and its Args.
*/
class ZshCompletionOutput : public CmdLineOutput
{
class ZshCompletionOutput : public CmdLineOutput
{
public:
ZshCompletionOutput();
/**
@ -52,14 +50,14 @@ class ZshCompletionOutput : public CmdLineOutput
* produce alternative behavior.
* \param c - The CmdLine object the output is generated for.
*/
virtual void usage(CmdLineInterface& c);
virtual void usage(CmdLineInterface &c);
/**
* Prints the version to stdout. Can be overridden
* to produce alternative behavior.
* \param c - The CmdLine object the output is generated for.
*/
virtual void version(CmdLineInterface& c);
virtual void version(CmdLineInterface &c);
/**
* Prints (to stderr) an error message, short usage
@ -67,24 +65,22 @@ class ZshCompletionOutput : public CmdLineOutput
* \param c - The CmdLine object the output is generated for.
* \param e - The ArgException that caused the failure.
*/
virtual void failure(CmdLineInterface& c,
ArgException& e );
virtual void failure(CmdLineInterface &c, ArgException &e);
protected:
void basename(std::string &s);
void quoteSpecialChars(std::string &s);
void basename( std::string& s );
void quoteSpecialChars( std::string& s );
std::string getMutexList( CmdLineInterface& _cmd, Arg* a );
void printOption( Arg* it, std::string mutex );
void printArg( Arg* it );
std::string getMutexList(CmdLineInterface &_cmd, Arg *a);
void printOption(Arg *it, std::string mutex);
void printArg(Arg *it);
std::map<std::string, std::string> common;
char theDelimiter;
};
};
ZshCompletionOutput::ZshCompletionOutput()
{
ZshCompletionOutput::ZshCompletionOutput()
{
common["host"] = "_hosts";
common["hostname"] = "_hosts";
common["file"] = "_files";
@ -94,87 +90,99 @@ ZshCompletionOutput::ZshCompletionOutput()
common["directory"] = "_directories";
common["path"] = "_directories";
common["url"] = "_urls";
}
}
inline void ZshCompletionOutput::version(CmdLineInterface& _cmd)
{
inline void ZshCompletionOutput::version(CmdLineInterface &_cmd)
{
std::cout << _cmd.getVersion() << std::endl;
}
}
inline void ZshCompletionOutput::usage(CmdLineInterface& _cmd )
{
inline void ZshCompletionOutput::usage(CmdLineInterface &_cmd)
{
std::list<Arg*> argList = _cmd.getArgList();
std::string progName = _cmd.getProgramName();
std::string version = _cmd.getVersion();
theDelimiter = _cmd.getDelimiter();
basename(progName);
std::cout << "#compdef " << progName << std::endl << std::endl <<
"# " << progName << " version " << _cmd.getVersion() << std::endl << std::endl <<
"_arguments -s -S";
std::cout << "#compdef " << progName << std::endl << std::endl << "# " << progName <<
" version " << _cmd.getVersion() << std::endl << std::endl << "_arguments -s -S";
for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
{
if ( (*it)->shortID().at(0) == '<' )
if ((*it)->shortID().at(0) == '<')
{
printArg((*it));
else if ( (*it)->getFlag() != "-" )
}
else if ((*it)->getFlag() != "-")
{
printOption((*it), getMutexList(_cmd, *it));
}
}
std::cout << std::endl;
}
}
inline void ZshCompletionOutput::failure( CmdLineInterface& _cmd,
ArgException& e )
{
inline void ZshCompletionOutput::failure(CmdLineInterface &_cmd, ArgException &e)
{
static_cast<void>(_cmd); // unused
std::cout << e.what() << std::endl;
}
}
inline void ZshCompletionOutput::quoteSpecialChars( std::string& s )
{
inline void ZshCompletionOutput::quoteSpecialChars(std::string &s)
{
size_t idx = s.find_last_of(':');
while ( idx != std::string::npos )
while (idx != std::string::npos)
{
s.insert(idx, 1, '\\');
idx = s.find_last_of(':', idx);
}
idx = s.find_last_of('\'');
while ( idx != std::string::npos )
while (idx != std::string::npos)
{
s.insert(idx, "'\\'");
if (idx == 0)
{
idx = std::string::npos;
}
else
{
idx = s.find_last_of('\'', --idx);
}
}
}
}
inline void ZshCompletionOutput::basename( std::string& s )
{
inline void ZshCompletionOutput::basename(std::string &s)
{
size_t p = s.find_last_of('/');
if ( p != std::string::npos )
if (p != std::string::npos)
{
s.erase(0, p + 1);
}
}
}
inline void ZshCompletionOutput::printArg(Arg* a)
{
inline void ZshCompletionOutput::printArg(Arg *a)
{
static int count = 1;
std::cout << " \\" << std::endl << " '";
if ( a->acceptsMultipleValues() )
if (a->acceptsMultipleValues())
{
std::cout << '*';
}
else
{
std::cout << count++;
}
std::cout << ':';
if ( !a->isRequired() )
if (!a->isRequired())
{
std::cout << ':';
}
std::cout << a->getName() << ':';
std::map<std::string, std::string>::iterator compArg = common.find(a->getName());
if ( compArg != common.end() )
if (compArg != common.end())
{
std::cout << compArg->second;
}
@ -183,10 +191,10 @@ inline void ZshCompletionOutput::printArg(Arg* a)
std::cout << "_guard \"^-*\" " << a->getName();
}
std::cout << '\'';
}
}
inline void ZshCompletionOutput::printOption(Arg* a, std::string mutex)
{
inline void ZshCompletionOutput::printOption(Arg *a, std::string mutex)
{
std::string flag = a->flagStartChar() + a->getFlag();
std::string name = a->nameStartString() + a->getName();
std::string desc = a->getDescription();
@ -213,7 +221,7 @@ inline void ZshCompletionOutput::printOption(Arg* a, std::string mutex)
std::cout << " \\" << std::endl << " '" << mutex;
if ( a->getFlag().empty() )
if (a->getFlag().empty())
{
std::cout << name;
}
@ -221,34 +229,38 @@ inline void ZshCompletionOutput::printOption(Arg* a, std::string mutex)
{
std::cout << "'{" << flag << ',' << name << "}'";
}
if ( theDelimiter == '=' && a->isValueRequired() )
if (theDelimiter == '=' && a->isValueRequired())
{
std::cout << "=-";
}
quoteSpecialChars(desc);
std::cout << '[' << desc << ']';
if ( a->isValueRequired() )
if (a->isValueRequired())
{
std::string arg = a->shortID();
arg.erase(0, arg.find_last_of(theDelimiter) + 1);
if ( arg.at(arg.length()-1) == ']' )
arg.erase(arg.length()-1);
if ( arg.at(arg.length()-1) == ']' )
if (arg.at(arg.length() - 1) == ']')
{
arg.erase(arg.length() - 1);
}
if (arg.at(arg.length() - 1) == ']')
{
arg.erase(arg.length()-1);
arg.erase(arg.length() - 1);
}
if ( arg.at(0) == '<' )
if (arg.at(0) == '<')
{
arg.erase(arg.length()-1);
arg.erase(arg.length() - 1);
arg.erase(0, 1);
}
size_t p = arg.find('|');
if ( p != std::string::npos )
if (p != std::string::npos)
{
do
{
arg.replace(p, 1, 1, ' ');
}
while ( (p = arg.find_first_of('|', p)) != std::string::npos );
while ((p = arg.find_first_of('|', p)) != std::string::npos);
quoteSpecialChars(arg);
std::cout << ": :(" << arg << ')';
}
@ -256,7 +268,7 @@ inline void ZshCompletionOutput::printOption(Arg* a, std::string mutex)
{
std::cout << ':' << arg;
std::map<std::string, std::string>::iterator compArg = common.find(arg);
if ( compArg != common.end() )
if (compArg != common.end())
{
std::cout << ':' << compArg->second;
}
@ -264,12 +276,12 @@ inline void ZshCompletionOutput::printOption(Arg* a, std::string mutex)
}
std::cout << '\'';
}
}
inline std::string ZshCompletionOutput::getMutexList( CmdLineInterface& _cmd, Arg* a)
{
inline std::string ZshCompletionOutput::getMutexList(CmdLineInterface &_cmd, Arg *a)
{
XorHandler xorHandler = _cmd.getXorHandler();
std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
std::vector<std::vector<Arg*>> xorList = xorHandler.getXorList();
if (a->getName() == "help" || a->getName() == "version")
{
@ -277,45 +289,54 @@ inline std::string ZshCompletionOutput::getMutexList( CmdLineInterface& _cmd, Ar
}
std::ostringstream list;
if ( a->acceptsMultipleValues() )
if (a->acceptsMultipleValues())
{
list << '*';
}
for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
for (int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++)
{
for ( ArgVectorIterator it = xorList[i].begin();
for (ArgVectorIterator it = xorList[i].begin();
it != xorList[i].end();
it++)
if ( a == (*it) )
{
if (a == (*it))
{
list << '(';
for ( ArgVectorIterator iu = xorList[i].begin();
for (ArgVectorIterator iu = xorList[i].begin();
iu != xorList[i].end();
iu++ )
iu++)
{
bool notCur = (*iu) != a;
bool hasFlag = !(*iu)->getFlag().empty();
if ( iu != xorList[i].begin() && (notCur || hasFlag) )
if (iu != xorList[i].begin() && (notCur || hasFlag))
{
list << ' ';
}
if (hasFlag)
{
list << (*iu)->flagStartChar() << (*iu)->getFlag() << ' ';
if ( notCur || hasFlag )
}
if (notCur || hasFlag)
{
list << (*iu)->nameStartString() << (*iu)->getName();
}
}
list << ')';
return list.str();
}
}
}
// wasn't found in xor list
if (!a->getFlag().empty()) {
list << "(" << a->flagStartChar() << a->getFlag() << ' ' <<
a->nameStartString() << a->getName() << ')';
if (!a->getFlag().empty())
{
list << "(" << a->flagStartChar() << a->getFlag() << ' ' << a->nameStartString() <<
a->getName() << ')';
}
return list.str();
}
}
} //namespace TCLAP
#endif

Write Preview
Loading…
Cancel
Save