You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1073 lines
34 KiB
1073 lines
34 KiB
/***************************************************************************
|
|
* 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 <tqregexp.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";
|
|
|
|
m_actionSettings["actionEnableSyntaxHighlighting"] = "SyntaxHighlightingEnabled";
|
|
m_actionSettings["actionLoadLastOpenedFileOnStartup"] = "LoadLastOpenedFileOnStartup";
|
|
m_actionSettings["actionWhiteSpaceIsVisible"] = "WhiteSpaceIsVisible";
|
|
|
|
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
|
|
m_settings["VersionInSettingsFile"] = m_qsettings->readEntry("version", TQString::null);
|
|
|
|
// Read window's maximized status
|
|
m_settings["WindowIsMaximized"] = m_qsettings->readBoolEntry("maximized", false);
|
|
|
|
// Read window's position
|
|
TQString positionString = m_qsettings->readEntry("position", "@Point(50 50)");
|
|
TQRegExp posrx("@Point\\((-?\\d+)[ \\t]+(-?\\d+)\\)");
|
|
TQPoint position(50, 50);
|
|
if (posrx.exactMatch(positionString.stripWhiteSpace()))
|
|
{
|
|
TQStringList posList = posrx.capturedTexts();
|
|
position.setX(posList[1].toInt());
|
|
position.setY(posList[2].toInt());
|
|
}
|
|
m_settings["WindowPosition"] = position;
|
|
|
|
// Read window's size
|
|
TQString sizeString = m_qsettings->readEntry("size", "@Size(800 600)");
|
|
TQRegExp sizerx("@Size\\((-?\\d+)[ \\t]+(-?\\d+)\\)");
|
|
TQSize size(800, 600);
|
|
if (sizerx.exactMatch(sizeString.stripWhiteSpace()))
|
|
{
|
|
TQStringList sizeList = sizerx.capturedTexts();
|
|
size.setWidth(sizeList[1].toInt());
|
|
size.setHeight(sizeList[2].toInt());
|
|
}
|
|
m_settings["WindowSize"] = size;
|
|
|
|
// 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["SyntaxHighlightingEnabled"] = m_qsettings->readBoolEntry(
|
|
"SyntaxHighlightingEnabled", 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
|
|
m_qsettings->writeEntry("version", m_settings["VersionInSettingsFile"].toString());
|
|
|
|
// Write window's maximized status
|
|
m_qsettings->writeEntry("maximized", m_settings["WindowIsMaximized"].toBool());
|
|
|
|
// Write window's position
|
|
TQPoint position = m_settings["WindowPosition"].toPoint();
|
|
TQString positionString = TQString("@Point(%1 %2)").arg(position.x()).arg(position.y());
|
|
m_qsettings->writeEntry("position", positionString);
|
|
|
|
// Write window's size
|
|
TQSize size = m_settings["WindowSize"].toSize();
|
|
TQString sizeString = TQString("@Size(%1 %2)").arg(size.width()).arg(size.height());
|
|
m_qsettings->writeEntry("size", sizeString);
|
|
|
|
// 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("SyntaxHighlightingEnabled",
|
|
m_settings["SyntaxHighlightingEnabled"].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());
|
|
}
|
|
|
|
/*
|
|
\brief Extern widgets can connect to this slot to change settings.
|
|
|
|
According to the objects property "connectedSettingName" the corresponding
|
|
setting is known and set.
|
|
*/
|
|
void UiGuiSettings::handleValueChangeFromExtern(bool value)
|
|
{
|
|
if (sender())
|
|
{
|
|
// Get the corresponding setting name from the sender objects property
|
|
TQString senderName = TQString(sender()->name());
|
|
if (m_actionSettings.contains(senderName))
|
|
{
|
|
TQString settingName = m_actionSettings[senderName];
|
|
|
|
// Set the value of the setting to the objects value.
|
|
setValueByName(settingName, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
void UiGuiSettings::emitSignalForSetting(TQString settingName)
|
|
{
|
|
// Emit the signal for the changed value.
|
|
if (settingName == "LoadLastOpenedFileOnStartup")
|
|
{
|
|
emit loadLastOpenedFileOnStartup(m_settings[settingName].toBool());
|
|
}
|
|
else if (settingName == "SyntaxHighlightingEnabled")
|
|
{
|
|
emit syntaxHighlightingEnabled(m_settings[settingName].toBool());
|
|
}
|
|
else if (settingName == "WhiteSpaceIsVisible")
|
|
{
|
|
emit whiteSpaceIsVisible(m_settings[settingName].toBool());
|
|
}
|
|
else if (settingName == "TabWidth")
|
|
{
|
|
emit tabWidth(m_settings[settingName].toInt());
|
|
}
|
|
else if (settingName == "Language")
|
|
{
|
|
emit language(m_settings[settingName].toInt());
|
|
}
|
|
}
|
|
|
|
/*
|
|
\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"
|