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

Clean up UiSettings class

Browse Source 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/3/head
Michele Calgaro 1 year ago
parent 95f2a9c897
commit 6b2298c21d
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF
4 changed files with 1 additions and 743 deletions
Show Stats Download Patch File Download Diff File

2
src/CMakeLists.txt
Unescape View File

@ -36,6 +36,7 @@ set( ${target}_SRCS
UiGuiErrorMessage.cpp UiGuiErrorMessage.cpp
UiGuiHighlighter.cpp UiGuiHighlighter.cpp
UiGuiIniFileParser.cpp UiGuiIniFileParser.cpp
UiGuiSettings.cpp
# ongoing # ongoing
AboutDialogBase.ui AboutDialogBase.ui
@ -44,7 +45,6 @@ set( ${target}_SRCS
AboutDialog.cpp AboutDialog.cpp
MainWindow.cpp MainWindow.cpp
main.cpp main.cpp
UiGuiSettings.cpp
UiGuiSettingsDialog.cpp UiGuiSettingsDialog.cpp
) )

8
src/MainWindow.cpp
Unescape View File

@ -275,8 +275,6 @@ void MainWindow::initToolBar()
m_toolBarWidget = new ToolBarWidget(toolBar); m_toolBarWidget = new ToolBarWidget(toolBar);
// Connect the tool bar widgets to their functions. // Connect the tool bar widgets to their functions.
///-- m_settings->registerObjectProperty(_toolBarWidget->cbEnableSyntaxHL, "checked",
///-- "SyntaxHighlightingEnabled");
m_toolBarWidget->cbEnableSyntaxHL->hide(); m_toolBarWidget->cbEnableSyntaxHL->hide();
m_toolBarWidget->pbOpenSourceFile->setIconSet(TQPixmap(ICONS_PATH + "document-open.png")); m_toolBarWidget->pbOpenSourceFile->setIconSet(TQPixmap(ICONS_PATH + "document-open.png"));
@ -293,8 +291,6 @@ void MainWindow::initToolBar()
connect(m_toolBarWidget->cbLivePreview, SIGNAL(toggled(bool)), this, SLOT(previewTurnedOnOff(bool))); connect(m_toolBarWidget->cbLivePreview, SIGNAL(toggled(bool)), this, SLOT(previewTurnedOnOff(bool)));
connect(m_toolBarWidget->cbLivePreview, SIGNAL(toggled(bool)), connect(m_toolBarWidget->cbLivePreview, SIGNAL(toggled(bool)),
actionLiveIndentPreview, SLOT(setOn(bool))); actionLiveIndentPreview, SLOT(setOn(bool)));
///-- connect(actionLiveIndentPreview, SIGNAL(toggled(
///-- bool)), m_toolBarWidget->cbLivePreview, SLOT(setChecked(bool)));
} }
/* /*
@ -451,10 +447,6 @@ void MainWindow::initIndenter()
// Set this true, so the indenter is called at first program start // Set this true, so the indenter is called at first program start
m_indentSettingsChanged = true; m_indentSettingsChanged = true;
m_previewToggled = true; m_previewToggled = true;
///-- // Handle if indenter parameter tool tips are enabled
///-- m_settings->registerObjectProperty(actionIndenterParameterTooltipsEnabled,
///-- "checked", "indenterParameterTooltipsEnabled");
} }
/* /*

699
src/UiGuiSettings.cpp
Unescape View File

@ -379,703 +379,4 @@ 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" #include "UiGuiSettings.moc"

35
src/UiGuiSettings.h
Unescape View File

@ -43,59 +43,24 @@ class UiGuiSettings : public TQObject
~UiGuiSettings(); ~UiGuiSettings();
// [--] bool registerObjectProperty(TQObject *obj, const TQString &propertyName,
// [--] const TQString &settingName);
// [--] bool setObjectPropertyToSettingValue(TQObject *obj, const TQString &propertyName,
// [--] const TQString &settingName);
// [--] bool setObjectPropertyToSettingValueRecursive(TQObject *obj);
// [--] bool setSettingToObjectPropertyValue(TQObject *obj, const TQString &propertyName,
// [--] const TQString &settingName);
// [--] bool setSettingToObjectPropertyValueRecursive(TQObject *obj);
// [--] bool registerObjectSlot(TQObject *obj, const TQString &slotName,
// [--] const TQString &settingName);
void loadSettings(); void loadSettings();
void saveSettings(); void saveSettings();
bool setValueByName(const TQString &settingName, TQVariant value); bool setValueByName(const TQString &settingName, TQVariant value);
TQVariant getValueByName(const TQString &settingName) const; TQVariant getValueByName(const TQString &settingName) const;
TQStringList& getAvailableTranslations(); TQStringList& getAvailableTranslations();
public slots:
// [--] void unregisterObjectProperty(TQObject *obj);
// [--] void unregisterObjectSlot(TQObject *obj, const TQString &slotName = TQString::null,
// [--] const TQString &settingName = TQString::null);
// [--]
// [--] protected:
// [--]//---- bool invokeMethodWithValue(TQObject *obj, TQMetaMethod mMethod, TQVariant value);
// [--]
// [--] bool checkCustomPropertiesAndCallFunction(TQObject * obj,
// [--] bool (UiGuiSettings::*callBackFunc)(TQObject *obj, const TQString &propertyName,
// [--] const TQString &settingName));
// [--]
private slots: private slots:
// [--] void handleObjectPropertyChange();
void handleValueChangeFromExtern(bool value); void handleValueChangeFromExtern(bool value);
// [++] void handleValueChangeFromExtern(TQDate value);
// [++] void handleValueChangeFromExtern(TQByteArray value);
// Each possible setting needs an own signal.
signals: signals:
// [++] void versionInSettingsFile(TQString value);
// [++] void windowIsMaximized(bool value);
// [++] void windowPosition(TQPoint value);
// [++] void windowSize(TQSize value);
// [++] void fileEncoding(TQString value);
void recentlyOpenedListSize(int value); void recentlyOpenedListSize(int value);
void loadLastOpenedFileOnStartup(bool value); void loadLastOpenedFileOnStartup(bool value);
// [++] void lastOpenedFiles(TQString value);
// [++] void selectedIndenter(int value);
void syntaxHighlightingEnabled(bool value); void syntaxHighlightingEnabled(bool value);
void whiteSpaceIsVisible(bool value); void whiteSpaceIsVisible(bool value);
void indenterParameterTooltipsEnabled(bool value); void indenterParameterTooltipsEnabled(bool value);
void tabWidth(int value); void tabWidth(int value);
void language(int value); void language(int value);
// [++] void lastUpdateCheck(TQDate value);
// [++] void mainWindowState(TQByteArray value);
private: private:
void emitSignalForSetting(TQString settingName); void emitSignalForSetting(TQString settingName);

Write Preview
Loading…
Cancel
Save