/***************************************************************************
 *   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 "IndentHandler.h"

#include "UiGuiSettings.h"
#include "UiGuiErrorMessage.h"
#include "TemplateBatchScript.h"
#include "UiGuiIniFileParser.h"
#include "SettingsPaths.h"

#include <tntqtoolbox.h>
#include <tqvboxlayout.h>
#include <tntqapplication.h>
#include <tntqcheckbox.h>
#include <tntqcombobox.h>
#include <tntqtoolbutton.h>
#include <tntqfile.h>
#include <tntqprocess.h>
#include <tntqsettings.h>
#include <tntqstringlist.h>
#include <tntqlineedit.h>
#include <tntqspinbox.h>
#include <tntqlabel.h>
#include <tqbytearray.h>
#include <tntqdir.h>
#include <tntqmessagebox.h>
#include <tntqmainwindow.h>
#include <tntqtextstream.h>
#include <tntqtextcodec.h>
#include <tqtscript.h>
#include <tqdesktopservices.h>
#include <tqmenu.h>
#include <tntqaction.h>
#include <tqcontextmenuevent.h>
#include <tntqfiledialog.h>
#include <tqtdebug.h>

#ifdef Q_OS_WIN32
 #include <Windows.h>
#endif

// Avoid unused parameter warnings by this template
template<typename T>
inline void UNUSED_PARAMETER_WARNING_AVOID(T)
{
}

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

/*
    \class IndentHandler
    \ingroup grp_Indenter
    \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, TQWidget *mainWindow, TQWidget *parent) :
		TQWidget(parent), _indenterSelectionCombobox(NULL), _indenterParameterHelpButton(NULL),
		_toolBoxContainerLayout(NULL), _indenterParameterCategoriesToolBox(NULL), _indenterSettings(
			NULL), _mainWindow(NULL), _errorMessageDialog(NULL), _menuIndenter(NULL),
		_actionLoadIndenterConfigFile(NULL), _actionSaveIndenterConfigFile(NULL),
		_actionCreateShellScript(NULL), _actionResetIndenterParameters(NULL),
		_parameterChangedCallback(NULL), _windowClosedCallback(NULL)
{
	Q_ASSERT_X(indenterID >= 0, "IndentHandler", "the selected indenterID is < 0");

	setObjectName(TQString::fromUtf8("indentHandler"));

	_mainWindow = mainWindow;

	initIndenterMenu();

	connect(_actionLoadIndenterConfigFile, SIGNAL(triggered()), this, SLOT(openConfigFileDialog()));
	connect(_actionSaveIndenterConfigFile, SIGNAL(triggered()), this, SLOT(
						saveasIndentCfgFileDialog()));
	connect(_actionCreateShellScript, SIGNAL(triggered()), this,
	        SLOT(createIndenterCallShellScript()));
	connect(_actionResetIndenterParameters, SIGNAL(triggered()), this,
	        SLOT(resetIndenterParameter()));

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

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

	// Create horizontal layout for indenter selector and help button.
	TQHBoxLayout *hboxLayout = new TQHBoxLayout();
	//hboxLayout->setMargin(2);
	_toolBoxContainerLayout->addLayout(hboxLayout);

	// Create the indenter selection combo box.
	_indenterSelectionCombobox = new TQComboBox(this);
	_indenterSelectionCombobox->setSizeAdjustPolicy(TQComboBox::AdjustToMinimumContentsLengthWithIcon);
	_indenterSelectionCombobox->setMinimumContentsLength(20);
	connect(_indenterSelectionCombobox, SIGNAL(activated(int)), this, SLOT(setIndenter(int)));
	UiGuiSettings::getInstance()->registerObjectProperty(_indenterSelectionCombobox, "currentIndex",
	        "selectedIndenter");
	hboxLayout->addWidget(_indenterSelectionCombobox);

	// Create the indenter parameter help button.
	_indenterParameterHelpButton = new TQToolButton(this);
	_indenterParameterHelpButton->setObjectName(TQString::fromUtf8("indenterParameterHelpButton"));
	_indenterParameterHelpButton->setIcon(TQIcon(TQString::fromUtf8(":/mainWindow/help.png")));
	hboxLayout->addWidget(_indenterParameterHelpButton);
	// Handle if the indenter parameter help button is pressed.
	connect(_indenterParameterHelpButton, SIGNAL(clicked()), this, SLOT(showIndenterManual()));

	// create a toolbox and set its resize behavior
	_indenterParameterCategoriesToolBox = new TQToolBox(this);
	_indenterParameterCategoriesToolBox->setObjectName(TQString::fromUtf8(
						"_indenterParameterCategoriesToolBox"));

#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
	connect(_indenterParameterCategoriesToolBox, SIGNAL(currentChanged(int)), this,
	        SLOT(updateDrawing()));
#endif // UNIVERSALINDENTGUI_NPP_EXPORTS

	//_indenterParameterCategoriesToolBox->setSizePolicy( TQSizePolicy::Expanding,
	// TQSizePolicy::Expanding );
	//_indenterParameterCategoriesToolBox->setMaximumSize(TQSize(16777215, 16777215));
	// insert the toolbox into the vlayout
	_toolBoxContainerLayout->addWidget(_indenterParameterCategoriesToolBox);

	_indenterExecutableCallString = "";
	_indenterExecutableSuffix     = "";

	_indenterDirctoryStr = SettingsPaths::getIndenterPath();
	_tempDirctoryStr     = SettingsPaths::getTempPath();
	_settingsDirctoryStr = SettingsPaths::getSettingsPath();
	TQDir indenterDirctory = TQDir(_indenterDirctoryStr);

	if (_mainWindow != NULL)
	{
		_errorMessageDialog = new UiGuiErrorMessage(_mainWindow);
	}
	else
	{
		_errorMessageDialog = new UiGuiErrorMessage(this);
	}

	_indenterIniFileList = indenterDirctory.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(_indenterDirctoryStr + "/" + _indenterIniFileList.at(indenterID));

		// Find out how the indenter can be executed.
		createIndenterCallString();

		// Load the users last settings made for this indenter.
		loadConfigFile(_settingsDirctoryStr + "/" + _indenterFileName + ".cfg");

		// Fill the indenter selection combo box with the list of available indenters.
		if (!getAvailableIndenters().isEmpty())
		{
			_indenterSelectionCombobox->addItems(getAvailableIndenters());
			_indenterSelectionCombobox->setCurrentIndex(indenterID);
			connect(_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(_indenterDirctoryStr).absolutePath() + "\".");
	}

	retranslateUi();
}

/*
    \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(_settingsDirctoryStr + "/" + _indenterFileName + ".cfg", parameterString);
	}

	delete _errorMessageDialog;
}

/*
    \brief Initializes the context menu used for some actions like saving the indenter config file.
 */
void IndentHandler::initIndenterMenu()
{
	if (_menuIndenter == NULL)
	{
		_actionLoadIndenterConfigFile = new TQAction(this);
		_actionLoadIndenterConfigFile->setObjectName(TQString::fromUtf8("_actionLoadIndenterConfigFile"));
		_actionLoadIndenterConfigFile->setIcon(TQIcon(TQString::fromUtf8(
							":/mainWindow/load_indent_cfg.png")));

		_actionSaveIndenterConfigFile = new TQAction(this);
		_actionSaveIndenterConfigFile->setObjectName(TQString::fromUtf8("_actionSaveIndenterConfigFile"));
		_actionSaveIndenterConfigFile->setIcon(TQIcon(TQString::fromUtf8(
							":/mainWindow/save_indent_cfg.png")));

		_actionCreateShellScript = new TQAction(this);
		_actionCreateShellScript->setObjectName(TQString::fromUtf8("_actionCreateShellScript"));
		_actionCreateShellScript->setIcon(TQIcon(TQString::fromUtf8(":/mainWindow/shell.png")));

		_actionResetIndenterParameters = new TQAction(this);
		_actionResetIndenterParameters->setObjectName(TQString::fromUtf8(
							"_actionResetIndenterParameters"));
		_actionResetIndenterParameters->setIcon(TQIcon(TQString::fromUtf8(
							":/mainWindow/view-refresh.png")));

		_menuIndenter = new TQMenu(this);
		_menuIndenter->setObjectName(TQString::fromUtf8("_menuIndenter"));
		_menuIndenter->addAction(_actionLoadIndenterConfigFile);
		_menuIndenter->addAction(_actionSaveIndenterConfigFile);
		_menuIndenter->addAction(_actionCreateShellScript);
		_menuIndenter->addAction(_actionResetIndenterParameters);
	}
}

/*
    \brief Returns the context menu used for some actions like saving the indenter config file.
 */
TQMenu* IndentHandler::getIndenterMenu()
{
	return _menuIndenter;
}

/*
    \brief Returns the actions of the context menu used for some actions like saving the indenter config file.
 */
TQList<TQAction*> IndentHandler::getIndenterMenuActions()
{
	TQList<TQAction*> actionList;
	actionList << _actionLoadIndenterConfigFile << _actionSaveIndenterConfigFile <<
	        _actionCreateShellScript << _actionResetIndenterParameters;
	return actionList;
}

/*
    \brief Opens the context menu, used for some actions like saving the indenter config file, at the event position.
 */
void IndentHandler::contextMenuEvent(TQContextMenuEvent *event)
{
	getIndenterMenu()->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.
#if defined (Q_OS_WIN32)
	TQString shellParameterPlaceholder = "%1";
#else
	TQString shellParameterPlaceholder = "$1";
#endif

	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.
#if defined (Q_OS_WIN32)
	indenterCompleteCallString = _indenterExecutableCallString + indenterCompleteCallString;
#else
	indenterCompleteCallString = "#!/bin/bash\n" + _indenterExecutableCallString +
	        indenterCompleteCallString;
#endif

	// 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)
	{
#if defined (Q_OS_WIN32)
		replaceInputFileCommand = "move /Y " + _outputFileName + ".tmp \"" + shellParameterPlaceholder +
		        "\"\n";
#else
		replaceInputFileCommand = "mv " + _outputFileName + ".tmp \"" + shellParameterPlaceholder +
		        "\"\n";
#endif
	}

#if defined (Q_OS_WIN32)
	TQString shellScript(TemplateBatchScript::getTemplateBatchScript());
	shellScript = shellScript.replace("__INDENTERCALLSTRING2__",
	        indenterCompleteCallString + "\n" + replaceInputFileCommand);
	indenterCompleteCallString = indenterCompleteCallString.replace("%1", "%%G");
	replaceInputFileCommand    = replaceInputFileCommand.replace("%1", "%%G");
	shellScript = shellScript.replace("__INDENTERCALLSTRING1__",
	        indenterCompleteCallString + "\n" + replaceInputFileCommand);
#else
	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);
#endif

	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 (_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(_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(_tempDirctoryStr + "/" + _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(_tempDirctoryStr + "/" + _inputFileName + inputFileExtension);
	TQFile inputSrcFile(_tempDirctoryStr + "/" + _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;
	}

#ifdef Q_OS_WIN32
	// Paths may contain Unicode or other foreign characters. Windows commands line tools will
	// receive als falsely encoded path string by TQProcess or they connot correctly handle
	// the Unicode path on their own.
	// Because of this the path gets converted to Windows short paths using the 8.3 notation.

	tqDebug() << __LINE__ << " " << __FUNCTION__ <<
	        ": Temp dir before trying to convert it to short Windows path is" << _tempDirctoryStr;

	// At first convert the temp path to Windows like separators.
	TQString tempDirctoryStrHelper =
	        TQDir::toNativeSeparators(_tempDirctoryStr).replace("\\", "\\\\");
	// Then convert the TQString to a WCHAR array and NULL terminate it.
	WCHAR *tempDirctoryWindowsStr = new WCHAR[tempDirctoryStrHelper.length() + 1];
	tempDirctoryStrHelper.toWCharArray(tempDirctoryWindowsStr);
	tempDirctoryWindowsStr[tempDirctoryStrHelper.length()] = (WCHAR)NULL;

	// Get the length of the resulting short path.
	long   length = 0;
	TCHAR *buffer = NULL;
	length = GetShortPathName((LPCTSTR)tempDirctoryWindowsStr, NULL, 0);

	// If the short path could be retrieved, create a correct sized buffer, store the
	// short path in it and convert all back to TQString.
	if (length != 0)
	{
 #ifdef UNICODE
		buffer = new WCHAR[length];
		length = GetShortPathName((LPCTSTR)tempDirctoryWindowsStr, buffer, length);
		tempDirctoryStrHelper = TQString::fromWCharArray(buffer);
 #else
		buffer = new TCHAR[length];
		length = GetShortPathName((LPCTSTR)tempDirctoryWindowsStr, buffer, length);
		tempDirctoryStrHelper = buffer;
 #endif
		_tempDirctoryStr = TQDir::fromNativeSeparators(tempDirctoryStrHelper).replace("//", "/");
		delete[] buffer;

		// Check whether the short path still contains some kind of non ascii characters.
		if (_tempDirctoryStr.length() != _tempDirctoryStr.toAscii().length())
		{
			tqWarning() << __LINE__ << " " << __FUNCTION__ <<
			        ": Shortened path still contains non ascii characters. Could cause some indenters not to work properly!";
		}
	}
	else
	{
		tqWarning() << __LINE__ << " " << __FUNCTION__ <<
		        ": Couldn't retrieve a short version of the temporary path!";
	}

	tqDebug() << __LINE__ << " " << __FUNCTION__ <<
	        ": Temp dir after trying to convert it to short Windows path is " << _tempDirctoryStr;

	delete[] tempDirctoryWindowsStr;
#endif

	// 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 + "\"" + _tempDirctoryStr + "/" +
		        _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 (_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(_indenterDirctoryStr));
		return sourceCode;
	}

	// Generate the indenter call string either for win32 or other systems.
	indenterCompleteCallString = _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(_tempDirctoryStr).absoluteFilePath();
	indentProcess.setEnvironment(env);

	// Set the directory for the indenter execution
	indentProcess.setWorkingDirectory(TQFileInfo(_tempDirctoryStr).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(_tempDirctoryStr + "/" + _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(_tempDirctoryStr + "/" + _outputFileName + inputFileExtension);
	TQFile::remove(_tempDirctoryStr + "/" + _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(NULL);

			// 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);
		_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 (_mainWindow != NULL)
				{
					spinBox->installEventFilter(_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 (_mainWindow != NULL)
				{
					label->installEventFilter(_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()));
#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
				connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(updateDrawing()));
#endif // UNIVERSALINDENTGUI_NPP_EXPORTS
			}
			// 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 (_mainWindow != NULL)
				{
					chkBox->installEventFilter(_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 (_mainWindow != NULL)
				{
					lineEdit->installEventFilter(_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 (_mainWindow != NULL)
				{
					label->installEventFilter(_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()));
#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
				connect(lineEdit, SIGNAL(textChanged(const TQString)), this, SLOT(updateDrawing()));
#endif // UNIVERSALINDENTGUI_NPP_EXPORTS
			}
			// 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 (_mainWindow != NULL)
				{
					comboBox->installEventFilter(_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()));
#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
				connect(comboBox, SIGNAL(activated(int)), this, SLOT(updateDrawing()));
#endif // UNIVERSALINDENTGUI_NPP_EXPORTS
			}
		}
	}

	// 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(_indenterDirctoryStr + "/" + 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);

#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
	disconnect(_indenterParameterCategoriesToolBox, SIGNAL(currentChanged(int)), this,
	        SLOT(updateDrawing()));
#endif // UNIVERSALINDENTGUI_NPP_EXPORTS

	// Generate the parameter string that will be saved to the indenters config file.
	TQString parameterString = getParameterString();
	if (!_indenterFileName.isEmpty())
	{
		saveConfigFile(_settingsDirctoryStr + "/" + _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;
	}

	// remove all pages from the toolbox
	for (int i = 0; i < _indenterParameterCategoriesToolBox->count(); i++)
	{
		_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;

#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
	TQWidget dummyWidget;
	_indenterParameterCategoriesToolBox->addItem(&dummyWidget, "dummyText");
#endif

	readIndentIniFile(_indenterDirctoryStr + "/" + _indenterIniFileList.at(indenterID));

	// Find out how the indenter can be executed.
	createIndenterCallString();

	// Load the users last settings made for this indenter.
	loadConfigFile(_settingsDirctoryStr + "/" + _indenterFileName + ".cfg");

	handleChangedIndenterSettings();

	TQApplication::restoreOverrideCursor();

#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
	connect(_indenterParameterCategoriesToolBox, SIGNAL(currentChanged(int)), this,
	        SLOT(updateDrawing()));
	_indenterParameterCategoriesToolBox->removeItem(_indenterParameterCategoriesToolBox->indexOf(&
	        dummyWidget));
#endif // UNIVERSALINDENTGUI_NPP_EXPORTS
}

/*
    \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(_indenterDirctoryStr + "/" + _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(_indenterDirctoryStr).absoluteFilePath());

	foreach(TQString suffix, TQStringList() << "" << ".exe" << ".bat" << ".com" << ".sh")
	{
		_indenterExecutableSuffix     = suffix;
		_indenterExecutableCallString = TQFileInfo(_indenterDirctoryStr).absoluteFilePath() + "/" +
		        _indenterFileName;
		_indenterExecutableCallString += suffix;

		// Only try to call the indenter, if the file exists.
		if (TQFile::exists(_indenterExecutableCallString))
		{
			// Only try to call the indenter directly if it is no php file
			if (TQFileInfo(_indenterExecutableCallString).suffix().toLower() != "php")
			{
				indentProcess.start(
					"\"" + _indenterExecutableCallString +  +"\" " + _indenterShowHelpParameter);
				if (indentProcess.waitForFinished(2000))
				{
					_indenterExecutableCallString = "\"" + _indenterExecutableCallString + "\"";
					return true;
				}
				else if (indentProcess.error() == TQProcess::Timedout)
				{
					_indenterExecutableCallString = "\"" + _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(_indenterExecutableCallString);

			// If indenter executable file has .php as suffix, use php as default interpreter
			if (TQFileInfo(_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())
			{
				_indenterExecutableCallString = interpreterName + " \"" + _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
	// -------------------------------------------------------------------
	_indenterExecutableSuffix     = ".js";
	_indenterExecutableCallString = TQFileInfo(_indenterDirctoryStr).absoluteFilePath() + "/" +
	        _indenterFileName;
	_indenterExecutableCallString += _indenterExecutableSuffix;
	if (TQFile::exists(_indenterExecutableCallString))
	{
		return true;
	}

	// If unsuccessful try to call the indenter global, using some suffix
	// ------------------------------------------------------------------
	foreach(TQString suffix, TQStringList() << "" << ".exe" << ".bat" << ".com" << ".sh")
	{
		_indenterExecutableSuffix     = suffix;
		_indenterExecutableCallString = _indenterFileName + suffix;
		indentProcess.start(_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
	// -------------------------------------------------------------------------------
	_indenterExecutableCallString = "\"" + TQFileInfo(_indenterDirctoryStr).absoluteFilePath() + "/" +
	        _indenterFileName;

	foreach(TQString suffix, TQStringList() << ".exe" << ".com")
	{
		_indenterExecutableSuffix = suffix;
		if (TQFile::exists(_indenterDirctoryStr + "/" + _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."));
				_indenterExecutableCallString = "";
				return false;
			}
			else
			{
				_indenterExecutableCallString = "\"" +
				        TQFileInfo(_indenterDirctoryStr).absoluteFilePath() + "/";
				_indenterExecutableCallString += _indenterFileName + suffix + "\"";
				_indenterExecutableCallString  = "wine " + _indenterExecutableCallString;

				return true;
			}
		}
	}

	_indenterExecutableCallString = "";
	_indenterExecutableSuffix     = "";
	return false;
}

/*
    \brief Returns a string that points to where the indenters manual can be found.
 */
TQString IndentHandler::getManual()
{
	if (_indenterSettings != NULL)
	{
		return _indenterSettings->value("header/manual").toString();
	}
	else
	{
		return "";
	}
}

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

/*
    \brief Can be called to update all widgets text to the currently selected language.
 */
void IndentHandler::retranslateUi()
{
	_indenterSelectionCombobox->setToolTip(tr(
						"<html><head><meta name=\"qrichtext\" content=\"1\" /></head><body style=\" white-space: pre-wrap; font-family:MS Shell Dlg; font-size:8.25pt; font-weight:400; font-style:normal; text-decoration:none;\"><p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">Shows the currently chosen indenters name and lets you choose other available indenters</p></body></html>"));
	_indenterParameterHelpButton->setToolTip(tr(
						"Brings you to the online manual of the currently selected indenter, where you can get further help on the possible parameters."));

	_actionLoadIndenterConfigFile->setText(TQApplication::translate("IndentHandler",
	        "Load Indenter Config File", 0, TQApplication::UnicodeUTF8));
	_actionLoadIndenterConfigFile->setStatusTip(TQApplication::translate("IndentHandler",
	        "Opens a file dialog to load the original config file of the indenter.", 0,
	        TQApplication::UnicodeUTF8));
	_actionLoadIndenterConfigFile->setShortcut(TQApplication::translate("IndentHandler", "Alt+O", 0,
	        TQApplication::UnicodeUTF8));

	_actionSaveIndenterConfigFile->setText(TQApplication::translate("IndentHandler",
	        "Save Indenter Config File", 0, TQApplication::UnicodeUTF8));
	_actionSaveIndenterConfigFile->setStatusTip(TQApplication::translate("IndentHandler",
	        "Opens a dialog to save the current indenter configuration to a file.", 0,
	        TQApplication::UnicodeUTF8));
	_actionSaveIndenterConfigFile->setShortcut(TQApplication::translate("IndentHandler", "Alt+S", 0,
	        TQApplication::UnicodeUTF8));

	_actionCreateShellScript->setText(TQApplication::translate("IndentHandler",
	        "Create Indenter Call Shell Script", 0, TQApplication::UnicodeUTF8));
	_actionCreateShellScript->setToolTip(TQApplication::translate("IndentHandler",
	        "Create a shell script that calls the current selected indenter for formatting an as parameter given file with the current indent settings.",
	        0, TQApplication::UnicodeUTF8));
	_actionCreateShellScript->setStatusTip(TQApplication::translate("IndentHandler",
	        "Create a shell script that calls the current selected indenter for formatting an as parameter given file with the current indent settings.",
	        0, TQApplication::UnicodeUTF8));

	_actionResetIndenterParameters->setText(TQApplication::translate("IndentHandler",
	        "Reset indenter parameters", 0, TQApplication::UnicodeUTF8));
	_actionResetIndenterParameters->setToolTip(TQApplication::translate("IndentHandler",
	        "Resets all indenter parameters to the default values.", 0, TQApplication::UnicodeUTF8));
	_actionResetIndenterParameters->setStatusTip(TQApplication::translate("IndentHandler",
	        "Resets all indenter parameters to the default values.", 0, TQApplication::UnicodeUTF8));
}

/*
    \brief Returns the name of the currently selected indenter.
 */
TQString IndentHandler::getCurrentIndenterName()
{
	TQString currentIndenterName = _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 currently selected 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(NULL, 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 indenter config file save as dialog to save the config file under a chosen name.

    If the file already exists and it should be overwritten, a warning is 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;
#if defined (Q_OS_WIN32)
	shellScriptExtension = "bat";
#else
	shellScriptExtension = "sh";
#endif

	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());
#if !defined (Q_OS_WIN32)
		// For none Windows systems set the files executable flag
		outSrcFile.setPermissions(
			outSrcFile.permissions() | TQFile::ExeOwner | TQFile::ExeUser | TQFile::ExeGroup);
#endif
		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 indenters 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 Sets the function pointer \a _parameterChangedCallback to the given callback
    function \a paramChangedCallback.

    Is needed for use as Notepad++ plugin.
 */
void IndentHandler::setParameterChangedCallback(void (*paramChangedCallback)(void))
{
	_parameterChangedCallback = paramChangedCallback;
}

/*
    \brief Emits the \a indenterSettingsChanged signal and if set executes the \a _parameterChangedCallback function.

   Is needed for use as Notepad++ plugin.
 */
void IndentHandler::handleChangedIndenterSettings()
{
	emit(indenterSettingsChanged());

	if (_parameterChangedCallback != NULL)
	{
		_parameterChangedCallback();
	}
}

/*
    \brief Sets a callback function that shall be called, when the this indenter parameter window gets closed.

   Is needed for use as Notepad++ plugin.
 */
void IndentHandler::setWindowClosedCallback(void (*winClosedCallback)(void))
{
	_windowClosedCallback = winClosedCallback;
}

/*
    \brief Is called on this indenter parameter window close and if set calls the function \a _windowClosedCallback.

    Is needed for use as Notepad++ plugin.
 */
void IndentHandler::closeEvent(TQCloseEvent *event)
{
	if (_windowClosedCallback != NULL)
	{
		_windowClosedCallback();
	}
	event->accept();
}

/*
    \brief Returns the id (list index) of the currently selected indenter.
 */
int IndentHandler::getIndenterId()
{
	return _indenterSelectionCombobox->currentIndex();
}

void IndentHandler::updateDrawing()
{
#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
	if (isVisible())
	{
		TQRect savedGeometry = geometry();
		setGeometry(savedGeometry.adjusted(0, 0, 0, 1));
		repaint();
		setGeometry(savedGeometry);
	}
#endif // UNIVERSALINDENTGUI_NPP_EXPORTS
}

void IndentHandler::wheelEvent(TQWheelEvent *event)
{
	UNUSED_PARAMETER_WARNING_AVOID(event);
#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS
	TQWidget::wheelEvent(event);
	updateDrawing();
#endif // UNIVERSALINDENTGUI_NPP_EXPORTS
}

/*
    \brief Converts characters < > and & in the \a text to HTML codes &lt &gt and &amp.
 */

//TODO: This function should go into a string helper/tool class/file.
TQString IndentHandler::encodeToHTML(const TQString &text)
{
	TQString htmlText = text;
	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;
}