diff options
Diffstat (limited to 'src/UiGuiSettings.cpp')
| -rw-r--r-- | src/UiGuiSettings.cpp | 993 |
1 files changed, 993 insertions, 0 deletions
diff --git a/src/UiGuiSettings.cpp b/src/UiGuiSettings.cpp new file mode 100644 index 0000000..b231577 --- /dev/null +++ b/src/UiGuiSettings.cpp @@ -0,0 +1,993 @@ +/*************************************************************************** +* 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 "UiGuiSettings.h" +#include "SettingsPaths.h" + +#include <tqdatetime.h> +#include <tqdir.h> +#include <tqpoint.h> +#include <tqsettings.h> +#include <tqsize.h> +#include <tqwidget.h> + + +/* + \class UiGuiSettings + \brief Handles the settings of the program. Reads them on startup and saves them on exit. + Is a singleton class and can only be accessed via getInstance(). +*/ + +// Inits the single class instance pointer. +UiGuiSettings *UiGuiSettings::m_instance = nullptr; + +/* + \brief The constructor for the settings. +*/ +UiGuiSettings::UiGuiSettings() : TQObject() +{ + // Create the main application settings object from the UniversalIndentGUIrc file. + m_qsettings = new TQSettings(TQSettings::Ini); + // The next lines make user the settings are always stored in + // $HOME/.universalindentgui/universalindentguirc + m_qsettings->insertSearchPath(TQSettings::Unix, SettingsPaths::getSettingsPath()); + m_qsettings->setPath("UniversalIndentGUI", "UniversalIndentGUI", TQSettings::User); + // settings are stored in the universalindentguirc file, group UniversalIndentGUI + m_qsettings->beginGroup("universalindentgui/UniversalIndentGUI"); + + m_indenterDirectoryStr = SettingsPaths::getGlobalFilesPath() + "/indenters"; + readAvailableTranslations(); + loadSettings(); +} + +/* + \brief Returns the instance of the settings class. If no instance exists, one will be created. + */ +UiGuiSettings* UiGuiSettings::getInstance() +{ + if (!m_instance) + { + // Create the settings object, which loads all UiGui settings from a file. + m_instance = new UiGuiSettings(); + } + + return m_instance; +} + +/* + \brief Deletes the existing instance of UiGuiSettings and removes the created temp dir. + */ +void UiGuiSettings::deleteInstance() +{ + SettingsPaths::cleanAndRemoveTempDir(); + if (m_instance) + { + delete m_instance; + m_instance = nullptr; + } +} + +/* + \brief The destructor saves the settings to a file. + */ +UiGuiSettings::~UiGuiSettings() +{ + saveSettings(); + delete m_qsettings; +} + +/* + \brief Scans the translations directory for available translation files and + stores them in the TQList \a m_availableTranslations. + */ +void UiGuiSettings::readAvailableTranslations() +{ + TQStringList languageFileList; + + // English is the default language. A translation file does not exist but to have a menu entry, + // added here. + languageFileList << "universalindent_en.qm"; + + // Find all translation files in the "translations" directory. + TQDir translationDirectory = TQDir(SettingsPaths::getGlobalFilesPath() + "/translations"); + for (TQString &file : translationDirectory.entryList(TQString("universalindent_*.qm"))) + { + languageFileList << file; + } + + // Loop for each found translation file + for (TQString &languageShort : languageFileList) + { + // Remove the leading string "universalindent_" from the filename. + languageShort.remove(0, 16); + // Remove trailing file extension ".qm". + languageShort.truncate(languageShort.length() - 3); + + m_availableTranslations.append(languageShort); + } +} + +/* + \brief Returns a list of the mnemonics of the available translations. + */ +TQStringList& UiGuiSettings::getAvailableTranslations() +{ + return m_availableTranslations; +} + +/* + \brief Returns the value of the by \a settingsName defined setting as TQVariant. + + If the named setting does not exist, 0 is being returned. +*/ +TQVariant UiGuiSettings::getValueByName(const TQString &settingName) const +{ + // Test if the named setting really exists. + if (m_settings.contains(settingName)) + { + return m_settings[settingName]; + } + return TQVariant(0); +} + +/* + \brief Sets the value of the by \a settingsName defined setting to the value \a value. + + The to \a settingsName corresponding signal is emitted, if the value has changed. + */ +bool UiGuiSettings::setValueByName(const TQString &settingName, TQVariant value) +{ + // Test if the named setting really exists. + if (m_settings.contains(settingName)) + { + // Test if the new value is different to the one before. + if (m_settings[settingName] != value) + { + m_settings[settingName] = value; + // Emit the signal for the changed setting. + emitSignalForSetting(settingName); + } + return true; + } + return false; +} + +/*! + \brief Loads the settings for the main application. + + Settings are for example last selected indenter, last loaded source code file and so on. +*/ +void UiGuiSettings::loadSettings() +{ + // Read the version string saved in the settings file. + m_settings["VersionInSettingsFile"] = m_qsettings->readEntry("version", TQString::null); + + // Read windows last size and position from the settings file. + m_settings["WindowIsMaximized"] = m_qsettings->readBoolEntry("maximized", false); + m_settings["WindowPosition"] = m_qsettings->readEntry("position", "@Point(50, 50)"); + m_settings["WindowSize"] = m_qsettings->readEntry("size", "@Size(800, 600)"); + + // Read last selected encoding for the opened source code file. + m_settings["FileEncoding"] = m_qsettings->readEntry("encoding", "UTF-8"); + + // Read maximum length of list for recently opened files. + m_settings["RecentlyOpenedListSize"] = m_qsettings->readNumEntry("recentlyOpenedListSize", 5); + + // Read if last opened source code file should be loaded on startup. + m_settings["LoadLastOpenedFileOnStartup"] = m_qsettings->readBoolEntry( + "loadLastSourceCodeFileOnStartup", true); + + // Read last opened source code file from the settings file. + m_settings["LastOpenedFiles"] = m_qsettings->readEntry("lastSourceCodeFile", + m_indenterDirectoryStr + "/example.cpp"); + + // Read last selected indenter from the settings file. + int selectedIndenter = m_qsettings->readNumEntry("selectedIndenter", 0); + if (selectedIndenter < 0) + { + selectedIndenter = 0; + } + m_settings["SelectedIndenter"] = selectedIndenter; + + // Read if syntax highlighting is enabled. + m_settings["SyntaxHighlightningEnabled"] = m_qsettings->readBoolEntry( + "SyntaxHighlightningEnabled", true); + + // Read if white space characters should be displayed. + m_settings["WhiteSpaceIsVisible"] = m_qsettings->readBoolEntry("whiteSpaceIsVisible", false); + + // Read if indenter parameter tool tips are enabled. + m_settings["IndenterParameterTooltipsEnabled"] = m_qsettings->readBoolEntry( + "indenterParameterTooltipsEnabled", true); + + // Read the tab width from the settings file. + m_settings["TabWidth"] = m_qsettings->readNumEntry("tabWidth", 4); + + // Read the last selected language and stores the index it has in the list of available + // translations. + TQString language = m_qsettings->readEntry("language", "en"); + int idx = m_availableTranslations.findIndex(language); + if (idx < 0) + { + idx = m_availableTranslations.findIndex("en"); // "en" is always present + } + m_settings["Language"] = idx; + + // TODO - MainWindow::saveState() missing in TQt3 + // Read the main window state. + // m_settings["MainWindowState"] = m_qsettings->readEntry("MainWindowState", "@ByteArray()"); +} + +/*! + \brief Saves the settings for the main application. + + Settings are for example last selected indenter, last loaded source code file and so on. +*/ +void UiGuiSettings::saveSettings() +{ + // Write the version string saved in the settings file. + m_qsettings->writeEntry("version", m_settings["VersionInSettingsFile"].toString()); + + // Write windows last size and position from the settings file. + m_qsettings->writeEntry("maximized", m_settings["WindowIsMaximized"].toBool()); + m_qsettings->writeEntry("position", m_settings["WindowPosition"].toString()); + m_qsettings->writeEntry("size", m_settings["WindowSize"].toString()); + + // Write last selected encoding for the opened source code file. + m_qsettings->writeEntry("encoding", m_settings["FileEncoding"].toString()); + + // Write maximum length of list for recently opened files. + m_qsettings->writeEntry("recentlyOpenedListSize", m_settings["RecentlyOpenedListSize"].toInt()); + + // Write if last opened source code file should be loaded on startup. + m_qsettings->writeEntry("loadLastSourceCodeFileOnStartup", + m_settings["LoadLastOpenedFileOnStartup"].toBool()); + + // Write last opened source code file from the settings file. + m_qsettings->writeEntry("lastSourceCodeFile", m_settings["LastOpenedFiles"].toString()); + + // Write last selected indenter from the settings file. + m_qsettings->writeEntry("selectedIndenter", m_settings["SelectedIndenter"].toInt()); + + // Write if syntax highlighting is enabled. + m_qsettings->writeEntry("SyntaxHighlightningEnabled", + m_settings["SyntaxHighlightningEnabled"].toBool()); + + // Write if white space characters should be displayed. + m_qsettings->writeEntry("whiteSpaceIsVisible", m_settings["WhiteSpaceIsVisible"].toBool()); + + // Write if indenter parameter tool tips are enabled. + m_qsettings->writeEntry("indenterParameterTooltipsEnabled", + m_settings["IndenterParameterTooltipsEnabled"].toBool()); + + // Write the tab width from the settings file. + m_qsettings->writeEntry("tabWidth", m_settings["TabWidth"].toInt()); + + // Write the last selected language and stores the index it has in the list of available + m_qsettings->writeEntry("language", m_availableTranslations[m_settings["Language"].toInt()]); + + // TODO - MainWindow::saveState() missing in TQt3 + // Write the main window state. + //m_qsettings->writeEntry("MainWindowState", m_settings["MainWindowState"].toByteArray()); +} + +void UiGuiSettings::emitSignalForSetting(TQString settingName) +{ +} + +/* + \brief Register the by \a propertyName defined property of \a obj to be connected to the setting defined by \a settingName. + + The \a propertyName must be one of those that are listed in the TQt "Properties" documentation section of a TQt Object. + All further needed info is retrieved via the \a obj's MetaObject, like the to the property bound signal. + * / +bool UiGuiSettings::registerObjectProperty(TQObject *obj, const TQString &propertyName, + const TQString &settingName) +{ + const TQMetaObject *metaObject = obj->metaObject(); + bool connectSuccess = false; + + // Connect to the objects destroyed signal, so that it will be correctly unregistered. + connectSuccess = + connect(obj, SIGNAL(destroyed(TQObject*)), this, + SLOT(unregisterObjectProperty(TQObject*))); + + int indexOfProp = metaObject->indexOfProperty(qPrintable(propertyName)); + if (connectSuccess && indexOfProp > -1) + { + TQMetaProperty mProp = metaObject->property(indexOfProp); + + // Connect to the property's value changed signal. + if (mProp.hasNotifySignal()) + { + TQMetaMethod signal = mProp.notifySignal(); + //TQString teststr = qPrintable(SIGNAL() + TQString(signal.signature())); + // The command "SIGNAL() + TQString(signal.signature())" assembles the signal methods + // signature to a valid TQt SIGNAL. + connectSuccess = + connect(obj, qPrintable(SIGNAL() + TQString(signal.signature())), this, + SLOT(handleObjectPropertyChange())); + } + + if (connectSuccess) + { + m_registeredObjectProperties[obj] = TQStringList() << propertyName << settingName; + } + else + { + //TODO: Write a debug warning to the log. + disconnect(obj, SIGNAL(destroyed(TQObject*)), this, + SLOT(unregisterObjectProperty(TQObject*))); + return false; + } + + // If setting already exists, set the objects property to the setting value. + if (m_qsettings->contains("UniversalIndentGUI/" + settingName)) + { + mProp.write(obj, m_qsettings->value("UniversalIndentGUI/" + settingName)); + } + // Otherwise add the setting and set it to the value of the objects property. + else + { + m_qsettings->setValue("UniversalIndentGUI/" + settingName, mProp.read(obj)); + } + } + else + { + //TODO: Write a debug warning to the log. + disconnect(obj, SIGNAL(destroyed(TQObject*)), this, SLOT(unregisterObjectProperty(TQObject*))); + return false; + } + + return true; +} + +//* + \brief Assigns the by \a settingName defined setting value to the by \a propertyName defined property of \a obj. + + Returns true, if the value could be assigned, otherwise returns false, which is the case if settingName doesn't exist + within the settings or if the mentioned propertyName wasn't found for the \a obj. + * / +bool UiGuiSettings::setObjectPropertyToSettingValue(TQObject *obj, const TQString &propertyName, + const TQString &settingName) +{ + const TQMetaObject *metaObject = obj->metaObject(); + + int indexOfProp = metaObject->indexOfProperty(qPrintable(propertyName)); + if (indexOfProp > -1) + { + TQMetaProperty mProp = metaObject->property(indexOfProp); + + // If setting already exists, set the objects property to the setting value. + if (m_qsettings->contains("UniversalIndentGUI/" + settingName)) + { + mProp.write(obj, m_qsettings->value("UniversalIndentGUI/" + settingName)); + } + // The setting didn't exist so return that setting the objects property failed. + else + { + //TODO: Write a debug warning to the log. + return false; + } + } + else + { + //TODO: Write a debug warning to the log. + return false; + } + + return true; +} + +/* + \brief Searches the child TQObjects of \a obj for a property name and setting name definition within + their custom properties and sets each property to settings value. + + The custom properties, for which are searched, are "connectedPropertyName" and "connectedSettingName", + where "connectedPropertyName" is the name of a TQObject property as it is documented in the TQtDocs, and + "connectedSettingName" is the name of a setting here within UiGuiSettings. + + Returns true, if all found property and setting definitions could be successfully registered. + Returns false, if any of those registrations fails. + * / +bool UiGuiSettings::setObjectPropertyToSettingValueRecursive(TQObject *obj) +{ + return checkCustomPropertiesAndCallFunction(obj, &UiGuiSettings::setObjectPropertyToSettingValue); +} + +/* + \brief Assigns the by \a propertyName defined property's value of \a obj to the by \a settingName defined setting. + + If the \a settingName didn't exist yet, it will be created. + + Returns true, if the value could be assigned, otherwise returns false, which is the case if the mentioned + propertyName wasn't found for the \a obj. + * / +bool UiGuiSettings::setSettingToObjectPropertyValue(TQObject *obj, const TQString &propertyName, + const TQString &settingName) +{ + const TQMetaObject *metaObject = obj->metaObject(); + + int indexOfProp = metaObject->indexOfProperty(qPrintable(propertyName)); + if (indexOfProp > -1) + { + TQMetaProperty mProp = metaObject->property(indexOfProp); + + setValueByName(settingName, mProp.read(obj)); + } + else + { + //TODO: Write a debug warning to the log. + return false; + } + + return true; +} + +/* + \brief Searches the child TQObjects of \a obj for a property name and setting name definition within + their custom properties and sets each setting to the property value. + + The custom properties, for which are searched, are "connectedPropertyName" and "connectedSettingName", + where "connectedPropertyName" is the name of a TQObject property as it is documented in the TQtDocs, and + "connectedSettingName" is the name of a setting here within UiGuiSettings. If the settingName + didn't exist yet, it will be created. + + Returns true, if all found property and setting definitions could be successfully registered. + Returns false, if any of those registrations fails. + * / +bool UiGuiSettings::setSettingToObjectPropertyValueRecursive(TQObject *obj) +{ + return checkCustomPropertiesAndCallFunction(obj, &UiGuiSettings::setSettingToObjectPropertyValue); +} + +/* + \brief Iterates over all \a objs child TQObjects and checks whether they have the custom properties + "connectedPropertyName" and "connectedSettingName" set. If both are set, it invokes the \a callBackFunc + with both. + * / +bool UiGuiSettings::checkCustomPropertiesAndCallFunction(TQObject *obj, bool (UiGuiSettings::*callBackFunc)( + TQObject *obj, const TQString &propertyName, + const TQString &settingName)) +{ + bool success = true; + + // Find all widgets that have PropertyName and SettingName defined in their style sheet. + TQList<TQObject*> allObjects = obj->findChildren<TQObject*>(); + foreach(TQObject * object, allObjects) + { + TQString propertyName = object->property("connectedPropertyName").toString(); + TQString settingName = object->property("connectedSettingName").toString(); + + // If property and setting name were found, register that widget with the settings. + if (!propertyName.isEmpty() && !settingName.isEmpty()) + { + success &= (this->*callBackFunc)(object, propertyName, settingName); + } + } + + return success; +} + +/* + \brief The with a certain property registered \a obj gets unregistered. + * / +void UiGuiSettings::unregisterObjectProperty(TQObject *obj) +{ + if (m_registeredObjectProperties.contains(obj)) + { + const TQMetaObject *metaObject = obj->metaObject(); + TQString propertyName = m_registeredObjectProperties[obj].first(); + TQString settingName = m_registeredObjectProperties[obj].last(); + + bool connectSuccess = false; + int indexOfProp = metaObject->indexOfProperty(qPrintable(propertyName)); + if (indexOfProp > -1) + { + TQMetaProperty mProp = metaObject->property(indexOfProp); + + // Disconnect to the property's value changed signal. + if (mProp.hasNotifySignal()) + { + TQMetaMethod signal = mProp.notifySignal(); + // The command "SIGNAL() + TQString(signal.signature())" assembles the signal methods + // signature to a valid TQt SIGNAL. + connectSuccess = disconnect(obj, qPrintable(SIGNAL() + TQString( + signal.signature())), this, SLOT(handleObjectPropertyChange())); + } + } + m_registeredObjectProperties.remove(obj); + } +} + +/* + \brief Registers a slot form the \a obj by its \a slotName to be invoked, if the by \a settingName defined + setting changes. + + The registered slot may have no parameters or exactly one. If it accepts one parameter, whenever the setting + \a settingName changes the slot gets tried to be invoked with the settings value as parameter. This only works, + if the slot parameter is of the same type as the setting. + * / +bool UiGuiSettings::registerObjectSlot(TQObject *obj, const TQString &slotName, + const TQString &settingName) +{ + const TQMetaObject *metaObject = obj->metaObject(); + + bool connectSuccess = false; + // Connect to the objects destroyed signal, so that it will be correctly unregistered. + connectSuccess = + connect(obj, SIGNAL(destroyed(TQObject*)), this, SLOT(unregisterObjectSlot(TQObject*))); + + TQString normalizedSlotName = TQMetaObject::normalizedSignature(qPrintable(slotName)); + int indexOfMethod = metaObject->indexOfMethod(qPrintable(normalizedSlotName)); + if (connectSuccess && indexOfMethod > -1) + { + TQMetaMethod mMethod = metaObject->method(indexOfMethod); + //TQMetaMethod::Access access = mMethod.access(); + //TQMetaMethod::MethodType methType = mMethod.methodType(); + + // Since the method can at maximum be invoked with the setting value as argument, + // only methods taking max one argument are allowed. + if (mMethod.parameterTypes().size() <= 1) + { + m_registeredObjectSlots.insert(obj, TQStringList() << normalizedSlotName << settingName); + } + else + { + //TODO: Write a debug warning to the log. + disconnect(obj, SIGNAL(destroyed(TQObject*)), this, SLOT(unregisterObjectSlot(TQObject*))); + return false; + } + } + else + { + //TODO: Write a debug warning to the log. + disconnect(obj, SIGNAL(destroyed(TQObject*)), this, SLOT(unregisterObjectSlot(TQObject*))); + return false; + } + + return true; +} + +/* + \brief If \a obj, \a slotName and \a settingName are given, that certain connection is unregistered. + If only \a obj is given, all to this object registered slot-setting connections are unregistered. + * / +void UiGuiSettings::unregisterObjectSlot(TQObject *obj, const TQString &slotName, + const TQString &settingName) +{ + //const TQMetaObject *metaObject = obj->metaObject(); + TQString normalizedSlotName = TQMetaObject::normalizedSignature(qPrintable(slotName)); + TQMutableMapIterator<TQObject*, TQStringList> it(m_registeredObjectSlots); + while (it.hasNext()) + { + it.next(); + if (it.key() == obj && slotName.isEmpty() && settingName.isEmpty()) + { + it.remove(); + } + else if (it.key() == obj && it.value().first() == slotName && it.value().last() == settingName) + { + it.remove(); + } + } +} + +/* + \brief This private slot gets invoked whenever a registered objects property changes + and distributes the new value to all other to the same settingName registered objects. + * / +void UiGuiSettings::handleObjectPropertyChange() +{ + TQObject *obj = TQObject::sender(); + TQString className = obj->metaObject()->className(); + const TQMetaObject *metaObject = obj->metaObject(); + TQString propertyName = m_registeredObjectProperties[obj].first(); + TQString settingName = m_registeredObjectProperties[obj].last(); + + int indexOfProp = metaObject->indexOfProperty(qPrintable(propertyName)); + if (indexOfProp > -1) + { + TQMetaProperty mProp = metaObject->property(indexOfProp); + setValueByName(settingName, mProp.read(obj)); + } +} + +/* + \brief Sets the setting defined by \a settingName to \a value. + + When setting a changed value, all to this settingName registered objects get + the changed value set too. + If the \a settingName didn't exist yet, it will be created. + * / +void UiGuiSettings::setValueByName(const TQString &settingName, const TQVariant &value) +{ + // Do the updating only, if the setting was really changed. + if (m_qsettings->value("UniversalIndentGUI/" + settingName) != value) + { + m_qsettings->setValue("UniversalIndentGUI/" + settingName, value); + + // Set the new value for all registered object properties for settingName. + for (TQMap<TQObject*, TQStringList>::ConstIterator it = m_registeredObjectProperties.begin(); + it != m_registeredObjectProperties.end(); ++it) + { + if (it.value().last() == settingName) + { + TQObject *obj = it.key(); + const TQMetaObject *metaObject = obj->metaObject(); + TQString propertyName = it.value().first(); + + int indexOfProp = metaObject->indexOfProperty(qPrintable(propertyName)); + if (indexOfProp > -1) + { + TQMetaProperty mProp = metaObject->property(indexOfProp); + mProp.write(obj, value); + } + } + } + + // Invoke all registered object methods for settingName. + for (TQMap<TQObject*, TQStringList>::ConstIterator it = m_registeredObjectSlots.begin(); + it != m_registeredObjectSlots.end(); ++it) + { + if (it.value().last() == settingName) + { + TQObject *obj = it.key(); + const TQMetaObject *metaObject = obj->metaObject(); + TQString slotName = it.value().first(); + + int indexOfMethod = metaObject->indexOfMethod(qPrintable(slotName)); + if (indexOfMethod > -1) + { + TQMetaMethod mMethod = metaObject->method(indexOfMethod); + //TQMetaMethod::Access access = mMethod.access(); + //TQMetaMethod::MethodType methType = mMethod.methodType(); + + bool success = false; + + // Handle registered slots taking one parameter. + if (mMethod.parameterTypes().size() == 1) + { + if (mMethod.parameterTypes().first() == value.typeName()) + { + success = invokeMethodWithValue(obj, mMethod, value); + } + } + // Handle registered slots taking zero parameters. + else + { + success = mMethod.invoke(obj, TQt::DirectConnection); + } + + if (success == false) + { + // TODO: Write a warning to the log if no success. + } + } + } + } + } +} + +#include <tqbitarray.h> +#include <tqbitmap.h> +#include <tqbrush.h> +#include <tqcursor.h> +#include <tqdatetime.h> +#include <tqfont.h> +#include <tqicon.h> +#include <tqkeysequence.h> +#include <tqlocale.h> +#include <tqpalette.h> +#include <tqpen.h> +#include <tqsizepolicy.h> +#include <tqtextformat.h> +#include <tqtextlength.h> +#include <tqurl.h> +#if TQT_VERSION >= 0x040600 + #include <tqmatrix4x4.h> + #include <tqvector2d.h> +#endif + +bool UiGuiSettings::invokeMethodWithValue(TQObject *obj, TQMetaMethod mMethod, TQVariant value) +{ + switch (value.type()) + { + case TQVariant::BitArray: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQBitArray, value.toBitArray())); + } + + case TQVariant::Bitmap: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQBitmap, value.value<TQBitmap>())); + } + + case TQVariant::Bool: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(bool, value.toBool())); + } + + case TQVariant::Brush: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQBrush, value.value<TQBrush>())); + } + + case TQVariant::ByteArray: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQByteArray, value.toByteArray())); + } + + case TQVariant::Char: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQChar, value.toChar())); + } + + case TQVariant::Color: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQColor, value.value<TQColor>())); + } + + case TQVariant::Cursor: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQCursor, value.value<TQCursor>())); + } + + case TQVariant::Date: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQDate, value.toDate())); + } + + case TQVariant::DateTime: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQDateTime, value.toDateTime())); + } + + case TQVariant::Double: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(double, value.toDouble())); + } + + case TQVariant::Font: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQFont, value.value<TQFont>())); + } + + case TQVariant::Hash: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQVariantHash, value.toHash())); + } + + case TQVariant::Icon: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQIcon, value.value<TQIcon>())); + } + + case TQVariant::Image: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQImage, value.value<TQImage>())); + } + + case TQVariant::Int: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(int, value.toInt())); + } + + case TQVariant::KeySequence: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQKeySequence, + value.value<TQKeySequence>())); + } + + case TQVariant::Line: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQLine, value.toLine())); + } + + case TQVariant::LineF: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQLineF, value.toLineF())); + } + + case TQVariant::List: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQVariantList, value.toList())); + } + + case TQVariant::Locale: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQLocale, value.toLocale())); + } + + case TQVariant::LongLong: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(qlonglong, value.toLongLong())); + } + + case TQVariant::Map: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQVariantMap, value.toMap())); + } + + case TQVariant::Matrix: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQMatrix, value.value<TQMatrix>())); + } + + case TQVariant::Transform: + { + return mMethod.invoke(obj, TQt::DirectConnection, + Q_ARG(TQTransform, value.value<TQTransform>())); + } + +#if TQT_VERSION >= 0x040600 + case TQVariant::Matrix4x4: + { + return mMethod.invoke(obj, TQt::DirectConnection, + Q_ARG(TQMatrix4x4, value.value<TQMatrix4x4>())); + } + +#endif + case TQVariant::Palette: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQPalette, value.value<TQPalette>())); + } + + case TQVariant::Pen: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQPen, value.value<TQPen>())); + } + + case TQVariant::Pixmap: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQPixmap, value.value<TQPixmap>())); + } + + case TQVariant::Point: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQPoint, value.toPoint())); + } + + // case TQVariant::PointArray : + // return Q_ARG(TQPointArray, value.value<TQPointArray>()) ); + case TQVariant::PointF: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQPointF, value.toPointF())); + } + + case TQVariant::Polygon: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQPolygon, value.value<TQPolygon>())); + } + +#if TQT_VERSION >= 0x040600 + case TQVariant::Quaternion: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQQuaternion, + value.value<TQQuaternion>())); + } + +#endif + case TQVariant::Rect: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQRect, value.toRect())); + } + + case TQVariant::RectF: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQRectF, value.toRectF())); + } + + case TQVariant::RegExp: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQRegExp, value.toRegExp())); + } + + case TQVariant::Region: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQRegion, value.value<TQRegion>())); + } + + case TQVariant::Size: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQSize, value.toSize())); + } + + case TQVariant::SizeF: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQSizeF, value.toSizeF())); + } + + case TQVariant::SizePolicy: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQSizePolicy, + value.value<TQSizePolicy>())); + } + + case TQVariant::String: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQString, value.toString())); + } + + case TQVariant::StringList: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQStringList, value.toStringList())); + } + + case TQVariant::TextFormat: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQTextFormat, + value.value<TQTextFormat>())); + } + + case TQVariant::TextLength: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQTextLength, + value.value<TQTextLength>())); + } + + case TQVariant::Time: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQTime, value.toTime())); + } + + case TQVariant::UInt: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(uint, value.toUInt())); + } + + case TQVariant::ULongLong: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(qulonglong, value.toULongLong())); + } + + case TQVariant::Url: + { + return mMethod.invoke(obj, TQt::DirectConnection, Q_ARG(TQUrl, value.toUrl())); + } + +#if TQT_VERSION >= 0x040600 + case TQVariant::Vector2D: + { + return mMethod.invoke(obj, TQt::DirectConnection, + Q_ARG(TQVector2D, value.value<TQVector2D>())); + } + + case TQVariant::Vector3D: + { + return mMethod.invoke(obj, TQt::DirectConnection, + Q_ARG(TQVector3D, value.value<TQVector3D>())); + } + + case TQVariant::Vector4D: + { + return mMethod.invoke(obj, TQt::DirectConnection, + Q_ARG(TQVector4D, value.value<TQVector4D>())); + } + +#endif + default: + { + return false; + } + } +} +*/ + +#include "UiGuiSettings.moc" |