path: root/src/IndentHandler.cpp

/***************************************************************************
 *   Copyright (C) 2006-2012 by Thomas Schweitzer                          *
 *   thomas-schweitzer(at)arcor.de                                         *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License version 2.0 as   *
 *   published by the Free Software Foundation.                            *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program in the file LICENSE.GPL; if not, write to the *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "config.h"
#include "IndentHandler.h"

#include "MainWindow.h"
#include "SettingsPaths.h"
//--- #include "UiGuiSettings.h"
//--- #include "UiGuiErrorMessage.h"
//--- #include "TemplateBatchScript.h"
//--- #include "UiGuiIniFileParser.h"

#include <tqcombobox.h>
#include <tqdir.h>
#include <tqlayout.h>
#include <tqpopupmenu.h>
#include <tqtoolbox.h>
#include <tqtoolbutton.h>
//--- #include <tqapplication.h>
//--- #include <tqcheckbox.h>
//--- #include <tqfile.h>
//--- #include <tqprocess.h>
//--- #include <tqsettings.h>
//--- #include <tqstringlist.h>
//--- #include <tqlineedit.h>
//--- #include <tqspinbox.h>
//--- #include <tqlabel.h>
//--- #include <tqbytearray.h>
//--- #include <tqmessagebox.h>
//--- #include <tqtextstream.h>
//--- #include <tqtextcodec.h>
//--- #include <tqtscript.h>
//--- #include <tqdesktopservices.h>
//--- #include <tqaction.h>
//--- #include <tqcontextmenuevent.h>
//--- #include <tqfiledialog.h>
//--- #include <tqtdebug.h>

// \defgroup grp_Indenter All concerning handling of the indenter.

/*
    \class IndentHandler
    \brief A widget for handling many indenters that are configured by an ini file.

    This is a widget that is used by the main window. It handles access to the
    indenter config file and calls the chosen indenter to reformat the source text.
    Calls the indenter each time a setting has been changed and informs
    the main window about the reformatted source code.
*/


/*
    \brief Constructor of the indent handler.

    By calling this constructor the indenter to be loaded, can be selected by setting
    its \a indenterID, which is the number of found indenter ini files in alphabetic
    order starting at index 0.
 */
IndentHandler::IndentHandler(int indenterID, MainWindow *mainWindow, TQWidget *parent)
	:	TQWidget(parent), m_mainWindow(mainWindow), m_parent(parent), m_toolBoxContainerLayout(nullptr),
    m_indenterSelectionCombobox(nullptr), m_indenterParameterHelpButton(nullptr),
		m_indenterParameterCategoriesToolBox(nullptr)
//--- _indenterSettings(nullptr), _errorMessageDialog(nullptr)
{
	if (indenterID < 0)
	{
		indenterID = 0;
	}

	// define this widgets resize behavior
	setSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding);

	if (m_mainWindow)
	{
		connect((TQObject*)m_mainWindow->actionLoadIndenterConfigFile, SIGNAL(activated()),
		        this, SLOT(openConfigFileDialog()));
		connect((TQObject*)m_mainWindow->actionSaveIndenterConfigFile, SIGNAL(activated()),
		        this, SLOT(saveasIndentCfgFileDialog()));
		connect((TQObject*)m_mainWindow->actionCreateShellScript, SIGNAL(activated()),
		        this, SLOT(createIndenterCallShellScript()));
		connect((TQObject*)m_mainWindow->actionResetIndenterParameters, SIGNAL(activated()),
		        this, SLOT(resetIndenterParameter()));
	}

	// create vertical layout box, into which the toolbox will be added
	m_toolBoxContainerLayout = new TQVBoxLayout(this);
	m_toolBoxContainerLayout->setMargin(2);
	m_toolBoxContainerLayout->setSpacing(5);

	// Create horizontal layout for indenter selector and help button.
	TQHBoxLayout *hboxLayout = new TQHBoxLayout();
	hboxLayout->setSpacing(5);
	m_toolBoxContainerLayout->addLayout(hboxLayout);

	// Create the indenter selection combo box.
	m_indenterSelectionCombobox = new TQComboBox(this);
	m_indenterSelectionCombobox->setSizePolicy(TQSizePolicy::MinimumExpanding, TQSizePolicy::Minimum);
	connect(m_indenterSelectionCombobox, SIGNAL(activated(int)), this, SLOT(setIndenter(int)));
	hboxLayout->addWidget(m_indenterSelectionCombobox);

	// Create the indenter parameter help button.
	m_indenterParameterHelpButton = new TQToolButton(this);
	m_indenterParameterHelpButton->setIconSet(TQPixmap(TQString(APP_ICONS_PATH)+ "help.png"));
	connect(m_indenterParameterHelpButton, SIGNAL(clicked()), this, SLOT(showIndenterManual()));
	hboxLayout->addWidget(m_indenterParameterHelpButton);

	// create a toolbox and set its resize behavior
	m_indenterParameterCategoriesToolBox = new TQToolBox(this);
	m_indenterParameterCategoriesToolBox->setSizePolicy(TQSizePolicy::MinimumExpanding,
	        TQSizePolicy::Expanding);
	m_toolBoxContainerLayout->addWidget(m_indenterParameterCategoriesToolBox);

	m_indenterExecutableCallString = "";
	m_indenterExecutableSuffix     = "";

	m_indenterDirectoryStr  = SettingsPaths::getIndenterPath();
	m_tempDirectoryStr      = SettingsPaths::getTempPath();
	m_settingsDirectoryStr  = SettingsPaths::getSettingsPath();
	TQDir indenterDirectory = TQDir(m_indenterDirectoryStr);

//--- 	if (m_mainWindow != nullptr)
//--- 	{
//--- 		_errorMessageDialog = new UiGuiErrorMessage(m_mainWindow);
//--- 	}
//--- 	else
//--- 	{
//--- 		_errorMessageDialog = new UiGuiErrorMessage(this);
//--- 	}

//--- 	_indenterIniFileList = indenterDirectory.entryList(TQStringList("uigui_*.ini"));
//--- 	if (_indenterIniFileList.count() > 0)
//--- 	{
//--- 		// Take care if the selected indenterID is smaller or greater than the number of existing
//--- 		// indenters
//--- 		if (indenterID < 0)
//--- 		{
//--- 			indenterID = 0;
//--- 		}
//--- 		if (indenterID >= _indenterIniFileList.count())
//--- 		{
//--- 			indenterID = _indenterIniFileList.count() - 1;
//--- 		}
//--- 
//--- 		// Reads and parses the by indenterID defined indent ini file and creates toolbox entries
//--- 		readIndentIniFile(m_indenterDirectoryStr + "/" + _indenterIniFileList.at(indenterID));
//--- 
//--- 		// Find out how the indenter can be executed.
//--- 		createIndenterCallString();
//--- 
//--- 		// Load the users last settings made for this indenter.
//--- 		loadConfigFile(m_settingsDirectoryStr + "/" + _indenterFileName + ".cfg");
//--- 
//--- 		// Fill the indenter selection combo box with the list of available indenters.
//--- 		if (!getAvailableIndenters().isEmpty())
//--- 		{
//--- 			m_indenterSelectionCombobox->addItems(getAvailableIndenters());
//--- 			m_indenterSelectionCombobox->setCurrentIndex(indenterID);
//--- 			connect(m_indenterSelectionCombobox, SIGNAL(currentIndexChanged(int)), this,
//--- 			        SIGNAL(selectedIndenterIndexChanged(int)));
//--- 		}
//--- 	}
//--- 	else
//--- 	{
//--- 		_errorMessageDialog->showMessage(tr("No indenter ini files"),
//--- 		        tr("There exists no indenter ini files in the directory \"") +
//--- 		        TQDir(m_indenterDirectoryStr).absolutePath() + "\".");
//--- 	}
}

/*
    \brief Implicitly writes the current indenter parameters to the indenters config file.
 */
IndentHandler::~IndentHandler()
{
//--- 	// Generate the parameter string that will be saved to the indenters config file.
//--- 	TQString parameterString = getParameterString();
//--- 	if (!_indenterFileName.isEmpty())
//--- 	{
//--- 		saveConfigFile(m_settingsDirectoryStr + "/" + _indenterFileName + ".cfg", parameterString);
//--- 	}
//--- 
//--- 	delete _errorMessageDialog;
}

/*
    \brief Opens the context menu, used for some actions like saving the indenter config file,
		at the event position.
 */
void IndentHandler::contextMenuEvent(TQContextMenuEvent *event)
{
	if (m_mainWindow)
	{
		m_mainWindow->menuIndenter->exec(event->globalPos());
	}
}

//--- /*
//---     \brief Creates the content for a shell script that can be used as a external tool call
//---     to indent an as parameter defined file.
//---  */
//--- TQString IndentHandler::generateShellScript(const TQString &configFilename)
//--- {
//--- 	TQString indenterCompleteCallString;
//--- 	TQString parameterInputFile;
//--- 	TQString parameterOuputFile;
//--- 	TQString parameterParameterFile;
//--- 	TQString replaceInputFileCommand;
//--- 
//--- 	// Define the placeholder for parameter variables either in batch or bash programming.
//--- 	TQString shellParameterPlaceholder = "$1";
//--- 
//--- 	parameterInputFile = " " + _inputFileParameter + "\"" + shellParameterPlaceholder + "\"";
//--- 
//--- 	if (_outputFileParameter != "none" && _outputFileParameter != "stdout")
//--- 	{
//--- 		if (_outputFileName == _inputFileName)
//--- 		{
//--- 			parameterOuputFile = " " + _outputFileParameter + "\"" + shellParameterPlaceholder + "\"";
//--- 		}
//--- 		else
//--- 		{
//--- 			parameterOuputFile = " " + _outputFileParameter + _outputFileName + ".tmp";
//--- 		}
//--- 	}
//--- 
//--- 	// If the config file name is empty it is assumed that all parameters are sent via command line
//--- 	// call
//--- 	if (_globalConfigFilename.isEmpty())
//--- 	{
//--- 		parameterParameterFile = " " + getParameterString();
//--- 	}
//--- 	// else if needed add the parameter to the indenter call string where the config file can be
//--- 	// found.
//--- 	else if (_useCfgFileParameter != "none")
//--- 	{
//--- 		parameterParameterFile = " " + _useCfgFileParameter + "\"./" + configFilename + "\"";
//--- 	}
//--- 
//--- 	// Assemble indenter call string for parameters according to the set order.
//--- 	if (_parameterOrder == "ipo")
//--- 	{
//--- 		indenterCompleteCallString = parameterInputFile + parameterParameterFile + parameterOuputFile;
//--- 	}
//--- 	else if (_parameterOrder == "pio")
//--- 	{
//--- 		indenterCompleteCallString = parameterParameterFile + parameterInputFile + parameterOuputFile;
//--- 	}
//--- 	else if (_parameterOrder == "poi")
//--- 	{
//--- 		indenterCompleteCallString = parameterParameterFile + parameterOuputFile + parameterInputFile;
//--- 	}
//--- 	else
//--- 	{
//--- 		indenterCompleteCallString = parameterInputFile + parameterOuputFile + parameterParameterFile;
//--- 	}
//--- 
//--- 	// Generate the indenter call string either for win32 or other systems.
//--- 	indenterCompleteCallString = "#!/bin/bash\n" + m_indenterExecutableCallString +
//--- 	        indenterCompleteCallString;
//--- 
//--- 	// If the indenter writes to stdout pipe the output into a file
//--- 	if (_outputFileParameter == "stdout")
//--- 	{
//--- 		indenterCompleteCallString = indenterCompleteCallString + " >" + _outputFileName + ".tmp";
//--- 	}
//--- 
//--- 	// If the output filename is not the same as the input filename copy the output over the input.
//--- 	if (_outputFileName != _inputFileName)
//--- 	{
//--- 		replaceInputFileCommand = "mv " + _outputFileName + ".tmp \"" + shellParameterPlaceholder +
//--- 		        "\"\n";
//--- 	}
//--- 
//--- 	TQString shellScript(TemplateBatchScript::getTemplateBatchScript());
//--- 	shellScript = shellScript.replace("__INDENTERCALLSTRING2__",
//--- 	        indenterCompleteCallString + "\n" + replaceInputFileCommand);
//--- 	indenterCompleteCallString = indenterCompleteCallString.replace("$1", "$file2indent");
//--- 	replaceInputFileCommand    = replaceInputFileCommand.replace("$1", "$file2indent");
//--- 	shellScript = shellScript.replace("__INDENTERCALLSTRING1__",
//--- 	        indenterCompleteCallString + "\n" + replaceInputFileCommand);
//--- 
//--- 	return shellScript;
//--- }
//--- 
//--- /*
//---     \brief Format \a sourceCode by calling the indenter.
//--- 
//---     The \a inputFileExtension has to be given as parameter so the called indenter
//---     can identify the programming language if needed.
//---  */
//--- TQString IndentHandler::callIndenter(TQString sourceCode, TQString inputFileExtension)
//--- {
//--- 	if (m_indenterExecutableSuffix == ".js")
//--- 	{
//--- 		return callJavaScriptIndenter(sourceCode);
//--- 	}
//--- 	else
//--- 	{
//--- 		return callExecutableIndenter(sourceCode, inputFileExtension);
//--- 	}
//--- }
//--- 
//--- /*
//---     \brief Format \a sourceCode by calling the interpreted JavaScript code of the indenter.
//--- 
//---     The \a inputFileExtension has to be given as parameter so the called indenter
//---     can identify the programming language if needed.
//---  */
//--- TQString IndentHandler::callJavaScriptIndenter(TQString sourceCode)
//--- {
//--- 	TQScriptEngine engine;
//--- 
//--- 	engine.globalObject().setProperty("unformattedCode", sourceCode);
//--- 
//--- 	TQFile   jsDecoderFile(m_indenterExecutableCallString);
//--- 	TQString jsDecoderCode;
//--- 	if (jsDecoderFile.open(TQFile::ReadOnly))
//--- 	{
//--- 		jsDecoderCode = jsDecoderFile.readAll();
//--- 	}
//--- 	jsDecoderFile.close();
//--- 
//--- 	TQScriptValue value = engine.evaluate(jsDecoderCode);
//--- 	return value.toString();
//--- }
//--- 
//--- /*
//---     \brief Format \a sourceCode by calling the binary executable of the indenter.
//--- 
//---     The \a inputFileExtension has to be given as parameter so the called indenter
//---     can identify the programming language if needed.
//---  */
//--- TQString IndentHandler::callExecutableIndenter(TQString sourceCode, TQString inputFileExtension)
//--- {
//--- 	Q_ASSERT_X(!_inputFileName.isEmpty(), "callIndenter", "_inputFileName is empty");
//--- 	//    Q_ASSERT_X( !_outputFileName.isEmpty(), "callIndenter", "_outputFileName is empty" );
//--- 	Q_ASSERT_X(!_indenterFileName.isEmpty(), "callIndenter", "_indenterFileName is empty");
//--- 
//--- 	if (_indenterFileName.isEmpty())
//--- 	{
//--- 		return "";
//--- 	}
//--- 
//--- 	TQString  formattedSourceCode;
//--- 	TQString  indenterCompleteCallString;
//--- 	TQString  parameterInputFile;
//--- 	TQString  parameterOuputFile;
//--- 	TQString  parameterParameterFile;
//--- 	TQProcess indentProcess;
//--- 	TQString  processReturnString;
//--- 
//--- 	// Generate the parameter string that will be saved to the indenters config file
//--- 	TQString parameterString = getParameterString();
//--- 
//--- 	if (!_globalConfigFilename.isEmpty())
//--- 	{
//--- 		saveConfigFile(m_tempDirectoryStr + "/" + _globalConfigFilename, parameterString);
//--- 	}
//--- 
//--- 	// Only add a dot to file extension if the string is not empty
//--- 	if (!inputFileExtension.isEmpty())
//--- 	{
//--- 		inputFileExtension = "." + inputFileExtension;
//--- 	}
//--- 
//--- 	// Delete any previously used input src file and create a new input src file.
//--- 	TQFile::remove(m_tempDirectoryStr + "/" + _inputFileName + inputFileExtension);
//--- 	TQFile inputSrcFile(m_tempDirectoryStr + "/" + _inputFileName + inputFileExtension);
//--- 	// Write the source code to the input file for the indenter
//--- 	if (inputSrcFile.open(TQFile::ReadWrite | TQFile::Text))
//--- 	{
//--- 		inputSrcFile.write(sourceCode.toUtf8());
//--- 		inputSrcFile.close();
//--- 		tqDebug() << __LINE__ << " " << __FUNCTION__ << ": Wrote to be indented source code to file " <<
//--- 		        inputSrcFile.fileName();
//--- 	}
//--- 	else
//--- 	{
//--- 		qCritical() << __LINE__ << " " << __FUNCTION__ <<
//--- 		        ": Couldn't write to be indented source code to file " << inputSrcFile.fileName();
//--- 	}
//--- 
//--- 	// Set the input file for the to be called indenter.
//--- 	if (_inputFileParameter.trimmed() == "<" || _inputFileParameter == "stdin")
//--- 	{
//--- 		parameterInputFile = "";
//--- 		indentProcess.setStandardInputFile(inputSrcFile.fileName());
//--- 	}
//--- 	else
//--- 	{
//--- 		parameterInputFile = " " + _inputFileParameter + _inputFileName + inputFileExtension;
//--- 	}
//--- 
//--- 	// Set the output file for the to be called indenter.
//--- 	if (_outputFileParameter != "none" && _outputFileParameter != "stdout")
//--- 	{
//--- 		parameterOuputFile = " " + _outputFileParameter + _outputFileName + inputFileExtension;
//--- 	}
//--- 
//--- 	// If the config file name is empty it is assumed that all parameters are sent via command line
//--- 	// call
//--- 	if (_globalConfigFilename.isEmpty())
//--- 	{
//--- 		parameterParameterFile = " " + parameterString;
//--- 	}
//--- 	// if needed add the parameter to the indenter call string where the config file can be found
//--- 	else if (_useCfgFileParameter != "none")
//--- 	{
//--- 		parameterParameterFile = " " + _useCfgFileParameter + "\"" + m_tempDirectoryStr + "/" +
//--- 		        _globalConfigFilename + "\"";
//--- 	}
//--- 
//--- 	// Assemble indenter call string for parameters according to the set order.
//--- 	if (_parameterOrder == "ipo")
//--- 	{
//--- 		indenterCompleteCallString = parameterInputFile + parameterParameterFile + parameterOuputFile;
//--- 	}
//--- 	else if (_parameterOrder == "pio")
//--- 	{
//--- 		indenterCompleteCallString = parameterParameterFile + parameterInputFile + parameterOuputFile;
//--- 	}
//--- 	else if (_parameterOrder == "poi")
//--- 	{
//--- 		indenterCompleteCallString = parameterParameterFile + parameterOuputFile + parameterInputFile;
//--- 	}
//--- 	else
//--- 	{
//--- 		indenterCompleteCallString = parameterInputFile + parameterOuputFile + parameterParameterFile;
//--- 	}
//--- 
//--- 	// If no indenter executable call string could be created before, show an error message.
//--- 	if (m_indenterExecutableCallString.isEmpty())
//--- 	{
//--- 		_errorMessageDialog->showMessage(tr("No indenter executable"), tr(
//--- 							"There exists no indenter executable with the name \"%1\" in the directory \"%2\" nor in the global environment.").arg(
//--- 							_indenterFileName).arg(m_indenterDirectoryStr));
//--- 		return sourceCode;
//--- 	}
//--- 
//--- 	// Generate the indenter call string either for win32 or other systems.
//--- 	indenterCompleteCallString = m_indenterExecutableCallString + indenterCompleteCallString;
//--- 
//--- 	// errors and standard outputs from the process call are merged together
//--- 	//indentProcess.setReadChannelMode(TQProcess::MergedChannels);
//--- 
//--- 	// Set the directory where the indenter will be executed for the process' environment as PWD.
//--- 	TQStringList env = indentProcess.environment();
//--- 	env << "PWD=" + TQFileInfo(m_tempDirectoryStr).absoluteFilePath();
//--- 	indentProcess.setEnvironment(env);
//--- 
//--- 	// Set the directory for the indenter execution
//--- 	indentProcess.setWorkingDirectory(TQFileInfo(m_tempDirectoryStr).absoluteFilePath());
//--- 
//--- 	tqDebug() << __LINE__ << " " << __FUNCTION__ << ": Will call the indenter in the directory " <<
//--- 	        indentProcess.workingDirectory() << " using this commandline call: " <<
//--- 	        indenterCompleteCallString;
//--- 
//--- 	indentProcess.start(indenterCompleteCallString);
//--- 
//--- 	processReturnString = "";
//--- 	bool calledProcessSuccessfully = indentProcess.waitForFinished(10000);
//--- 	// test if there was an error during starting the process of the indenter
//--- 	if (!calledProcessSuccessfully)
//--- 	{
//--- 		processReturnString  = "<html><body>";
//--- 		processReturnString += tr("<b>Returned error message:</b> ") + indentProcess.errorString() +
//--- 		        "<br>";
//--- 
//--- 		switch (indentProcess.error())
//--- 		{
//--- 			case TQProcess::FailedToStart:
//--- 			{
//--- 				processReturnString += tr("<b>Reason could be:</b> ") +
//--- 				        "The process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program.<br>";
//--- 				break;
//--- 			}
//--- 
//--- 			case TQProcess::Crashed:
//--- 			{
//--- 				processReturnString += "The process crashed some time after starting successfully.<br>";
//--- 				break;
//--- 			}
//--- 
//--- 			case TQProcess::Timedout:
//--- 			{
//--- 				processReturnString +=
//--- 				        "The called indenter did not response for over 10 seconds, so aborted its execution.<br>";
//--- 				break;
//--- 			}
//--- 
//--- 			case TQProcess::WriteError:
//--- 			{
//--- 				processReturnString +=
//--- 				        "An error occurred when attempting to write to the process. For example, the process may not be running, or it may have closed its input channel.<br>";
//--- 				break;
//--- 			}
//--- 
//--- 			case TQProcess::ReadError:
//--- 			{
//--- 				processReturnString +=
//--- 				        "An error occurred when attempting to read from the process. For example, the process may not be running.<br>";
//--- 				break;
//--- 			}
//--- 
//--- 			case TQProcess::UnknownError:
//--- 			{
//--- 				processReturnString +=
//--- 				        "An unknown error occurred. This is the default return value of error().<br>";
//--- 				break;
//--- 			}
//--- 
//--- 			default:
//--- 			{
//--- 				break;
//--- 			}
//--- 		}
//--- 		processReturnString += tr("<br><b>Callstring was:</b> ") + encodeToHTML(
//--- 			indenterCompleteCallString);
//--- 		processReturnString += tr("<br><br><b>Indenter output was:</b><pre>") + "<br>" + "(STDOUT):" +
//--- 		        encodeToHTML(indentProcess.readAllStandardOutput()) + "<br>" + "(STDERR):" +
//--- 		        encodeToHTML(indentProcess.readAllStandardError()) + "<br>" + "</pre></html></body>";
//--- 		tqWarning() << __LINE__ << " " << __FUNCTION__ << processReturnString;
//--- 		TQApplication::restoreOverrideCursor();
//--- 		_errorMessageDialog->showMessage(tr("Error calling Indenter"), processReturnString);
//--- 	}
//--- 
//--- 	// If the indenter returned an error code != 0 show its output.
//--- 	if (indentProcess.exitCode() != 0)
//--- 	{
//--- 		TQString exitCode;
//--- 		exitCode.setNum(indentProcess.exitCode());
//--- 		processReturnString = tr("<b>Indenter returned with exit code:</b> ") + exitCode + "<br>" + tr(
//--- 			"<b>Indent console output was:</b> ") + "<br>" + "(STDOUT):" + encodeToHTML(
//--- 			indentProcess.readAllStandardOutput()) + "<br>" + "(STDERR):" + encodeToHTML(
//--- 			indentProcess.readAllStandardError()) + "<br>" + tr("<br><b>Callstring was:</b> ") +
//--- 		        encodeToHTML(indenterCompleteCallString) + "</html></body>";
//--- 		tqWarning() << __LINE__ << " " << __FUNCTION__ << processReturnString;
//--- 		TQApplication::restoreOverrideCursor();
//--- 		_errorMessageDialog->showMessage(tr("Indenter returned error"), processReturnString);
//--- 	}
//--- 
//--- 	// Only get the formatted source code, if calling the indenter did succeed.
//--- 	if (calledProcessSuccessfully)
//--- 	{
//--- 		// If the indenter results are written to stdout, read them from there...
//--- 		if (indentProcess.exitCode() == 0 && _outputFileParameter == "stdout")
//--- 		{
//--- 			formattedSourceCode = indentProcess.readAllStandardOutput();
//--- 			tqDebug() << __LINE__ << " " << __FUNCTION__ << ": Read indenter output from StdOut.";
//--- 		}
//--- 		// ... else read the output file generated by the indenter call.
//--- 		else
//--- 		{
//--- 			TQFile outSrcFile(m_tempDirectoryStr + "/" + _outputFileName + inputFileExtension);
//--- 			if (outSrcFile.open(TQFile::ReadOnly | TQFile::Text))
//--- 			{
//--- 				TQTextStream outSrcStrm(&outSrcFile);
//--- 				outSrcStrm.setCodec(TQTextCodec::codecForName("UTF-8"));
//--- 				formattedSourceCode = outSrcStrm.readAll();
//--- 				outSrcFile.close();
//--- 				tqDebug() << __LINE__ << " " << __FUNCTION__ << ": Read indenter output from file " <<
//--- 				        outSrcFile.fileName();
//--- 			}
//--- 			else
//--- 			{
//--- 				qCritical() << __LINE__ << " " << __FUNCTION__ <<
//--- 				        ": Couldn't read indenter output from file " << outSrcFile.fileName();
//--- 			}
//--- 		}
//--- 	}
//--- 	else
//--- 	{
//--- 		return sourceCode;
//--- 	}
//--- 
//--- 	// Delete the temporary input and output files.
//--- 	TQFile::remove(m_tempDirectoryStr + "/" + _outputFileName + inputFileExtension);
//--- 	TQFile::remove(m_tempDirectoryStr + "/" + _inputFileName + inputFileExtension);
//--- 
//--- 	return formattedSourceCode;
//--- }
//--- 
//--- /*
//---     \brief Generates and returns a string with all parameters needed to call the indenter.
//---  */
//--- TQString IndentHandler::getParameterString()
//--- {
//--- 	TQString parameterString = "";
//--- 
//--- 	// generate parameter string for all boolean values
//--- 	foreach(ParamBoolean pBoolean, _paramBooleans)
//--- 	{
//--- 		if (pBoolean.checkBox->isChecked())
//--- 		{
//--- 			if (!pBoolean.trueString.isEmpty())
//--- 			{
//--- 				parameterString += pBoolean.trueString + _cfgFileParameterEnding;
//--- 			}
//--- 		}
//--- 		else
//--- 		{
//--- 			if (!pBoolean.falseString.isEmpty())
//--- 			{
//--- 				parameterString += pBoolean.falseString + _cfgFileParameterEnding;
//--- 			}
//--- 		}
//--- 	}
//--- 
//--- 	// generate parameter string for all numeric values
//--- 	foreach(ParamNumeric pNumeric, _paramNumerics)
//--- 	{
//--- 		if (pNumeric.valueEnabledChkBox->isChecked())
//--- 		{
//--- 			parameterString += pNumeric.paramCallName + TQString::number(pNumeric.spinBox->value()) +
//--- 			        _cfgFileParameterEnding;
//--- 		}
//--- 	}
//--- 
//--- 	// generate parameter string for all string values
//--- 	foreach(ParamString pString, _paramStrings)
//--- 	{
//--- 		if (!pString.lineEdit->text().isEmpty() && pString.valueEnabledChkBox->isChecked())
//--- 		{
//--- 			// Create parameter definition for each value devided by a | sign.
//--- 			foreach(TQString paramValue, pString.lineEdit->text().split("|"))
//--- 			{
//--- 				parameterString += pString.paramCallName + paramValue + _cfgFileParameterEnding;
//--- 			}
//--- 		}
//--- 	}
//--- 
//--- 	// generate parameter string for all multiple choice values
//--- 	foreach(ParamMultiple pMultiple, _paramMultiples)
//--- 	{
//--- 		if (pMultiple.valueEnabledChkBox->isChecked())
//--- 		{
//--- 			parameterString += pMultiple.choicesStrings.at(pMultiple.comboBox->currentIndex()) +
//--- 			        _cfgFileParameterEnding;
//--- 		}
//--- 	}
//--- 
//--- 	return parameterString;
//--- }
//--- 
//--- /*
//---     \brief Write settings for the indenter to a config file.
//---  */
//--- void IndentHandler::saveConfigFile(TQString filePathName, TQString paramString)
//--- {
//--- 	TQFile::remove(filePathName);
//--- 	TQFile cfgFile(filePathName);
//--- 
//--- 	cfgFile.open(TQFile::ReadWrite | TQFile::Text);
//--- 	cfgFile.write(paramString.toAscii());
//--- 	cfgFile.close();
//--- }
//--- 
//--- /*
//---     \brief Load the config file for the indenter and apply the settings made there.
//---  */
//--- bool IndentHandler::loadConfigFile(TQString filePathName)
//--- {
//--- 	TQFile   cfgFile(filePathName);
//--- 	int      index;
//--- 	int      crPos;
//--- 	int      paramValue    = 0;
//--- 	TQString paramValueStr = "";
//--- 	TQString cfgFileData   = "";
//--- 
//--- 	// If the to be loaded config file does not exist leave all values as they are and return false.
//--- 	if (!cfgFile.exists())
//--- 	{
//--- 		return false;
//--- 	}
//--- 	// else if the to be read config file exists, retrieve its whole content.
//--- 	else
//--- 	{
//--- 		// Open the config file and read all data
//--- 		cfgFile.open(TQFile::ReadOnly | TQFile::Text);
//--- 		cfgFileData = cfgFile.readAll();
//--- 		cfgFile.close();
//--- 	}
//--- 
//--- 	// Search for name of each boolean parameter and set its value if found.
//--- 	foreach(ParamBoolean pBoolean, _paramBooleans)
//--- 	{
//--- 		// boolean value that will be assigned to the checkbox
//--- 		bool paramValue = false;
//--- 
//--- 		// first search for the longer parameter string
//--- 		// the true parameter string is longer than the false string
//--- 		if (pBoolean.trueString.length() > pBoolean.falseString.length())
//--- 		{
//--- 			// search for the true string
//--- 			index = cfgFileData.indexOf(pBoolean.trueString, 0, TQt::CaseInsensitive);
//--- 			// if true string found set the parameter value to true
//--- 			if (index != -1)
//--- 			{
//--- 				paramValue = true;
//--- 			}
//--- 			// if true string not found, search for false string
//--- 			else
//--- 			{
//--- 				index = cfgFileData.indexOf(pBoolean.falseString, 0, TQt::CaseInsensitive);
//--- 				// if false string found set the parameter value to false
//--- 				if (index != -1)
//--- 				{
//--- 					paramValue = false;
//--- 				}
//--- 				// neither true nor false parameter found so use default value
//--- 				else
//--- 				{
//--- 					paramValue = _indenterSettings->value(pBoolean.paramName + "/ValueDefault").toBool();
//--- 				}
//--- 			}
//--- 		}
//--- 		// the false parameter string is longer than the true string
//--- 		else
//--- 		{
//--- 			// search for the false string
//--- 			index = cfgFileData.indexOf(pBoolean.falseString, 0, TQt::CaseInsensitive);
//--- 			// if false string found set the parameter value to false
//--- 			if (index != -1)
//--- 			{
//--- 				paramValue = false;
//--- 			}
//--- 			// if false string not found, search for true string
//--- 			else
//--- 			{
//--- 				index = cfgFileData.indexOf(pBoolean.trueString, 0, TQt::CaseInsensitive);
//--- 				// if true string found set the parameter value to true
//--- 				if (index != -1)
//--- 				{
//--- 					paramValue = true;
//--- 				}
//--- 				// neither true nor false parameter found so use default value
//--- 				else
//--- 				{
//--- 					paramValue = _indenterSettings->value(pBoolean.paramName + "/ValueDefault").toBool();
//--- 				}
//--- 			}
//--- 		}
//--- 		pBoolean.checkBox->setChecked(paramValue);
//--- 	}
//--- 
//--- 	// Search for name of each numeric parameter and set the value found behind it.
//--- 	foreach(ParamNumeric pNumeric, _paramNumerics)
//--- 	{
//--- 		index = cfgFileData.indexOf(pNumeric.paramCallName, 0, TQt::CaseInsensitive);
//--- 		// parameter was found in config file
//--- 		if (index != -1)
//--- 		{
//--- 			// set index after the parameter name, so in front of the number
//--- 			index += pNumeric.paramCallName.length();
//--- 
//--- 			// Find the end of the parameter by searching for set config file parameter ending. Most of
//--- 			// time this is a carriage return.
//--- 			crPos = cfgFileData.indexOf(_cfgFileParameterEnding, index + 1);
//--- 
//--- 			// get the number and convert it to int
//--- 			TQString test = cfgFileData.mid(index, crPos - index);
//--- 			paramValue = cfgFileData.mid(index, crPos - index).toInt(nullptr);
//--- 
//--- 			// disable the signal-slot connection. Otherwise signal is emmitted each time when value is
//--- 			// set
//--- 			TQObject::disconnect(pNumeric.spinBox, SIGNAL(valueChanged(int)), this,
//--- 			        SLOT(handleChangedIndenterSettings()));
//--- 			pNumeric.spinBox->setValue(paramValue);
//--- 			pNumeric.valueEnabledChkBox->setChecked(true);
//--- 			TQObject::connect(pNumeric.spinBox, SIGNAL(valueChanged(int)), this,
//--- 			        SLOT(handleChangedIndenterSettings()));
//--- 		}
//--- 		// parameter was not found in config file
//--- 		else
//--- 		{
//--- 			int defaultValue = _indenterSettings->value(pNumeric.paramName + "/ValueDefault").toInt();
//--- 			pNumeric.spinBox->setValue(defaultValue);
//--- 			pNumeric.valueEnabledChkBox->setChecked(false);
//--- 		}
//--- 	}
//--- 
//--- 	// Search for name of each string parameter and set it.
//--- 	foreach(ParamString pString, _paramStrings)
//--- 	{
//--- 		paramValueStr = "";
//--- 		// The number of the found values for this parameter name.
//--- 		int numberOfValues = 0;
//--- 		index = cfgFileData.indexOf(pString.paramCallName, 0, TQt::CaseInsensitive);
//--- 		// If parameter was found in config file
//--- 		if (index != -1)
//--- 		{
//--- 			while (index != -1)
//--- 			{
//--- 				numberOfValues++;
//--- 
//--- 				// Set index after the parameter name, so it points to the front of the string value.
//--- 				index += pString.paramCallName.length();
//--- 
//--- 				// Find the end of the parameter by searching for set config file parameter ending. Most of
//--- 				// time this is a carriage return.
//--- 				crPos = cfgFileData.indexOf(_cfgFileParameterEnding, index + 1);
//--- 
//--- 				// Get the string and remember it.
//--- 				if (numberOfValues < 2)
//--- 				{
//--- 					paramValueStr = TQString(cfgFileData.mid(index, crPos - index));
//--- 				}
//--- 				// If the same parameter has been set multiple times, concatenate the strings dvivided by a
//--- 				// |.
//--- 				else
//--- 				{
//--- 					paramValueStr = paramValueStr + "|" + TQString(cfgFileData.mid(index, crPos - index));
//--- 				}
//--- 
//--- 				// Get next value for this setting, if one exists.
//--- 				index = cfgFileData.indexOf(pString.paramCallName, crPos + 1, TQt::CaseInsensitive);
//--- 			}
//--- 			// Set the text for the line edit.
//--- 			pString.lineEdit->setText(paramValueStr);
//--- 			pString.valueEnabledChkBox->setChecked(true);
//--- 		}
//--- 		// Parameter was not found in config file
//--- 		else
//--- 		{
//--- 			paramValueStr = _indenterSettings->value(pString.paramName + "/ValueDefault").toString();
//--- 			pString.lineEdit->setText(paramValueStr);
//--- 			pString.valueEnabledChkBox->setChecked(false);
//--- 		}
//--- 	}
//--- 
//--- 	// search for name of each multiple choice parameter and set it
//--- 	foreach(ParamMultiple pMultiple, _paramMultiples)
//--- 	{
//--- 		int i = 0;
//--- 		index = -1;
//--- 
//--- 		// search for all parameter names of the multiple choice list
//--- 		// if one is found, set it and leave the while loop
//--- 		while (i < pMultiple.choicesStrings.count() && index == -1)
//--- 		{
//--- 			index = cfgFileData.indexOf(pMultiple.choicesStrings.at(i), 0, TQt::CaseInsensitive);
//--- 			if (index != -1)
//--- 			{
//--- 				pMultiple.comboBox->setCurrentIndex(i);
//--- 				pMultiple.valueEnabledChkBox->setChecked(true);
//--- 			}
//--- 			i++;
//--- 		}
//--- 
//--- 		// parameter was not set in config file, so use default value
//--- 		if (index == -1)
//--- 		{
//--- 			int defaultValue = _indenterSettings->value(pMultiple.paramName + "/ValueDefault").toInt();
//--- 			pMultiple.comboBox->setCurrentIndex(defaultValue);
//--- 			pMultiple.valueEnabledChkBox->setChecked(false);
//--- 		}
//--- 	}
//--- 
//--- 	return true;
//--- }
//--- 
//--- /*
//---     \brief Sets all indenter parameters to their default values defined in the ini file.
//---  */
//--- void IndentHandler::resetToDefaultValues()
//--- {
//--- 	// Search for name of each boolean parameter and set its value if found.
//--- 	foreach(ParamBoolean pBoolean, _paramBooleans)
//--- 	{
//--- 		// Boolean value that will be assigned to the checkbox.
//--- 		bool defaultValue = _indenterSettings->value(pBoolean.paramName + "/ValueDefault").toBool();
//--- 		pBoolean.checkBox->setChecked(defaultValue);
//--- 	}
//--- 
//--- 	// Search for name of each numeric parameter and set the value found behind it.
//--- 	foreach(ParamNumeric pNumeric, _paramNumerics)
//--- 	{
//--- 		int defaultValue = _indenterSettings->value(pNumeric.paramName + "/ValueDefault").toInt();
//--- 		pNumeric.spinBox->setValue(defaultValue);
//--- 		pNumeric.valueEnabledChkBox->setChecked(_indenterSettings->value(
//--- 							pNumeric.paramName + "/Enabled").toBool());
//--- 	}
//--- 
//--- 	// Search for name of each string parameter and set it.
//--- 	foreach(ParamString pString, _paramStrings)
//--- 	{
//--- 		TQString defaultValue =
//--- 		        _indenterSettings->value(pString.paramName + "/ValueDefault").toString();
//--- 		pString.lineEdit->setText(defaultValue);
//--- 		pString.valueEnabledChkBox->setChecked(_indenterSettings->value(
//--- 							pString.paramName + "/Enabled").toBool());
//--- 	}
//--- 
//--- 	// Search for name of each multiple choice parameter and set it.
//--- 	foreach(ParamMultiple pMultiple, _paramMultiples)
//--- 	{
//--- 		int defaultValue = _indenterSettings->value(pMultiple.paramName + "/ValueDefault").toInt();
//--- 		pMultiple.comboBox->setCurrentIndex(defaultValue);
//--- 		pMultiple.valueEnabledChkBox->setChecked(_indenterSettings->value(pMultiple.paramName +
//--- 		        "/Enabled").toBool());
//--- 	}
//--- }
//--- 
//--- /*
//---     \brief Opens and parses the indenter ini file that is declared by \a iniFilePath.
//---  */
//--- void IndentHandler::readIndentIniFile(TQString iniFilePath)
//--- {
//--- 	Q_ASSERT_X(!iniFilePath.isEmpty(), "readIndentIniFile", "iniFilePath is empty");
//--- 
//--- 	// open the ini-file that contains all available indenter settings with their additional infos
//--- 	_indenterSettings = new UiGuiIniFileParser(iniFilePath);
//--- 
//--- 	TQStringList categories;
//--- 	//TQString indenterGroupString = "";
//--- 	TQString paramToolTip = "";
//--- 
//--- 	//
//--- 	//  parse ini file indenter header
//--- 	//
//--- 
//--- 	_indenterName           = _indenterSettings->value("header/indenterName").toString();
//--- 	_indenterFileName       = _indenterSettings->value("header/indenterFileName").toString();
//--- 	_globalConfigFilename   = _indenterSettings->value("header/configFilename").toString();
//--- 	_useCfgFileParameter    = _indenterSettings->value("header/useCfgFileParameter").toString();
//--- 	_cfgFileParameterEnding = _indenterSettings->value("header/cfgFileParameterEnding").toString();
//--- 	if (_cfgFileParameterEnding == "cr")
//--- 	{
//--- 		_cfgFileParameterEnding = "\n";
//--- 	}
//--- 	_indenterShowHelpParameter = _indenterSettings->value("header/showHelpParameter").toString();
//--- 
//--- 	if (_indenterFileName.isEmpty())
//--- 	{
//--- 		_errorMessageDialog->showMessage(tr("Indenter ini file header error"), tr(
//--- 							"The loaded indenter ini file \"%1\"has a faulty header. At least the indenters file name is not set.").arg(
//--- 							iniFilePath));
//--- 	}
//--- 
//--- 	// Read the parameter order. Possible values are (p=parameter[file] i=inputfile o=outputfile)
//--- 	// pio, ipo, iop
//--- 	_parameterOrder      = _indenterSettings->value("header/parameterOrder", "pio").toString();
//--- 	_inputFileParameter  = _indenterSettings->value("header/inputFileParameter").toString();
//--- 	_inputFileName       = _indenterSettings->value("header/inputFileName").toString();
//--- 	_outputFileParameter = _indenterSettings->value("header/outputFileParameter").toString();
//--- 	_outputFileName      = _indenterSettings->value("header/outputFileName").toString();
//--- 	_fileTypes = _indenterSettings->value("header/fileTypes").toString();
//--- 	_fileTypes.replace('|', " ");
//--- 
//--- 	// read the categories names which are separated by "|"
//--- 	TQString categoriesStr = _indenterSettings->value("header/categories").toString();
//--- 	categories = categoriesStr.split("|");
//--- 	// Assure that the category list is never empty. At least contain a "general" section.
//--- 	if (categories.isEmpty())
//--- 	{
//--- 		categories.append("General");
//--- 	}
//--- 
//--- 	IndenterParameterCategoryPage categoryPage;
//--- 
//--- 	// create a page for each category and store its references in a toolboxpage-array
//--- 	foreach(TQString category, categories)
//--- 	{
//--- 		categoryPage.widget = new TQWidget();
//--- 		categoryPage.widget->setObjectName(category);
//--- 		categoryPage.widget->setSizePolicy(TQSizePolicy::MinimumExpanding,
//--- 		        TQSizePolicy::MinimumExpanding);
//--- 		categoryPage.vboxLayout = new TQVBoxLayout(categoryPage.widget);
//--- 		categoryPage.vboxLayout->setSpacing(6);
//--- 		categoryPage.vboxLayout->setMargin(9);
//--- 		categoryPage.vboxLayout->setObjectName(category);
//--- 		_indenterParameterCategoryPages.append(categoryPage);
//--- 		m_indenterParameterCategoriesToolBox->addItem(categoryPage.widget, category);
//--- 	}
//--- 
//--- 	//
//--- 	//  parse ini file indenter parameters
//--- 	//
//--- 
//--- 	// read all possible parameters written in brackets []
//--- 	_indenterParameters = _indenterSettings->childGroups();
//--- 
//--- 	// read each parameter to create the corresponding input field
//--- 	foreach(TQString indenterParameter, _indenterParameters)
//--- 	{
//--- 		// if it is not the indent header definition read the parameter and add it to
//--- 		// the corresponding category toolbox page
//--- 		if (indenterParameter != "header")
//--- 		{
//--- 			// read to which category the parameter belongs
//--- 			int category = _indenterSettings->value(indenterParameter + "/Category").toInt();
//--- 			// Assure that the category number is never greater than the available categories.
//--- 			if (category > _indenterParameterCategoryPages.size() - 1)
//--- 			{
//--- 				category = _indenterParameterCategoryPages.size() - 1;
//--- 			}
//--- 			// read which type of input field the parameter needs
//--- 			TQString editType = _indenterSettings->value(indenterParameter + "/EditorType").toString();
//--- 
//--- 			// edit type is numeric so create a spinbox with label
//--- 			if (editType == "numeric")
//--- 			{
//--- 				// read the parameter name as it is used at the command line or in its config file
//--- 				TQString parameterCallName =
//--- 				        _indenterSettings->value(indenterParameter + "/CallName").toString();
//--- 
//--- 				// create checkbox which enables or disables the parameter
//--- 				TQCheckBox *chkBox = new TQCheckBox(_indenterParameterCategoryPages.at(category).widget);
//--- 				chkBox->setChecked(_indenterSettings->value(indenterParameter + "/Enabled").toBool());
//--- 				chkBox->setToolTip(
//--- 					"Enables/disables the parameter. If disabled the indenters default value will be used.");
//--- 				chkBox->setSizePolicy(TQSizePolicy::Fixed, TQSizePolicy::Fixed);
//--- 				int left, top, right, bottom;
//--- 				chkBox->getContentsMargins(&left, &top, &right, &bottom);
//--- 				chkBox->setContentsMargins(left, top, 0, bottom);
//--- 
//--- 				// create the spinbox
//--- 				TQSpinBox *spinBox = new TQSpinBox(_indenterParameterCategoryPages.at(category).widget);
//--- 				paramToolTip = _indenterSettings->value(indenterParameter + "/Description").toString();
//--- 				spinBox->setToolTip(paramToolTip);
//--- 				spinBox->setMaximumWidth(50);
//--- 				spinBox->setMinimumWidth(50);
//--- 				if (m_mainWindow != nullptr)
//--- 				{
//--- 					spinBox->installEventFilter(m_mainWindow);
//--- 				}
//--- 				if (_indenterSettings->value(indenterParameter + "/MinVal").toString() != "")
//--- 				{
//--- 					spinBox->setMinimum(_indenterSettings->value(indenterParameter + "/MinVal").toInt());
//--- 				}
//--- 				else
//--- 				{
//--- 					spinBox->setMinimum(0);
//--- 				}
//--- 				if (_indenterSettings->value(indenterParameter + "/MaxVal").toString() != "")
//--- 				{
//--- 					spinBox->setMaximum(_indenterSettings->value(indenterParameter + "/MaxVal").toInt());
//--- 				}
//--- 				else
//--- 				{
//--- 					spinBox->setMaximum(2000);
//--- 				}
//--- 
//--- 				// create the label
//--- 				TQLabel *label = new TQLabel(_indenterParameterCategoryPages.at(category).widget);
//--- 				label->setText(indenterParameter);
//--- 				label->setBuddy(spinBox);
//--- 				label->setToolTip(paramToolTip);
//--- 				if (m_mainWindow != nullptr)
//--- 				{
//--- 					label->installEventFilter(m_mainWindow);
//--- 				}
//--- 
//--- 				// put all into a layout and add it to the toolbox page
//--- 				TQHBoxLayout *hboxLayout = new TQHBoxLayout();
//--- 				hboxLayout->addWidget(chkBox);
//--- 				hboxLayout->addWidget(spinBox);
//--- 				hboxLayout->addWidget(label);
//--- 				_indenterParameterCategoryPages.at(category).vboxLayout->addLayout(hboxLayout);
//--- 
//--- 				// remember parameter name and reference to its spinbox
//--- 				ParamNumeric paramNumeric;
//--- 				paramNumeric.paramName     = indenterParameter;
//--- 				paramNumeric.paramCallName = parameterCallName;
//--- 				paramNumeric.spinBox       = spinBox;
//--- 				paramNumeric.label = label;
//--- 				paramNumeric.valueEnabledChkBox = chkBox;
//--- 				paramNumeric.spinBox->setValue(_indenterSettings->value(paramNumeric.paramName +
//--- 				        "/ValueDefault").toInt());
//--- 				_paramNumerics.append(paramNumeric);
//--- 
//--- 				TQObject::connect(spinBox, SIGNAL(valueChanged(int)), this,
//--- 				        SLOT(handleChangedIndenterSettings()));
//--- 				TQObject::connect(chkBox, SIGNAL(clicked()), this, SLOT(handleChangedIndenterSettings()));
//--- 			}
//--- 			// edit type is boolean so create a checkbox
//--- 			else if (editType == "boolean")
//--- 			{
//--- 				// create the checkbox, make its settings and add it to the toolbox page
//--- 				TQCheckBox *chkBox = new TQCheckBox(_indenterParameterCategoryPages.at(category).widget);
//--- 				chkBox->setText(indenterParameter);
//--- 				paramToolTip = _indenterSettings->value(indenterParameter + "/Description").toString();
//--- 				chkBox->setToolTip(paramToolTip);
//--- 				if (m_mainWindow != nullptr)
//--- 				{
//--- 					chkBox->installEventFilter(m_mainWindow);
//--- 				}
//--- 				_indenterParameterCategoryPages.at(category).vboxLayout->addWidget(chkBox);
//--- 
//--- 				// remember parameter name and reference to its checkbox
//--- 				ParamBoolean paramBoolean;
//--- 				paramBoolean.paramName = indenterParameter;
//--- 				paramBoolean.checkBox  = chkBox;
//--- 				TQStringList trueFalseStrings =
//--- 				        _indenterSettings->value(indenterParameter + "/TrueFalse").toString().split("|");
//--- 				paramBoolean.trueString  = trueFalseStrings.at(0);
//--- 				paramBoolean.falseString = trueFalseStrings.at(1);
//--- 				paramBoolean.checkBox->setChecked(_indenterSettings->value(paramBoolean.paramName +
//--- 				        "/ValueDefault").toBool());
//--- 				_paramBooleans.append(paramBoolean);
//--- 
//--- 				TQObject::connect(chkBox, SIGNAL(clicked()), this, SLOT(handleChangedIndenterSettings()));
//--- 			}
//--- 			// edit type is numeric so create a line edit with label
//--- 			else if (editType == "string")
//--- 			{
//--- 				// read the parameter name as it is used at the command line or in its config file
//--- 				TQString parameterCallName =
//--- 				        _indenterSettings->value(indenterParameter + "/CallName").toString();
//--- 
//--- 				// create check box which enables or disables the parameter
//--- 				TQCheckBox *chkBox = new TQCheckBox(_indenterParameterCategoryPages.at(category).widget);
//--- 				chkBox->setChecked(_indenterSettings->value(indenterParameter + "/Enabled").toBool());
//--- 				chkBox->setToolTip(
//--- 					"Enables/disables the parameter. If disabled the indenters default value will be used.");
//--- 				chkBox->setSizePolicy(TQSizePolicy::Fixed, TQSizePolicy::Fixed);
//--- 				int left, top, right, bottom;
//--- 				chkBox->getContentsMargins(&left, &top, &right, &bottom);
//--- 				chkBox->setContentsMargins(left, top, 0, bottom);
//--- 
//--- 				// create the line edit
//--- 				TQLineEdit *lineEdit = new TQLineEdit(_indenterParameterCategoryPages.at(category).widget);
//--- 				paramToolTip = _indenterSettings->value(indenterParameter + "/Description").toString();
//--- 				lineEdit->setToolTip(paramToolTip);
//--- 				lineEdit->setMaximumWidth(50);
//--- 				lineEdit->setMinimumWidth(50);
//--- 				if (m_mainWindow != nullptr)
//--- 				{
//--- 					lineEdit->installEventFilter(m_mainWindow);
//--- 				}
//--- 
//--- 				// create the label
//--- 				TQLabel *label = new TQLabel(_indenterParameterCategoryPages.at(category).widget);
//--- 				label->setText(indenterParameter);
//--- 				label->setBuddy(lineEdit);
//--- 				label->setSizePolicy(TQSizePolicy::MinimumExpanding, TQSizePolicy::Preferred);
//--- 				label->setToolTip(paramToolTip);
//--- 				if (m_mainWindow != nullptr)
//--- 				{
//--- 					label->installEventFilter(m_mainWindow);
//--- 				}
//--- 
//--- 				// put all into a layout and add it to the toolbox page
//--- 				TQHBoxLayout *hboxLayout = new TQHBoxLayout();
//--- 				hboxLayout->addWidget(chkBox);
//--- 				hboxLayout->addWidget(lineEdit);
//--- 				hboxLayout->addWidget(label);
//--- 				_indenterParameterCategoryPages.at(category).vboxLayout->addLayout(hboxLayout);
//--- 
//--- 				// remember parameter name and reference to its line edit
//--- 				ParamString paramString;
//--- 				paramString.paramName     = indenterParameter;
//--- 				paramString.paramCallName = parameterCallName;
//--- 				paramString.lineEdit      = lineEdit;
//--- 				paramString.label = label;
//--- 				paramString.valueEnabledChkBox = chkBox;
//--- 				paramString.lineEdit->setText(_indenterSettings->value(paramString.paramName +
//--- 				        "/ValueDefault").toString());
//--- 				_paramStrings.append(paramString);
//--- 
//--- 				TQObject::connect(lineEdit, SIGNAL(editingFinished()), this,
//--- 				        SLOT(handleChangedIndenterSettings()));
//--- 				TQObject::connect(chkBox, SIGNAL(clicked()), this, SLOT(handleChangedIndenterSettings()));
//--- 			}
//--- 			// edit type is multiple so create a combobox with label
//--- 			else if (editType == "multiple")
//--- 			{
//--- 				// read the parameter name as it is used at the command line or in its config file
//--- 				TQString parameterCallName =
//--- 				        _indenterSettings->value(indenterParameter + "/CallName").toString();
//--- 
//--- 				// create checkbox which enables or disables the parameter
//--- 				TQCheckBox *chkBox = new TQCheckBox(_indenterParameterCategoryPages.at(category).widget);
//--- 				chkBox->setChecked(_indenterSettings->value(indenterParameter + "/Enabled").toBool());
//--- 				chkBox->setToolTip(
//--- 					"Enables/disables the parameter. If disabled the indenters default value will be used.");
//--- 				chkBox->setSizePolicy(TQSizePolicy::Fixed, TQSizePolicy::Fixed);
//--- 				int left, top, right, bottom;
//--- 				chkBox->getContentsMargins(&left, &top, &right, &bottom);
//--- 				chkBox->setContentsMargins(left, top, 0, bottom);
//--- 
//--- 				// create the combo box
//--- 				TQComboBox *comboBox = new TQComboBox(_indenterParameterCategoryPages.at(
//--- 									category).widget);
//--- 				TQStringList choicesStrings =
//--- 				        _indenterSettings->value(indenterParameter + "/Choices").toString().split("|");
//--- 				TQStringList choicesStringsReadable = _indenterSettings->value(
//--- 					indenterParameter + "/ChoicesReadable").toString().split("|", TQString::SkipEmptyParts);
//--- 				if (choicesStringsReadable.isEmpty())
//--- 				{
//--- 					comboBox->addItems(choicesStrings);
//--- 				}
//--- 				else
//--- 				{
//--- 					comboBox->addItems(choicesStringsReadable);
//--- 				}
//--- 				paramToolTip = _indenterSettings->value(indenterParameter + "/Description").toString();
//--- 				comboBox->setToolTip(paramToolTip);
//--- 				if (m_mainWindow != nullptr)
//--- 				{
//--- 					comboBox->installEventFilter(m_mainWindow);
//--- 				}
//--- 
//--- 				// put all into a layout and add it to the toolbox page
//--- 				TQHBoxLayout *hboxLayout = new TQHBoxLayout();
//--- 				hboxLayout->addWidget(chkBox);
//--- 				hboxLayout->addWidget(comboBox);
//--- 				_indenterParameterCategoryPages.at(category).vboxLayout->addLayout(hboxLayout);
//--- 
//--- 				// remember parameter name and reference to its lineedit
//--- 				ParamMultiple paramMultiple;
//--- 				paramMultiple.paramName      = indenterParameter;
//--- 				paramMultiple.paramCallName  = parameterCallName;
//--- 				paramMultiple.comboBox       = comboBox;
//--- 				paramMultiple.choicesStrings = choicesStrings;
//--- 				paramMultiple.choicesStringsReadable = choicesStringsReadable;
//--- 				paramMultiple.valueEnabledChkBox     = chkBox;
//--- 				paramMultiple.comboBox->setCurrentIndex(_indenterSettings->value(paramMultiple.paramName +
//--- 				        "/ValueDefault").toInt());
//--- 				_paramMultiples.append(paramMultiple);
//--- 
//--- 				TQObject::connect(comboBox, SIGNAL(activated(int)), this,
//--- 				        SLOT(handleChangedIndenterSettings()));
//--- 				TQObject::connect(chkBox, SIGNAL(clicked()), this, SLOT(handleChangedIndenterSettings()));
//--- 			}
//--- 		}
//--- 	}
//--- 
//--- 	// put a spacer at each page end
//--- 	foreach(IndenterParameterCategoryPage categoryPage, _indenterParameterCategoryPages)
//--- 	{
//--- 		categoryPage.vboxLayout->addStretch();
//--- 	}
//--- }
//--- 
//--- /*
//---     \brief Searches and returns all indenters a configuration file is found for.
//--- 
//---     Opens all uigui ini files found in the list \a _indenterIniFileList, opens each ini file
//---     and reads the there defined real name of the indenter. These names are being returned as TQStringList.
//---  */
//--- TQStringList IndentHandler::getAvailableIndenters()
//--- {
//--- 	TQStringList indenterNamesList;
//--- 
//--- 	// Loop for every existing uigui ini file
//--- 	foreach(TQString indenterIniFile, _indenterIniFileList)
//--- 	{
//--- 		// Open the ini file and search for the indenter name
//--- 		TQFile file(m_indenterDirectoryStr + "/" + indenterIniFile);
//--- 		if (file.open(TQIODevice::ReadOnly | TQIODevice::Text))
//--- 		{
//--- 			int index = -1;
//--- 			TQByteArray line;
//--- 			// Search for the string "indenterName=" and get the following string until line end.
//--- 			while (index == -1 && !file.atEnd())
//--- 			{
//--- 				line  = file.readLine();
//--- 				index = line.indexOf("indenterName=", 0);
//--- 			}
//--- 
//--- 			if (index == 0)
//--- 			{
//--- 				line = line.remove(0, 13);
//--- 				indenterNamesList << line.trimmed();
//--- 			}
//--- 		}
//--- 	}
//--- 	return indenterNamesList;
//--- }

/*
    \brief Deletes all elements in the toolbox and initializes the indenter selected by \a indenterID.
 */
void IndentHandler::setIndenter(int indenterID)
{
//--- 	TQApplication::setOverrideCursor(TQt::WaitCursor);
//--- 
//--- 	// Generate the parameter string that will be saved to the indenters config file.
//--- 	TQString parameterString = getParameterString();
//--- 	if (!_indenterFileName.isEmpty())
//--- 	{
//--- 		saveConfigFile(m_settingsDirectoryStr + "/" + _indenterFileName + ".cfg", parameterString);
//--- 	}
//--- 
//--- 	// Take care if the selected indenterID is smaller or greater than the number of existing
//--- 	// indenters
//--- 	if (indenterID < 0)
//--- 	{
//--- 		indenterID = 0;
//--- 	}
//--- 	if (indenterID >= _indenterIniFileList.count())
//--- 	{
//--- 		indenterID = _indenterIniFileList.count() - 1;
//--- 	}
//--- 
//---   // MIKE: TODO: need to save selected indenterID into Settings
//--- 
//--- 	// remove all pages from the toolbox
//--- 	for (int i = 0; i < m_indenterParameterCategoriesToolBox->count(); i++)
//--- 	{
//--- 		m_indenterParameterCategoriesToolBox->removeItem(i);
//--- 	}
//--- 
//--- 	// delete all toolbox pages and by this its children
//--- 	foreach(IndenterParameterCategoryPage categoryPage, _indenterParameterCategoryPages)
//--- 	{
//--- 		delete categoryPage.widget;
//--- 	}
//--- 
//--- 	// empty all lists, which stored infos for the toolbox pages and its widgets
//--- 	_indenterParameterCategoryPages.clear();
//--- 	_paramStrings.clear();
//--- 	_paramNumerics.clear();
//--- 	_paramBooleans.clear();
//--- 	_paramMultiples.clear();
//--- 	delete _indenterSettings;
//--- 
//--- 	readIndentIniFile(m_indenterDirectoryStr + "/" + _indenterIniFileList.at(indenterID));
//--- 
//--- 	// Find out how the indenter can be executed.
//--- 	createIndenterCallString();
//--- 
//--- 	// Load the users last settings made for this indenter.
//--- 	loadConfigFile(m_settingsDirectoryStr + "/" + _indenterFileName + ".cfg");
//--- 
//--- 	handleChangedIndenterSettings();
//--- 
//--- 	TQApplication::restoreOverrideCursor();
}

//--- /*
//---     \brief Returns a string containing by the indenter supported file types/extensions divided by a space.
//---  */
//--- TQString IndentHandler::getPossibleIndenterFileExtensions()
//--- {
//--- 	return _fileTypes;
//--- }
//--- 
//--- /*
//---     \brief Returns the path and filename of the current indenter config file.
//---  */
//--- TQString IndentHandler::getIndenterCfgFile()
//--- {
//--- 	TQFileInfo fileInfo(m_indenterDirectoryStr + "/" + _globalConfigFilename);
//--- 	return fileInfo.absoluteFilePath();
//--- }
//--- 
//--- /*
//---     \brief Tries to create a call path string for the indenter executable. If successful returns true.
//---  */
//--- bool IndentHandler::createIndenterCallString()
//--- {
//--- 	TQProcess indentProcess;
//--- 
//--- 	if (_indenterFileName.isEmpty())
//--- 	{
//--- 		return false;
//--- 	}
//--- 
//--- 	// First try to call the indenter inside of the data dir, using some suffix
//--- 	// ------------------------------------------------------------------------
//--- 
//--- 	// Set the directory for the indenter execution
//--- 	indentProcess.setWorkingDirectory(TQFileInfo(m_indenterDirectoryStr).absoluteFilePath());
//--- 
//--- 	foreach(TQString suffix, TQStringList() << "" << ".exe" << ".bat" << ".com" << ".sh")
//--- 	{
//--- 		m_indenterExecutableSuffix     = suffix;
//--- 		m_indenterExecutableCallString = TQFileInfo(m_indenterDirectoryStr).absoluteFilePath() + "/" +
//--- 		        _indenterFileName;
//--- 		m_indenterExecutableCallString += suffix;
//--- 
//--- 		// Only try to call the indenter, if the file exists.
//--- 		if (TQFile::exists(m_indenterExecutableCallString))
//--- 		{
//--- 			// Only try to call the indenter directly if it is no php file
//--- 			if (TQFileInfo(m_indenterExecutableCallString).suffix().toLower() != "php")
//--- 			{
//--- 				indentProcess.start(
//--- 					"\"" + m_indenterExecutableCallString +  +"\" " + _indenterShowHelpParameter);
//--- 				if (indentProcess.waitForFinished(2000))
//--- 				{
//--- 					m_indenterExecutableCallString = "\"" + m_indenterExecutableCallString + "\"";
//--- 					return true;
//--- 				}
//--- 				else if (indentProcess.error() == TQProcess::Timedout)
//--- 				{
//--- 					m_indenterExecutableCallString = "\"" + m_indenterExecutableCallString + "\"";
//--- 					return true;
//--- 				}
//--- 			}
//--- 
//--- 			// Test for needed interpreters
//--- 			// ----------------------------
//--- 			// If the file could not be executed, try to find a shebang at its start or test if its a php
//--- 			// file.
//--- 			TQString interpreterName = "";
//--- 			TQFile   indenterExecutable(m_indenterExecutableCallString);
//--- 
//--- 			// If indenter executable file has .php as suffix, use php as default interpreter
//--- 			if (TQFileInfo(m_indenterExecutableCallString).suffix().toLower() == "php")
//--- 			{
//--- 				interpreterName = "php -f";
//--- 			}
//--- 			// Else try to open the file and read the shebang.
//--- 			else if (indenterExecutable.open(TQFile::ReadOnly))
//--- 			{
//--- 				// Read the first line of the file.
//--- 				TQTextStream indenterExecutableContent(&indenterExecutable);
//--- 				TQString     firstLineOfIndenterExe = indenterExecutableContent.readLine(75);
//--- 				indenterExecutable.close();
//--- 
//--- 				// If the initial shebang is found, read the named intepreter. e.g. perl
//--- 				if (firstLineOfIndenterExe.startsWith("#!"))
//--- 				{
//--- 					// Get the rightmost word. by splitting the string into only full words.
//--- 					interpreterName = firstLineOfIndenterExe.split("/").last();
//--- 				}
//--- 			}
//--- 
//--- 			// Try to call the interpreter, if it exists.
//--- 			if (!interpreterName.isEmpty())
//--- 			{
//--- 				m_indenterExecutableCallString = interpreterName + " \"" + m_indenterExecutableCallString +
//--- 				        "\"";
//--- 				indentProcess.start(interpreterName + " -h");
//--- 				if (indentProcess.waitForFinished(2000))
//--- 				{
//--- 					return true;
//--- 				}
//--- 				else if (indentProcess.error() == TQProcess::Timedout)
//--- 				{
//--- 					return true;
//--- 				}
//--- 				// now we know an interpreter is needed but it could not be called, so inform the user.
//--- 				else
//--- 				{
//--- 					_errorMessageDialog->showMessage(tr("Interpreter needed"), tr(
//--- 										"To use the selected indenter the program \"%1\" needs to be available in the global environment. You should add an entry to your path settings.").arg(
//--- 										interpreterName));
//--- 					return true;
//--- 				}
//--- 			}
//--- 		}
//--- 	}
//--- 
//--- 	// If unsuccessful try if the indenter executable is a JavaScript file
//--- 	// -------------------------------------------------------------------
//--- 	m_indenterExecutableSuffix     = ".js";
//--- 	m_indenterExecutableCallString = TQFileInfo(m_indenterDirectoryStr).absoluteFilePath() + "/" +
//--- 	        _indenterFileName;
//--- 	m_indenterExecutableCallString += m_indenterExecutableSuffix;
//--- 	if (TQFile::exists(m_indenterExecutableCallString))
//--- 	{
//--- 		return true;
//--- 	}
//--- 
//--- 	// If unsuccessful try to call the indenter global, using some suffix
//--- 	// ------------------------------------------------------------------
//--- 	foreach(TQString suffix, TQStringList() << "" << ".exe" << ".bat" << ".com" << ".sh")
//--- 	{
//--- 		m_indenterExecutableSuffix     = suffix;
//--- 		m_indenterExecutableCallString = _indenterFileName + suffix;
//--- 		indentProcess.start(m_indenterExecutableCallString + " " + _indenterShowHelpParameter);
//--- 		if (indentProcess.waitForFinished(2000))
//--- 		{
//--- 			return true;
//--- 		}
//--- 		else if (indentProcess.error() == TQProcess::Timedout)
//--- 		{
//--- 			return true;
//--- 		}
//--- 	}
//--- 
//--- 	// If even globally calling the indenter fails, try calling .com and .exe via wine
//--- 	// -------------------------------------------------------------------------------
//--- 	m_indenterExecutableCallString = "\"" + TQFileInfo(m_indenterDirectoryStr).absoluteFilePath() + "/" +
//--- 	        _indenterFileName;
//--- 
//--- 	foreach(TQString suffix, TQStringList() << ".exe" << ".com")
//--- 	{
//--- 		m_indenterExecutableSuffix = suffix;
//--- 		if (TQFile::exists(m_indenterDirectoryStr + "/" + _indenterFileName + suffix))
//--- 		{
//--- 			TQProcess wineTestProcess;
//--- 			wineTestProcess.start("wine --version");
//--- 			// if the process of wine was not callable assume that wine is not installed
//--- 			if (!wineTestProcess.waitForFinished(2000))
//--- 			{
//--- 				_errorMessageDialog->showMessage(tr("wine not installed"), tr(
//--- 									"There exists only a win32 executable of the indenter and wine does not seem to be installed. Please install wine to be able to run the indenter."));
//--- 				m_indenterExecutableCallString = "";
//--- 				return false;
//--- 			}
//--- 			else
//--- 			{
//--- 				m_indenterExecutableCallString = "\"" +
//--- 				        TQFileInfo(m_indenterDirectoryStr).absoluteFilePath() + "/";
//--- 				m_indenterExecutableCallString += _indenterFileName + suffix + "\"";
//--- 				m_indenterExecutableCallString  = "wine " + m_indenterExecutableCallString;
//--- 
//--- 				return true;
//--- 			}
//--- 		}
//--- 	}
//--- 
//--- 	m_indenterExecutableCallString = "";
//--- 	m_indenterExecutableSuffix     = "";
//--- 	return false;
//--- }
//--- 
//--- /*
//---     \brief Returns a string that points to where the indenters manual can be found.
//---  */
//--- TQString IndentHandler::getManual()
//--- {
//--- 	if (_indenterSettings != nullptr)
//--- 	{
//--- 		return _indenterSettings->value("header/manual").toString();
//--- 	}
//--- 	else
//--- 	{
//--- 		return "";
//--- 	}
//--- }

/*
    \brief This slot gets the reference to the indenters manual and opens it.
 */
void IndentHandler::showIndenterManual() const
{
//--- 	TQString manualReference = getManual();
//--- 	TQDesktopServices::openUrl(manualReference);
}

//--- /*
//---     \brief Returns the name of the currently selected indenter.
//---  */
//--- TQString IndentHandler::getCurrentIndenterName()
//--- {
//--- 	TQString currentIndenterName = m_indenterSelectionCombobox->currentText();
//--- 
//--- 	// Remove the supported programming languages from indenters name, which are set in braces.
//--- 	if (currentIndenterName.indexOf("(") > 0)
//--- 	{
//--- 		// Using index-1 to also leave out the blank before the brace.
//--- 		currentIndenterName = currentIndenterName.left(currentIndenterName.indexOf("(") - 1);
//--- 	}
//--- 
//--- 	return currentIndenterName;
//--- }

/*
    \brief Shows a file open dialog to open an existing config file for the current indenter.
    If the file was successfully opened, the indent handler is called to load the settings
		and update itself.
*/
void IndentHandler::openConfigFileDialog()
{
//--- 	TQString configFilePath;
//--- 
//--- 	configFilePath = TQFileDialog::getOpenFileName(nullptr, tr(
//--- 						"Choose indenter config file"), getIndenterCfgFile(), "All files (*.*)");
//--- 
//--- 	if (configFilePath != "")
//--- 	{
//--- 		// If the config file was loaded successfully, inform any who is interested about it.
//--- 		if (loadConfigFile(configFilePath))
//--- 		{
//--- 			handleChangedIndenterSettings();
//--- 		}
//--- 	}
}

/*
    \brief Calls the "save as" dialog to save the indenter config file under a chosen name.
    If the file already exists and it should be overwritten, a warning will be shown before.
*/
void IndentHandler::saveasIndentCfgFileDialog()
{
//--- 	TQString fileExtensions = tr("All files") + " (*.*)";
//--- 
//--- 	//TQString openedSourceFileContent = openFileDialog( tr("Choose source code file"), "./",
//--- 	// fileExtensions );
//--- 	TQString fileName = TQFileDialog::getSaveFileName(this, tr(
//--- 						"Save indent config file"), getIndenterCfgFile(), fileExtensions);
//--- 
//--- 	if (fileName != "")
//--- 	{
//--- 		TQFile::remove(fileName);
//--- 		TQFile outCfgFile(fileName);
//--- 		outCfgFile.open(TQFile::ReadWrite | TQFile::Text);
//--- 		outCfgFile.write(getParameterString().toAscii());
//--- 		outCfgFile.close();
//--- 	}
}

/*
    \brief Invokes the indenter to create a shell script.
    Lets the indenter create a shell script for calling the indenter out of any
    other application and open a save dialog for saving the shell script.
*/
void IndentHandler::createIndenterCallShellScript()
{
//--- 	TQString shellScriptExtension;
//--- 	shellScriptExtension = "sh";
//--- 
//--- 	TQString fileExtensions = tr("Shell Script") + " (*." + shellScriptExtension + ");;" + tr(
//--- 		"All files") + " (*.*)";
//--- 
//--- 	TQString currentIndenterName = getCurrentIndenterName();
//--- 	currentIndenterName = currentIndenterName.replace(" ", "_");
//--- 
//--- 	TQString shellScriptFileName = TQFileDialog::getSaveFileName(this, tr(
//--- 						"Save shell script"), "call_" + currentIndenterName + "." + shellScriptExtension,
//--- 	        fileExtensions);
//--- 
//--- 	// Saving has been canceled if the filename is empty
//--- 	if (shellScriptFileName.isEmpty())
//--- 	{
//--- 		return;
//--- 	}
//--- 
//--- 	// Delete any old file, write the new contents and set executable permissions.
//--- 	TQFile::remove(shellScriptFileName);
//--- 	TQFile outSrcFile(shellScriptFileName);
//--- 	if (outSrcFile.open(TQFile::ReadWrite | TQFile::Text))
//--- 	{
//--- 		TQString shellScriptConfigFilename = TQFileInfo(shellScriptFileName).baseName() + "." +
//--- 		        TQFileInfo(_globalConfigFilename).suffix();
//--- 
//--- 		// Get the content of the shell/batch script.
//--- 		TQString indenterCallShellScript = generateShellScript(shellScriptConfigFilename);
//--- 
//--- 		// Replace placeholder for script name in script template.
//--- 		indenterCallShellScript = indenterCallShellScript.replace("__INDENTERCALLSTRINGSCRIPTNAME__", TQFileInfo(
//--- 							shellScriptFileName).fileName());
//--- 
//--- 		outSrcFile.write(indenterCallShellScript.toAscii());
//--- 		// For non Windows systems set the files executable flag
//--- 		outSrcFile.setPermissions(
//--- 			outSrcFile.permissions() | TQFile::ExeOwner | TQFile::ExeUser | TQFile::ExeGroup);
//--- 		outSrcFile.close();
//--- 
//--- 		// Save the indenter config file to the same directory, where the shell srcipt was saved to,
//--- 		// because the script will reference it there via "./".
//--- 		if (!_globalConfigFilename.isEmpty())
//--- 		{
//--- 			saveConfigFile(TQFileInfo(
//--- 								shellScriptFileName).path() + "/" + shellScriptConfigFilename,
//--- 			        getParameterString());
//--- 		}
//--- 	}
}

/*
    \brief Resets all parameters to the indenter's default values as they are specified
		in the uigui ini file, but asks the user whether to do it really.
 */
void IndentHandler::resetIndenterParameter()
{
//--- 	int messageBoxAnswer = TQMessageBox::question(this, tr("Really reset parameters?"), tr(
//--- 						"Do you really want to reset the indenter parameters to the default values?"),
//--- 	        TQMessageBox::Yes | TQMessageBox::Abort);
//--- 	if (messageBoxAnswer == TQMessageBox::Yes)
//--- 	{
//--- 		resetToDefaultValues();
//--- 	}
}

//--- /*
//---     \brief Catch some events and let some other be handled by the super class.
//--- 
//---     Is needed for use as Notepad++ plugin.
//---  */
//--- bool IndentHandler::event(TQEvent *event)
//--- {
//--- 	if (event->type() == TQEvent::WindowActivate)
//--- 	{
//--- 		event->accept();
//--- 		return true;
//--- 	}
//--- 	else if (event->type() == TQEvent::WindowDeactivate)
//--- 	{
//--- 		event->accept();
//--- 		return true;
//--- 	}
//--- 	else
//--- 	{
//--- 		event->ignore();
//--- 		return TQWidget::event(event);
//--- 	}
//--- }
//--- 
//--- /*
//---     \brief Emits the \a indenterSettingsChanged signal
//---  */
//--- void IndentHandler::handleChangedIndenterSettings()
//--- {
//--- 	emit(indenterSettingsChanged());
//--- }
//--- 
//--- /*
//---     \brief Returns the id (list index) of the currently selected indenter.
//---  */
//--- int IndentHandler::getIndenterId()
//--- {
//--- 	return m_indenterSelectionCombobox->currentIndex();
//--- }
//--- 
//--- 	htmlText.replace("&", "&amp;");
//--- 	htmlText.replace("<", "&lt;");
//--- 	htmlText.replace(">", "&gt;");
//--- 	htmlText.replace('"', "&quot;");
//--- 	htmlText.replace("'", "&#39;");
//--- 	htmlText.replace("^", "&circ;");
//--- 	htmlText.replace("~", "&tilde;");
//--- 	htmlText.replace("€", "&euro;");
//--- 	htmlText.replace("©", "&copy;");
//--- 	return htmlText;
//--- }

#include "IndentHandler.moc"