diff --git a/GUI/coregui/Views/Components/SampleEditor/DesignerScene.cpp b/GUI/coregui/Views/Components/SampleEditor/DesignerScene.cpp
index 9769b641fa5890513c1c6d09cb4e511bbe907248..41cf2832caabcdf967978e935216950b5e2ce04e 100644
--- a/GUI/coregui/Views/Components/SampleEditor/DesignerScene.cpp
+++ b/GUI/coregui/Views/Components/SampleEditor/DesignerScene.cpp
@@ -48,65 +48,93 @@ void DesignerScene::createLayerDock()
}
-//void DesignerScene::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
-//{
-// std::cout << "DesignerScene::dragEnterEvent() ->" << std::endl;
-// event->acceptProposedAction();
-//}
-
-
-//void DesignerScene::dragMoveEvent(QGraphicsSceneDragDropEvent *event)
-//{
+void DesignerScene::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
+{
+ std::cout << "DesignerScene::dragEnterEvent() ->" << std::endl;
// event->acceptProposedAction();
-// std::cout << "DesignerScene::dragMoveEvent() -> " << event->pos().x() << " " << event->pos().y() << std::endl;
-//}
+// event->accept();
+ QGraphicsScene::dragEnterEvent(event);
+}
-//void DesignerScene::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
-//{
-// std::cout << "DesignerScene::dragLeaveEvent() ->" << std::endl;
+void DesignerScene::dragMoveEvent(QGraphicsSceneDragDropEvent *event)
+{
+ std::cout << "DesignerScene::dragMoveEvent() -> " << event->scenePos().x() << " " << event->scenePos().y() << std::endl;
+ const DesignerMimeData *mimeData = checkDragEvent(event);
+// if (mimeData) {
+// std::cout << "DesignerScene::dragMoveEvent() -> yes" << event->scenePos().x() << " " << event->scenePos().y() << std::endl;
+// } else {
+// std::cout << "DesignerScene::dragMoveEvent() -> no" << event->scenePos().x() << " " << event->scenePos().y() << std::endl;
// event->acceptProposedAction();
-//}
+// QGraphicsScene::dragMoveEvent(event);
+// }
+ if(mimeData) {
+ if(mimeData->getClassName() == QString("Layer") || mimeData->getClassName() == QString("MultiLayer") ) {
+ QGraphicsScene::dragMoveEvent(event);
+ }
+ }
+}
-//void DesignerScene::dropEvent(QGraphicsSceneDragDropEvent *event)
-//{
-// std::cout << "DesignerScene::dropEvent() -> " << std::endl;
-// const DesignerMimeData *mimeData = checkDragEvent(event);
-// if (mimeData) {
-// std::cout << "SampleEditorScene::dropEvent() -> yes " << mimeData->getClassName().toStdString() << std::endl;
-// ISampleView *view = m_widgetFactory->create( mimeData->getClassName() );
-// addItem(view);
-// view->setPos(event->scenePos().x()-view->boundingRect().width()/2, event->scenePos().y()-view->boundingRect().height()/2);
-// }
-//}
+void DesignerScene::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
+{
+ std::cout << "DesignerScene::dragLeaveEvent() ->" << std::endl;
+ QGraphicsScene::dragLeaveEvent(event);
+// event->acceptProposedAction();
+}
-//void DesignerScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
-//{
-// std::cout << "DesignerScene::mouseMoveEvent() -> " << event->scenePos().x() << " " << event->scenePos().y() << std::endl;
-// QGraphicsScene::mouseMoveEvent(event);
-//}
+void DesignerScene::dropEvent(QGraphicsSceneDragDropEvent *event)
+{
+ std::cout << "DesignerScene::dropEvent() -> " << std::endl;
+ //event->acceptProposedAction();
+ const DesignerMimeData *mimeData = checkDragEvent(event);
+ if (mimeData) {
+ if(mimeData->getClassName() == QString("Layer") || mimeData->getClassName() == QString("MultiLayer") ) {
+ QGraphicsScene::dropEvent(event);
+ } else {
+ ISampleView *view = m_widgetFactory->create( mimeData->getClassName() );
+ addItem(view);
+ view->setPos(event->scenePos().x()-view->boundingRect().width()/2, event->scenePos().y()-view->boundingRect().height()/2);
+
+ }
+
+ std::cout << "SampleEditorScene::dropEvent() -> yes " << mimeData->getClassName().toStdString() << std::endl;
+
+ }
+ //QGraphicsScene::dropEvent(event);
+}
-//const DesignerMimeData *DesignerScene::checkDragEvent(QGraphicsSceneDragDropEvent * event)
-//{
-// const DesignerMimeData *mimeData = qobject_cast<const DesignerMimeData *>(event->mimeData());
-// if (!mimeData) {
-// event->ignore();
-// return 0;
-// }
+void DesignerScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+ std::cout << "DesignerScene::mouseMoveEvent() -> " << event->scenePos().x() << " " << event->scenePos().y() << std::endl;
+ QGraphicsScene::mouseMoveEvent(event);
+}
-// if(mimeData->hasFormat("bornagain/widget") ) {
-// std::cout << "DesignerScene::checkDragEvent() yes" << std::endl;
-// event->setAccepted(true);
-// } else {
-// std::cout << "DesignerScene::checkDragEvent() no" << std::endl;
-// event->setAccepted(false);
-// }
-// return mimeData;
-//}
+
+const DesignerMimeData *DesignerScene::checkDragEvent(QGraphicsSceneDragDropEvent * event)
+{
+ std::cout << "DesignerScene::checkDragEvent -> " << std::endl;
+ const DesignerMimeData *mimeData = qobject_cast<const DesignerMimeData *>(event->mimeData());
+ if (!mimeData) {
+ event->ignore();
+ return 0;
+ }
+
+ if(mimeData->hasFormat("bornagain/widget") ) {
+// && (mimeData->getClassName() != QString("Layer") )
+// && (mimeData->getClassName() != QString("MultiLayer") ) ) {
+
+ std::cout << "DesignerScene::checkDragEvent -> yes" << std::endl;
+ event->setAccepted(true);
+ } else {
+ event->setAccepted(false);
+ }
+ return mimeData;
+}
+
diff --git a/GUI/coregui/Views/Components/SampleEditor/DesignerScene.h b/GUI/coregui/Views/Components/SampleEditor/DesignerScene.h
index a339041483a56403d26eef74e9e1c39ce74598b4..76b17c78e94609fed6c46c5812fd2ecddbc8a310 100644
--- a/GUI/coregui/Views/Components/SampleEditor/DesignerScene.h
+++ b/GUI/coregui/Views/Components/SampleEditor/DesignerScene.h
@@ -33,14 +33,15 @@ public:
protected:
-// virtual void dragEnterEvent(QGraphicsSceneDragDropEvent *event);
-// virtual void dragMoveEvent(QGraphicsSceneDragDropEvent *event);
-// virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent *event);
-// virtual void dropEvent(QGraphicsSceneDragDropEvent *event);
-// virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+ virtual void dragEnterEvent(QGraphicsSceneDragDropEvent *event);
+ virtual void dragMoveEvent(QGraphicsSceneDragDropEvent *event);
+ virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent *event);
+ virtual void dropEvent(QGraphicsSceneDragDropEvent *event);
+ virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
-private:
const DesignerMimeData *checkDragEvent(QGraphicsSceneDragDropEvent * event);
+
+private:
void createLayerDock();
int m_xmin;
diff --git a/GUI/coregui/Views/Components/SampleEditor/DesignerView.cpp b/GUI/coregui/Views/Components/SampleEditor/DesignerView.cpp
index 0c66f352d019618d5e50c6c756e7776083b5c989..e6fe80e225f0c11844e48b197c577401154cfe05 100644
--- a/GUI/coregui/Views/Components/SampleEditor/DesignerView.cpp
+++ b/GUI/coregui/Views/Components/SampleEditor/DesignerView.cpp
@@ -23,11 +23,11 @@ DesignerView::DesignerView(QWidget *parent, QGraphicsScene *scene)
{
// setMinimumSize(128, 128);
// setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
- setAcceptDrops(true);
+ setAcceptDrops(false);
QVBoxLayout *layout = new QVBoxLayout;
m_graphicsView = new QGraphicsView(scene);
- //m_graphicsView->setAcceptDrops(true);
+ m_graphicsView->setAcceptDrops(true);
layout->addWidget(m_graphicsView);
setLayout(layout);
@@ -144,18 +144,18 @@ void DesignerView::keyPressEvent(QKeyEvent *event)
//}
-void DesignerView::dropEvent(QDropEvent *event)
-{
- std::cout << "SampleEditorScene::dropEvent() -> " << std::endl;
- const DesignerMimeData *mimeData = checkDragEvent(event);
- if (mimeData) {
- std::cout << "DesignerView::dropEvent() -> yes " << mimeData->getClassName().toStdString() << std::endl;
-
- ISampleView *view = m_widgetFactory->create( mimeData->getClassName() );
- m_graphicsView->scene()->addItem(view);
- view->setPos(event->pos().x()-view->boundingRect().width()/2, event->pos().y()-view->boundingRect().height()/2);
- }
-}
+//void DesignerView::dropEvent(QDropEvent *event)
+//{
+// std::cout << "SampleEditorScene::dropEvent() -> " << std::endl;
+// const DesignerMimeData *mimeData = checkDragEvent(event);
+// if (mimeData) {
+// std::cout << "DesignerView::dropEvent() -> yes " << mimeData->getClassName().toStdString() << std::endl;
+
+// ISampleView *view = m_widgetFactory->create( mimeData->getClassName() );
+// m_graphicsView->scene()->addItem(view);
+// view->setPos(event->pos().x()-view->boundingRect().width()/2, event->pos().y()-view->boundingRect().height()/2);
+// }
+//}
void DesignerView::mouseMoveEvent(QMouseEvent *event)
@@ -167,6 +167,7 @@ void DesignerView::mouseMoveEvent(QMouseEvent *event)
const DesignerMimeData *DesignerView::checkDragEvent(QDropEvent * event)
{
+ std::cout << "DesignerView::checkDragEvent()" << std::endl;
const DesignerMimeData *mimeData = qobject_cast<const DesignerMimeData *>(event->mimeData());
if (!mimeData) {
event->ignore();
diff --git a/GUI/coregui/Views/Components/SampleEditor/DesignerView.h b/GUI/coregui/Views/Components/SampleEditor/DesignerView.h
index d52d59a3838ca7f4be0d1b379352fbd9b2656ace..96265b6437b7aa09e2db102166b67f04ef1bf248 100644
--- a/GUI/coregui/Views/Components/SampleEditor/DesignerView.h
+++ b/GUI/coregui/Views/Components/SampleEditor/DesignerView.h
@@ -28,7 +28,7 @@ protected:
// virtual void dragEnterEvent(QDragEnterEvent *event);
// virtual void dragMoveEvent(QDragMoveEvent *event);
// virtual void dragLeaveEvent(QDragLeaveEvent *event);
- virtual void dropEvent(QDropEvent *event);
+// virtual void dropEvent(QDropEvent *event);
virtual void mouseMoveEvent(QMouseEvent *event);
// void wheelEvent(QWheelEvent *event);
diff --git a/GUI/coregui/Views/Components/SampleEditor/LayerView.cpp b/GUI/coregui/Views/Components/SampleEditor/LayerView.cpp
index b5558f0c772139082600b00457c98fc1050172c7..8f55c0bfa711197ffe9f366adee072234143e092 100644
--- a/GUI/coregui/Views/Components/SampleEditor/LayerView.cpp
+++ b/GUI/coregui/Views/Components/SampleEditor/LayerView.cpp
@@ -20,6 +20,7 @@ LayerView::LayerView(QGraphicsItem *parent)
, m_color(qrand() % 256, qrand() % 256, qrand() % 256)
, m_rect(0, 0, DesignerHelper::getLayerWidth(), DesignerHelper::getLayerHeight())
, m_fixed_xpos(0)
+ , m_fixed(false)
{
// setToolTip(QString("QColor(%1, %2, %3)\n%4")
// .arg(color.red()).arg(color.green()).arg(color.blue())
@@ -60,6 +61,12 @@ void LayerView::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
void LayerView::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
std::cout << "LayerView::mousePressEvent -> " << x() << " " << y() << std::endl;
+ // remove selection from child items
+ QList<QGraphicsItem *> list = childItems();
+ foreach(QGraphicsItem *item, list) {
+ item->setSelected(false);
+ }
+
QGraphicsObject::mousePressEvent(event);
}
@@ -101,7 +108,7 @@ void LayerView::dragMoveEvent(QGraphicsSceneDragDropEvent *event)
QVariant LayerView::itemChange(GraphicsItemChange change, const QVariant &value)
{
std::cout << "YYY itemChange " << x() << " " << y() << std::endl;
- if (change == ItemPositionChange && scene()) {
+ if (change == ItemPositionChange && scene() && m_fixed) {
// value is the new position.
QPointF newPos = value.toPointF();
// QRectF rect = parentItem()->boundingRect();
diff --git a/GUI/coregui/Views/Components/SampleEditor/LayerView.h b/GUI/coregui/Views/Components/SampleEditor/LayerView.h
index d49dc64634a2b3e130dd824dfa845586416a0139..4414f47956ccc47c49de724d38c00e9e6962b01a 100644
--- a/GUI/coregui/Views/Components/SampleEditor/LayerView.h
+++ b/GUI/coregui/Views/Components/SampleEditor/LayerView.h
@@ -23,7 +23,7 @@ public:
QRect rect() const { return m_rect; }
- void setFixedX() { m_fixed_xpos = x(); }
+ void setFixedX() { m_fixed_xpos = x(); m_fixed=true; }
qreal getFixedX() { return m_fixed_xpos; }
Q_SIGNALS:
@@ -46,6 +46,7 @@ private:
QColor m_color;
QRect m_rect;
qreal m_fixed_xpos;
+ bool m_fixed;
};
diff --git a/GUI/coregui/coregui.pro b/GUI/coregui/coregui.pro
index a95ae0a7527fb3a346f10fe4ed9017068253f65e..e95c2ba4b1ea442005fe356a21612f9e5a7a00b3 100644
--- a/GUI/coregui/coregui.pro
+++ b/GUI/coregui/coregui.pro
@@ -13,6 +13,7 @@ CONFIG += BORNAGAIN_ROOT BORNAGAIN_PYTHON
include($$PWD/Views/Components/widgetbox/widgetbox.pri)
include($$PWD/Views/Components/SampleEditor/SampleEditor.pri)
+include($$PWD/qttools/qtpropertybrowser/qtpropertybrowser.pri)
SOURCES += \
mainwindow/main.cpp \
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtAbstractEditorFactoryBase b/GUI/coregui/qttools/qtpropertybrowser/QtAbstractEditorFactoryBase
new file mode 100644
index 0000000000000000000000000000000000000000..ab4e7104a4c6146c65f899d9a7816464ae197436
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtAbstractEditorFactoryBase
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtAbstractPropertyBrowser b/GUI/coregui/qttools/qtpropertybrowser/QtAbstractPropertyBrowser
new file mode 100644
index 0000000000000000000000000000000000000000..ab4e7104a4c6146c65f899d9a7816464ae197436
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtAbstractPropertyBrowser
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtAbstractPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtAbstractPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..ab4e7104a4c6146c65f899d9a7816464ae197436
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtAbstractPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtBoolPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtBoolPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtBoolPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtBrowserItem b/GUI/coregui/qttools/qtpropertybrowser/QtBrowserItem
new file mode 100644
index 0000000000000000000000000000000000000000..ab4e7104a4c6146c65f899d9a7816464ae197436
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtBrowserItem
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtButtonPropertyBrowser b/GUI/coregui/qttools/qtpropertybrowser/QtButtonPropertyBrowser
new file mode 100644
index 0000000000000000000000000000000000000000..56e089704acc0bfbb84da89ea6d8cb55fc829c2c
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtButtonPropertyBrowser
@@ -0,0 +1 @@
+#include "qtbuttonpropertybrowser.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtCharEditorFactory b/GUI/coregui/qttools/qtpropertybrowser/QtCharEditorFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtCharEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtCharPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtCharPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtCharPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtCheckBoxFactory b/GUI/coregui/qttools/qtpropertybrowser/QtCheckBoxFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtCheckBoxFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtColorEditorFactory b/GUI/coregui/qttools/qtpropertybrowser/QtColorEditorFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtColorEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtColorPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtColorPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtColorPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtCursorEditorFactory b/GUI/coregui/qttools/qtpropertybrowser/QtCursorEditorFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtCursorEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtCursorPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtCursorPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtCursorPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtDateEditFactory b/GUI/coregui/qttools/qtpropertybrowser/QtDateEditFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtDateEditFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtDatePropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtDatePropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtDatePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtDateTimeEditFactory b/GUI/coregui/qttools/qtpropertybrowser/QtDateTimeEditFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtDateTimeEditFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtDateTimePropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtDateTimePropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtDateTimePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtDoublePropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtDoublePropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtDoublePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtDoubleSpinBoxFactory b/GUI/coregui/qttools/qtpropertybrowser/QtDoubleSpinBoxFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtDoubleSpinBoxFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtEnumEditorFactory b/GUI/coregui/qttools/qtpropertybrowser/QtEnumEditorFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtEnumEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtEnumPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtEnumPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtEnumPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtFlagPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtFlagPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtFlagPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtFontEditorFactory b/GUI/coregui/qttools/qtpropertybrowser/QtFontEditorFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtFontEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtFontPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtFontPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtFontPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtGroupBoxPropertyBrowser b/GUI/coregui/qttools/qtpropertybrowser/QtGroupBoxPropertyBrowser
new file mode 100644
index 0000000000000000000000000000000000000000..27964c08034d74ce98f807d4911bd0d561c2862a
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtGroupBoxPropertyBrowser
@@ -0,0 +1 @@
+#include "qtgroupboxpropertybrowser.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtGroupPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtGroupPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtGroupPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtIntPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtIntPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtIntPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtKeySequenceEditorFactory b/GUI/coregui/qttools/qtpropertybrowser/QtKeySequenceEditorFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtKeySequenceEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtKeySequencePropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtKeySequencePropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtKeySequencePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtLineEditFactory b/GUI/coregui/qttools/qtpropertybrowser/QtLineEditFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtLineEditFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtLocalePropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtLocalePropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtLocalePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtPointFPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtPointFPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtPointFPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtPointPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtPointPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtPointPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtProperty b/GUI/coregui/qttools/qtpropertybrowser/QtProperty
new file mode 100644
index 0000000000000000000000000000000000000000..ab4e7104a4c6146c65f899d9a7816464ae197436
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtProperty
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtRectFPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtRectFPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtRectFPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtRectPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtRectPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtRectPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtScrollBarFactory b/GUI/coregui/qttools/qtpropertybrowser/QtScrollBarFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtScrollBarFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtSizeFPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtSizeFPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtSizeFPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtSizePolicyPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtSizePolicyPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtSizePolicyPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtSizePropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtSizePropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtSizePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtSliderFactory b/GUI/coregui/qttools/qtpropertybrowser/QtSliderFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtSliderFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtSpinBoxFactory b/GUI/coregui/qttools/qtpropertybrowser/QtSpinBoxFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtSpinBoxFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtStringPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtStringPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtStringPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtTimeEditFactory b/GUI/coregui/qttools/qtpropertybrowser/QtTimeEditFactory
new file mode 100644
index 0000000000000000000000000000000000000000..75f35adabc6dba82246c4f3c0741637739af4957
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtTimeEditFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtTimePropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtTimePropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..1842e431d3a55dcacd53500d7da9b930551bc046
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtTimePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtTreePropertyBrowser b/GUI/coregui/qttools/qtpropertybrowser/QtTreePropertyBrowser
new file mode 100644
index 0000000000000000000000000000000000000000..aab106c75301d35ef666c0a00652a0edd9b6ca1d
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtTreePropertyBrowser
@@ -0,0 +1 @@
+#include "qttreepropertybrowser.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtVariantEditorFactory b/GUI/coregui/qttools/qtpropertybrowser/QtVariantEditorFactory
new file mode 100644
index 0000000000000000000000000000000000000000..8118190d503968715600525fa17c2c2b06006709
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtVariantEditorFactory
@@ -0,0 +1 @@
+#include "qtvariantproperty.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtVariantProperty b/GUI/coregui/qttools/qtpropertybrowser/QtVariantProperty
new file mode 100644
index 0000000000000000000000000000000000000000..8118190d503968715600525fa17c2c2b06006709
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtVariantProperty
@@ -0,0 +1 @@
+#include "qtvariantproperty.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/QtVariantPropertyManager b/GUI/coregui/qttools/qtpropertybrowser/QtVariantPropertyManager
new file mode 100644
index 0000000000000000000000000000000000000000..8118190d503968715600525fa17c2c2b06006709
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/QtVariantPropertyManager
@@ -0,0 +1 @@
+#include "qtvariantproperty.h"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-arrow.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-arrow.png
new file mode 100644
index 0000000000000000000000000000000000000000..a69ef4eb6158503c7c67c916aea86e65fdc81f72
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-arrow.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-busy.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-busy.png
new file mode 100644
index 0000000000000000000000000000000000000000..53717e49928a5d0e791baf971e95adc0bbe318d2
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-busy.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-closedhand.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-closedhand.png
new file mode 100644
index 0000000000000000000000000000000000000000..b78dd1dac5a827fa698f1993718f22c282019505
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-closedhand.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-cross.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-cross.png
new file mode 100644
index 0000000000000000000000000000000000000000..fe38e744805f61abefcc555e07d399725c3fd7e6
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-cross.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-forbidden.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-forbidden.png
new file mode 100644
index 0000000000000000000000000000000000000000..2b08c4e2a3cafc992459a8f484e6c8e6c3e74857
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-forbidden.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-hand.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-hand.png
new file mode 100644
index 0000000000000000000000000000000000000000..d2004aefa7337edc3e15327992e1d69fda5b1831
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-hand.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-hsplit.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-hsplit.png
new file mode 100644
index 0000000000000000000000000000000000000000..a5667e3ffba185fd0138ddfca3d4d88049928812
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-hsplit.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-ibeam.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-ibeam.png
new file mode 100644
index 0000000000000000000000000000000000000000..097fc5fa7287da71ffd907b3a11adbda4516aca6
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-ibeam.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-openhand.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-openhand.png
new file mode 100644
index 0000000000000000000000000000000000000000..9181c859edaf9aa2c16bc7dbc753609beddd8351
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-openhand.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeall.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeall.png
new file mode 100644
index 0000000000000000000000000000000000000000..69f13eb347a6c299e06844729a14f657b282fe8f
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeall.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeb.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeb.png
new file mode 100644
index 0000000000000000000000000000000000000000..f37d7b91e8cde73243fa78df45c7808aba1c5fa0
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeb.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizef.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizef.png
new file mode 100644
index 0000000000000000000000000000000000000000..3b127a05d34b48a2f4f9b9cc77b681c6b43afcdd
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizef.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeh.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeh.png
new file mode 100644
index 0000000000000000000000000000000000000000..a9f40cbc3d77c566c11c32c0631b4f94f44dd441
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizeh.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizev.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizev.png
new file mode 100644
index 0000000000000000000000000000000000000000..1edbab27a5b05555aaf515931f69ad6bf7e417f0
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-sizev.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-uparrow.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-uparrow.png
new file mode 100644
index 0000000000000000000000000000000000000000..d3e70ef4c2413c6f81c7cfffa32be7228b2b27b9
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-uparrow.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-vsplit.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-vsplit.png
new file mode 100644
index 0000000000000000000000000000000000000000..1beda2570e4328382ea43512acfe23d386214f37
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-vsplit.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-wait.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-wait.png
new file mode 100644
index 0000000000000000000000000000000000000000..69056c479e9b2f009e366dfd71999a7c74f97620
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-wait.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/images/cursor-whatsthis.png b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-whatsthis.png
new file mode 100644
index 0000000000000000000000000000000000000000..b47601c3780eec780fdae43bab7481bbfebdddae
Binary files /dev/null and b/GUI/coregui/qttools/qtpropertybrowser/images/cursor-whatsthis.png differ
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtbuttonpropertybrowser.cpp b/GUI/coregui/qttools/qtpropertybrowser/qtbuttonpropertybrowser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..293fbf6bfdb63d38ed9f7448f29104ec976e721b
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtbuttonpropertybrowser.cpp
@@ -0,0 +1,627 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtbuttonpropertybrowser.h"
+#include <QSet>
+#include <QGridLayout>
+#include <QLabel>
+#include <QTimer>
+#include <QMap>
+#include <QToolButton>
+#include <QStyle>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QtButtonPropertyBrowserPrivate
+{
+ QtButtonPropertyBrowser *q_ptr;
+ Q_DECLARE_PUBLIC(QtButtonPropertyBrowser)
+public:
+
+ void init(QWidget *parent);
+
+ void propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex);
+ void propertyRemoved(QtBrowserItem *index);
+ void propertyChanged(QtBrowserItem *index);
+ QWidget *createEditor(QtProperty *property, QWidget *parent) const
+ { return q_ptr->createEditor(property, parent); }
+
+ void slotEditorDestroyed();
+ void slotUpdate();
+ void slotToggled(bool checked);
+
+ struct WidgetItem
+ {
+ WidgetItem() : widget(0), label(0), widgetLabel(0),
+ button(0), container(0), layout(0), /*line(0), */parent(0), expanded(false) { }
+ QWidget *widget; // can be null
+ QLabel *label; // main label with property name
+ QLabel *widgetLabel; // label substitute showing the current value if there is no widget
+ QToolButton *button; // expandable button for items with children
+ QWidget *container; // container which is expanded when the button is clicked
+ QGridLayout *layout; // layout in container
+ WidgetItem *parent;
+ QList<WidgetItem *> children;
+ bool expanded;
+ };
+private:
+ void updateLater();
+ void updateItem(WidgetItem *item);
+ void insertRow(QGridLayout *layout, int row) const;
+ void removeRow(QGridLayout *layout, int row) const;
+ int gridRow(WidgetItem *item) const;
+ int gridSpan(WidgetItem *item) const;
+ void setExpanded(WidgetItem *item, bool expanded);
+ QToolButton *createButton(QWidget *panret = 0) const;
+
+ QMap<QtBrowserItem *, WidgetItem *> m_indexToItem;
+ QMap<WidgetItem *, QtBrowserItem *> m_itemToIndex;
+ QMap<QWidget *, WidgetItem *> m_widgetToItem;
+ QMap<QObject *, WidgetItem *> m_buttonToItem;
+ QGridLayout *m_mainLayout;
+ QList<WidgetItem *> m_children;
+ QList<WidgetItem *> m_recreateQueue;
+};
+
+QToolButton *QtButtonPropertyBrowserPrivate::createButton(QWidget *parent) const
+{
+ QToolButton *button = new QToolButton(parent);
+ button->setCheckable(true);
+ button->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
+ button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
+ button->setArrowType(Qt::DownArrow);
+ button->setIconSize(QSize(3, 16));
+ /*
+ QIcon icon;
+ icon.addPixmap(q_ptr->style()->standardPixmap(QStyle::SP_ArrowDown), QIcon::Normal, QIcon::Off);
+ icon.addPixmap(q_ptr->style()->standardPixmap(QStyle::SP_ArrowUp), QIcon::Normal, QIcon::On);
+ button->setIcon(icon);
+ */
+ return button;
+}
+
+int QtButtonPropertyBrowserPrivate::gridRow(WidgetItem *item) const
+{
+ QList<WidgetItem *> siblings;
+ if (item->parent)
+ siblings = item->parent->children;
+ else
+ siblings = m_children;
+
+ int row = 0;
+ QListIterator<WidgetItem *> it(siblings);
+ while (it.hasNext()) {
+ WidgetItem *sibling = it.next();
+ if (sibling == item)
+ return row;
+ row += gridSpan(sibling);
+ }
+ return -1;
+}
+
+int QtButtonPropertyBrowserPrivate::gridSpan(WidgetItem *item) const
+{
+ if (item->container && item->expanded)
+ return 2;
+ return 1;
+}
+
+void QtButtonPropertyBrowserPrivate::init(QWidget *parent)
+{
+ m_mainLayout = new QGridLayout();
+ parent->setLayout(m_mainLayout);
+ QLayoutItem *item = new QSpacerItem(0, 0,
+ QSizePolicy::Fixed, QSizePolicy::Expanding);
+ m_mainLayout->addItem(item, 0, 0);
+}
+
+void QtButtonPropertyBrowserPrivate::slotEditorDestroyed()
+{
+ QWidget *editor = qobject_cast<QWidget *>(q_ptr->sender());
+ if (!editor)
+ return;
+ if (!m_widgetToItem.contains(editor))
+ return;
+ m_widgetToItem[editor]->widget = 0;
+ m_widgetToItem.remove(editor);
+}
+
+void QtButtonPropertyBrowserPrivate::slotUpdate()
+{
+ QListIterator<WidgetItem *> itItem(m_recreateQueue);
+ while (itItem.hasNext()) {
+ WidgetItem *item = itItem.next();
+
+ WidgetItem *parent = item->parent;
+ QWidget *w = 0;
+ QGridLayout *l = 0;
+ const int oldRow = gridRow(item);
+ if (parent) {
+ w = parent->container;
+ l = parent->layout;
+ } else {
+ w = q_ptr;
+ l = m_mainLayout;
+ }
+
+ int span = 1;
+ if (!item->widget && !item->widgetLabel)
+ span = 2;
+ item->label = new QLabel(w);
+ item->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
+ l->addWidget(item->label, oldRow, 0, 1, span);
+
+ updateItem(item);
+ }
+ m_recreateQueue.clear();
+}
+
+void QtButtonPropertyBrowserPrivate::setExpanded(WidgetItem *item, bool expanded)
+{
+ if (item->expanded == expanded)
+ return;
+
+ if (!item->container)
+ return;
+
+ item->expanded = expanded;
+ const int row = gridRow(item);
+ WidgetItem *parent = item->parent;
+ QGridLayout *l = 0;
+ if (parent)
+ l = parent->layout;
+ else
+ l = m_mainLayout;
+
+ if (expanded) {
+ insertRow(l, row + 1);
+ l->addWidget(item->container, row + 1, 0, 1, 2);
+ item->container->show();
+ } else {
+ l->removeWidget(item->container);
+ item->container->hide();
+ removeRow(l, row + 1);
+ }
+
+ item->button->setChecked(expanded);
+ item->button->setArrowType(expanded ? Qt::UpArrow : Qt::DownArrow);
+}
+
+void QtButtonPropertyBrowserPrivate::slotToggled(bool checked)
+{
+ WidgetItem *item = m_buttonToItem.value(q_ptr->sender());
+ if (!item)
+ return;
+
+ setExpanded(item, checked);
+
+ if (checked)
+ emit q_ptr->expanded(m_itemToIndex.value(item));
+ else
+ emit q_ptr->collapsed(m_itemToIndex.value(item));
+}
+
+void QtButtonPropertyBrowserPrivate::updateLater()
+{
+ QTimer::singleShot(0, q_ptr, SLOT(slotUpdate()));
+}
+
+void QtButtonPropertyBrowserPrivate::propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex)
+{
+ WidgetItem *afterItem = m_indexToItem.value(afterIndex);
+ WidgetItem *parentItem = m_indexToItem.value(index->parent());
+
+ WidgetItem *newItem = new WidgetItem();
+ newItem->parent = parentItem;
+
+ QGridLayout *layout = 0;
+ QWidget *parentWidget = 0;
+ int row = -1;
+ if (!afterItem) {
+ row = 0;
+ if (parentItem)
+ parentItem->children.insert(0, newItem);
+ else
+ m_children.insert(0, newItem);
+ } else {
+ row = gridRow(afterItem) + gridSpan(afterItem);
+ if (parentItem)
+ parentItem->children.insert(parentItem->children.indexOf(afterItem) + 1, newItem);
+ else
+ m_children.insert(m_children.indexOf(afterItem) + 1, newItem);
+ }
+
+ if (!parentItem) {
+ layout = m_mainLayout;
+ parentWidget = q_ptr;
+ } else {
+ if (!parentItem->container) {
+ m_recreateQueue.removeAll(parentItem);
+ WidgetItem *grandParent = parentItem->parent;
+ QGridLayout *l = 0;
+ const int oldRow = gridRow(parentItem);
+ if (grandParent) {
+ l = grandParent->layout;
+ } else {
+ l = m_mainLayout;
+ }
+ QFrame *container = new QFrame();
+ container->setFrameShape(QFrame::Panel);
+ container->setFrameShadow(QFrame::Raised);
+ parentItem->container = container;
+ parentItem->button = createButton();
+ m_buttonToItem[parentItem->button] = parentItem;
+ q_ptr->connect(parentItem->button, SIGNAL(toggled(bool)), q_ptr, SLOT(slotToggled(bool)));
+ parentItem->layout = new QGridLayout();
+ container->setLayout(parentItem->layout);
+ if (parentItem->label) {
+ l->removeWidget(parentItem->label);
+ delete parentItem->label;
+ parentItem->label = 0;
+ }
+ int span = 1;
+ if (!parentItem->widget && !parentItem->widgetLabel)
+ span = 2;
+ l->addWidget(parentItem->button, oldRow, 0, 1, span);
+ updateItem(parentItem);
+ }
+ layout = parentItem->layout;
+ parentWidget = parentItem->container;
+ }
+
+ newItem->label = new QLabel(parentWidget);
+ newItem->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
+ newItem->widget = createEditor(index->property(), parentWidget);
+ if (newItem->widget) {
+ QObject::connect(newItem->widget, SIGNAL(destroyed()), q_ptr, SLOT(slotEditorDestroyed()));
+ m_widgetToItem[newItem->widget] = newItem;
+ } else if (index->property()->hasValue()) {
+ newItem->widgetLabel = new QLabel(parentWidget);
+ newItem->widgetLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));
+ }
+
+ insertRow(layout, row);
+ int span = 1;
+ if (newItem->widget)
+ layout->addWidget(newItem->widget, row, 1);
+ else if (newItem->widgetLabel)
+ layout->addWidget(newItem->widgetLabel, row, 1);
+ else
+ span = 2;
+ layout->addWidget(newItem->label, row, 0, span, 1);
+
+ m_itemToIndex[newItem] = index;
+ m_indexToItem[index] = newItem;
+
+ updateItem(newItem);
+}
+
+void QtButtonPropertyBrowserPrivate::propertyRemoved(QtBrowserItem *index)
+{
+ WidgetItem *item = m_indexToItem.value(index);
+
+ m_indexToItem.remove(index);
+ m_itemToIndex.remove(item);
+
+ WidgetItem *parentItem = item->parent;
+
+ const int row = gridRow(item);
+
+ if (parentItem)
+ parentItem->children.removeAt(parentItem->children.indexOf(item));
+ else
+ m_children.removeAt(m_children.indexOf(item));
+
+ const int colSpan = gridSpan(item);
+
+ m_buttonToItem.remove(item->button);
+
+ if (item->widget)
+ delete item->widget;
+ if (item->label)
+ delete item->label;
+ if (item->widgetLabel)
+ delete item->widgetLabel;
+ if (item->button)
+ delete item->button;
+ if (item->container)
+ delete item->container;
+
+ if (!parentItem) {
+ removeRow(m_mainLayout, row);
+ if (colSpan > 1)
+ removeRow(m_mainLayout, row);
+ } else if (parentItem->children.count() != 0) {
+ removeRow(parentItem->layout, row);
+ if (colSpan > 1)
+ removeRow(parentItem->layout, row);
+ } else {
+ const WidgetItem *grandParent = parentItem->parent;
+ QGridLayout *l = 0;
+ if (grandParent) {
+ l = grandParent->layout;
+ } else {
+ l = m_mainLayout;
+ }
+
+ const int parentRow = gridRow(parentItem);
+ const int parentSpan = gridSpan(parentItem);
+
+ l->removeWidget(parentItem->button);
+ l->removeWidget(parentItem->container);
+ delete parentItem->button;
+ delete parentItem->container;
+ parentItem->button = 0;
+ parentItem->container = 0;
+ parentItem->layout = 0;
+ if (!m_recreateQueue.contains(parentItem))
+ m_recreateQueue.append(parentItem);
+ if (parentSpan > 1)
+ removeRow(l, parentRow + 1);
+
+ updateLater();
+ }
+ m_recreateQueue.removeAll(item);
+
+ delete item;
+}
+
+void QtButtonPropertyBrowserPrivate::insertRow(QGridLayout *layout, int row) const
+{
+ QMap<QLayoutItem *, QRect> itemToPos;
+ int idx = 0;
+ while (idx < layout->count()) {
+ int r, c, rs, cs;
+ layout->getItemPosition(idx, &r, &c, &rs, &cs);
+ if (r >= row) {
+ itemToPos[layout->takeAt(idx)] = QRect(r + 1, c, rs, cs);
+ } else {
+ idx++;
+ }
+ }
+
+ const QMap<QLayoutItem *, QRect>::ConstIterator icend = itemToPos.constEnd();
+ for(QMap<QLayoutItem *, QRect>::ConstIterator it = itemToPos.constBegin(); it != icend; ++it) {
+ const QRect r = it.value();
+ layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height());
+ }
+}
+
+void QtButtonPropertyBrowserPrivate::removeRow(QGridLayout *layout, int row) const
+{
+ QMap<QLayoutItem *, QRect> itemToPos;
+ int idx = 0;
+ while (idx < layout->count()) {
+ int r, c, rs, cs;
+ layout->getItemPosition(idx, &r, &c, &rs, &cs);
+ if (r > row) {
+ itemToPos[layout->takeAt(idx)] = QRect(r - 1, c, rs, cs);
+ } else {
+ idx++;
+ }
+ }
+
+ const QMap<QLayoutItem *, QRect>::ConstIterator icend = itemToPos.constEnd();
+ for(QMap<QLayoutItem *, QRect>::ConstIterator it = itemToPos.constBegin(); it != icend; ++it) {
+ const QRect r = it.value();
+ layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height());
+ }
+}
+
+void QtButtonPropertyBrowserPrivate::propertyChanged(QtBrowserItem *index)
+{
+ WidgetItem *item = m_indexToItem.value(index);
+
+ updateItem(item);
+}
+
+void QtButtonPropertyBrowserPrivate::updateItem(WidgetItem *item)
+{
+ QtProperty *property = m_itemToIndex[item]->property();
+ if (item->button) {
+ QFont font = item->button->font();
+ font.setUnderline(property->isModified());
+ item->button->setFont(font);
+ item->button->setText(property->propertyName());
+ item->button->setToolTip(property->toolTip());
+ item->button->setStatusTip(property->statusTip());
+ item->button->setWhatsThis(property->whatsThis());
+ item->button->setEnabled(property->isEnabled());
+ }
+ if (item->label) {
+ QFont font = item->label->font();
+ font.setUnderline(property->isModified());
+ item->label->setFont(font);
+ item->label->setText(property->propertyName());
+ item->label->setToolTip(property->toolTip());
+ item->label->setStatusTip(property->statusTip());
+ item->label->setWhatsThis(property->whatsThis());
+ item->label->setEnabled(property->isEnabled());
+ }
+ if (item->widgetLabel) {
+ QFont font = item->widgetLabel->font();
+ font.setUnderline(false);
+ item->widgetLabel->setFont(font);
+ item->widgetLabel->setText(property->valueText());
+ item->widgetLabel->setToolTip(property->valueText());
+ item->widgetLabel->setEnabled(property->isEnabled());
+ }
+ if (item->widget) {
+ QFont font = item->widget->font();
+ font.setUnderline(false);
+ item->widget->setFont(font);
+ item->widget->setEnabled(property->isEnabled());
+ item->widget->setToolTip(property->valueText());
+ }
+}
+
+
+
+/*!
+ \class QtButtonPropertyBrowser
+
+ \brief The QtButtonPropertyBrowser class provides a drop down QToolButton
+ based property browser.
+
+ A property browser is a widget that enables the user to edit a
+ given set of properties. Each property is represented by a label
+ specifying the property's name, and an editing widget (e.g. a line
+ edit or a combobox) holding its value. A property can have zero or
+ more subproperties.
+
+ QtButtonPropertyBrowser provides drop down button for all nested
+ properties, i.e. subproperties are enclosed by a container associated with
+ the drop down button. The parent property's name is displayed as button text. For example:
+
+ \image qtbuttonpropertybrowser.png
+
+ Use the QtAbstractPropertyBrowser API to add, insert and remove
+ properties from an instance of the QtButtonPropertyBrowser
+ class. The properties themselves are created and managed by
+ implementations of the QtAbstractPropertyManager class.
+
+ \sa QtTreePropertyBrowser, QtAbstractPropertyBrowser
+*/
+
+/*!
+ \fn void QtButtonPropertyBrowser::collapsed(QtBrowserItem *item)
+
+ This signal is emitted when the \a item is collapsed.
+
+ \sa expanded(), setExpanded()
+*/
+
+/*!
+ \fn void QtButtonPropertyBrowser::expanded(QtBrowserItem *item)
+
+ This signal is emitted when the \a item is expanded.
+
+ \sa collapsed(), setExpanded()
+*/
+
+/*!
+ Creates a property browser with the given \a parent.
+*/
+QtButtonPropertyBrowser::QtButtonPropertyBrowser(QWidget *parent)
+ : QtAbstractPropertyBrowser(parent)
+{
+ d_ptr = new QtButtonPropertyBrowserPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->init(this);
+}
+
+/*!
+ Destroys this property browser.
+
+ Note that the properties that were inserted into this browser are
+ \e not destroyed since they may still be used in other
+ browsers. The properties are owned by the manager that created
+ them.
+
+ \sa QtProperty, QtAbstractPropertyManager
+*/
+QtButtonPropertyBrowser::~QtButtonPropertyBrowser()
+{
+ const QMap<QtButtonPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator icend = d_ptr->m_itemToIndex.constEnd();
+ for (QMap<QtButtonPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator it = d_ptr->m_itemToIndex.constBegin(); it != icend; ++it)
+ delete it.key();
+ delete d_ptr;
+}
+
+/*!
+ \reimp
+*/
+void QtButtonPropertyBrowser::itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem)
+{
+ d_ptr->propertyInserted(item, afterItem);
+}
+
+/*!
+ \reimp
+*/
+void QtButtonPropertyBrowser::itemRemoved(QtBrowserItem *item)
+{
+ d_ptr->propertyRemoved(item);
+}
+
+/*!
+ \reimp
+*/
+void QtButtonPropertyBrowser::itemChanged(QtBrowserItem *item)
+{
+ d_ptr->propertyChanged(item);
+}
+
+/*!
+ Sets the \a item to either collapse or expanded, depending on the value of \a expanded.
+
+ \sa isExpanded(), expanded(), collapsed()
+*/
+
+void QtButtonPropertyBrowser::setExpanded(QtBrowserItem *item, bool expanded)
+{
+ QtButtonPropertyBrowserPrivate::WidgetItem *itm = d_ptr->m_indexToItem.value(item);
+ if (itm)
+ d_ptr->setExpanded(itm, expanded);
+}
+
+/*!
+ Returns true if the \a item is expanded; otherwise returns false.
+
+ \sa setExpanded()
+*/
+
+bool QtButtonPropertyBrowser::isExpanded(QtBrowserItem *item) const
+{
+ QtButtonPropertyBrowserPrivate::WidgetItem *itm = d_ptr->m_indexToItem.value(item);
+ if (itm)
+ return itm->expanded;
+ return false;
+}
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#include "moc_qtbuttonpropertybrowser.cpp"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtbuttonpropertybrowser.h b/GUI/coregui/qttools/qtpropertybrowser/qtbuttonpropertybrowser.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdab1485cac8d295778057f7d1a125148020c2ae
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtbuttonpropertybrowser.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QTBUTTONPROPERTYBROWSER_H
+#define QTBUTTONPROPERTYBROWSER_H
+
+#include "qtpropertybrowser.h"
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QtButtonPropertyBrowserPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtButtonPropertyBrowser : public QtAbstractPropertyBrowser
+{
+ Q_OBJECT
+public:
+
+ QtButtonPropertyBrowser(QWidget *parent = 0);
+ ~QtButtonPropertyBrowser();
+
+ void setExpanded(QtBrowserItem *item, bool expanded);
+ bool isExpanded(QtBrowserItem *item) const;
+
+Q_SIGNALS:
+
+ void collapsed(QtBrowserItem *item);
+ void expanded(QtBrowserItem *item);
+
+protected:
+ virtual void itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem);
+ virtual void itemRemoved(QtBrowserItem *item);
+ virtual void itemChanged(QtBrowserItem *item);
+
+private:
+
+ QtButtonPropertyBrowserPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtButtonPropertyBrowser)
+ Q_DISABLE_COPY(QtButtonPropertyBrowser)
+ Q_PRIVATE_SLOT(d_func(), void slotUpdate())
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed())
+ Q_PRIVATE_SLOT(d_func(), void slotToggled(bool))
+
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#endif
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qteditorfactory.cpp b/GUI/coregui/qttools/qtpropertybrowser/qteditorfactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..afd15206b99398e4d929149cbd9b14f5d210373d
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qteditorfactory.cpp
@@ -0,0 +1,2682 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qteditorfactory.h"
+#include "qtpropertybrowserutils_p.h"
+#include <QSpinBox>
+#include <QScrollBar>
+#include <QComboBox>
+#include <QAbstractItemView>
+#include <QLineEdit>
+#include <QDateTimeEdit>
+#include <QHBoxLayout>
+#include <QMenu>
+#include <QKeyEvent>
+#include <QApplication>
+#include <QLabel>
+#include <QToolButton>
+#include <QColorDialog>
+#include <QFontDialog>
+#include <QSpacerItem>
+#include <QStyleOption>
+#include <QPainter>
+#include <QMap>
+
+#if defined(Q_CC_MSVC)
+# pragma warning(disable: 4786) /* MS VS 6: truncating debug info after 255 characters */
+#endif
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+// Set a hard coded left margin to account for the indentation
+// of the tree view icon when switching to an editor
+
+static inline void setupTreeViewEditorMargin(QLayout *lt)
+{
+ enum { DecorationMargin = 4 };
+ if (QApplication::layoutDirection() == Qt::LeftToRight)
+ lt->setContentsMargins(DecorationMargin, 0, 0, 0);
+ else
+ lt->setContentsMargins(0, 0, DecorationMargin, 0);
+}
+
+// ---------- EditorFactoryPrivate :
+// Base class for editor factory private classes. Manages mapping of properties to editors and vice versa.
+
+template <class Editor>
+class EditorFactoryPrivate
+{
+public:
+
+ typedef QList<Editor *> EditorList;
+ typedef QMap<QtProperty *, EditorList> PropertyToEditorListMap;
+ typedef QMap<Editor *, QtProperty *> EditorToPropertyMap;
+
+ Editor *createEditor(QtProperty *property, QWidget *parent);
+ void initializeEditor(QtProperty *property, Editor *e);
+ void slotEditorDestroyed(QObject *object);
+
+ PropertyToEditorListMap m_createdEditors;
+ EditorToPropertyMap m_editorToProperty;
+};
+
+template <class Editor>
+Editor *EditorFactoryPrivate<Editor>::createEditor(QtProperty *property, QWidget *parent)
+{
+ Editor *editor = new Editor(parent);
+ initializeEditor(property, editor);
+ return editor;
+}
+
+template <class Editor>
+void EditorFactoryPrivate<Editor>::initializeEditor(QtProperty *property, Editor *editor)
+{
+ typename PropertyToEditorListMap::iterator it = m_createdEditors.find(property);
+ if (it == m_createdEditors.end())
+ it = m_createdEditors.insert(property, EditorList());
+ it.value().append(editor);
+ m_editorToProperty.insert(editor, property);
+}
+
+template <class Editor>
+void EditorFactoryPrivate<Editor>::slotEditorDestroyed(QObject *object)
+{
+ const typename EditorToPropertyMap::iterator ecend = m_editorToProperty.end();
+ for (typename EditorToPropertyMap::iterator itEditor = m_editorToProperty.begin(); itEditor != ecend; ++itEditor) {
+ if (itEditor.key() == object) {
+ Editor *editor = itEditor.key();
+ QtProperty *property = itEditor.value();
+ const typename PropertyToEditorListMap::iterator pit = m_createdEditors.find(property);
+ if (pit != m_createdEditors.end()) {
+ pit.value().removeAll(editor);
+ if (pit.value().empty())
+ m_createdEditors.erase(pit);
+ }
+ m_editorToProperty.erase(itEditor);
+ return;
+ }
+ }
+}
+
+// ------------ QtSpinBoxFactory
+
+class QtSpinBoxFactoryPrivate : public EditorFactoryPrivate<QSpinBox>
+{
+ QtSpinBoxFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtSpinBoxFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, int value);
+ void slotRangeChanged(QtProperty *property, int min, int max);
+ void slotSingleStepChanged(QtProperty *property, int step);
+ void slotReadOnlyChanged(QtProperty *property, bool readOnly);
+ void slotSetValue(int value);
+};
+
+void QtSpinBoxFactoryPrivate::slotPropertyChanged(QtProperty *property, int value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+ QListIterator<QSpinBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QSpinBox *editor = itEditor.next();
+ if (editor->value() != value) {
+ editor->blockSignals(true);
+ editor->setValue(value);
+ editor->blockSignals(false);
+ }
+ }
+}
+
+void QtSpinBoxFactoryPrivate::slotRangeChanged(QtProperty *property, int min, int max)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtIntPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QSpinBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QSpinBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setRange(min, max);
+ editor->setValue(manager->value(property));
+ editor->blockSignals(false);
+ }
+}
+
+void QtSpinBoxFactoryPrivate::slotSingleStepChanged(QtProperty *property, int step)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+ QListIterator<QSpinBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QSpinBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setSingleStep(step);
+ editor->blockSignals(false);
+ }
+}
+
+void QtSpinBoxFactoryPrivate::slotReadOnlyChanged( QtProperty *property, bool readOnly)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtIntPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QSpinBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QSpinBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setReadOnly(readOnly);
+ editor->blockSignals(false);
+ }
+}
+
+void QtSpinBoxFactoryPrivate::slotSetValue(int value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QSpinBox *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QSpinBox *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor) {
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtIntPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+ }
+}
+
+/*!
+ \class QtSpinBoxFactory
+
+ \brief The QtSpinBoxFactory class provides QSpinBox widgets for
+ properties created by QtIntPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtIntPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtSpinBoxFactory::QtSpinBoxFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtIntPropertyManager>(parent)
+{
+ d_ptr = new QtSpinBoxFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtSpinBoxFactory::~QtSpinBoxFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtSpinBoxFactory::connectPropertyManager(QtIntPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotPropertyChanged(QtProperty *, int)));
+ connect(manager, SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ connect(manager, SIGNAL(singleStepChanged(QtProperty *, int)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, int)));
+ connect(manager, SIGNAL(readOnlyChanged(QtProperty *, bool)),
+ this, SLOT(slotReadOnlyChanged(QtProperty *, bool)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtSpinBoxFactory::createEditor(QtIntPropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ QSpinBox *editor = d_ptr->createEditor(property, parent);
+ editor->setSingleStep(manager->singleStep(property));
+ editor->setRange(manager->minimum(property), manager->maximum(property));
+ editor->setValue(manager->value(property));
+ editor->setKeyboardTracking(false);
+ editor->setReadOnly(manager->isReadOnly(property));
+
+ connect(editor, SIGNAL(valueChanged(int)), this, SLOT(slotSetValue(int)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtSpinBoxFactory::disconnectPropertyManager(QtIntPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotPropertyChanged(QtProperty *, int)));
+ disconnect(manager, SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ disconnect(manager, SIGNAL(singleStepChanged(QtProperty *, int)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, int)));
+ disconnect(manager, SIGNAL(readOnlyChanged(QtProperty *, bool)),
+ this, SLOT(slotReadOnlyChanged(QtProperty *, bool)));
+}
+
+// QtSliderFactory
+
+class QtSliderFactoryPrivate : public EditorFactoryPrivate<QSlider>
+{
+ QtSliderFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtSliderFactory)
+public:
+ void slotPropertyChanged(QtProperty *property, int value);
+ void slotRangeChanged(QtProperty *property, int min, int max);
+ void slotSingleStepChanged(QtProperty *property, int step);
+ void slotSetValue(int value);
+};
+
+void QtSliderFactoryPrivate::slotPropertyChanged(QtProperty *property, int value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+ QListIterator<QSlider *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QSlider *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setValue(value);
+ editor->blockSignals(false);
+ }
+}
+
+void QtSliderFactoryPrivate::slotRangeChanged(QtProperty *property, int min, int max)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtIntPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QSlider *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QSlider *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setRange(min, max);
+ editor->setValue(manager->value(property));
+ editor->blockSignals(false);
+ }
+}
+
+void QtSliderFactoryPrivate::slotSingleStepChanged(QtProperty *property, int step)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+ QListIterator<QSlider *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QSlider *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setSingleStep(step);
+ editor->blockSignals(false);
+ }
+}
+
+void QtSliderFactoryPrivate::slotSetValue(int value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QSlider *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QSlider *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor ) {
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtIntPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+ }
+}
+
+/*!
+ \class QtSliderFactory
+
+ \brief The QtSliderFactory class provides QSlider widgets for
+ properties created by QtIntPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtIntPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtSliderFactory::QtSliderFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtIntPropertyManager>(parent)
+{
+ d_ptr = new QtSliderFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtSliderFactory::~QtSliderFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtSliderFactory::connectPropertyManager(QtIntPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotPropertyChanged(QtProperty *, int)));
+ connect(manager, SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ connect(manager, SIGNAL(singleStepChanged(QtProperty *, int)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, int)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtSliderFactory::createEditor(QtIntPropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ QSlider *editor = new QSlider(Qt::Horizontal, parent);
+ d_ptr->initializeEditor(property, editor);
+ editor->setSingleStep(manager->singleStep(property));
+ editor->setRange(manager->minimum(property), manager->maximum(property));
+ editor->setValue(manager->value(property));
+
+ connect(editor, SIGNAL(valueChanged(int)), this, SLOT(slotSetValue(int)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtSliderFactory::disconnectPropertyManager(QtIntPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotPropertyChanged(QtProperty *, int)));
+ disconnect(manager, SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ disconnect(manager, SIGNAL(singleStepChanged(QtProperty *, int)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, int)));
+}
+
+// QtSliderFactory
+
+class QtScrollBarFactoryPrivate : public EditorFactoryPrivate<QScrollBar>
+{
+ QtScrollBarFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtScrollBarFactory)
+public:
+ void slotPropertyChanged(QtProperty *property, int value);
+ void slotRangeChanged(QtProperty *property, int min, int max);
+ void slotSingleStepChanged(QtProperty *property, int step);
+ void slotSetValue(int value);
+};
+
+void QtScrollBarFactoryPrivate::slotPropertyChanged(QtProperty *property, int value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QListIterator<QScrollBar *> itEditor( m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QScrollBar *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setValue(value);
+ editor->blockSignals(false);
+ }
+}
+
+void QtScrollBarFactoryPrivate::slotRangeChanged(QtProperty *property, int min, int max)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtIntPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QScrollBar *> itEditor( m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QScrollBar *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setRange(min, max);
+ editor->setValue(manager->value(property));
+ editor->blockSignals(false);
+ }
+}
+
+void QtScrollBarFactoryPrivate::slotSingleStepChanged(QtProperty *property, int step)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+ QListIterator<QScrollBar *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QScrollBar *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setSingleStep(step);
+ editor->blockSignals(false);
+ }
+}
+
+void QtScrollBarFactoryPrivate::slotSetValue(int value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QScrollBar *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QScrollBar *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtIntPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtScrollBarFactory
+
+ \brief The QtScrollBarFactory class provides QScrollBar widgets for
+ properties created by QtIntPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtIntPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtScrollBarFactory::QtScrollBarFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtIntPropertyManager>(parent)
+{
+ d_ptr = new QtScrollBarFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtScrollBarFactory::~QtScrollBarFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtScrollBarFactory::connectPropertyManager(QtIntPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotPropertyChanged(QtProperty *, int)));
+ connect(manager, SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ connect(manager, SIGNAL(singleStepChanged(QtProperty *, int)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, int)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtScrollBarFactory::createEditor(QtIntPropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ QScrollBar *editor = new QScrollBar(Qt::Horizontal, parent);
+ d_ptr->initializeEditor(property, editor);
+ editor->setSingleStep(manager->singleStep(property));
+ editor->setRange(manager->minimum(property), manager->maximum(property));
+ editor->setValue(manager->value(property));
+ connect(editor, SIGNAL(valueChanged(int)), this, SLOT(slotSetValue(int)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtScrollBarFactory::disconnectPropertyManager(QtIntPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotPropertyChanged(QtProperty *, int)));
+ disconnect(manager, SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ disconnect(manager, SIGNAL(singleStepChanged(QtProperty *, int)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, int)));
+}
+
+// QtCheckBoxFactory
+
+class QtCheckBoxFactoryPrivate : public EditorFactoryPrivate<QtBoolEdit>
+{
+ QtCheckBoxFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtCheckBoxFactory)
+public:
+ void slotPropertyChanged(QtProperty *property, bool value);
+ void slotSetValue(bool value);
+};
+
+void QtCheckBoxFactoryPrivate::slotPropertyChanged(QtProperty *property, bool value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QListIterator<QtBoolEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QtBoolEdit *editor = itEditor.next();
+ editor->blockCheckBoxSignals(true);
+ editor->setChecked(value);
+ editor->blockCheckBoxSignals(false);
+ }
+}
+
+void QtCheckBoxFactoryPrivate::slotSetValue(bool value)
+{
+ QObject *object = q_ptr->sender();
+
+ const QMap<QtBoolEdit *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QtBoolEdit *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtBoolPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtCheckBoxFactory
+
+ \brief The QtCheckBoxFactory class provides QCheckBox widgets for
+ properties created by QtBoolPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtBoolPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtCheckBoxFactory::QtCheckBoxFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtBoolPropertyManager>(parent)
+{
+ d_ptr = new QtCheckBoxFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtCheckBoxFactory::~QtCheckBoxFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtCheckBoxFactory::connectPropertyManager(QtBoolPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, bool)),
+ this, SLOT(slotPropertyChanged(QtProperty *, bool)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtCheckBoxFactory::createEditor(QtBoolPropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ QtBoolEdit *editor = d_ptr->createEditor(property, parent);
+ editor->setChecked(manager->value(property));
+
+ connect(editor, SIGNAL(toggled(bool)), this, SLOT(slotSetValue(bool)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtCheckBoxFactory::disconnectPropertyManager(QtBoolPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, bool)),
+ this, SLOT(slotPropertyChanged(QtProperty *, bool)));
+}
+
+// QtDoubleSpinBoxFactory
+
+class QtDoubleSpinBoxFactoryPrivate : public EditorFactoryPrivate<QDoubleSpinBox>
+{
+ QtDoubleSpinBoxFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtDoubleSpinBoxFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, double value);
+ void slotRangeChanged(QtProperty *property, double min, double max);
+ void slotSingleStepChanged(QtProperty *property, double step);
+ void slotDecimalsChanged(QtProperty *property, int prec);
+ void slotReadOnlyChanged(QtProperty *property, bool readOnly);
+ void slotSetValue(double value);
+};
+
+void QtDoubleSpinBoxFactoryPrivate::slotPropertyChanged(QtProperty *property, double value)
+{
+ QList<QDoubleSpinBox *> editors = m_createdEditors[property];
+ QListIterator<QDoubleSpinBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QDoubleSpinBox *editor = itEditor.next();
+ if (editor->value() != value) {
+ editor->blockSignals(true);
+ editor->setValue(value);
+ editor->blockSignals(false);
+ }
+ }
+}
+
+void QtDoubleSpinBoxFactoryPrivate::slotRangeChanged(QtProperty *property,
+ double min, double max)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtDoublePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QList<QDoubleSpinBox *> editors = m_createdEditors[property];
+ QListIterator<QDoubleSpinBox *> itEditor(editors);
+ while (itEditor.hasNext()) {
+ QDoubleSpinBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setRange(min, max);
+ editor->setValue(manager->value(property));
+ editor->blockSignals(false);
+ }
+}
+
+void QtDoubleSpinBoxFactoryPrivate::slotSingleStepChanged(QtProperty *property, double step)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtDoublePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QList<QDoubleSpinBox *> editors = m_createdEditors[property];
+ QListIterator<QDoubleSpinBox *> itEditor(editors);
+ while (itEditor.hasNext()) {
+ QDoubleSpinBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setSingleStep(step);
+ editor->blockSignals(false);
+ }
+}
+
+void QtDoubleSpinBoxFactoryPrivate::slotReadOnlyChanged( QtProperty *property, bool readOnly)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtDoublePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QDoubleSpinBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QDoubleSpinBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setReadOnly(readOnly);
+ editor->blockSignals(false);
+ }
+}
+
+void QtDoubleSpinBoxFactoryPrivate::slotDecimalsChanged(QtProperty *property, int prec)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtDoublePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QList<QDoubleSpinBox *> editors = m_createdEditors[property];
+ QListIterator<QDoubleSpinBox *> itEditor(editors);
+ while (itEditor.hasNext()) {
+ QDoubleSpinBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setDecimals(prec);
+ editor->setValue(manager->value(property));
+ editor->blockSignals(false);
+ }
+}
+
+void QtDoubleSpinBoxFactoryPrivate::slotSetValue(double value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QDoubleSpinBox *, QtProperty *>::ConstIterator itcend = m_editorToProperty.constEnd();
+ for (QMap<QDoubleSpinBox *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != itcend; ++itEditor) {
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtDoublePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+ }
+}
+
+/*! \class QtDoubleSpinBoxFactory
+
+ \brief The QtDoubleSpinBoxFactory class provides QDoubleSpinBox
+ widgets for properties created by QtDoublePropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtDoublePropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtDoubleSpinBoxFactory::QtDoubleSpinBoxFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtDoublePropertyManager>(parent)
+{
+ d_ptr = new QtDoubleSpinBoxFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtDoubleSpinBoxFactory::~QtDoubleSpinBoxFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtDoubleSpinBoxFactory::connectPropertyManager(QtDoublePropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotPropertyChanged(QtProperty *, double)));
+ connect(manager, SIGNAL(rangeChanged(QtProperty *, double, double)),
+ this, SLOT(slotRangeChanged(QtProperty *, double, double)));
+ connect(manager, SIGNAL(singleStepChanged(QtProperty *, double)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, double)));
+ connect(manager, SIGNAL(decimalsChanged(QtProperty *, int)),
+ this, SLOT(slotDecimalsChanged(QtProperty *, int)));
+ connect(manager, SIGNAL(readOnlyChanged(QtProperty *, bool)),
+ this, SLOT(slotReadOnlyChanged(QtProperty *, bool)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtDoubleSpinBoxFactory::createEditor(QtDoublePropertyManager *manager,
+ QtProperty *property, QWidget *parent)
+{
+ QDoubleSpinBox *editor = d_ptr->createEditor(property, parent);
+ editor->setSingleStep(manager->singleStep(property));
+ editor->setDecimals(manager->decimals(property));
+ editor->setRange(manager->minimum(property), manager->maximum(property));
+ editor->setValue(manager->value(property));
+ editor->setKeyboardTracking(false);
+ editor->setReadOnly(manager->isReadOnly(property));
+
+ connect(editor, SIGNAL(valueChanged(double)), this, SLOT(slotSetValue(double)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtDoubleSpinBoxFactory::disconnectPropertyManager(QtDoublePropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotPropertyChanged(QtProperty *, double)));
+ disconnect(manager, SIGNAL(rangeChanged(QtProperty *, double, double)),
+ this, SLOT(slotRangeChanged(QtProperty *, double, double)));
+ disconnect(manager, SIGNAL(singleStepChanged(QtProperty *, double)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, double)));
+ disconnect(manager, SIGNAL(decimalsChanged(QtProperty *, int)),
+ this, SLOT(slotDecimalsChanged(QtProperty *, int)));
+ disconnect(manager, SIGNAL(readOnlyChanged(QtProperty *, bool)),
+ this, SLOT(slotReadOnlyChanged(QtProperty *, bool)));
+}
+
+// QtLineEditFactory
+
+class QtLineEditFactoryPrivate : public EditorFactoryPrivate<QLineEdit>
+{
+ QtLineEditFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtLineEditFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, const QString &value);
+ void slotRegExpChanged(QtProperty *property, const QRegExp ®Exp);
+ void slotSetValue(const QString &value);
+ void slotEchoModeChanged(QtProperty *, int);
+ void slotReadOnlyChanged(QtProperty *, bool);
+};
+
+void QtLineEditFactoryPrivate::slotPropertyChanged(QtProperty *property,
+ const QString &value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QListIterator<QLineEdit *> itEditor( m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QLineEdit *editor = itEditor.next();
+ if (editor->text() != value) {
+ editor->blockSignals(true);
+ editor->setText(value);
+ editor->blockSignals(false);
+ }
+ }
+}
+
+void QtLineEditFactoryPrivate::slotRegExpChanged(QtProperty *property,
+ const QRegExp ®Exp)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtStringPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QLineEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QLineEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ const QValidator *oldValidator = editor->validator();
+ QValidator *newValidator = 0;
+ if (regExp.isValid()) {
+ newValidator = new QRegExpValidator(regExp, editor);
+ }
+ editor->setValidator(newValidator);
+ if (oldValidator)
+ delete oldValidator;
+ editor->blockSignals(false);
+ }
+}
+
+void QtLineEditFactoryPrivate::slotEchoModeChanged(QtProperty *property, int echoMode)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtStringPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QLineEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QLineEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setEchoMode((EchoMode)echoMode);
+ editor->blockSignals(false);
+ }
+}
+
+void QtLineEditFactoryPrivate::slotReadOnlyChanged( QtProperty *property, bool readOnly)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtStringPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QLineEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QLineEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setReadOnly(readOnly);
+ editor->blockSignals(false);
+ }
+}
+
+void QtLineEditFactoryPrivate::slotSetValue(const QString &value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QLineEdit *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QLineEdit *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtStringPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+
+
+/*!
+ \class QtLineEditFactory
+
+ \brief The QtLineEditFactory class provides QLineEdit widgets for
+ properties created by QtStringPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtStringPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtLineEditFactory::QtLineEditFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtStringPropertyManager>(parent)
+{
+ d_ptr = new QtLineEditFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtLineEditFactory::~QtLineEditFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtLineEditFactory::connectPropertyManager(QtStringPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, const QString &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QString &)));
+ connect(manager, SIGNAL(regExpChanged(QtProperty *, const QRegExp &)),
+ this, SLOT(slotRegExpChanged(QtProperty *, const QRegExp &)));
+ connect(manager, SIGNAL(echoModeChanged(QtProperty*, int)),
+ this, SLOT(slotEchoModeChanged(QtProperty *, int)));
+ connect(manager, SIGNAL(readOnlyChanged(QtProperty*, bool)),
+ this, SLOT(slotReadOnlyChanged(QtProperty *, bool)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtLineEditFactory::createEditor(QtStringPropertyManager *manager,
+ QtProperty *property, QWidget *parent)
+{
+
+ QLineEdit *editor = d_ptr->createEditor(property, parent);
+ editor->setEchoMode((EchoMode)manager->echoMode(property));
+ editor->setReadOnly(manager->isReadOnly(property));
+ QRegExp regExp = manager->regExp(property);
+ if (regExp.isValid()) {
+ QValidator *validator = new QRegExpValidator(regExp, editor);
+ editor->setValidator(validator);
+ }
+ editor->setText(manager->value(property));
+
+ connect(editor, SIGNAL(textChanged(const QString &)),
+ this, SLOT(slotSetValue(const QString &)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtLineEditFactory::disconnectPropertyManager(QtStringPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, const QString &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QString &)));
+ disconnect(manager, SIGNAL(regExpChanged(QtProperty *, const QRegExp &)),
+ this, SLOT(slotRegExpChanged(QtProperty *, const QRegExp &)));
+ disconnect(manager, SIGNAL(echoModeChanged(QtProperty*,int)),
+ this, SLOT(slotEchoModeChanged(QtProperty *, int)));
+ disconnect(manager, SIGNAL(readOnlyChanged(QtProperty*, bool)),
+ this, SLOT(slotReadOnlyChanged(QtProperty *, bool)));
+
+}
+
+// QtDateEditFactory
+
+class QtDateEditFactoryPrivate : public EditorFactoryPrivate<QDateEdit>
+{
+ QtDateEditFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtDateEditFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, const QDate &value);
+ void slotRangeChanged(QtProperty *property, const QDate &min, const QDate &max);
+ void slotSetValue(const QDate &value);
+};
+
+void QtDateEditFactoryPrivate::slotPropertyChanged(QtProperty *property, const QDate &value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+ QListIterator<QDateEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QDateEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setDate(value);
+ editor->blockSignals(false);
+ }
+}
+
+void QtDateEditFactoryPrivate::slotRangeChanged(QtProperty *property,
+ const QDate &min, const QDate &max)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtDatePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QListIterator<QDateEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QDateEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setDateRange(min, max);
+ editor->setDate(manager->value(property));
+ editor->blockSignals(false);
+ }
+}
+
+void QtDateEditFactoryPrivate::slotSetValue(const QDate &value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QDateEdit *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QDateEdit *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtDatePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtDateEditFactory
+
+ \brief The QtDateEditFactory class provides QDateEdit widgets for
+ properties created by QtDatePropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtDatePropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtDateEditFactory::QtDateEditFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtDatePropertyManager>(parent)
+{
+ d_ptr = new QtDateEditFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtDateEditFactory::~QtDateEditFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtDateEditFactory::connectPropertyManager(QtDatePropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, const QDate &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QDate &)));
+ connect(manager, SIGNAL(rangeChanged(QtProperty *, const QDate &, const QDate &)),
+ this, SLOT(slotRangeChanged(QtProperty *, const QDate &, const QDate &)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtDateEditFactory::createEditor(QtDatePropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ QDateEdit *editor = d_ptr->createEditor(property, parent);
+ editor->setCalendarPopup(true);
+ editor->setDateRange(manager->minimum(property), manager->maximum(property));
+ editor->setDate(manager->value(property));
+
+ connect(editor, SIGNAL(dateChanged(const QDate &)),
+ this, SLOT(slotSetValue(const QDate &)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtDateEditFactory::disconnectPropertyManager(QtDatePropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, const QDate &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QDate &)));
+ disconnect(manager, SIGNAL(rangeChanged(QtProperty *, const QDate &, const QDate &)),
+ this, SLOT(slotRangeChanged(QtProperty *, const QDate &, const QDate &)));
+}
+
+// QtTimeEditFactory
+
+class QtTimeEditFactoryPrivate : public EditorFactoryPrivate<QTimeEdit>
+{
+ QtTimeEditFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtTimeEditFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, const QTime &value);
+ void slotSetValue(const QTime &value);
+};
+
+void QtTimeEditFactoryPrivate::slotPropertyChanged(QtProperty *property, const QTime &value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+ QListIterator<QTimeEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QTimeEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setTime(value);
+ editor->blockSignals(false);
+ }
+}
+
+void QtTimeEditFactoryPrivate::slotSetValue(const QTime &value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QTimeEdit *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QTimeEdit *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtTimePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtTimeEditFactory
+
+ \brief The QtTimeEditFactory class provides QTimeEdit widgets for
+ properties created by QtTimePropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtTimePropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtTimeEditFactory::QtTimeEditFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtTimePropertyManager>(parent)
+{
+ d_ptr = new QtTimeEditFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtTimeEditFactory::~QtTimeEditFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtTimeEditFactory::connectPropertyManager(QtTimePropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, const QTime &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QTime &)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtTimeEditFactory::createEditor(QtTimePropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ QTimeEdit *editor = d_ptr->createEditor(property, parent);
+ editor->setTime(manager->value(property));
+
+ connect(editor, SIGNAL(timeChanged(const QTime &)),
+ this, SLOT(slotSetValue(const QTime &)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtTimeEditFactory::disconnectPropertyManager(QtTimePropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, const QTime &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QTime &)));
+}
+
+// QtDateTimeEditFactory
+
+class QtDateTimeEditFactoryPrivate : public EditorFactoryPrivate<QDateTimeEdit>
+{
+ QtDateTimeEditFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtDateTimeEditFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, const QDateTime &value);
+ void slotSetValue(const QDateTime &value);
+
+};
+
+void QtDateTimeEditFactoryPrivate::slotPropertyChanged(QtProperty *property,
+ const QDateTime &value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QListIterator<QDateTimeEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QDateTimeEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setDateTime(value);
+ editor->blockSignals(false);
+ }
+}
+
+void QtDateTimeEditFactoryPrivate::slotSetValue(const QDateTime &value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QDateTimeEdit *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QDateTimeEdit *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtDateTimePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtDateTimeEditFactory
+
+ \brief The QtDateTimeEditFactory class provides QDateTimeEdit
+ widgets for properties created by QtDateTimePropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtDateTimePropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtDateTimeEditFactory::QtDateTimeEditFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtDateTimePropertyManager>(parent)
+{
+ d_ptr = new QtDateTimeEditFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtDateTimeEditFactory::~QtDateTimeEditFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtDateTimeEditFactory::connectPropertyManager(QtDateTimePropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, const QDateTime &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QDateTime &)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtDateTimeEditFactory::createEditor(QtDateTimePropertyManager *manager,
+ QtProperty *property, QWidget *parent)
+{
+ QDateTimeEdit *editor = d_ptr->createEditor(property, parent);
+ editor->setDateTime(manager->value(property));
+
+ connect(editor, SIGNAL(dateTimeChanged(const QDateTime &)),
+ this, SLOT(slotSetValue(const QDateTime &)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtDateTimeEditFactory::disconnectPropertyManager(QtDateTimePropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, const QDateTime &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QDateTime &)));
+}
+
+// QtKeySequenceEditorFactory
+
+class QtKeySequenceEditorFactoryPrivate : public EditorFactoryPrivate<QtKeySequenceEdit>
+{
+ QtKeySequenceEditorFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtKeySequenceEditorFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, const QKeySequence &value);
+ void slotSetValue(const QKeySequence &value);
+};
+
+void QtKeySequenceEditorFactoryPrivate::slotPropertyChanged(QtProperty *property,
+ const QKeySequence &value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QListIterator<QtKeySequenceEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QtKeySequenceEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setKeySequence(value);
+ editor->blockSignals(false);
+ }
+}
+
+void QtKeySequenceEditorFactoryPrivate::slotSetValue(const QKeySequence &value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QtKeySequenceEdit *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QtKeySequenceEdit *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtKeySequencePropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtKeySequenceEditorFactory
+
+ \brief The QtKeySequenceEditorFactory class provides editor
+ widgets for properties created by QtKeySequencePropertyManager objects.
+
+ \sa QtAbstractEditorFactory
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtKeySequenceEditorFactory::QtKeySequenceEditorFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtKeySequencePropertyManager>(parent)
+{
+ d_ptr = new QtKeySequenceEditorFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtKeySequenceEditorFactory::~QtKeySequenceEditorFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtKeySequenceEditorFactory::connectPropertyManager(QtKeySequencePropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, const QKeySequence &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QKeySequence &)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtKeySequenceEditorFactory::createEditor(QtKeySequencePropertyManager *manager,
+ QtProperty *property, QWidget *parent)
+{
+ QtKeySequenceEdit *editor = d_ptr->createEditor(property, parent);
+ editor->setKeySequence(manager->value(property));
+
+ connect(editor, SIGNAL(keySequenceChanged(const QKeySequence &)),
+ this, SLOT(slotSetValue(const QKeySequence &)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtKeySequenceEditorFactory::disconnectPropertyManager(QtKeySequencePropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, const QKeySequence &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QKeySequence &)));
+}
+
+// QtCharEdit
+
+class QtCharEdit : public QWidget
+{
+ Q_OBJECT
+public:
+ QtCharEdit(QWidget *parent = 0);
+
+ QChar value() const;
+ bool eventFilter(QObject *o, QEvent *e);
+public Q_SLOTS:
+ void setValue(const QChar &value);
+Q_SIGNALS:
+ void valueChanged(const QChar &value);
+protected:
+ void focusInEvent(QFocusEvent *e);
+ void focusOutEvent(QFocusEvent *e);
+ void keyPressEvent(QKeyEvent *e);
+ void keyReleaseEvent(QKeyEvent *e);
+ void paintEvent(QPaintEvent *);
+ bool event(QEvent *e);
+private slots:
+ void slotClearChar();
+private:
+ void handleKeyEvent(QKeyEvent *e);
+
+ QChar m_value;
+ QLineEdit *m_lineEdit;
+};
+
+QtCharEdit::QtCharEdit(QWidget *parent)
+ : QWidget(parent), m_lineEdit(new QLineEdit(this))
+{
+ QHBoxLayout *layout = new QHBoxLayout(this);
+ layout->addWidget(m_lineEdit);
+ layout->setMargin(0);
+ m_lineEdit->installEventFilter(this);
+ m_lineEdit->setReadOnly(true);
+ m_lineEdit->setFocusProxy(this);
+ setFocusPolicy(m_lineEdit->focusPolicy());
+ setAttribute(Qt::WA_InputMethodEnabled);
+}
+
+bool QtCharEdit::eventFilter(QObject *o, QEvent *e)
+{
+ if (o == m_lineEdit && e->type() == QEvent::ContextMenu) {
+ QContextMenuEvent *c = static_cast<QContextMenuEvent *>(e);
+ QMenu *menu = m_lineEdit->createStandardContextMenu();
+ QList<QAction *> actions = menu->actions();
+ QListIterator<QAction *> itAction(actions);
+ while (itAction.hasNext()) {
+ QAction *action = itAction.next();
+ action->setShortcut(QKeySequence());
+ QString actionString = action->text();
+ const int pos = actionString.lastIndexOf(QLatin1Char('\t'));
+ if (pos > 0)
+ actionString = actionString.remove(pos, actionString.length() - pos);
+ action->setText(actionString);
+ }
+ QAction *actionBefore = 0;
+ if (actions.count() > 0)
+ actionBefore = actions[0];
+ QAction *clearAction = new QAction(tr("Clear Char"), menu);
+ menu->insertAction(actionBefore, clearAction);
+ menu->insertSeparator(actionBefore);
+ clearAction->setEnabled(!m_value.isNull());
+ connect(clearAction, SIGNAL(triggered()), this, SLOT(slotClearChar()));
+ menu->exec(c->globalPos());
+ delete menu;
+ e->accept();
+ return true;
+ }
+
+ return QWidget::eventFilter(o, e);
+}
+
+void QtCharEdit::slotClearChar()
+{
+ if (m_value.isNull())
+ return;
+ setValue(QChar());
+ emit valueChanged(m_value);
+}
+
+void QtCharEdit::handleKeyEvent(QKeyEvent *e)
+{
+ const int key = e->key();
+ switch (key) {
+ case Qt::Key_Control:
+ case Qt::Key_Shift:
+ case Qt::Key_Meta:
+ case Qt::Key_Alt:
+ case Qt::Key_Super_L:
+ case Qt::Key_Return:
+ return;
+ default:
+ break;
+ }
+
+ const QString text = e->text();
+ if (text.count() != 1)
+ return;
+
+ const QChar c = text.at(0);
+ if (!c.isPrint())
+ return;
+
+ if (m_value == c)
+ return;
+
+ m_value = c;
+ const QString str = m_value.isNull() ? QString() : QString(m_value);
+ m_lineEdit->setText(str);
+ e->accept();
+ emit valueChanged(m_value);
+}
+
+void QtCharEdit::setValue(const QChar &value)
+{
+ if (value == m_value)
+ return;
+
+ m_value = value;
+ QString str = value.isNull() ? QString() : QString(value);
+ m_lineEdit->setText(str);
+}
+
+QChar QtCharEdit::value() const
+{
+ return m_value;
+}
+
+void QtCharEdit::focusInEvent(QFocusEvent *e)
+{
+ m_lineEdit->event(e);
+ m_lineEdit->selectAll();
+ QWidget::focusInEvent(e);
+}
+
+void QtCharEdit::focusOutEvent(QFocusEvent *e)
+{
+ m_lineEdit->event(e);
+ QWidget::focusOutEvent(e);
+}
+
+void QtCharEdit::keyPressEvent(QKeyEvent *e)
+{
+ handleKeyEvent(e);
+ e->accept();
+}
+
+void QtCharEdit::keyReleaseEvent(QKeyEvent *e)
+{
+ m_lineEdit->event(e);
+}
+
+void QtCharEdit::paintEvent(QPaintEvent *)
+{
+ QStyleOption opt;
+ opt.init(this);
+ QPainter p(this);
+ style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
+}
+
+bool QtCharEdit::event(QEvent *e)
+{
+ switch(e->type()) {
+ case QEvent::Shortcut:
+ case QEvent::ShortcutOverride:
+ case QEvent::KeyRelease:
+ e->accept();
+ return true;
+ default:
+ break;
+ }
+ return QWidget::event(e);
+}
+
+// QtCharEditorFactory
+
+class QtCharEditorFactoryPrivate : public EditorFactoryPrivate<QtCharEdit>
+{
+ QtCharEditorFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtCharEditorFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, const QChar &value);
+ void slotSetValue(const QChar &value);
+
+};
+
+void QtCharEditorFactoryPrivate::slotPropertyChanged(QtProperty *property,
+ const QChar &value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QListIterator<QtCharEdit *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QtCharEdit *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setValue(value);
+ editor->blockSignals(false);
+ }
+}
+
+void QtCharEditorFactoryPrivate::slotSetValue(const QChar &value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QtCharEdit *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QtCharEdit *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtCharPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtCharEditorFactory
+
+ \brief The QtCharEditorFactory class provides editor
+ widgets for properties created by QtCharPropertyManager objects.
+
+ \sa QtAbstractEditorFactory
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtCharEditorFactory::QtCharEditorFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtCharPropertyManager>(parent)
+{
+ d_ptr = new QtCharEditorFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtCharEditorFactory::~QtCharEditorFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtCharEditorFactory::connectPropertyManager(QtCharPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, const QChar &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QChar &)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtCharEditorFactory::createEditor(QtCharPropertyManager *manager,
+ QtProperty *property, QWidget *parent)
+{
+ QtCharEdit *editor = d_ptr->createEditor(property, parent);
+ editor->setValue(manager->value(property));
+
+ connect(editor, SIGNAL(valueChanged(const QChar &)),
+ this, SLOT(slotSetValue(const QChar &)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtCharEditorFactory::disconnectPropertyManager(QtCharPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, const QChar &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QChar &)));
+}
+
+// QtEnumEditorFactory
+
+class QtEnumEditorFactoryPrivate : public EditorFactoryPrivate<QComboBox>
+{
+ QtEnumEditorFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtEnumEditorFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, int value);
+ void slotEnumNamesChanged(QtProperty *property, const QStringList &);
+ void slotEnumIconsChanged(QtProperty *property, const QMap<int, QIcon> &);
+ void slotSetValue(int value);
+};
+
+void QtEnumEditorFactoryPrivate::slotPropertyChanged(QtProperty *property, int value)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QListIterator<QComboBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QComboBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->setCurrentIndex(value);
+ editor->blockSignals(false);
+ }
+}
+
+void QtEnumEditorFactoryPrivate::slotEnumNamesChanged(QtProperty *property,
+ const QStringList &enumNames)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtEnumPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ QMap<int, QIcon> enumIcons = manager->enumIcons(property);
+
+ QListIterator<QComboBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QComboBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ editor->clear();
+ editor->addItems(enumNames);
+ const int nameCount = enumNames.count();
+ for (int i = 0; i < nameCount; i++)
+ editor->setItemIcon(i, enumIcons.value(i));
+ editor->setCurrentIndex(manager->value(property));
+ editor->blockSignals(false);
+ }
+}
+
+void QtEnumEditorFactoryPrivate::slotEnumIconsChanged(QtProperty *property,
+ const QMap<int, QIcon> &enumIcons)
+{
+ if (!m_createdEditors.contains(property))
+ return;
+
+ QtEnumPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+
+ const QStringList enumNames = manager->enumNames(property);
+ QListIterator<QComboBox *> itEditor(m_createdEditors[property]);
+ while (itEditor.hasNext()) {
+ QComboBox *editor = itEditor.next();
+ editor->blockSignals(true);
+ const int nameCount = enumNames.count();
+ for (int i = 0; i < nameCount; i++)
+ editor->setItemIcon(i, enumIcons.value(i));
+ editor->setCurrentIndex(manager->value(property));
+ editor->blockSignals(false);
+ }
+}
+
+void QtEnumEditorFactoryPrivate::slotSetValue(int value)
+{
+ QObject *object = q_ptr->sender();
+ const QMap<QComboBox *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (QMap<QComboBox *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtEnumPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtEnumEditorFactory
+
+ \brief The QtEnumEditorFactory class provides QComboBox widgets for
+ properties created by QtEnumPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtEnumPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtEnumEditorFactory::QtEnumEditorFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtEnumPropertyManager>(parent)
+{
+ d_ptr = new QtEnumEditorFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtEnumEditorFactory::~QtEnumEditorFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtEnumEditorFactory::connectPropertyManager(QtEnumPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotPropertyChanged(QtProperty *, int)));
+ connect(manager, SIGNAL(enumNamesChanged(QtProperty *, const QStringList &)),
+ this, SLOT(slotEnumNamesChanged(QtProperty *, const QStringList &)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtEnumEditorFactory::createEditor(QtEnumPropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ QComboBox *editor = d_ptr->createEditor(property, parent);
+ editor->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
+ editor->setMinimumContentsLength(1);
+ editor->view()->setTextElideMode(Qt::ElideRight);
+ QStringList enumNames = manager->enumNames(property);
+ editor->addItems(enumNames);
+ QMap<int, QIcon> enumIcons = manager->enumIcons(property);
+ const int enumNamesCount = enumNames.count();
+ for (int i = 0; i < enumNamesCount; i++)
+ editor->setItemIcon(i, enumIcons.value(i));
+ editor->setCurrentIndex(manager->value(property));
+
+ connect(editor, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSetValue(int)));
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtEnumEditorFactory::disconnectPropertyManager(QtEnumPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotPropertyChanged(QtProperty *, int)));
+ disconnect(manager, SIGNAL(enumNamesChanged(QtProperty *, const QStringList &)),
+ this, SLOT(slotEnumNamesChanged(QtProperty *, const QStringList &)));
+}
+
+// QtCursorEditorFactory
+
+Q_GLOBAL_STATIC(QtCursorDatabase, cursorDatabase)
+
+class QtCursorEditorFactoryPrivate
+{
+ QtCursorEditorFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtCursorEditorFactory)
+public:
+ QtCursorEditorFactoryPrivate();
+
+ void slotPropertyChanged(QtProperty *property, const QCursor &cursor);
+ void slotEnumChanged(QtProperty *property, int value);
+ void slotEditorDestroyed(QObject *object);
+
+ QtEnumEditorFactory *m_enumEditorFactory;
+ QtEnumPropertyManager *m_enumPropertyManager;
+
+ QMap<QtProperty *, QtProperty *> m_propertyToEnum;
+ QMap<QtProperty *, QtProperty *> m_enumToProperty;
+ QMap<QtProperty *, QList<QWidget *> > m_enumToEditors;
+ QMap<QWidget *, QtProperty *> m_editorToEnum;
+ bool m_updatingEnum;
+};
+
+QtCursorEditorFactoryPrivate::QtCursorEditorFactoryPrivate()
+ : m_updatingEnum(false)
+{
+
+}
+
+void QtCursorEditorFactoryPrivate::slotPropertyChanged(QtProperty *property, const QCursor &cursor)
+{
+ // update enum property
+ QtProperty *enumProp = m_propertyToEnum.value(property);
+ if (!enumProp)
+ return;
+
+ m_updatingEnum = true;
+ m_enumPropertyManager->setValue(enumProp, cursorDatabase()->cursorToValue(cursor));
+ m_updatingEnum = false;
+}
+
+void QtCursorEditorFactoryPrivate::slotEnumChanged(QtProperty *property, int value)
+{
+ if (m_updatingEnum)
+ return;
+ // update cursor property
+ QtProperty *prop = m_enumToProperty.value(property);
+ if (!prop)
+ return;
+ QtCursorPropertyManager *cursorManager = q_ptr->propertyManager(prop);
+ if (!cursorManager)
+ return;
+#ifndef QT_NO_CURSOR
+ cursorManager->setValue(prop, QCursor(cursorDatabase()->valueToCursor(value)));
+#endif
+}
+
+void QtCursorEditorFactoryPrivate::slotEditorDestroyed(QObject *object)
+{
+ // remove from m_editorToEnum map;
+ // remove from m_enumToEditors map;
+ // if m_enumToEditors doesn't contains more editors delete enum property;
+ const QMap<QWidget *, QtProperty *>::ConstIterator ecend = m_editorToEnum.constEnd();
+ for (QMap<QWidget *, QtProperty *>::ConstIterator itEditor = m_editorToEnum.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QWidget *editor = itEditor.key();
+ QtProperty *enumProp = itEditor.value();
+ m_editorToEnum.remove(editor);
+ m_enumToEditors[enumProp].removeAll(editor);
+ if (m_enumToEditors[enumProp].isEmpty()) {
+ m_enumToEditors.remove(enumProp);
+ QtProperty *property = m_enumToProperty.value(enumProp);
+ m_enumToProperty.remove(enumProp);
+ m_propertyToEnum.remove(property);
+ delete enumProp;
+ }
+ return;
+ }
+}
+
+/*!
+ \class QtCursorEditorFactory
+
+ \brief The QtCursorEditorFactory class provides QComboBox widgets for
+ properties created by QtCursorPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtCursorPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtCursorEditorFactory::QtCursorEditorFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtCursorPropertyManager>(parent)
+{
+ d_ptr = new QtCursorEditorFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_enumEditorFactory = new QtEnumEditorFactory(this);
+ d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
+ connect(d_ptr->m_enumPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotEnumChanged(QtProperty *, int)));
+ d_ptr->m_enumEditorFactory->addPropertyManager(d_ptr->m_enumPropertyManager);
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtCursorEditorFactory::~QtCursorEditorFactory()
+{
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtCursorEditorFactory::connectPropertyManager(QtCursorPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty *, const QCursor &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QCursor &)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtCursorEditorFactory::createEditor(QtCursorPropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ QtProperty *enumProp = 0;
+ if (d_ptr->m_propertyToEnum.contains(property)) {
+ enumProp = d_ptr->m_propertyToEnum[property];
+ } else {
+ enumProp = d_ptr->m_enumPropertyManager->addProperty(property->propertyName());
+ d_ptr->m_enumPropertyManager->setEnumNames(enumProp, cursorDatabase()->cursorShapeNames());
+ d_ptr->m_enumPropertyManager->setEnumIcons(enumProp, cursorDatabase()->cursorShapeIcons());
+#ifndef QT_NO_CURSOR
+ d_ptr->m_enumPropertyManager->setValue(enumProp, cursorDatabase()->cursorToValue(manager->value(property)));
+#endif
+ d_ptr->m_propertyToEnum[property] = enumProp;
+ d_ptr->m_enumToProperty[enumProp] = property;
+ }
+ QtAbstractEditorFactoryBase *af = d_ptr->m_enumEditorFactory;
+ QWidget *editor = af->createEditor(enumProp, parent);
+ d_ptr->m_enumToEditors[enumProp].append(editor);
+ d_ptr->m_editorToEnum[editor] = enumProp;
+ connect(editor, SIGNAL(destroyed(QObject *)),
+ this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtCursorEditorFactory::disconnectPropertyManager(QtCursorPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty *, const QCursor &)),
+ this, SLOT(slotPropertyChanged(QtProperty *, const QCursor &)));
+}
+
+// QtColorEditWidget
+
+class QtColorEditWidget : public QWidget {
+ Q_OBJECT
+
+public:
+ QtColorEditWidget(QWidget *parent);
+
+ bool eventFilter(QObject *obj, QEvent *ev);
+
+public Q_SLOTS:
+ void setValue(const QColor &value);
+
+Q_SIGNALS:
+ void valueChanged(const QColor &value);
+
+protected:
+ void paintEvent(QPaintEvent *);
+
+private Q_SLOTS:
+ void buttonClicked();
+
+private:
+ QColor m_color;
+ QLabel *m_pixmapLabel;
+ QLabel *m_label;
+ QToolButton *m_button;
+};
+
+QtColorEditWidget::QtColorEditWidget(QWidget *parent) :
+ QWidget(parent),
+ m_pixmapLabel(new QLabel),
+ m_label(new QLabel),
+ m_button(new QToolButton)
+{
+ QHBoxLayout *lt = new QHBoxLayout(this);
+ setupTreeViewEditorMargin(lt);
+ lt->setSpacing(0);
+ lt->addWidget(m_pixmapLabel);
+ lt->addWidget(m_label);
+ lt->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Ignored));
+
+ m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
+ m_button->setFixedWidth(20);
+ setFocusProxy(m_button);
+ setFocusPolicy(m_button->focusPolicy());
+ m_button->setText(tr("..."));
+ m_button->installEventFilter(this);
+ connect(m_button, SIGNAL(clicked()), this, SLOT(buttonClicked()));
+ lt->addWidget(m_button);
+ m_pixmapLabel->setPixmap(QtPropertyBrowserUtils::brushValuePixmap(QBrush(m_color)));
+ m_label->setText(QtPropertyBrowserUtils::colorValueText(m_color));
+}
+
+void QtColorEditWidget::setValue(const QColor &c)
+{
+ if (m_color != c) {
+ m_color = c;
+ m_pixmapLabel->setPixmap(QtPropertyBrowserUtils::brushValuePixmap(QBrush(c)));
+ m_label->setText(QtPropertyBrowserUtils::colorValueText(c));
+ }
+}
+
+void QtColorEditWidget::buttonClicked()
+{
+ bool ok = false;
+ QRgb oldRgba = m_color.rgba();
+ QRgb newRgba = QColorDialog::getRgba(oldRgba, &ok, this);
+ if (ok && newRgba != oldRgba) {
+ setValue(QColor::fromRgba(newRgba));
+ emit valueChanged(m_color);
+ }
+}
+
+bool QtColorEditWidget::eventFilter(QObject *obj, QEvent *ev)
+{
+ if (obj == m_button) {
+ switch (ev->type()) {
+ case QEvent::KeyPress:
+ case QEvent::KeyRelease: { // Prevent the QToolButton from handling Enter/Escape meant control the delegate
+ switch (static_cast<const QKeyEvent*>(ev)->key()) {
+ case Qt::Key_Escape:
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ ev->ignore();
+ return true;
+ default:
+ break;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ return QWidget::eventFilter(obj, ev);
+}
+
+void QtColorEditWidget::paintEvent(QPaintEvent *)
+{
+ QStyleOption opt;
+ opt.init(this);
+ QPainter p(this);
+ style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
+}
+
+// QtColorEditorFactoryPrivate
+
+class QtColorEditorFactoryPrivate : public EditorFactoryPrivate<QtColorEditWidget>
+{
+ QtColorEditorFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtColorEditorFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, const QColor &value);
+ void slotSetValue(const QColor &value);
+};
+
+void QtColorEditorFactoryPrivate::slotPropertyChanged(QtProperty *property,
+ const QColor &value)
+{
+ const PropertyToEditorListMap::iterator it = m_createdEditors.find(property);
+ if (it == m_createdEditors.end())
+ return;
+ QListIterator<QtColorEditWidget *> itEditor(it.value());
+
+ while (itEditor.hasNext())
+ itEditor.next()->setValue(value);
+}
+
+void QtColorEditorFactoryPrivate::slotSetValue(const QColor &value)
+{
+ QObject *object = q_ptr->sender();
+ const EditorToPropertyMap::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (EditorToPropertyMap::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtColorPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtColorEditorFactory
+
+ \brief The QtColorEditorFactory class provides color editing for
+ properties created by QtColorPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtColorPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtColorEditorFactory::QtColorEditorFactory(QObject *parent) :
+ QtAbstractEditorFactory<QtColorPropertyManager>(parent),
+ d_ptr(new QtColorEditorFactoryPrivate())
+{
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtColorEditorFactory::~QtColorEditorFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtColorEditorFactory::connectPropertyManager(QtColorPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty*,QColor)),
+ this, SLOT(slotPropertyChanged(QtProperty*,QColor)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtColorEditorFactory::createEditor(QtColorPropertyManager *manager,
+ QtProperty *property, QWidget *parent)
+{
+ QtColorEditWidget *editor = d_ptr->createEditor(property, parent);
+ editor->setValue(manager->value(property));
+ connect(editor, SIGNAL(valueChanged(QColor)), this, SLOT(slotSetValue(QColor)));
+ connect(editor, SIGNAL(destroyed(QObject *)), this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtColorEditorFactory::disconnectPropertyManager(QtColorPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty*,QColor)), this, SLOT(slotPropertyChanged(QtProperty*,QColor)));
+}
+
+// QtFontEditWidget
+
+class QtFontEditWidget : public QWidget {
+ Q_OBJECT
+
+public:
+ QtFontEditWidget(QWidget *parent);
+
+ bool eventFilter(QObject *obj, QEvent *ev);
+
+public Q_SLOTS:
+ void setValue(const QFont &value);
+
+Q_SIGNALS:
+ void valueChanged(const QFont &value);
+
+protected:
+ void paintEvent(QPaintEvent *);
+
+private Q_SLOTS:
+ void buttonClicked();
+
+private:
+ QFont m_font;
+ QLabel *m_pixmapLabel;
+ QLabel *m_label;
+ QToolButton *m_button;
+};
+
+QtFontEditWidget::QtFontEditWidget(QWidget *parent) :
+ QWidget(parent),
+ m_pixmapLabel(new QLabel),
+ m_label(new QLabel),
+ m_button(new QToolButton)
+{
+ QHBoxLayout *lt = new QHBoxLayout(this);
+ setupTreeViewEditorMargin(lt);
+ lt->setSpacing(0);
+ lt->addWidget(m_pixmapLabel);
+ lt->addWidget(m_label);
+ lt->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Ignored));
+
+ m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
+ m_button->setFixedWidth(20);
+ setFocusProxy(m_button);
+ setFocusPolicy(m_button->focusPolicy());
+ m_button->setText(tr("..."));
+ m_button->installEventFilter(this);
+ connect(m_button, SIGNAL(clicked()), this, SLOT(buttonClicked()));
+ lt->addWidget(m_button);
+ m_pixmapLabel->setPixmap(QtPropertyBrowserUtils::fontValuePixmap(m_font));
+ m_label->setText(QtPropertyBrowserUtils::fontValueText(m_font));
+}
+
+void QtFontEditWidget::setValue(const QFont &f)
+{
+ if (m_font != f) {
+ m_font = f;
+ m_pixmapLabel->setPixmap(QtPropertyBrowserUtils::fontValuePixmap(f));
+ m_label->setText(QtPropertyBrowserUtils::fontValueText(f));
+ }
+}
+
+void QtFontEditWidget::buttonClicked()
+{
+ bool ok = false;
+ QFont newFont = QFontDialog::getFont(&ok, m_font, this, tr("Select Font"));
+ if (ok && newFont != m_font) {
+ QFont f = m_font;
+ // prevent mask for unchanged attributes, don't change other attributes (like kerning, etc...)
+ if (m_font.family() != newFont.family())
+ f.setFamily(newFont.family());
+ if (m_font.pointSize() != newFont.pointSize())
+ f.setPointSize(newFont.pointSize());
+ if (m_font.bold() != newFont.bold())
+ f.setBold(newFont.bold());
+ if (m_font.italic() != newFont.italic())
+ f.setItalic(newFont.italic());
+ if (m_font.underline() != newFont.underline())
+ f.setUnderline(newFont.underline());
+ if (m_font.strikeOut() != newFont.strikeOut())
+ f.setStrikeOut(newFont.strikeOut());
+ setValue(f);
+ emit valueChanged(m_font);
+ }
+}
+
+bool QtFontEditWidget::eventFilter(QObject *obj, QEvent *ev)
+{
+ if (obj == m_button) {
+ switch (ev->type()) {
+ case QEvent::KeyPress:
+ case QEvent::KeyRelease: { // Prevent the QToolButton from handling Enter/Escape meant control the delegate
+ switch (static_cast<const QKeyEvent*>(ev)->key()) {
+ case Qt::Key_Escape:
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ ev->ignore();
+ return true;
+ default:
+ break;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ return QWidget::eventFilter(obj, ev);
+}
+
+void QtFontEditWidget::paintEvent(QPaintEvent *)
+{
+ QStyleOption opt;
+ opt.init(this);
+ QPainter p(this);
+ style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
+}
+
+// QtFontEditorFactoryPrivate
+
+class QtFontEditorFactoryPrivate : public EditorFactoryPrivate<QtFontEditWidget>
+{
+ QtFontEditorFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtFontEditorFactory)
+public:
+
+ void slotPropertyChanged(QtProperty *property, const QFont &value);
+ void slotSetValue(const QFont &value);
+};
+
+void QtFontEditorFactoryPrivate::slotPropertyChanged(QtProperty *property,
+ const QFont &value)
+{
+ const PropertyToEditorListMap::iterator it = m_createdEditors.find(property);
+ if (it == m_createdEditors.end())
+ return;
+ QListIterator<QtFontEditWidget *> itEditor(it.value());
+
+ while (itEditor.hasNext())
+ itEditor.next()->setValue(value);
+}
+
+void QtFontEditorFactoryPrivate::slotSetValue(const QFont &value)
+{
+ QObject *object = q_ptr->sender();
+ const EditorToPropertyMap::ConstIterator ecend = m_editorToProperty.constEnd();
+ for (EditorToPropertyMap::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
+ if (itEditor.key() == object) {
+ QtProperty *property = itEditor.value();
+ QtFontPropertyManager *manager = q_ptr->propertyManager(property);
+ if (!manager)
+ return;
+ manager->setValue(property, value);
+ return;
+ }
+}
+
+/*!
+ \class QtFontEditorFactory
+
+ \brief The QtFontEditorFactory class provides font editing for
+ properties created by QtFontPropertyManager objects.
+
+ \sa QtAbstractEditorFactory, QtFontPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtFontEditorFactory::QtFontEditorFactory(QObject *parent) :
+ QtAbstractEditorFactory<QtFontPropertyManager>(parent),
+ d_ptr(new QtFontEditorFactoryPrivate())
+{
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtFontEditorFactory::~QtFontEditorFactory()
+{
+ qDeleteAll(d_ptr->m_editorToProperty.keys());
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtFontEditorFactory::connectPropertyManager(QtFontPropertyManager *manager)
+{
+ connect(manager, SIGNAL(valueChanged(QtProperty*,QFont)),
+ this, SLOT(slotPropertyChanged(QtProperty*,QFont)));
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtFontEditorFactory::createEditor(QtFontPropertyManager *manager,
+ QtProperty *property, QWidget *parent)
+{
+ QtFontEditWidget *editor = d_ptr->createEditor(property, parent);
+ editor->setValue(manager->value(property));
+ connect(editor, SIGNAL(valueChanged(QFont)), this, SLOT(slotSetValue(QFont)));
+ connect(editor, SIGNAL(destroyed(QObject *)), this, SLOT(slotEditorDestroyed(QObject *)));
+ return editor;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtFontEditorFactory::disconnectPropertyManager(QtFontPropertyManager *manager)
+{
+ disconnect(manager, SIGNAL(valueChanged(QtProperty*,QFont)), this, SLOT(slotPropertyChanged(QtProperty*,QFont)));
+}
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#include "moc_qteditorfactory.cpp"
+#include "qteditorfactory.moc"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qteditorfactory.h b/GUI/coregui/qttools/qtpropertybrowser/qteditorfactory.h
new file mode 100644
index 0000000000000000000000000000000000000000..37204ce056f3b8e1fa87928148e81d4335150544
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qteditorfactory.h
@@ -0,0 +1,405 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QTEDITORFACTORY_H
+#define QTEDITORFACTORY_H
+
+#include "qtpropertymanager.h"
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QtSpinBoxFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtSpinBoxFactory : public QtAbstractEditorFactory<QtIntPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtSpinBoxFactory(QObject *parent = 0);
+ ~QtSpinBoxFactory();
+protected:
+ void connectPropertyManager(QtIntPropertyManager *manager);
+ QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtIntPropertyManager *manager);
+private:
+ QtSpinBoxFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtSpinBoxFactory)
+ Q_DISABLE_COPY(QtSpinBoxFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))
+ Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotReadOnlyChanged(QtProperty *, bool))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtSliderFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtSliderFactory : public QtAbstractEditorFactory<QtIntPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtSliderFactory(QObject *parent = 0);
+ ~QtSliderFactory();
+protected:
+ void connectPropertyManager(QtIntPropertyManager *manager);
+ QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtIntPropertyManager *manager);
+private:
+ QtSliderFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtSliderFactory)
+ Q_DISABLE_COPY(QtSliderFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))
+ Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtScrollBarFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtScrollBarFactory : public QtAbstractEditorFactory<QtIntPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtScrollBarFactory(QObject *parent = 0);
+ ~QtScrollBarFactory();
+protected:
+ void connectPropertyManager(QtIntPropertyManager *manager);
+ QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtIntPropertyManager *manager);
+private:
+ QtScrollBarFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtScrollBarFactory)
+ Q_DISABLE_COPY(QtScrollBarFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))
+ Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtCheckBoxFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtCheckBoxFactory : public QtAbstractEditorFactory<QtBoolPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtCheckBoxFactory(QObject *parent = 0);
+ ~QtCheckBoxFactory();
+protected:
+ void connectPropertyManager(QtBoolPropertyManager *manager);
+ QWidget *createEditor(QtBoolPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtBoolPropertyManager *manager);
+private:
+ QtCheckBoxFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtCheckBoxFactory)
+ Q_DISABLE_COPY(QtCheckBoxFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, bool))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(bool))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtDoubleSpinBoxFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtDoubleSpinBoxFactory : public QtAbstractEditorFactory<QtDoublePropertyManager>
+{
+ Q_OBJECT
+public:
+ QtDoubleSpinBoxFactory(QObject *parent = 0);
+ ~QtDoubleSpinBoxFactory();
+protected:
+ void connectPropertyManager(QtDoublePropertyManager *manager);
+ QWidget *createEditor(QtDoublePropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtDoublePropertyManager *manager);
+private:
+ QtDoubleSpinBoxFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtDoubleSpinBoxFactory)
+ Q_DISABLE_COPY(QtDoubleSpinBoxFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, double))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, double, double))
+ Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, double))
+ Q_PRIVATE_SLOT(d_func(), void slotDecimalsChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotReadOnlyChanged(QtProperty *, bool))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(double))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtLineEditFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtLineEditFactory : public QtAbstractEditorFactory<QtStringPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtLineEditFactory(QObject *parent = 0);
+ ~QtLineEditFactory();
+protected:
+ void connectPropertyManager(QtStringPropertyManager *manager);
+ QWidget *createEditor(QtStringPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtStringPropertyManager *manager);
+private:
+ QtLineEditFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtLineEditFactory)
+ Q_DISABLE_COPY(QtLineEditFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QString &))
+ Q_PRIVATE_SLOT(d_func(), void slotRegExpChanged(QtProperty *, const QRegExp &))
+ Q_PRIVATE_SLOT(d_func(), void slotEchoModeChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotReadOnlyChanged(QtProperty *, bool))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QString &))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtDateEditFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtDateEditFactory : public QtAbstractEditorFactory<QtDatePropertyManager>
+{
+ Q_OBJECT
+public:
+ QtDateEditFactory(QObject *parent = 0);
+ ~QtDateEditFactory();
+protected:
+ void connectPropertyManager(QtDatePropertyManager *manager);
+ QWidget *createEditor(QtDatePropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtDatePropertyManager *manager);
+private:
+ QtDateEditFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtDateEditFactory)
+ Q_DISABLE_COPY(QtDateEditFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QDate &))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *,
+ const QDate &, const QDate &))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QDate &))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtTimeEditFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtTimeEditFactory : public QtAbstractEditorFactory<QtTimePropertyManager>
+{
+ Q_OBJECT
+public:
+ QtTimeEditFactory(QObject *parent = 0);
+ ~QtTimeEditFactory();
+protected:
+ void connectPropertyManager(QtTimePropertyManager *manager);
+ QWidget *createEditor(QtTimePropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtTimePropertyManager *manager);
+private:
+ QtTimeEditFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtTimeEditFactory)
+ Q_DISABLE_COPY(QtTimeEditFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QTime &))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QTime &))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtDateTimeEditFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtDateTimeEditFactory : public QtAbstractEditorFactory<QtDateTimePropertyManager>
+{
+ Q_OBJECT
+public:
+ QtDateTimeEditFactory(QObject *parent = 0);
+ ~QtDateTimeEditFactory();
+protected:
+ void connectPropertyManager(QtDateTimePropertyManager *manager);
+ QWidget *createEditor(QtDateTimePropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtDateTimePropertyManager *manager);
+private:
+ QtDateTimeEditFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtDateTimeEditFactory)
+ Q_DISABLE_COPY(QtDateTimeEditFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QDateTime &))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QDateTime &))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtKeySequenceEditorFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtKeySequenceEditorFactory : public QtAbstractEditorFactory<QtKeySequencePropertyManager>
+{
+ Q_OBJECT
+public:
+ QtKeySequenceEditorFactory(QObject *parent = 0);
+ ~QtKeySequenceEditorFactory();
+protected:
+ void connectPropertyManager(QtKeySequencePropertyManager *manager);
+ QWidget *createEditor(QtKeySequencePropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtKeySequencePropertyManager *manager);
+private:
+ QtKeySequenceEditorFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtKeySequenceEditorFactory)
+ Q_DISABLE_COPY(QtKeySequenceEditorFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QKeySequence &))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QKeySequence &))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtCharEditorFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtCharEditorFactory : public QtAbstractEditorFactory<QtCharPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtCharEditorFactory(QObject *parent = 0);
+ ~QtCharEditorFactory();
+protected:
+ void connectPropertyManager(QtCharPropertyManager *manager);
+ QWidget *createEditor(QtCharPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtCharPropertyManager *manager);
+private:
+ QtCharEditorFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtCharEditorFactory)
+ Q_DISABLE_COPY(QtCharEditorFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QChar &))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QChar &))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtEnumEditorFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtEnumEditorFactory : public QtAbstractEditorFactory<QtEnumPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtEnumEditorFactory(QObject *parent = 0);
+ ~QtEnumEditorFactory();
+protected:
+ void connectPropertyManager(QtEnumPropertyManager *manager);
+ QWidget *createEditor(QtEnumPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtEnumPropertyManager *manager);
+private:
+ QtEnumEditorFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtEnumEditorFactory)
+ Q_DISABLE_COPY(QtEnumEditorFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotEnumNamesChanged(QtProperty *,
+ const QStringList &))
+ Q_PRIVATE_SLOT(d_func(), void slotEnumIconsChanged(QtProperty *,
+ const QMap<int, QIcon> &))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtCursorEditorFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtCursorEditorFactory : public QtAbstractEditorFactory<QtCursorPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtCursorEditorFactory(QObject *parent = 0);
+ ~QtCursorEditorFactory();
+protected:
+ void connectPropertyManager(QtCursorPropertyManager *manager);
+ QWidget *createEditor(QtCursorPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtCursorPropertyManager *manager);
+private:
+ QtCursorEditorFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtCursorEditorFactory)
+ Q_DISABLE_COPY(QtCursorEditorFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QCursor &))
+ Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+};
+
+class QtColorEditorFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtColorEditorFactory : public QtAbstractEditorFactory<QtColorPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtColorEditorFactory(QObject *parent = 0);
+ ~QtColorEditorFactory();
+protected:
+ void connectPropertyManager(QtColorPropertyManager *manager);
+ QWidget *createEditor(QtColorPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtColorPropertyManager *manager);
+private:
+ QtColorEditorFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtColorEditorFactory)
+ Q_DISABLE_COPY(QtColorEditorFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QColor &))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QColor &))
+};
+
+class QtFontEditorFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtFontEditorFactory : public QtAbstractEditorFactory<QtFontPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtFontEditorFactory(QObject *parent = 0);
+ ~QtFontEditorFactory();
+protected:
+ void connectPropertyManager(QtFontPropertyManager *manager);
+ QWidget *createEditor(QtFontPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtFontPropertyManager *manager);
+private:
+ QtFontEditorFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtFontEditorFactory)
+ Q_DISABLE_COPY(QtFontEditorFactory)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QFont &))
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
+ Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QFont &))
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#endif
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtgroupboxpropertybrowser.cpp b/GUI/coregui/qttools/qtpropertybrowser/qtgroupboxpropertybrowser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b2c4989d5d36ad9dc4fe5e4aedf0795394e8bc31
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtgroupboxpropertybrowser.cpp
@@ -0,0 +1,534 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtgroupboxpropertybrowser.h"
+#include <QSet>
+#include <QGridLayout>
+#include <QLabel>
+#include <QGroupBox>
+#include <QTimer>
+#include <QMap>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QtGroupBoxPropertyBrowserPrivate
+{
+ QtGroupBoxPropertyBrowser *q_ptr;
+ Q_DECLARE_PUBLIC(QtGroupBoxPropertyBrowser)
+public:
+
+ void init(QWidget *parent);
+
+ void propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex);
+ void propertyRemoved(QtBrowserItem *index);
+ void propertyChanged(QtBrowserItem *index);
+ QWidget *createEditor(QtProperty *property, QWidget *parent) const
+ { return q_ptr->createEditor(property, parent); }
+
+ void slotEditorDestroyed();
+ void slotUpdate();
+
+ struct WidgetItem
+ {
+ WidgetItem() : widget(0), label(0), widgetLabel(0),
+ groupBox(0), layout(0), line(0), parent(0) { }
+ QWidget *widget; // can be null
+ QLabel *label;
+ QLabel *widgetLabel;
+ QGroupBox *groupBox;
+ QGridLayout *layout;
+ QFrame *line;
+ WidgetItem *parent;
+ QList<WidgetItem *> children;
+ };
+private:
+ void updateLater();
+ void updateItem(WidgetItem *item);
+ void insertRow(QGridLayout *layout, int row) const;
+ void removeRow(QGridLayout *layout, int row) const;
+
+ bool hasHeader(WidgetItem *item) const;
+
+ QMap<QtBrowserItem *, WidgetItem *> m_indexToItem;
+ QMap<WidgetItem *, QtBrowserItem *> m_itemToIndex;
+ QMap<QWidget *, WidgetItem *> m_widgetToItem;
+ QGridLayout *m_mainLayout;
+ QList<WidgetItem *> m_children;
+ QList<WidgetItem *> m_recreateQueue;
+};
+
+void QtGroupBoxPropertyBrowserPrivate::init(QWidget *parent)
+{
+ m_mainLayout = new QGridLayout();
+ parent->setLayout(m_mainLayout);
+ QLayoutItem *item = new QSpacerItem(0, 0,
+ QSizePolicy::Fixed, QSizePolicy::Expanding);
+ m_mainLayout->addItem(item, 0, 0);
+}
+
+void QtGroupBoxPropertyBrowserPrivate::slotEditorDestroyed()
+{
+ QWidget *editor = qobject_cast<QWidget *>(q_ptr->sender());
+ if (!editor)
+ return;
+ if (!m_widgetToItem.contains(editor))
+ return;
+ m_widgetToItem[editor]->widget = 0;
+ m_widgetToItem.remove(editor);
+}
+
+void QtGroupBoxPropertyBrowserPrivate::slotUpdate()
+{
+ QListIterator<WidgetItem *> itItem(m_recreateQueue);
+ while (itItem.hasNext()) {
+ WidgetItem *item = itItem.next();
+
+ WidgetItem *par = item->parent;
+ QWidget *w = 0;
+ QGridLayout *l = 0;
+ int oldRow = -1;
+ if (!par) {
+ w = q_ptr;
+ l = m_mainLayout;
+ oldRow = m_children.indexOf(item);
+ } else {
+ w = par->groupBox;
+ l = par->layout;
+ oldRow = par->children.indexOf(item);
+ if (hasHeader(par))
+ oldRow += 2;
+ }
+
+ if (item->widget) {
+ item->widget->setParent(w);
+ } else if (item->widgetLabel) {
+ item->widgetLabel->setParent(w);
+ } else {
+ item->widgetLabel = new QLabel(w);
+ item->widgetLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));
+ item->widgetLabel->setTextFormat(Qt::PlainText);
+ }
+ int span = 1;
+ if (item->widget)
+ l->addWidget(item->widget, oldRow, 1, 1, 1);
+ else if (item->widgetLabel)
+ l->addWidget(item->widgetLabel, oldRow, 1, 1, 1);
+ else
+ span = 2;
+ item->label = new QLabel(w);
+ item->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
+ l->addWidget(item->label, oldRow, 0, 1, span);
+
+ updateItem(item);
+ }
+ m_recreateQueue.clear();
+}
+
+void QtGroupBoxPropertyBrowserPrivate::updateLater()
+{
+ QTimer::singleShot(0, q_ptr, SLOT(slotUpdate()));
+}
+
+void QtGroupBoxPropertyBrowserPrivate::propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex)
+{
+ WidgetItem *afterItem = m_indexToItem.value(afterIndex);
+ WidgetItem *parentItem = m_indexToItem.value(index->parent());
+
+ WidgetItem *newItem = new WidgetItem();
+ newItem->parent = parentItem;
+
+ QGridLayout *layout = 0;
+ QWidget *parentWidget = 0;
+ int row = -1;
+ if (!afterItem) {
+ row = 0;
+ if (parentItem)
+ parentItem->children.insert(0, newItem);
+ else
+ m_children.insert(0, newItem);
+ } else {
+ if (parentItem) {
+ row = parentItem->children.indexOf(afterItem) + 1;
+ parentItem->children.insert(row, newItem);
+ } else {
+ row = m_children.indexOf(afterItem) + 1;
+ m_children.insert(row, newItem);
+ }
+ }
+ if (parentItem && hasHeader(parentItem))
+ row += 2;
+
+ if (!parentItem) {
+ layout = m_mainLayout;
+ parentWidget = q_ptr;;
+ } else {
+ if (!parentItem->groupBox) {
+ m_recreateQueue.removeAll(parentItem);
+ WidgetItem *par = parentItem->parent;
+ QWidget *w = 0;
+ QGridLayout *l = 0;
+ int oldRow = -1;
+ if (!par) {
+ w = q_ptr;
+ l = m_mainLayout;
+ oldRow = m_children.indexOf(parentItem);
+ } else {
+ w = par->groupBox;
+ l = par->layout;
+ oldRow = par->children.indexOf(parentItem);
+ if (hasHeader(par))
+ oldRow += 2;
+ }
+ parentItem->groupBox = new QGroupBox(w);
+ parentItem->layout = new QGridLayout();
+ parentItem->groupBox->setLayout(parentItem->layout);
+ if (parentItem->label) {
+ l->removeWidget(parentItem->label);
+ delete parentItem->label;
+ parentItem->label = 0;
+ }
+ if (parentItem->widget) {
+ l->removeWidget(parentItem->widget);
+ parentItem->widget->setParent(parentItem->groupBox);
+ parentItem->layout->addWidget(parentItem->widget, 0, 0, 1, 2);
+ parentItem->line = new QFrame(parentItem->groupBox);
+ } else if (parentItem->widgetLabel) {
+ l->removeWidget(parentItem->widgetLabel);
+ delete parentItem->widgetLabel;
+ parentItem->widgetLabel = 0;
+ }
+ if (parentItem->line) {
+ parentItem->line->setFrameShape(QFrame::HLine);
+ parentItem->line->setFrameShadow(QFrame::Sunken);
+ parentItem->layout->addWidget(parentItem->line, 1, 0, 1, 2);
+ }
+ l->addWidget(parentItem->groupBox, oldRow, 0, 1, 2);
+ updateItem(parentItem);
+ }
+ layout = parentItem->layout;
+ parentWidget = parentItem->groupBox;
+ }
+
+ newItem->label = new QLabel(parentWidget);
+ newItem->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
+ newItem->widget = createEditor(index->property(), parentWidget);
+ if (!newItem->widget) {
+ newItem->widgetLabel = new QLabel(parentWidget);
+ newItem->widgetLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));
+ newItem->widgetLabel->setTextFormat(Qt::PlainText);
+ } else {
+ QObject::connect(newItem->widget, SIGNAL(destroyed()), q_ptr, SLOT(slotEditorDestroyed()));
+ m_widgetToItem[newItem->widget] = newItem;
+ }
+
+ insertRow(layout, row);
+ int span = 1;
+ if (newItem->widget)
+ layout->addWidget(newItem->widget, row, 1);
+ else if (newItem->widgetLabel)
+ layout->addWidget(newItem->widgetLabel, row, 1);
+ else
+ span = 2;
+ layout->addWidget(newItem->label, row, 0, 1, span);
+
+ m_itemToIndex[newItem] = index;
+ m_indexToItem[index] = newItem;
+
+ updateItem(newItem);
+}
+
+void QtGroupBoxPropertyBrowserPrivate::propertyRemoved(QtBrowserItem *index)
+{
+ WidgetItem *item = m_indexToItem.value(index);
+
+ m_indexToItem.remove(index);
+ m_itemToIndex.remove(item);
+
+ WidgetItem *parentItem = item->parent;
+
+ int row = -1;
+
+ if (parentItem) {
+ row = parentItem->children.indexOf(item);
+ parentItem->children.removeAt(row);
+ if (hasHeader(parentItem))
+ row += 2;
+ } else {
+ row = m_children.indexOf(item);
+ m_children.removeAt(row);
+ }
+
+ if (item->widget)
+ delete item->widget;
+ if (item->label)
+ delete item->label;
+ if (item->widgetLabel)
+ delete item->widgetLabel;
+ if (item->groupBox)
+ delete item->groupBox;
+
+ if (!parentItem) {
+ removeRow(m_mainLayout, row);
+ } else if (parentItem->children.count() != 0) {
+ removeRow(parentItem->layout, row);
+ } else {
+ WidgetItem *par = parentItem->parent;
+ QGridLayout *l = 0;
+ int oldRow = -1;
+ if (!par) {
+ l = m_mainLayout;
+ oldRow = m_children.indexOf(parentItem);
+ } else {
+ l = par->layout;
+ oldRow = par->children.indexOf(parentItem);
+ if (hasHeader(par))
+ oldRow += 2;
+ }
+
+ if (parentItem->widget) {
+ parentItem->widget->hide();
+ parentItem->widget->setParent(0);
+ } else if (parentItem->widgetLabel) {
+ parentItem->widgetLabel->hide();
+ parentItem->widgetLabel->setParent(0);
+ } else {
+ //parentItem->widgetLabel = new QLabel(w);
+ }
+ l->removeWidget(parentItem->groupBox);
+ delete parentItem->groupBox;
+ parentItem->groupBox = 0;
+ parentItem->line = 0;
+ parentItem->layout = 0;
+ if (!m_recreateQueue.contains(parentItem))
+ m_recreateQueue.append(parentItem);
+ updateLater();
+ }
+ m_recreateQueue.removeAll(item);
+
+ delete item;
+}
+
+void QtGroupBoxPropertyBrowserPrivate::insertRow(QGridLayout *layout, int row) const
+{
+ QMap<QLayoutItem *, QRect> itemToPos;
+ int idx = 0;
+ while (idx < layout->count()) {
+ int r, c, rs, cs;
+ layout->getItemPosition(idx, &r, &c, &rs, &cs);
+ if (r >= row) {
+ itemToPos[layout->takeAt(idx)] = QRect(r + 1, c, rs, cs);
+ } else {
+ idx++;
+ }
+ }
+
+ const QMap<QLayoutItem *, QRect>::ConstIterator icend = itemToPos.constEnd();
+ for (QMap<QLayoutItem *, QRect>::ConstIterator it = itemToPos.constBegin(); it != icend; ++it) {
+ const QRect r = it.value();
+ layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height());
+ }
+}
+
+void QtGroupBoxPropertyBrowserPrivate::removeRow(QGridLayout *layout, int row) const
+{
+ QMap<QLayoutItem *, QRect> itemToPos;
+ int idx = 0;
+ while (idx < layout->count()) {
+ int r, c, rs, cs;
+ layout->getItemPosition(idx, &r, &c, &rs, &cs);
+ if (r > row) {
+ itemToPos[layout->takeAt(idx)] = QRect(r - 1, c, rs, cs);
+ } else {
+ idx++;
+ }
+ }
+
+ const QMap<QLayoutItem *, QRect>::ConstIterator icend = itemToPos.constEnd();
+ for (QMap<QLayoutItem *, QRect>::ConstIterator it = itemToPos.constBegin(); it != icend; ++it) {
+ const QRect r = it.value();
+ layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height());
+ }
+}
+
+bool QtGroupBoxPropertyBrowserPrivate::hasHeader(WidgetItem *item) const
+{
+ if (item->widget)
+ return true;
+ return false;
+}
+
+void QtGroupBoxPropertyBrowserPrivate::propertyChanged(QtBrowserItem *index)
+{
+ WidgetItem *item = m_indexToItem.value(index);
+
+ updateItem(item);
+}
+
+void QtGroupBoxPropertyBrowserPrivate::updateItem(WidgetItem *item)
+{
+ QtProperty *property = m_itemToIndex[item]->property();
+ if (item->groupBox) {
+ QFont font = item->groupBox->font();
+ font.setUnderline(property->isModified());
+ item->groupBox->setFont(font);
+ item->groupBox->setTitle(property->propertyName());
+ item->groupBox->setToolTip(property->toolTip());
+ item->groupBox->setStatusTip(property->statusTip());
+ item->groupBox->setWhatsThis(property->whatsThis());
+ item->groupBox->setEnabled(property->isEnabled());
+ }
+ if (item->label) {
+ QFont font = item->label->font();
+ font.setUnderline(property->isModified());
+ item->label->setFont(font);
+ item->label->setText(property->propertyName());
+ item->label->setToolTip(property->toolTip());
+ item->label->setStatusTip(property->statusTip());
+ item->label->setWhatsThis(property->whatsThis());
+ item->label->setEnabled(property->isEnabled());
+ }
+ if (item->widgetLabel) {
+ QFont font = item->widgetLabel->font();
+ font.setUnderline(false);
+ item->widgetLabel->setFont(font);
+ item->widgetLabel->setText(property->valueText());
+ item->widgetLabel->setToolTip(property->valueText());
+ item->widgetLabel->setEnabled(property->isEnabled());
+ }
+ if (item->widget) {
+ QFont font = item->widget->font();
+ font.setUnderline(false);
+ item->widget->setFont(font);
+ item->widget->setEnabled(property->isEnabled());
+ item->widget->setToolTip(property->valueText());
+ }
+ //item->setIcon(1, property->valueIcon());
+}
+
+
+
+/*!
+ \class QtGroupBoxPropertyBrowser
+
+ \brief The QtGroupBoxPropertyBrowser class provides a QGroupBox
+ based property browser.
+
+ A property browser is a widget that enables the user to edit a
+ given set of properties. Each property is represented by a label
+ specifying the property's name, and an editing widget (e.g. a line
+ edit or a combobox) holding its value. A property can have zero or
+ more subproperties.
+
+ QtGroupBoxPropertyBrowser provides group boxes for all nested
+ properties, i.e. subproperties are enclosed by a group box with
+ the parent property's name as its title. For example:
+
+ \image qtgroupboxpropertybrowser.png
+
+ Use the QtAbstractPropertyBrowser API to add, insert and remove
+ properties from an instance of the QtGroupBoxPropertyBrowser
+ class. The properties themselves are created and managed by
+ implementations of the QtAbstractPropertyManager class.
+
+ \sa QtTreePropertyBrowser, QtAbstractPropertyBrowser
+*/
+
+/*!
+ Creates a property browser with the given \a parent.
+*/
+QtGroupBoxPropertyBrowser::QtGroupBoxPropertyBrowser(QWidget *parent)
+ : QtAbstractPropertyBrowser(parent)
+{
+ d_ptr = new QtGroupBoxPropertyBrowserPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->init(this);
+}
+
+/*!
+ Destroys this property browser.
+
+ Note that the properties that were inserted into this browser are
+ \e not destroyed since they may still be used in other
+ browsers. The properties are owned by the manager that created
+ them.
+
+ \sa QtProperty, QtAbstractPropertyManager
+*/
+QtGroupBoxPropertyBrowser::~QtGroupBoxPropertyBrowser()
+{
+ const QMap<QtGroupBoxPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator icend = d_ptr->m_itemToIndex.constEnd();
+ for (QMap<QtGroupBoxPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator it = d_ptr->m_itemToIndex.constBegin(); it != icend; ++it)
+ delete it.key();
+ delete d_ptr;
+}
+
+/*!
+ \reimp
+*/
+void QtGroupBoxPropertyBrowser::itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem)
+{
+ d_ptr->propertyInserted(item, afterItem);
+}
+
+/*!
+ \reimp
+*/
+void QtGroupBoxPropertyBrowser::itemRemoved(QtBrowserItem *item)
+{
+ d_ptr->propertyRemoved(item);
+}
+
+/*!
+ \reimp
+*/
+void QtGroupBoxPropertyBrowser::itemChanged(QtBrowserItem *item)
+{
+ d_ptr->propertyChanged(item);
+}
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#include "moc_qtgroupboxpropertybrowser.cpp"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtgroupboxpropertybrowser.h b/GUI/coregui/qttools/qtpropertybrowser/qtgroupboxpropertybrowser.h
new file mode 100644
index 0000000000000000000000000000000000000000..78b4a9b1013d93d46d332399e83334c0b0b5a7b7
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtgroupboxpropertybrowser.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QTGROUPBOXPROPERTYBROWSER_H
+#define QTGROUPBOXPROPERTYBROWSER_H
+
+#include "qtpropertybrowser.h"
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QtGroupBoxPropertyBrowserPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtGroupBoxPropertyBrowser : public QtAbstractPropertyBrowser
+{
+ Q_OBJECT
+public:
+
+ QtGroupBoxPropertyBrowser(QWidget *parent = 0);
+ ~QtGroupBoxPropertyBrowser();
+
+protected:
+ virtual void itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem);
+ virtual void itemRemoved(QtBrowserItem *item);
+ virtual void itemChanged(QtBrowserItem *item);
+
+private:
+
+ QtGroupBoxPropertyBrowserPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtGroupBoxPropertyBrowser)
+ Q_DISABLE_COPY(QtGroupBoxPropertyBrowser)
+ Q_PRIVATE_SLOT(d_func(), void slotUpdate())
+ Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed())
+
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#endif
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.cpp b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..738bfbf1fd646d671dac8838b25930d4a308add2
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.cpp
@@ -0,0 +1,2026 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtpropertybrowser.h"
+#include <QSet>
+#include <QMap>
+#include <QIcon>
+#include <QLineEdit>
+
+#if defined(Q_CC_MSVC)
+# pragma warning(disable: 4786) /* MS VS 6: truncating debug info after 255 characters */
+#endif
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QtPropertyPrivate
+{
+public:
+ QtPropertyPrivate(QtAbstractPropertyManager *manager)
+ : m_enabled(true),
+ m_modified(false),
+ m_manager(manager) {}
+ QtProperty *q_ptr;
+
+ QSet<QtProperty *> m_parentItems;
+ QList<QtProperty *> m_subItems;
+
+ QString m_toolTip;
+ QString m_statusTip;
+ QString m_whatsThis;
+ QString m_name;
+ bool m_enabled;
+ bool m_modified;
+
+ QtAbstractPropertyManager * const m_manager;
+};
+
+class QtAbstractPropertyManagerPrivate
+{
+ QtAbstractPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtAbstractPropertyManager)
+public:
+ void propertyDestroyed(QtProperty *property);
+ void propertyChanged(QtProperty *property) const;
+ void propertyRemoved(QtProperty *property,
+ QtProperty *parentProperty) const;
+ void propertyInserted(QtProperty *property, QtProperty *parentProperty,
+ QtProperty *afterProperty) const;
+
+ QSet<QtProperty *> m_properties;
+};
+
+/*!
+ \class QtProperty
+
+ \brief The QtProperty class encapsulates an instance of a property.
+
+ Properties are created by objects of QtAbstractPropertyManager
+ subclasses; a manager can create properties of a given type, and
+ is used in conjunction with the QtAbstractPropertyBrowser class. A
+ property is always owned by the manager that created it, which can
+ be retrieved using the propertyManager() function.
+
+ QtProperty contains the most common property attributes, and
+ provides functions for retrieving as well as setting their values:
+
+ \table
+ \header \o Getter \o Setter
+ \row
+ \o propertyName() \o setPropertyName()
+ \row
+ \o statusTip() \o setStatusTip()
+ \row
+ \o toolTip() \o setToolTip()
+ \row
+ \o whatsThis() \o setWhatsThis()
+ \row
+ \o isEnabled() \o setEnabled()
+ \row
+ \o isModified() \o setModified()
+ \row
+ \o valueText() \o Nop
+ \row
+ \o valueIcon() \o Nop
+ \endtable
+
+ It is also possible to nest properties: QtProperty provides the
+ addSubProperty(), insertSubProperty() and removeSubProperty() functions to
+ manipulate the set of subproperties. Use the subProperties()
+ function to retrieve a property's current set of subproperties.
+ Note that nested properties are not owned by the parent property,
+ i.e. each subproperty is owned by the manager that created it.
+
+ \sa QtAbstractPropertyManager, QtBrowserItem
+*/
+
+/*!
+ Creates a property with the given \a manager.
+
+ This constructor is only useful when creating a custom QtProperty
+ subclass (e.g. QtVariantProperty). To create a regular QtProperty
+ object, use the QtAbstractPropertyManager::addProperty()
+ function instead.
+
+ \sa QtAbstractPropertyManager::addProperty()
+*/
+QtProperty::QtProperty(QtAbstractPropertyManager *manager)
+{
+ d_ptr = new QtPropertyPrivate(manager);
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this property.
+
+ Note that subproperties are detached but not destroyed, i.e. they
+ can still be used in another context.
+
+ \sa QtAbstractPropertyManager::clear()
+
+*/
+QtProperty::~QtProperty()
+{
+ QSetIterator<QtProperty *> itParent(d_ptr->m_parentItems);
+ while (itParent.hasNext()) {
+ QtProperty *property = itParent.next();
+ property->d_ptr->m_manager->d_ptr->propertyRemoved(this, property);
+ }
+
+ d_ptr->m_manager->d_ptr->propertyDestroyed(this);
+
+ QListIterator<QtProperty *> itChild(d_ptr->m_subItems);
+ while (itChild.hasNext()) {
+ QtProperty *property = itChild.next();
+ property->d_ptr->m_parentItems.remove(this);
+ }
+
+ itParent.toFront();
+ while (itParent.hasNext()) {
+ QtProperty *property = itParent.next();
+ property->d_ptr->m_subItems.removeAll(this);
+ }
+ delete d_ptr;
+}
+
+/*!
+ Returns the set of subproperties.
+
+ Note that subproperties are not owned by \e this property, but by
+ the manager that created them.
+
+ \sa insertSubProperty(), removeSubProperty()
+*/
+QList<QtProperty *> QtProperty::subProperties() const
+{
+ return d_ptr->m_subItems;
+}
+
+/*!
+ Returns a pointer to the manager that owns this property.
+*/
+QtAbstractPropertyManager *QtProperty::propertyManager() const
+{
+ return d_ptr->m_manager;
+}
+
+/*!
+ Returns the property's tool tip.
+
+ \sa setToolTip()
+*/
+QString QtProperty::toolTip() const
+{
+ return d_ptr->m_toolTip;
+}
+
+/*!
+ Returns the property's status tip.
+
+ \sa setStatusTip()
+*/
+QString QtProperty::statusTip() const
+{
+ return d_ptr->m_statusTip;
+}
+
+/*!
+ Returns the property's "What's This" help text.
+
+ \sa setWhatsThis()
+*/
+QString QtProperty::whatsThis() const
+{
+ return d_ptr->m_whatsThis;
+}
+
+/*!
+ Returns the property's name.
+
+ \sa setPropertyName()
+*/
+QString QtProperty::propertyName() const
+{
+ return d_ptr->m_name;
+}
+
+/*!
+ Returns whether the property is enabled.
+
+ \sa setEnabled()
+*/
+bool QtProperty::isEnabled() const
+{
+ return d_ptr->m_enabled;
+}
+
+/*!
+ Returns whether the property is modified.
+
+ \sa setModified()
+*/
+bool QtProperty::isModified() const
+{
+ return d_ptr->m_modified;
+}
+
+/*!
+ Returns whether the property has a value.
+
+ \sa QtAbstractPropertyManager::hasValue()
+*/
+bool QtProperty::hasValue() const
+{
+ return d_ptr->m_manager->hasValue(this);
+}
+
+/*!
+ Returns an icon representing the current state of this property.
+
+ If the given property type can not generate such an icon, this
+ function returns an invalid icon.
+
+ \sa QtAbstractPropertyManager::valueIcon()
+*/
+QIcon QtProperty::valueIcon() const
+{
+ return d_ptr->m_manager->valueIcon(this);
+}
+
+/*!
+ Returns a string representing the current state of this property.
+
+ If the given property type can not generate such a string, this
+ function returns an empty string.
+
+ \sa QtAbstractPropertyManager::valueText()
+*/
+QString QtProperty::valueText() const
+{
+ return d_ptr->m_manager->valueText(this);
+}
+
+/*!
+ Returns the display text according to the echo-mode set on the editor.
+
+ When the editor is a QLineEdit, this will return a string equal to what
+ is displayed.
+
+ \sa QtAbstractPropertyManager::valueText()
+*/
+QString QtProperty::displayText() const
+{
+ return d_ptr->m_manager->displayText(this);
+}
+
+/*!
+ Sets the property's tool tip to the given \a text.
+
+ \sa toolTip()
+*/
+void QtProperty::setToolTip(const QString &text)
+{
+ if (d_ptr->m_toolTip == text)
+ return;
+
+ d_ptr->m_toolTip = text;
+ propertyChanged();
+}
+
+/*!
+ Sets the property's status tip to the given \a text.
+
+ \sa statusTip()
+*/
+void QtProperty::setStatusTip(const QString &text)
+{
+ if (d_ptr->m_statusTip == text)
+ return;
+
+ d_ptr->m_statusTip = text;
+ propertyChanged();
+}
+
+/*!
+ Sets the property's "What's This" help text to the given \a text.
+
+ \sa whatsThis()
+*/
+void QtProperty::setWhatsThis(const QString &text)
+{
+ if (d_ptr->m_whatsThis == text)
+ return;
+
+ d_ptr->m_whatsThis = text;
+ propertyChanged();
+}
+
+/*!
+ \fn void QtProperty::setPropertyName(const QString &name)
+
+ Sets the property's name to the given \a name.
+
+ \sa propertyName()
+*/
+void QtProperty::setPropertyName(const QString &text)
+{
+ if (d_ptr->m_name == text)
+ return;
+
+ d_ptr->m_name = text;
+ propertyChanged();
+}
+
+/*!
+ Enables or disables the property according to the passed \a enable value.
+
+ \sa isEnabled()
+*/
+void QtProperty::setEnabled(bool enable)
+{
+ if (d_ptr->m_enabled == enable)
+ return;
+
+ d_ptr->m_enabled = enable;
+ propertyChanged();
+}
+
+/*!
+ Sets the property's modified state according to the passed \a modified value.
+
+ \sa isModified()
+*/
+void QtProperty::setModified(bool modified)
+{
+ if (d_ptr->m_modified == modified)
+ return;
+
+ d_ptr->m_modified = modified;
+ propertyChanged();
+}
+
+/*!
+ Appends the given \a property to this property's subproperties.
+
+ If the given \a property already is added, this function does
+ nothing.
+
+ \sa insertSubProperty(), removeSubProperty()
+*/
+void QtProperty::addSubProperty(QtProperty *property)
+{
+ QtProperty *after = 0;
+ if (d_ptr->m_subItems.count() > 0)
+ after = d_ptr->m_subItems.last();
+ insertSubProperty(property, after);
+}
+
+/*!
+ \fn void QtProperty::insertSubProperty(QtProperty *property, QtProperty *precedingProperty)
+
+ Inserts the given \a property after the specified \a
+ precedingProperty into this property's list of subproperties. If
+ \a precedingProperty is 0, the specified \a property is inserted
+ at the beginning of the list.
+
+ If the given \a property already is inserted, this function does
+ nothing.
+
+ \sa addSubProperty(), removeSubProperty()
+*/
+void QtProperty::insertSubProperty(QtProperty *property,
+ QtProperty *afterProperty)
+{
+ if (!property)
+ return;
+
+ if (property == this)
+ return;
+
+ // traverse all children of item. if this item is a child of item then cannot add.
+ QList<QtProperty *> pendingList = property->subProperties();
+ QMap<QtProperty *, bool> visited;
+ while (!pendingList.isEmpty()) {
+ QtProperty *i = pendingList.first();
+ if (i == this)
+ return;
+ pendingList.removeFirst();
+ if (visited.contains(i))
+ continue;
+ visited[i] = true;
+ pendingList += i->subProperties();
+ }
+
+ pendingList = subProperties();
+ int pos = 0;
+ int newPos = 0;
+ QtProperty *properAfterProperty = 0;
+ while (pos < pendingList.count()) {
+ QtProperty *i = pendingList.at(pos);
+ if (i == property)
+ return; // if item is already inserted in this item then cannot add.
+ if (i == afterProperty) {
+ newPos = pos + 1;
+ properAfterProperty = afterProperty;
+ }
+ pos++;
+ }
+
+ d_ptr->m_subItems.insert(newPos, property);
+ property->d_ptr->m_parentItems.insert(this);
+
+ d_ptr->m_manager->d_ptr->propertyInserted(property, this, properAfterProperty);
+}
+
+/*!
+ Removes the given \a property from the list of subproperties
+ without deleting it.
+
+ \sa addSubProperty(), insertSubProperty()
+*/
+void QtProperty::removeSubProperty(QtProperty *property)
+{
+ if (!property)
+ return;
+
+ d_ptr->m_manager->d_ptr->propertyRemoved(property, this);
+
+ QList<QtProperty *> pendingList = subProperties();
+ int pos = 0;
+ while (pos < pendingList.count()) {
+ if (pendingList.at(pos) == property) {
+ d_ptr->m_subItems.removeAt(pos);
+ property->d_ptr->m_parentItems.remove(this);
+
+ return;
+ }
+ pos++;
+ }
+}
+
+/*!
+ \internal
+*/
+void QtProperty::propertyChanged()
+{
+ d_ptr->m_manager->d_ptr->propertyChanged(this);
+}
+
+////////////////////////////////
+
+void QtAbstractPropertyManagerPrivate::propertyDestroyed(QtProperty *property)
+{
+ if (m_properties.contains(property)) {
+ emit q_ptr->propertyDestroyed(property);
+ q_ptr->uninitializeProperty(property);
+ m_properties.remove(property);
+ }
+}
+
+void QtAbstractPropertyManagerPrivate::propertyChanged(QtProperty *property) const
+{
+ emit q_ptr->propertyChanged(property);
+}
+
+void QtAbstractPropertyManagerPrivate::propertyRemoved(QtProperty *property,
+ QtProperty *parentProperty) const
+{
+ emit q_ptr->propertyRemoved(property, parentProperty);
+}
+
+void QtAbstractPropertyManagerPrivate::propertyInserted(QtProperty *property,
+ QtProperty *parentProperty, QtProperty *afterProperty) const
+{
+ emit q_ptr->propertyInserted(property, parentProperty, afterProperty);
+}
+
+/*!
+ \class QtAbstractPropertyManager
+
+ \brief The QtAbstractPropertyManager provides an interface for
+ property managers.
+
+ A manager can create and manage properties of a given type, and is
+ used in conjunction with the QtAbstractPropertyBrowser class.
+
+ When using a property browser widget, the properties are created
+ and managed by implementations of the QtAbstractPropertyManager
+ class. To ensure that the properties' values will be displayed
+ using suitable editing widgets, the managers are associated with
+ objects of QtAbstractEditorFactory subclasses. The property browser
+ will use these associations to determine which factories it should
+ use to create the preferred editing widgets.
+
+ The QtAbstractPropertyManager class provides common functionality
+ like creating a property using the addProperty() function, and
+ retrieving the properties created by the manager using the
+ properties() function. The class also provides signals that are
+ emitted when the manager's properties change: propertyInserted(),
+ propertyRemoved(), propertyChanged() and propertyDestroyed().
+
+ QtAbstractPropertyManager subclasses are supposed to provide their
+ own type specific API. Note that several ready-made
+ implementations are available:
+
+ \list
+ \o QtBoolPropertyManager
+ \o QtColorPropertyManager
+ \o QtDatePropertyManager
+ \o QtDateTimePropertyManager
+ \o QtDoublePropertyManager
+ \o QtEnumPropertyManager
+ \o QtFlagPropertyManager
+ \o QtFontPropertyManager
+ \o QtGroupPropertyManager
+ \o QtIntPropertyManager
+ \o QtPointPropertyManager
+ \o QtRectPropertyManager
+ \o QtSizePropertyManager
+ \o QtSizePolicyPropertyManager
+ \o QtStringPropertyManager
+ \o QtTimePropertyManager
+ \o QtVariantPropertyManager
+ \endlist
+
+ \sa QtAbstractEditorFactoryBase, QtAbstractPropertyBrowser, QtProperty
+*/
+
+/*!
+ \fn void QtAbstractPropertyManager::propertyInserted(QtProperty *newProperty,
+ QtProperty *parentProperty, QtProperty *precedingProperty)
+
+ This signal is emitted when a new subproperty is inserted into an
+ existing property, passing pointers to the \a newProperty, \a
+ parentProperty and \a precedingProperty as parameters.
+
+ If \a precedingProperty is 0, the \a newProperty was inserted at
+ the beginning of the \a parentProperty's subproperties list.
+
+ Note that signal is emitted only if the \a parentProperty is created
+ by this manager.
+
+ \sa QtAbstractPropertyBrowser::itemInserted()
+*/
+
+/*!
+ \fn void QtAbstractPropertyManager::propertyChanged(QtProperty *property)
+
+ This signal is emitted whenever a property's data changes, passing
+ a pointer to the \a property as parameter.
+
+ Note that signal is only emitted for properties that are created by
+ this manager.
+
+ \sa QtAbstractPropertyBrowser::itemChanged()
+*/
+
+/*!
+ \fn void QtAbstractPropertyManager::propertyRemoved(QtProperty *property, QtProperty *parent)
+
+ This signal is emitted when a subproperty is removed, passing
+ pointers to the removed \a property and the \a parent property as
+ parameters.
+
+ Note that signal is emitted only when the \a parent property is
+ created by this manager.
+
+ \sa QtAbstractPropertyBrowser::itemRemoved()
+*/
+
+/*!
+ \fn void QtAbstractPropertyManager::propertyDestroyed(QtProperty *property)
+
+ This signal is emitted when the specified \a property is about to
+ be destroyed.
+
+ Note that signal is only emitted for properties that are created
+ by this manager.
+
+ \sa clear(), uninitializeProperty()
+*/
+
+/*!
+ \fn void QtAbstractPropertyBrowser::currentItemChanged(QtBrowserItem *current)
+
+ This signal is emitted when the current item changes. The current item is specified by \a current.
+
+ \sa QtAbstractPropertyBrowser::setCurrentItem()
+*/
+
+/*!
+ Creates an abstract property manager with the given \a parent.
+*/
+QtAbstractPropertyManager::QtAbstractPropertyManager(QObject *parent)
+ : QObject(parent)
+{
+ d_ptr = new QtAbstractPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys the manager. All properties created by the manager are
+ destroyed.
+*/
+QtAbstractPropertyManager::~QtAbstractPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Destroys all the properties that this manager has created.
+
+ \sa propertyDestroyed(), uninitializeProperty()
+*/
+void QtAbstractPropertyManager::clear() const
+{
+ while (!properties().isEmpty()) {
+ QSetIterator<QtProperty *> itProperty(properties());
+ QtProperty *prop = itProperty.next();
+ delete prop;
+ }
+}
+
+/*!
+ Returns the set of properties created by this manager.
+
+ \sa addProperty()
+*/
+QSet<QtProperty *> QtAbstractPropertyManager::properties() const
+{
+ return d_ptr->m_properties;
+}
+
+/*!
+ Returns whether the given \a property has a value.
+
+ The default implementation of this function returns true.
+
+ \sa QtProperty::hasValue()
+*/
+bool QtAbstractPropertyManager::hasValue(const QtProperty *property) const
+{
+ Q_UNUSED(property)
+ return true;
+}
+
+/*!
+ Returns an icon representing the current state of the given \a
+ property.
+
+ The default implementation of this function returns an invalid
+ icon.
+
+ \sa QtProperty::valueIcon()
+*/
+QIcon QtAbstractPropertyManager::valueIcon(const QtProperty *property) const
+{
+ Q_UNUSED(property)
+ return QIcon();
+}
+
+/*!
+ Returns a string representing the current state of the given \a
+ property.
+
+ The default implementation of this function returns an empty
+ string.
+
+ \sa QtProperty::valueText()
+*/
+QString QtAbstractPropertyManager::valueText(const QtProperty *property) const
+{
+ Q_UNUSED(property)
+ return QString();
+}
+
+/*!
+ Returns a string representing the current state of the given \a
+ property.
+
+ The default implementation of this function returns an empty
+ string.
+
+ \sa QtProperty::valueText()
+*/
+QString QtAbstractPropertyManager::displayText(const QtProperty *property) const
+{
+ Q_UNUSED(property)
+ return QString();
+}
+
+/*!
+ Returns the echo mode representing the current state of the given \a
+ property.
+
+ The default implementation of this function returns QLineEdit::Normal.
+
+ \sa QtProperty::valueText()
+*/
+EchoMode QtAbstractPropertyManager::echoMode(const QtProperty *property) const
+{
+ Q_UNUSED(property)
+ return QLineEdit::Normal;
+}
+
+/*!
+ Creates a property with the given \a name which then is owned by this manager.
+
+ Internally, this function calls the createProperty() and
+ initializeProperty() functions.
+
+ \sa initializeProperty(), properties()
+*/
+QtProperty *QtAbstractPropertyManager::addProperty(const QString &name)
+{
+ QtProperty *property = createProperty();
+ if (property) {
+ property->setPropertyName(name);
+ d_ptr->m_properties.insert(property);
+ initializeProperty(property);
+ }
+ return property;
+}
+
+/*!
+ Creates a property.
+
+ The base implementation produce QtProperty instances; Reimplement
+ this function to make this manager produce objects of a QtProperty
+ subclass.
+
+ \sa addProperty(), initializeProperty()
+*/
+QtProperty *QtAbstractPropertyManager::createProperty()
+{
+ return new QtProperty(this);
+}
+
+/*!
+ \fn void QtAbstractPropertyManager::initializeProperty(QtProperty *property) = 0
+
+ This function is called whenever a new valid property pointer has
+ been created, passing the pointer as parameter.
+
+ The purpose is to let the manager know that the \a property has
+ been created so that it can provide additional attributes for the
+ new property, e.g. QtIntPropertyManager adds \l
+ {QtIntPropertyManager::value()}{value}, \l
+ {QtIntPropertyManager::minimum()}{minimum} and \l
+ {QtIntPropertyManager::maximum()}{maximum} attributes. Since each manager
+ subclass adds type specific attributes, this function is pure
+ virtual and must be reimplemented when deriving from the
+ QtAbstractPropertyManager class.
+
+ \sa addProperty(), createProperty()
+*/
+
+/*!
+ This function is called just before the specified \a property is destroyed.
+
+ The purpose is to let the property manager know that the \a
+ property is being destroyed so that it can remove the property's
+ additional attributes.
+
+ \sa clear(), propertyDestroyed()
+*/
+void QtAbstractPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ Q_UNUSED(property)
+}
+
+////////////////////////////////////
+
+/*!
+ \class QtAbstractEditorFactoryBase
+
+ \brief The QtAbstractEditorFactoryBase provides an interface for
+ editor factories.
+
+ An editor factory is a class that is able to create an editing
+ widget of a specified type (e.g. line edits or comboboxes) for a
+ given QtProperty object, and it is used in conjunction with the
+ QtAbstractPropertyManager and QtAbstractPropertyBrowser classes.
+
+ When using a property browser widget, the properties are created
+ and managed by implementations of the QtAbstractPropertyManager
+ class. To ensure that the properties' values will be displayed
+ using suitable editing widgets, the managers are associated with
+ objects of QtAbstractEditorFactory subclasses. The property browser
+ will use these associations to determine which factories it should
+ use to create the preferred editing widgets.
+
+ Typically, an editor factory is created by subclassing the
+ QtAbstractEditorFactory template class which inherits
+ QtAbstractEditorFactoryBase. But note that several ready-made
+ implementations are available:
+
+ \list
+ \o QtCheckBoxFactory
+ \o QtDateEditFactory
+ \o QtDateTimeEditFactory
+ \o QtDoubleSpinBoxFactory
+ \o QtEnumEditorFactory
+ \o QtLineEditFactory
+ \o QtScrollBarFactory
+ \o QtSliderFactory
+ \o QtSpinBoxFactory
+ \o QtTimeEditFactory
+ \o QtVariantEditorFactory
+ \endlist
+
+ \sa QtAbstractPropertyManager, QtAbstractPropertyBrowser
+*/
+
+/*!
+ \fn virtual QWidget *QtAbstractEditorFactoryBase::createEditor(QtProperty *property,
+ QWidget *parent) = 0
+
+ Creates an editing widget (with the given \a parent) for the given
+ \a property.
+
+ This function is reimplemented in QtAbstractEditorFactory template class
+ which also provides a pure virtual convenience overload of this
+ function enabling access to the property's manager.
+
+ \sa QtAbstractEditorFactory::createEditor()
+*/
+
+/*!
+ \fn QtAbstractEditorFactoryBase::QtAbstractEditorFactoryBase(QObject *parent = 0)
+
+ Creates an abstract editor factory with the given \a parent.
+*/
+
+/*!
+ \fn virtual void QtAbstractEditorFactoryBase::breakConnection(QtAbstractPropertyManager *manager) = 0
+
+ \internal
+
+ Detaches property manager from factory.
+ This method is reimplemented in QtAbstractEditorFactory template subclass.
+ You don't need to reimplement it in your subclasses. Instead implement more convenient
+ QtAbstractEditorFactory::disconnectPropertyManager() which gives you access to particular manager subclass.
+*/
+
+/*!
+ \fn virtual void QtAbstractEditorFactoryBase::managerDestroyed(QObject *manager) = 0
+
+ \internal
+
+ This method is called when property manager is being destroyed.
+ Basically it notifies factory not to produce editors for properties owned by \a manager.
+ You don't need to reimplement it in your subclass. This method is implemented in
+ QtAbstractEditorFactory template subclass.
+*/
+
+/*!
+ \class QtAbstractEditorFactory
+
+ \brief The QtAbstractEditorFactory is the base template class for editor
+ factories.
+
+ An editor factory is a class that is able to create an editing
+ widget of a specified type (e.g. line edits or comboboxes) for a
+ given QtProperty object, and it is used in conjunction with the
+ QtAbstractPropertyManager and QtAbstractPropertyBrowser classes.
+
+ Note that the QtAbstractEditorFactory functions are using the
+ PropertyManager template argument class which can be any
+ QtAbstractPropertyManager subclass. For example:
+
+ \code
+ QtSpinBoxFactory *factory;
+ QSet<QtIntPropertyManager *> managers = factory->propertyManagers();
+ \endcode
+
+ Note that QtSpinBoxFactory by definition creates editing widgets
+ \e only for properties created by QtIntPropertyManager.
+
+ When using a property browser widget, the properties are created
+ and managed by implementations of the QtAbstractPropertyManager
+ class. To ensure that the properties' values will be displayed
+ using suitable editing widgets, the managers are associated with
+ objects of QtAbstractEditorFactory subclasses. The property browser will
+ use these associations to determine which factories it should use
+ to create the preferred editing widgets.
+
+ A QtAbstractEditorFactory object is capable of producing editors for
+ several property managers at the same time. To create an
+ association between this factory and a given manager, use the
+ addPropertyManager() function. Use the removePropertyManager() function to make
+ this factory stop producing editors for a given property
+ manager. Use the propertyManagers() function to retrieve the set of
+ managers currently associated with this factory.
+
+ Several ready-made implementations of the QtAbstractEditorFactory class
+ are available:
+
+ \list
+ \o QtCheckBoxFactory
+ \o QtDateEditFactory
+ \o QtDateTimeEditFactory
+ \o QtDoubleSpinBoxFactory
+ \o QtEnumEditorFactory
+ \o QtLineEditFactory
+ \o QtScrollBarFactory
+ \o QtSliderFactory
+ \o QtSpinBoxFactory
+ \o QtTimeEditFactory
+ \o QtVariantEditorFactory
+ \endlist
+
+ When deriving from the QtAbstractEditorFactory class, several pure virtual
+ functions must be implemented: the connectPropertyManager() function is
+ used by the factory to connect to the given manager's signals, the
+ createEditor() function is supposed to create an editor for the
+ given property controlled by the given manager, and finally the
+ disconnectPropertyManager() function is used by the factory to disconnect
+ from the specified manager's signals.
+
+ \sa QtAbstractEditorFactoryBase, QtAbstractPropertyManager
+*/
+
+/*!
+ \fn QtAbstractEditorFactory::QtAbstractEditorFactory(QObject *parent = 0)
+
+ Creates an editor factory with the given \a parent.
+
+ \sa addPropertyManager()
+*/
+
+/*!
+ \fn QWidget *QtAbstractEditorFactory::createEditor(QtProperty *property, QWidget *parent)
+
+ Creates an editing widget (with the given \a parent) for the given
+ \a property.
+*/
+
+/*!
+ \fn void QtAbstractEditorFactory::addPropertyManager(PropertyManager *manager)
+
+ Adds the given \a manager to this factory's set of managers,
+ making this factory produce editing widgets for properties created
+ by the given manager.
+
+ The PropertyManager type is a template argument class, and represents the chosen
+ QtAbstractPropertyManager subclass.
+
+ \sa propertyManagers(), removePropertyManager()
+*/
+
+/*!
+ \fn void QtAbstractEditorFactory::removePropertyManager(PropertyManager *manager)
+
+ Removes the given \a manager from this factory's set of
+ managers. The PropertyManager type is a template argument class, and may be
+ any QtAbstractPropertyManager subclass.
+
+ \sa propertyManagers(), addPropertyManager()
+*/
+
+/*!
+ \fn virtual void QtAbstractEditorFactory::connectPropertyManager(PropertyManager *manager) = 0
+
+ Connects this factory to the given \a manager's signals. The
+ PropertyManager type is a template argument class, and represents
+ the chosen QtAbstractPropertyManager subclass.
+
+ This function is used internally by the addPropertyManager() function, and
+ makes it possible to update an editing widget when the associated
+ property's data changes. This is typically done in custom slots
+ responding to the signals emitted by the property's manager,
+ e.g. QtIntPropertyManager::valueChanged() and
+ QtIntPropertyManager::rangeChanged().
+
+ \sa propertyManagers(), disconnectPropertyManager()
+*/
+
+/*!
+ \fn virtual QWidget *QtAbstractEditorFactory::createEditor(PropertyManager *manager, QtProperty *property,
+ QWidget *parent) = 0
+
+ Creates an editing widget with the given \a parent for the
+ specified \a property created by the given \a manager. The
+ PropertyManager type is a template argument class, and represents
+ the chosen QtAbstractPropertyManager subclass.
+
+ This function must be implemented in derived classes: It is
+ recommended to store a pointer to the widget and map it to the
+ given \a property, since the widget must be updated whenever the
+ associated property's data changes. This is typically done in
+ custom slots responding to the signals emitted by the property's
+ manager, e.g. QtIntPropertyManager::valueChanged() and
+ QtIntPropertyManager::rangeChanged().
+
+ \sa connectPropertyManager()
+*/
+
+/*!
+ \fn virtual void QtAbstractEditorFactory::disconnectPropertyManager(PropertyManager *manager) = 0
+
+ Disconnects this factory from the given \a manager's signals. The
+ PropertyManager type is a template argument class, and represents
+ the chosen QtAbstractPropertyManager subclass.
+
+ This function is used internally by the removePropertyManager() function.
+
+ \sa propertyManagers(), connectPropertyManager()
+*/
+
+/*!
+ \fn QSet<PropertyManager *> QtAbstractEditorFactory::propertyManagers() const
+
+ Returns the factory's set of associated managers. The
+ PropertyManager type is a template argument class, and represents
+ the chosen QtAbstractPropertyManager subclass.
+
+ \sa addPropertyManager(), removePropertyManager()
+*/
+
+/*!
+ \fn PropertyManager *QtAbstractEditorFactory::propertyManager(QtProperty *property) const
+
+ Returns the property manager for the given \a property, or 0 if
+ the given \a property doesn't belong to any of this factory's
+ registered managers.
+
+ The PropertyManager type is a template argument class, and represents the chosen
+ QtAbstractPropertyManager subclass.
+
+ \sa propertyManagers()
+*/
+
+/*!
+ \fn virtual void QtAbstractEditorFactory::managerDestroyed(QObject *manager)
+
+ \internal
+ \reimp
+*/
+
+////////////////////////////////////
+class QtBrowserItemPrivate
+{
+public:
+ QtBrowserItemPrivate(QtAbstractPropertyBrowser *browser, QtProperty *property, QtBrowserItem *parent)
+ : m_browser(browser), m_property(property), m_parent(parent), q_ptr(0) {}
+
+ void addChild(QtBrowserItem *index, QtBrowserItem *after);
+ void removeChild(QtBrowserItem *index);
+
+ QtAbstractPropertyBrowser * const m_browser;
+ QtProperty *m_property;
+ QtBrowserItem *m_parent;
+
+ QtBrowserItem *q_ptr;
+
+ QList<QtBrowserItem *> m_children;
+
+};
+
+void QtBrowserItemPrivate::addChild(QtBrowserItem *index, QtBrowserItem *after)
+{
+ if (m_children.contains(index))
+ return;
+ int idx = m_children.indexOf(after) + 1; // we insert after returned idx, if it was -1 then we set idx to 0;
+ m_children.insert(idx, index);
+}
+
+void QtBrowserItemPrivate::removeChild(QtBrowserItem *index)
+{
+ m_children.removeAll(index);
+}
+
+
+/*!
+ \class QtBrowserItem
+
+ \brief The QtBrowserItem class represents a property in
+ a property browser instance.
+
+ Browser items are created whenever a QtProperty is inserted to the
+ property browser. A QtBrowserItem uniquely identifies a
+ browser's item. Thus, if the same QtProperty is inserted multiple
+ times, each occurrence gets its own unique QtBrowserItem. The
+ items are owned by QtAbstractPropertyBrowser and automatically
+ deleted when they are removed from the browser.
+
+ You can traverse a browser's properties by calling parent() and
+ children(). The property and the browser associated with an item
+ are available as property() and browser().
+
+ \sa QtAbstractPropertyBrowser, QtProperty
+*/
+
+/*!
+ Returns the property which is accosiated with this item. Note that
+ several items can be associated with the same property instance in
+ the same property browser.
+
+ \sa QtAbstractPropertyBrowser::items()
+*/
+
+QtProperty *QtBrowserItem::property() const
+{
+ return d_ptr->m_property;
+}
+
+/*!
+ Returns the parent item of \e this item. Returns 0 if \e this item
+ is associated with top-level property in item's property browser.
+
+ \sa children()
+*/
+
+QtBrowserItem *QtBrowserItem::parent() const
+{
+ return d_ptr->m_parent;
+}
+
+/*!
+ Returns the children items of \e this item. The properties
+ reproduced from children items are always the same as
+ reproduced from associated property' children, for example:
+
+ \code
+ QtBrowserItem *item;
+ QList<QtBrowserItem *> childrenItems = item->children();
+
+ QList<QtProperty *> childrenProperties = item->property()->subProperties();
+ \endcode
+
+ The \e childrenItems list represents the same list as \e childrenProperties.
+*/
+
+QList<QtBrowserItem *> QtBrowserItem::children() const
+{
+ return d_ptr->m_children;
+}
+
+/*!
+ Returns the property browser which owns \e this item.
+*/
+
+QtAbstractPropertyBrowser *QtBrowserItem::browser() const
+{
+ return d_ptr->m_browser;
+}
+
+QtBrowserItem::QtBrowserItem(QtAbstractPropertyBrowser *browser, QtProperty *property, QtBrowserItem *parent)
+{
+ d_ptr = new QtBrowserItemPrivate(browser, property, parent);
+ d_ptr->q_ptr = this;
+}
+
+QtBrowserItem::~QtBrowserItem()
+{
+ delete d_ptr;
+}
+
+
+////////////////////////////////////
+
+typedef QMap<QtAbstractPropertyBrowser *, QMap<QtAbstractPropertyManager *,
+ QtAbstractEditorFactoryBase *> > Map1;
+typedef QMap<QtAbstractPropertyManager *, QMap<QtAbstractEditorFactoryBase *,
+ QList<QtAbstractPropertyBrowser *> > > Map2;
+Q_GLOBAL_STATIC(Map1, m_viewToManagerToFactory)
+Q_GLOBAL_STATIC(Map2, m_managerToFactoryToViews)
+
+class QtAbstractPropertyBrowserPrivate
+{
+ QtAbstractPropertyBrowser *q_ptr;
+ Q_DECLARE_PUBLIC(QtAbstractPropertyBrowser)
+public:
+ QtAbstractPropertyBrowserPrivate();
+
+ void insertSubTree(QtProperty *property,
+ QtProperty *parentProperty);
+ void removeSubTree(QtProperty *property,
+ QtProperty *parentProperty);
+ void createBrowserIndexes(QtProperty *property, QtProperty *parentProperty, QtProperty *afterProperty);
+ void removeBrowserIndexes(QtProperty *property, QtProperty *parentProperty);
+ QtBrowserItem *createBrowserIndex(QtProperty *property, QtBrowserItem *parentIndex, QtBrowserItem *afterIndex);
+ void removeBrowserIndex(QtBrowserItem *index);
+ void clearIndex(QtBrowserItem *index);
+
+ void slotPropertyInserted(QtProperty *property,
+ QtProperty *parentProperty, QtProperty *afterProperty);
+ void slotPropertyRemoved(QtProperty *property, QtProperty *parentProperty);
+ void slotPropertyDestroyed(QtProperty *property);
+ void slotPropertyDataChanged(QtProperty *property);
+
+ QList<QtProperty *> m_subItems;
+ QMap<QtAbstractPropertyManager *, QList<QtProperty *> > m_managerToProperties;
+ QMap<QtProperty *, QList<QtProperty *> > m_propertyToParents;
+
+ QMap<QtProperty *, QtBrowserItem *> m_topLevelPropertyToIndex;
+ QList<QtBrowserItem *> m_topLevelIndexes;
+ QMap<QtProperty *, QList<QtBrowserItem *> > m_propertyToIndexes;
+
+ QtBrowserItem *m_currentItem;
+};
+
+QtAbstractPropertyBrowserPrivate::QtAbstractPropertyBrowserPrivate() :
+ m_currentItem(0)
+{
+}
+
+void QtAbstractPropertyBrowserPrivate::insertSubTree(QtProperty *property,
+ QtProperty *parentProperty)
+{
+ if (m_propertyToParents.contains(property)) {
+ // property was already inserted, so its manager is connected
+ // and all its children are inserted and theirs managers are connected
+ // we just register new parent (parent has to be new).
+ m_propertyToParents[property].append(parentProperty);
+ // don't need to update m_managerToProperties map since
+ // m_managerToProperties[manager] already contains property.
+ return;
+ }
+ QtAbstractPropertyManager *manager = property->propertyManager();
+ if (m_managerToProperties[manager].isEmpty()) {
+ // connect manager's signals
+ q_ptr->connect(manager, SIGNAL(propertyInserted(QtProperty *,
+ QtProperty *, QtProperty *)),
+ q_ptr, SLOT(slotPropertyInserted(QtProperty *,
+ QtProperty *, QtProperty *)));
+ q_ptr->connect(manager, SIGNAL(propertyRemoved(QtProperty *,
+ QtProperty *)),
+ q_ptr, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ q_ptr->connect(manager, SIGNAL(propertyDestroyed(QtProperty *)),
+ q_ptr, SLOT(slotPropertyDestroyed(QtProperty *)));
+ q_ptr->connect(manager, SIGNAL(propertyChanged(QtProperty *)),
+ q_ptr, SLOT(slotPropertyDataChanged(QtProperty *)));
+ }
+ m_managerToProperties[manager].append(property);
+ m_propertyToParents[property].append(parentProperty);
+
+ QList<QtProperty *> subList = property->subProperties();
+ QListIterator<QtProperty *> itSub(subList);
+ while (itSub.hasNext()) {
+ QtProperty *subProperty = itSub.next();
+ insertSubTree(subProperty, property);
+ }
+}
+
+void QtAbstractPropertyBrowserPrivate::removeSubTree(QtProperty *property,
+ QtProperty *parentProperty)
+{
+ if (!m_propertyToParents.contains(property)) {
+ // ASSERT
+ return;
+ }
+
+ m_propertyToParents[property].removeAll(parentProperty);
+ if (!m_propertyToParents[property].isEmpty())
+ return;
+
+ m_propertyToParents.remove(property);
+ QtAbstractPropertyManager *manager = property->propertyManager();
+ m_managerToProperties[manager].removeAll(property);
+ if (m_managerToProperties[manager].isEmpty()) {
+ // disconnect manager's signals
+ q_ptr->disconnect(manager, SIGNAL(propertyInserted(QtProperty *,
+ QtProperty *, QtProperty *)),
+ q_ptr, SLOT(slotPropertyInserted(QtProperty *,
+ QtProperty *, QtProperty *)));
+ q_ptr->disconnect(manager, SIGNAL(propertyRemoved(QtProperty *,
+ QtProperty *)),
+ q_ptr, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ q_ptr->disconnect(manager, SIGNAL(propertyDestroyed(QtProperty *)),
+ q_ptr, SLOT(slotPropertyDestroyed(QtProperty *)));
+ q_ptr->disconnect(manager, SIGNAL(propertyChanged(QtProperty *)),
+ q_ptr, SLOT(slotPropertyDataChanged(QtProperty *)));
+
+ m_managerToProperties.remove(manager);
+ }
+
+ QList<QtProperty *> subList = property->subProperties();
+ QListIterator<QtProperty *> itSub(subList);
+ while (itSub.hasNext()) {
+ QtProperty *subProperty = itSub.next();
+ removeSubTree(subProperty, property);
+ }
+}
+
+void QtAbstractPropertyBrowserPrivate::createBrowserIndexes(QtProperty *property, QtProperty *parentProperty, QtProperty *afterProperty)
+{
+ QMap<QtBrowserItem *, QtBrowserItem *> parentToAfter;
+ if (afterProperty) {
+ QMap<QtProperty *, QList<QtBrowserItem *> >::ConstIterator it =
+ m_propertyToIndexes.find(afterProperty);
+ if (it == m_propertyToIndexes.constEnd())
+ return;
+
+ QList<QtBrowserItem *> indexes = it.value();
+ QListIterator<QtBrowserItem *> itIndex(indexes);
+ while (itIndex.hasNext()) {
+ QtBrowserItem *idx = itIndex.next();
+ QtBrowserItem *parentIdx = idx->parent();
+ if ((parentProperty && parentIdx && parentIdx->property() == parentProperty) || (!parentProperty && !parentIdx))
+ parentToAfter[idx->parent()] = idx;
+ }
+ } else if (parentProperty) {
+ QMap<QtProperty *, QList<QtBrowserItem *> >::ConstIterator it =
+ m_propertyToIndexes.find(parentProperty);
+ if (it == m_propertyToIndexes.constEnd())
+ return;
+
+ QList<QtBrowserItem *> indexes = it.value();
+ QListIterator<QtBrowserItem *> itIndex(indexes);
+ while (itIndex.hasNext()) {
+ QtBrowserItem *idx = itIndex.next();
+ parentToAfter[idx] = 0;
+ }
+ } else {
+ parentToAfter[0] = 0;
+ }
+
+ const QMap<QtBrowserItem *, QtBrowserItem *>::ConstIterator pcend = parentToAfter.constEnd();
+ for (QMap<QtBrowserItem *, QtBrowserItem *>::ConstIterator it = parentToAfter.constBegin(); it != pcend; ++it)
+ createBrowserIndex(property, it.key(), it.value());
+}
+
+QtBrowserItem *QtAbstractPropertyBrowserPrivate::createBrowserIndex(QtProperty *property,
+ QtBrowserItem *parentIndex, QtBrowserItem *afterIndex)
+{
+ QtBrowserItem *newIndex = new QtBrowserItem(q_ptr, property, parentIndex);
+ if (parentIndex) {
+ parentIndex->d_ptr->addChild(newIndex, afterIndex);
+ } else {
+ m_topLevelPropertyToIndex[property] = newIndex;
+ m_topLevelIndexes.insert(m_topLevelIndexes.indexOf(afterIndex) + 1, newIndex);
+ }
+ m_propertyToIndexes[property].append(newIndex);
+
+ q_ptr->itemInserted(newIndex, afterIndex);
+
+ QList<QtProperty *> subItems = property->subProperties();
+ QListIterator<QtProperty *> itChild(subItems);
+ QtBrowserItem *afterChild = 0;
+ while (itChild.hasNext()) {
+ QtProperty *child = itChild.next();
+ afterChild = createBrowserIndex(child, newIndex, afterChild);
+ }
+ return newIndex;
+}
+
+void QtAbstractPropertyBrowserPrivate::removeBrowserIndexes(QtProperty *property, QtProperty *parentProperty)
+{
+ QList<QtBrowserItem *> toRemove;
+ QMap<QtProperty *, QList<QtBrowserItem *> >::ConstIterator it =
+ m_propertyToIndexes.find(property);
+ if (it == m_propertyToIndexes.constEnd())
+ return;
+
+ QList<QtBrowserItem *> indexes = it.value();
+ QListIterator<QtBrowserItem *> itIndex(indexes);
+ while (itIndex.hasNext()) {
+ QtBrowserItem *idx = itIndex.next();
+ QtBrowserItem *parentIdx = idx->parent();
+ if ((parentProperty && parentIdx && parentIdx->property() == parentProperty) || (!parentProperty && !parentIdx))
+ toRemove.append(idx);
+ }
+
+ QListIterator<QtBrowserItem *> itRemove(toRemove);
+ while (itRemove.hasNext()) {
+ QtBrowserItem *index = itRemove.next();
+ removeBrowserIndex(index);
+ }
+}
+
+void QtAbstractPropertyBrowserPrivate::removeBrowserIndex(QtBrowserItem *index)
+{
+ QList<QtBrowserItem *> children = index->children();
+ for (int i = children.count(); i > 0; i--) {
+ removeBrowserIndex(children.at(i - 1));
+ }
+
+ q_ptr->itemRemoved(index);
+
+ if (index->parent()) {
+ index->parent()->d_ptr->removeChild(index);
+ } else {
+ m_topLevelPropertyToIndex.remove(index->property());
+ m_topLevelIndexes.removeAll(index);
+ }
+
+ QtProperty *property = index->property();
+
+ m_propertyToIndexes[property].removeAll(index);
+ if (m_propertyToIndexes[property].isEmpty())
+ m_propertyToIndexes.remove(property);
+
+ delete index;
+}
+
+void QtAbstractPropertyBrowserPrivate::clearIndex(QtBrowserItem *index)
+{
+ QList<QtBrowserItem *> children = index->children();
+ QListIterator<QtBrowserItem *> itChild(children);
+ while (itChild.hasNext()) {
+ clearIndex(itChild.next());
+ }
+ delete index;
+}
+
+void QtAbstractPropertyBrowserPrivate::slotPropertyInserted(QtProperty *property,
+ QtProperty *parentProperty, QtProperty *afterProperty)
+{
+ if (!m_propertyToParents.contains(parentProperty))
+ return;
+ createBrowserIndexes(property, parentProperty, afterProperty);
+ insertSubTree(property, parentProperty);
+ //q_ptr->propertyInserted(property, parentProperty, afterProperty);
+}
+
+void QtAbstractPropertyBrowserPrivate::slotPropertyRemoved(QtProperty *property,
+ QtProperty *parentProperty)
+{
+ if (!m_propertyToParents.contains(parentProperty))
+ return;
+ removeSubTree(property, parentProperty); // this line should be probably moved down after propertyRemoved call
+ //q_ptr->propertyRemoved(property, parentProperty);
+ removeBrowserIndexes(property, parentProperty);
+}
+
+void QtAbstractPropertyBrowserPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (!m_subItems.contains(property))
+ return;
+ q_ptr->removeProperty(property);
+}
+
+void QtAbstractPropertyBrowserPrivate::slotPropertyDataChanged(QtProperty *property)
+{
+ if (!m_propertyToParents.contains(property))
+ return;
+
+ QMap<QtProperty *, QList<QtBrowserItem *> >::ConstIterator it =
+ m_propertyToIndexes.find(property);
+ if (it == m_propertyToIndexes.constEnd())
+ return;
+
+ QList<QtBrowserItem *> indexes = it.value();
+ QListIterator<QtBrowserItem *> itIndex(indexes);
+ while (itIndex.hasNext()) {
+ QtBrowserItem *idx = itIndex.next();
+ q_ptr->itemChanged(idx);
+ }
+ //q_ptr->propertyChanged(property);
+}
+
+/*!
+ \class QtAbstractPropertyBrowser
+
+ \brief QtAbstractPropertyBrowser provides a base class for
+ implementing property browsers.
+
+ A property browser is a widget that enables the user to edit a
+ given set of properties. Each property is represented by a label
+ specifying the property's name, and an editing widget (e.g. a line
+ edit or a combobox) holding its value. A property can have zero or
+ more subproperties.
+
+ \image qtpropertybrowser.png
+
+ The top level properties can be retrieved using the
+ properties() function. To traverse each property's
+ subproperties, use the QtProperty::subProperties() function. In
+ addition, the set of top level properties can be manipulated using
+ the addProperty(), insertProperty() and removeProperty()
+ functions. Note that the QtProperty class provides a corresponding
+ set of functions making it possible to manipulate the set of
+ subproperties as well.
+
+ To remove all the properties from the property browser widget, use
+ the clear() function. This function will clear the editor, but it
+ will not delete the properties since they can still be used in
+ other editors.
+
+ The properties themselves are created and managed by
+ implementations of the QtAbstractPropertyManager class. A manager
+ can handle (i.e. create and manage) properties of a given type. In
+ the property browser the managers are associated with
+ implementations of the QtAbstractEditorFactory: A factory is a
+ class able to create an editing widget of a specified type.
+
+ When using a property browser widget, managers must be created for
+ each of the required property types before the properties
+ themselves can be created. To ensure that the properties' values
+ will be displayed using suitable editing widgets, the managers
+ must be associated with objects of the preferred factory
+ implementations using the setFactoryForManager() function. The
+ property browser will use these associations to determine which
+ factory it should use to create the preferred editing widget.
+
+ Note that a factory can be associated with many managers, but a
+ manager can only be associated with one single factory within the
+ context of a single property browser. The associations between
+ managers and factories can at any time be removed using the
+ unsetFactoryForManager() function.
+
+ Whenever the property data changes or a property is inserted or
+ removed, the itemChanged(), itemInserted() or
+ itemRemoved() functions are called, respectively. These
+ functions must be reimplemented in derived classes in order to
+ update the property browser widget. Be aware that some property
+ instances can appear several times in an abstract tree
+ structure. For example:
+
+ \table 100%
+ \row
+ \o
+ \code
+ QtProperty *property1, *property2, *property3;
+
+ property2->addSubProperty(property1);
+ property3->addSubProperty(property2);
+
+ QtAbstractPropertyBrowser *editor;
+
+ editor->addProperty(property1);
+ editor->addProperty(property2);
+ editor->addProperty(property3);
+ \endcode
+ \o \image qtpropertybrowser-duplicate.png
+ \endtable
+
+ The addProperty() function returns a QtBrowserItem that uniquely
+ identifies the created item.
+
+ To make a property editable in the property browser, the
+ createEditor() function must be called to provide the
+ property with a suitable editing widget.
+
+ Note that there are two ready-made property browser
+ implementations:
+
+ \list
+ \o QtGroupBoxPropertyBrowser
+ \o QtTreePropertyBrowser
+ \endlist
+
+ \sa QtAbstractPropertyManager, QtAbstractEditorFactoryBase
+*/
+
+/*!
+ \fn void QtAbstractPropertyBrowser::setFactoryForManager(PropertyManager *manager,
+ QtAbstractEditorFactory<PropertyManager> *factory)
+
+ Connects the given \a manager to the given \a factory, ensuring
+ that properties of the \a manager's type will be displayed with an
+ editing widget suitable for their value.
+
+ For example:
+
+ \code
+ QtIntPropertyManager *intManager;
+ QtDoublePropertyManager *doubleManager;
+
+ QtProperty *myInteger = intManager->addProperty();
+ QtProperty *myDouble = doubleManager->addProperty();
+
+ QtSpinBoxFactory *spinBoxFactory;
+ QtDoubleSpinBoxFactory *doubleSpinBoxFactory;
+
+ QtAbstractPropertyBrowser *editor;
+ editor->setFactoryForManager(intManager, spinBoxFactory);
+ editor->setFactoryForManager(doubleManager, doubleSpinBoxFactory);
+
+ editor->addProperty(myInteger);
+ editor->addProperty(myDouble);
+ \endcode
+
+ In this example the \c myInteger property's value is displayed
+ with a QSpinBox widget, while the \c myDouble property's value is
+ displayed with a QDoubleSpinBox widget.
+
+ Note that a factory can be associated with many managers, but a
+ manager can only be associated with one single factory. If the
+ given \a manager already is associated with another factory, the
+ old association is broken before the new one established.
+
+ This function ensures that the given \a manager and the given \a
+ factory are compatible, and it automatically calls the
+ QtAbstractEditorFactory::addPropertyManager() function if necessary.
+
+ \sa unsetFactoryForManager()
+*/
+
+/*!
+ \fn virtual void QtAbstractPropertyBrowser::itemInserted(QtBrowserItem *insertedItem,
+ QtBrowserItem *precedingItem) = 0
+
+ This function is called to update the widget whenever a property
+ is inserted or added to the property browser, passing pointers to
+ the \a insertedItem of property and the specified
+ \a precedingItem as parameters.
+
+ If \a precedingItem is 0, the \a insertedItem was put at
+ the beginning of its parent item's list of subproperties. If
+ the parent of \a insertedItem is 0, the \a insertedItem was added as a top
+ level property of \e this property browser.
+
+ This function must be reimplemented in derived classes. Note that
+ if the \a insertedItem's property has subproperties, this
+ method will be called for those properties as soon as the current call is finished.
+
+ \sa insertProperty(), addProperty()
+*/
+
+/*!
+ \fn virtual void QtAbstractPropertyBrowser::itemRemoved(QtBrowserItem *item) = 0
+
+ This function is called to update the widget whenever a property
+ is removed from the property browser, passing the pointer to the
+ \a item of the property as parameters. The passed \a item is
+ deleted just after this call is finished.
+
+ If the the parent of \a item is 0, the removed \a item was a
+ top level property in this editor.
+
+ This function must be reimplemented in derived classes. Note that
+ if the removed \a item's property has subproperties, this
+ method will be called for those properties just before the current call is started.
+
+ \sa removeProperty()
+*/
+
+/*!
+ \fn virtual void QtAbstractPropertyBrowser::itemChanged(QtBrowserItem *item) = 0
+
+ This function is called whenever a property's data changes,
+ passing a pointer to the \a item of property as parameter.
+
+ This function must be reimplemented in derived classes in order to
+ update the property browser widget whenever a property's name,
+ tool tip, status tip, "what's this" text, value text or value icon
+ changes.
+
+ Note that if the property browser contains several occurrences of
+ the same property, this method will be called once for each
+ occurrence (with a different item each time).
+
+ \sa QtProperty, items()
+*/
+
+/*!
+ Creates an abstract property browser with the given \a parent.
+*/
+QtAbstractPropertyBrowser::QtAbstractPropertyBrowser(QWidget *parent)
+ : QWidget(parent)
+{
+ d_ptr = new QtAbstractPropertyBrowserPrivate;
+ d_ptr->q_ptr = this;
+
+}
+
+/*!
+ Destroys the property browser, and destroys all the items that were
+ created by this property browser.
+
+ Note that the properties that were displayed in the editor are not
+ deleted since they still can be used in other editors. Neither
+ does the destructor delete the property managers and editor
+ factories that were used by this property browser widget unless
+ this widget was their parent.
+
+ \sa QtAbstractPropertyManager::~QtAbstractPropertyManager()
+*/
+QtAbstractPropertyBrowser::~QtAbstractPropertyBrowser()
+{
+ QList<QtBrowserItem *> indexes = topLevelItems();
+ QListIterator<QtBrowserItem *> itItem(indexes);
+ while (itItem.hasNext())
+ d_ptr->clearIndex(itItem.next());
+ delete d_ptr;
+}
+
+/*!
+ Returns the property browser's list of top level properties.
+
+ To traverse the subproperties, use the QtProperty::subProperties()
+ function.
+
+ \sa addProperty(), insertProperty(), removeProperty()
+*/
+QList<QtProperty *> QtAbstractPropertyBrowser::properties() const
+{
+ return d_ptr->m_subItems;
+}
+
+/*!
+ Returns the property browser's list of all items associated
+ with the given \a property.
+
+ There is one item per instance of the property in the browser.
+
+ \sa topLevelItem()
+*/
+
+QList<QtBrowserItem *> QtAbstractPropertyBrowser::items(QtProperty *property) const
+{
+ return d_ptr->m_propertyToIndexes.value(property);
+}
+
+/*!
+ Returns the top-level items associated with the given \a property.
+
+ Returns 0 if \a property wasn't inserted into this property
+ browser or isn't a top-level one.
+
+ \sa topLevelItems(), items()
+*/
+
+QtBrowserItem *QtAbstractPropertyBrowser::topLevelItem(QtProperty *property) const
+{
+ return d_ptr->m_topLevelPropertyToIndex.value(property);
+}
+
+/*!
+ Returns the list of top-level items.
+
+ \sa topLevelItem()
+*/
+
+QList<QtBrowserItem *> QtAbstractPropertyBrowser::topLevelItems() const
+{
+ return d_ptr->m_topLevelIndexes;
+}
+
+/*!
+ Removes all the properties from the editor, but does not delete
+ them since they can still be used in other editors.
+
+ \sa removeProperty(), QtAbstractPropertyManager::clear()
+*/
+void QtAbstractPropertyBrowser::clear()
+{
+ QList<QtProperty *> subList = properties();
+ QListIterator<QtProperty *> itSub(subList);
+ itSub.toBack();
+ while (itSub.hasPrevious()) {
+ QtProperty *property = itSub.previous();
+ removeProperty(property);
+ }
+}
+
+/*!
+ Appends the given \a property (and its subproperties) to the
+ property browser's list of top level properties. Returns the item
+ created by property browser which is associated with the \a property.
+ In order to get all children items created by the property
+ browser in this call, the returned item should be traversed.
+
+ If the specified \a property is already added, this function does
+ nothing and returns 0.
+
+ \sa insertProperty(), QtProperty::addSubProperty(), properties()
+*/
+QtBrowserItem *QtAbstractPropertyBrowser::addProperty(QtProperty *property)
+{
+ QtProperty *afterProperty = 0;
+ if (d_ptr->m_subItems.count() > 0)
+ afterProperty = d_ptr->m_subItems.last();
+ return insertProperty(property, afterProperty);
+}
+
+/*!
+ \fn QtBrowserItem *QtAbstractPropertyBrowser::insertProperty(QtProperty *property,
+ QtProperty *afterProperty)
+
+ Inserts the given \a property (and its subproperties) after
+ the specified \a afterProperty in the browser's list of top
+ level properties. Returns item created by property browser which
+ is associated with the \a property. In order to get all children items
+ created by the property browser in this call returned item should be traversed.
+
+ If the specified \a afterProperty is 0, the given \a property is
+ inserted at the beginning of the list. If \a property is
+ already inserted, this function does nothing and returns 0.
+
+ \sa addProperty(), QtProperty::insertSubProperty(), properties()
+*/
+QtBrowserItem *QtAbstractPropertyBrowser::insertProperty(QtProperty *property,
+ QtProperty *afterProperty)
+{
+ if (!property)
+ return 0;
+
+ // if item is already inserted in this item then cannot add.
+ QList<QtProperty *> pendingList = properties();
+ int pos = 0;
+ int newPos = 0;
+ while (pos < pendingList.count()) {
+ QtProperty *prop = pendingList.at(pos);
+ if (prop == property)
+ return 0;
+ if (prop == afterProperty) {
+ newPos = pos + 1;
+ }
+ pos++;
+ }
+ d_ptr->createBrowserIndexes(property, 0, afterProperty);
+
+ // traverse inserted subtree and connect to manager's signals
+ d_ptr->insertSubTree(property, 0);
+
+ d_ptr->m_subItems.insert(newPos, property);
+ //propertyInserted(property, 0, properAfterProperty);
+ return topLevelItem(property);
+}
+
+/*!
+ Removes the specified \a property (and its subproperties) from the
+ property browser's list of top level properties. All items
+ that were associated with the given \a property and its children
+ are deleted.
+
+ Note that the properties are \e not deleted since they can still
+ be used in other editors.
+
+ \sa clear(), QtProperty::removeSubProperty(), properties()
+*/
+void QtAbstractPropertyBrowser::removeProperty(QtProperty *property)
+{
+ if (!property)
+ return;
+
+ QList<QtProperty *> pendingList = properties();
+ int pos = 0;
+ while (pos < pendingList.count()) {
+ if (pendingList.at(pos) == property) {
+ d_ptr->m_subItems.removeAt(pos); //perhaps this two lines
+ d_ptr->removeSubTree(property, 0); //should be moved down after propertyRemoved call.
+ //propertyRemoved(property, 0);
+
+ d_ptr->removeBrowserIndexes(property, 0);
+
+ // when item is deleted, item will call removeItem for top level items,
+ // and itemRemoved for nested items.
+
+ return;
+ }
+ pos++;
+ }
+}
+
+/*!
+ Creates an editing widget (with the given \a parent) for the given
+ \a property according to the previously established associations
+ between property managers and editor factories.
+
+ If the property is created by a property manager which was not
+ associated with any of the existing factories in \e this property
+ editor, the function returns 0.
+
+ To make a property editable in the property browser, the
+ createEditor() function must be called to provide the
+ property with a suitable editing widget.
+
+ Reimplement this function to provide additional decoration for the
+ editing widgets created by the installed factories.
+
+ \sa setFactoryForManager()
+*/
+QWidget *QtAbstractPropertyBrowser::createEditor(QtProperty *property,
+ QWidget *parent)
+{
+ QtAbstractEditorFactoryBase *factory = 0;
+ QtAbstractPropertyManager *manager = property->propertyManager();
+
+ if (m_viewToManagerToFactory()->contains(this) &&
+ (*m_viewToManagerToFactory())[this].contains(manager)) {
+ factory = (*m_viewToManagerToFactory())[this][manager];
+ }
+
+ if (!factory)
+ return 0;
+ return factory->createEditor(property, parent);
+}
+
+bool QtAbstractPropertyBrowser::addFactory(QtAbstractPropertyManager *abstractManager,
+ QtAbstractEditorFactoryBase *abstractFactory)
+{
+ bool connectNeeded = false;
+ if (!m_managerToFactoryToViews()->contains(abstractManager) ||
+ !(*m_managerToFactoryToViews())[abstractManager].contains(abstractFactory)) {
+ connectNeeded = true;
+ } else if ((*m_managerToFactoryToViews())[abstractManager][abstractFactory]
+ .contains(this)) {
+ return connectNeeded;
+ }
+
+ if (m_viewToManagerToFactory()->contains(this) &&
+ (*m_viewToManagerToFactory())[this].contains(abstractManager)) {
+ unsetFactoryForManager(abstractManager);
+ }
+
+ (*m_managerToFactoryToViews())[abstractManager][abstractFactory].append(this);
+ (*m_viewToManagerToFactory())[this][abstractManager] = abstractFactory;
+
+ return connectNeeded;
+}
+
+/*!
+ Removes the association between the given \a manager and the
+ factory bound to it, automatically calling the
+ QtAbstractEditorFactory::removePropertyManager() function if necessary.
+
+ \sa setFactoryForManager()
+*/
+void QtAbstractPropertyBrowser::unsetFactoryForManager(QtAbstractPropertyManager *manager)
+{
+ if (!m_viewToManagerToFactory()->contains(this) ||
+ !(*m_viewToManagerToFactory())[this].contains(manager)) {
+ return;
+ }
+
+ QtAbstractEditorFactoryBase *abstractFactory =
+ (*m_viewToManagerToFactory())[this][manager];
+ (*m_viewToManagerToFactory())[this].remove(manager);
+ if ((*m_viewToManagerToFactory())[this].isEmpty()) {
+ (*m_viewToManagerToFactory()).remove(this);
+ }
+
+ (*m_managerToFactoryToViews())[manager][abstractFactory].removeAll(this);
+ if ((*m_managerToFactoryToViews())[manager][abstractFactory].isEmpty()) {
+ (*m_managerToFactoryToViews())[manager].remove(abstractFactory);
+ abstractFactory->breakConnection(manager);
+ if ((*m_managerToFactoryToViews())[manager].isEmpty()) {
+ (*m_managerToFactoryToViews()).remove(manager);
+ }
+ }
+}
+
+/*!
+ Returns the current item in the property browser.
+
+ \sa setCurrentItem()
+*/
+QtBrowserItem *QtAbstractPropertyBrowser::currentItem() const
+{
+ return d_ptr->m_currentItem;
+}
+
+/*!
+ Sets the current item in the property browser to \a item.
+
+ \sa currentItem(), currentItemChanged()
+*/
+void QtAbstractPropertyBrowser::setCurrentItem(QtBrowserItem *item)
+{
+ QtBrowserItem *oldItem = d_ptr->m_currentItem;
+ d_ptr->m_currentItem = item;
+ if (oldItem != item)
+ emit currentItemChanged(item);
+}
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#include "moc_qtpropertybrowser.cpp"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.h b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b734f0c7d49ea021a3cd863c55c966decc8f41e
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.h
@@ -0,0 +1,335 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QTPROPERTYBROWSER_H
+#define QTPROPERTYBROWSER_H
+
+#include <QWidget>
+#include <QSet>
+#include <QLineEdit>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+#if defined(Q_OS_WIN)
+# if !defined(QT_QTPROPERTYBROWSER_EXPORT) && !defined(QT_QTPROPERTYBROWSER_IMPORT)
+# define QT_QTPROPERTYBROWSER_EXPORT
+# elif defined(QT_QTPROPERTYBROWSER_IMPORT)
+# if defined(QT_QTPROPERTYBROWSER_EXPORT)
+# undef QT_QTPROPERTYBROWSER_EXPORT
+# endif
+# define QT_QTPROPERTYBROWSER_EXPORT __declspec(dllimport)
+# elif defined(QT_QTPROPERTYBROWSER_EXPORT)
+# undef QT_QTPROPERTYBROWSER_EXPORT
+# define QT_QTPROPERTYBROWSER_EXPORT __declspec(dllexport)
+# endif
+#else
+# define QT_QTPROPERTYBROWSER_EXPORT
+#endif
+
+typedef QLineEdit::EchoMode EchoMode;
+
+class QtAbstractPropertyManager;
+class QtPropertyPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtProperty
+{
+public:
+ virtual ~QtProperty();
+
+ QList<QtProperty *> subProperties() const;
+
+ QtAbstractPropertyManager *propertyManager() const;
+
+ QString toolTip() const;
+ QString statusTip() const;
+ QString whatsThis() const;
+ QString propertyName() const;
+ bool isEnabled() const;
+ bool isModified() const;
+
+ bool hasValue() const;
+ QIcon valueIcon() const;
+ QString valueText() const;
+ QString displayText() const;
+
+ void setToolTip(const QString &text);
+ void setStatusTip(const QString &text);
+ void setWhatsThis(const QString &text);
+ void setPropertyName(const QString &text);
+ void setEnabled(bool enable);
+ void setModified(bool modified);
+
+ void addSubProperty(QtProperty *property);
+ void insertSubProperty(QtProperty *property, QtProperty *afterProperty);
+ void removeSubProperty(QtProperty *property);
+protected:
+ explicit QtProperty(QtAbstractPropertyManager *manager);
+ void propertyChanged();
+private:
+ friend class QtAbstractPropertyManager;
+ QtPropertyPrivate *d_ptr;
+};
+
+class QtAbstractPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtAbstractPropertyManager : public QObject
+{
+ Q_OBJECT
+public:
+
+ explicit QtAbstractPropertyManager(QObject *parent = 0);
+ ~QtAbstractPropertyManager();
+
+ QSet<QtProperty *> properties() const;
+ void clear() const;
+
+ QtProperty *addProperty(const QString &name = QString());
+Q_SIGNALS:
+
+ void propertyInserted(QtProperty *property,
+ QtProperty *parent, QtProperty *after);
+ void propertyChanged(QtProperty *property);
+ void propertyRemoved(QtProperty *property, QtProperty *parent);
+ void propertyDestroyed(QtProperty *property);
+protected:
+ virtual bool hasValue(const QtProperty *property) const;
+ virtual QIcon valueIcon(const QtProperty *property) const;
+ virtual QString valueText(const QtProperty *property) const;
+ virtual QString displayText(const QtProperty *property) const;
+ virtual EchoMode echoMode(const QtProperty *) const;
+ virtual void initializeProperty(QtProperty *property) = 0;
+ virtual void uninitializeProperty(QtProperty *property);
+ virtual QtProperty *createProperty();
+private:
+ friend class QtProperty;
+ QtAbstractPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtAbstractPropertyManager)
+ Q_DISABLE_COPY(QtAbstractPropertyManager)
+};
+
+class QT_QTPROPERTYBROWSER_EXPORT QtAbstractEditorFactoryBase : public QObject
+{
+ Q_OBJECT
+public:
+ virtual QWidget *createEditor(QtProperty *property, QWidget *parent) = 0;
+protected:
+ explicit QtAbstractEditorFactoryBase(QObject *parent = 0)
+ : QObject(parent) {}
+
+ virtual void breakConnection(QtAbstractPropertyManager *manager) = 0;
+protected Q_SLOTS:
+ virtual void managerDestroyed(QObject *manager) = 0;
+
+ friend class QtAbstractPropertyBrowser;
+};
+
+template <class PropertyManager>
+class QtAbstractEditorFactory : public QtAbstractEditorFactoryBase
+{
+public:
+ explicit QtAbstractEditorFactory(QObject *parent) : QtAbstractEditorFactoryBase(parent) {}
+ QWidget *createEditor(QtProperty *property, QWidget *parent)
+ {
+ QSetIterator<PropertyManager *> it(m_managers);
+ while (it.hasNext()) {
+ PropertyManager *manager = it.next();
+ if (manager == property->propertyManager()) {
+ return createEditor(manager, property, parent);
+ }
+ }
+ return 0;
+ }
+ void addPropertyManager(PropertyManager *manager)
+ {
+ if (m_managers.contains(manager))
+ return;
+ m_managers.insert(manager);
+ connectPropertyManager(manager);
+ connect(manager, SIGNAL(destroyed(QObject *)),
+ this, SLOT(managerDestroyed(QObject *)));
+ }
+ void removePropertyManager(PropertyManager *manager)
+ {
+ if (!m_managers.contains(manager))
+ return;
+ disconnect(manager, SIGNAL(destroyed(QObject *)),
+ this, SLOT(managerDestroyed(QObject *)));
+ disconnectPropertyManager(manager);
+ m_managers.remove(manager);
+ }
+ QSet<PropertyManager *> propertyManagers() const
+ {
+ return m_managers;
+ }
+ PropertyManager *propertyManager(QtProperty *property) const
+ {
+ QtAbstractPropertyManager *manager = property->propertyManager();
+ QSetIterator<PropertyManager *> itManager(m_managers);
+ while (itManager.hasNext()) {
+ PropertyManager *m = itManager.next();
+ if (m == manager) {
+ return m;
+ }
+ }
+ return 0;
+ }
+protected:
+ virtual void connectPropertyManager(PropertyManager *manager) = 0;
+ virtual QWidget *createEditor(PropertyManager *manager, QtProperty *property,
+ QWidget *parent) = 0;
+ virtual void disconnectPropertyManager(PropertyManager *manager) = 0;
+ void managerDestroyed(QObject *manager)
+ {
+ QSetIterator<PropertyManager *> it(m_managers);
+ while (it.hasNext()) {
+ PropertyManager *m = it.next();
+ if (m == manager) {
+ m_managers.remove(m);
+ return;
+ }
+ }
+ }
+private:
+ void breakConnection(QtAbstractPropertyManager *manager)
+ {
+ QSetIterator<PropertyManager *> it(m_managers);
+ while (it.hasNext()) {
+ PropertyManager *m = it.next();
+ if (m == manager) {
+ removePropertyManager(m);
+ return;
+ }
+ }
+ }
+private:
+ QSet<PropertyManager *> m_managers;
+ friend class QtAbstractPropertyEditor;
+};
+
+class QtAbstractPropertyBrowser;
+class QtBrowserItemPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtBrowserItem
+{
+public:
+ QtProperty *property() const;
+ QtBrowserItem *parent() const;
+ QList<QtBrowserItem *> children() const;
+ QtAbstractPropertyBrowser *browser() const;
+private:
+ explicit QtBrowserItem(QtAbstractPropertyBrowser *browser, QtProperty *property, QtBrowserItem *parent);
+ ~QtBrowserItem();
+ QtBrowserItemPrivate *d_ptr;
+ friend class QtAbstractPropertyBrowserPrivate;
+};
+
+class QtAbstractPropertyBrowserPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtAbstractPropertyBrowser : public QWidget
+{
+ Q_OBJECT
+public:
+
+ explicit QtAbstractPropertyBrowser(QWidget *parent = 0);
+ ~QtAbstractPropertyBrowser();
+
+ QList<QtProperty *> properties() const;
+ QList<QtBrowserItem *> items(QtProperty *property) const;
+ QtBrowserItem *topLevelItem(QtProperty *property) const;
+ QList<QtBrowserItem *> topLevelItems() const;
+ void clear();
+
+ template <class PropertyManager>
+ void setFactoryForManager(PropertyManager *manager,
+ QtAbstractEditorFactory<PropertyManager> *factory) {
+ QtAbstractPropertyManager *abstractManager = manager;
+ QtAbstractEditorFactoryBase *abstractFactory = factory;
+
+ if (addFactory(abstractManager, abstractFactory))
+ factory->addPropertyManager(manager);
+ }
+
+ void unsetFactoryForManager(QtAbstractPropertyManager *manager);
+
+ QtBrowserItem *currentItem() const;
+ void setCurrentItem(QtBrowserItem *);
+
+Q_SIGNALS:
+ void currentItemChanged(QtBrowserItem *);
+
+public Q_SLOTS:
+
+ QtBrowserItem *addProperty(QtProperty *property);
+ QtBrowserItem *insertProperty(QtProperty *property, QtProperty *afterProperty);
+ void removeProperty(QtProperty *property);
+
+protected:
+
+ virtual void itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem) = 0;
+ virtual void itemRemoved(QtBrowserItem *item) = 0;
+ // can be tooltip, statustip, whatsthis, name, icon, text.
+ virtual void itemChanged(QtBrowserItem *item) = 0;
+
+ virtual QWidget *createEditor(QtProperty *property, QWidget *parent);
+private:
+
+ bool addFactory(QtAbstractPropertyManager *abstractManager,
+ QtAbstractEditorFactoryBase *abstractFactory);
+
+ QtAbstractPropertyBrowserPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtAbstractPropertyBrowser)
+ Q_DISABLE_COPY(QtAbstractPropertyBrowser)
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyInserted(QtProperty *,
+ QtProperty *, QtProperty *))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyRemoved(QtProperty *,
+ QtProperty *))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDataChanged(QtProperty *))
+
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#endif // QTPROPERTYBROWSER_H
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.pri b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.pri
new file mode 100644
index 0000000000000000000000000000000000000000..2797827872d6c4086f5118bc0c05ea6138488f7d
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.pri
@@ -0,0 +1,32 @@
+include(../common.pri)
+greaterThan(QT_MAJOR_VERSION, 4): QT *= widgets
+INCLUDEPATH += $$PWD
+DEPENDPATH += $$PWD
+
+qtpropertybrowser-uselib:!qtpropertybrowser-buildlib {
+ LIBS += -L$$QTPROPERTYBROWSER_LIBDIR -l$$QTPROPERTYBROWSER_LIBNAME
+} else {
+ DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0
+ SOURCES += $$PWD/qtpropertybrowser.cpp \
+ $$PWD/qtpropertymanager.cpp \
+ $$PWD/qteditorfactory.cpp \
+ $$PWD/qtvariantproperty.cpp \
+ $$PWD/qttreepropertybrowser.cpp \
+ $$PWD/qtbuttonpropertybrowser.cpp \
+ $$PWD/qtgroupboxpropertybrowser.cpp \
+ $$PWD/qtpropertybrowserutils.cpp
+ HEADERS += $$PWD/qtpropertybrowser.h \
+ $$PWD/qtpropertymanager.h \
+ $$PWD/qteditorfactory.h \
+ $$PWD/qtvariantproperty.h \
+ $$PWD/qttreepropertybrowser.h \
+ $$PWD/qtbuttonpropertybrowser.h \
+ $$PWD/qtgroupboxpropertybrowser.h \
+ $$PWD/qtpropertybrowserutils_p.h
+ RESOURCES += $$PWD/qtpropertybrowser.qrc
+}
+
+win32 {
+ contains(TEMPLATE, lib):contains(CONFIG, shared):DEFINES += QT_QTPROPERTYBROWSER_EXPORT
+ else:qtpropertybrowser-uselib:DEFINES += QT_QTPROPERTYBROWSER_IMPORT
+}
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.qrc b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.qrc
new file mode 100644
index 0000000000000000000000000000000000000000..03e9c5612e61d4248db1c4553ac01ed7331f93df
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowser.qrc
@@ -0,0 +1,23 @@
+<RCC version="1.0">
+ <qresource prefix="/qt-project.org/qtpropertybrowser">
+ <file>images/cursor-arrow.png</file>
+ <file>images/cursor-busy.png</file>
+ <file>images/cursor-closedhand.png</file>
+ <file>images/cursor-cross.png</file>
+ <file>images/cursor-forbidden.png</file>
+ <file>images/cursor-hand.png</file>
+ <file>images/cursor-hsplit.png</file>
+ <file>images/cursor-ibeam.png</file>
+ <file>images/cursor-openhand.png</file>
+ <file>images/cursor-sizeall.png</file>
+ <file>images/cursor-sizeb.png</file>
+ <file>images/cursor-sizef.png</file>
+ <file>images/cursor-sizeh.png</file>
+ <file>images/cursor-sizev.png</file>
+ <file>images/cursor-uparrow.png</file>
+ <file>images/cursor-vsplit.png</file>
+ <file>images/cursor-wait.png</file>
+ <file>images/cursor-whatsthis.png</file>
+ </qresource>
+</RCC>
+
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowserutils.cpp b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowserutils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f1cd61291115ede88d153337989c5723a822b095
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowserutils.cpp
@@ -0,0 +1,456 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtpropertybrowserutils_p.h"
+#include <QApplication>
+#include <QPainter>
+#include <QHBoxLayout>
+#include <QMouseEvent>
+#include <QCheckBox>
+#include <QLineEdit>
+#include <QMenu>
+#include <QStyleOption>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+QtCursorDatabase::QtCursorDatabase()
+{
+ appendCursor(Qt::ArrowCursor, QCoreApplication::translate("QtCursorDatabase", "Arrow"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-arrow.png")));
+ appendCursor(Qt::UpArrowCursor, QCoreApplication::translate("QtCursorDatabase", "Up Arrow"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-uparrow.png")));
+ appendCursor(Qt::CrossCursor, QCoreApplication::translate("QtCursorDatabase", "Cross"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-cross.png")));
+ appendCursor(Qt::WaitCursor, QCoreApplication::translate("QtCursorDatabase", "Wait"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-wait.png")));
+ appendCursor(Qt::IBeamCursor, QCoreApplication::translate("QtCursorDatabase", "IBeam"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-ibeam.png")));
+ appendCursor(Qt::SizeVerCursor, QCoreApplication::translate("QtCursorDatabase", "Size Vertical"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-sizev.png")));
+ appendCursor(Qt::SizeHorCursor, QCoreApplication::translate("QtCursorDatabase", "Size Horizontal"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-sizeh.png")));
+ appendCursor(Qt::SizeFDiagCursor, QCoreApplication::translate("QtCursorDatabase", "Size Backslash"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-sizef.png")));
+ appendCursor(Qt::SizeBDiagCursor, QCoreApplication::translate("QtCursorDatabase", "Size Slash"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-sizeb.png")));
+ appendCursor(Qt::SizeAllCursor, QCoreApplication::translate("QtCursorDatabase", "Size All"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-sizeall.png")));
+ appendCursor(Qt::BlankCursor, QCoreApplication::translate("QtCursorDatabase", "Blank"),
+ QIcon());
+ appendCursor(Qt::SplitVCursor, QCoreApplication::translate("QtCursorDatabase", "Split Vertical"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-vsplit.png")));
+ appendCursor(Qt::SplitHCursor, QCoreApplication::translate("QtCursorDatabase", "Split Horizontal"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-hsplit.png")));
+ appendCursor(Qt::PointingHandCursor, QCoreApplication::translate("QtCursorDatabase", "Pointing Hand"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-hand.png")));
+ appendCursor(Qt::ForbiddenCursor, QCoreApplication::translate("QtCursorDatabase", "Forbidden"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-forbidden.png")));
+ appendCursor(Qt::OpenHandCursor, QCoreApplication::translate("QtCursorDatabase", "Open Hand"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-openhand.png")));
+ appendCursor(Qt::ClosedHandCursor, QCoreApplication::translate("QtCursorDatabase", "Closed Hand"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-closedhand.png")));
+ appendCursor(Qt::WhatsThisCursor, QCoreApplication::translate("QtCursorDatabase", "What's This"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-whatsthis.png")));
+ appendCursor(Qt::BusyCursor, QCoreApplication::translate("QtCursorDatabase", "Busy"),
+ QIcon(QLatin1String(":/qt-project.org/qtpropertybrowser/images/cursor-busy.png")));
+}
+
+void QtCursorDatabase::clear()
+{
+ m_cursorNames.clear();
+ m_cursorIcons.clear();
+ m_valueToCursorShape.clear();
+ m_cursorShapeToValue.clear();
+}
+
+void QtCursorDatabase::appendCursor(Qt::CursorShape shape, const QString &name, const QIcon &icon)
+{
+ if (m_cursorShapeToValue.contains(shape))
+ return;
+ const int value = m_cursorNames.count();
+ m_cursorNames.append(name);
+ m_cursorIcons.insert(value, icon);
+ m_valueToCursorShape.insert(value, shape);
+ m_cursorShapeToValue.insert(shape, value);
+}
+
+QStringList QtCursorDatabase::cursorShapeNames() const
+{
+ return m_cursorNames;
+}
+
+QMap<int, QIcon> QtCursorDatabase::cursorShapeIcons() const
+{
+ return m_cursorIcons;
+}
+
+QString QtCursorDatabase::cursorToShapeName(const QCursor &cursor) const
+{
+ int val = cursorToValue(cursor);
+ if (val >= 0)
+ return m_cursorNames.at(val);
+ return QString();
+}
+
+QIcon QtCursorDatabase::cursorToShapeIcon(const QCursor &cursor) const
+{
+ int val = cursorToValue(cursor);
+ return m_cursorIcons.value(val);
+}
+
+int QtCursorDatabase::cursorToValue(const QCursor &cursor) const
+{
+#ifndef QT_NO_CURSOR
+ Qt::CursorShape shape = cursor.shape();
+ if (m_cursorShapeToValue.contains(shape))
+ return m_cursorShapeToValue[shape];
+#endif
+ return -1;
+}
+
+#ifndef QT_NO_CURSOR
+QCursor QtCursorDatabase::valueToCursor(int value) const
+{
+ if (m_valueToCursorShape.contains(value))
+ return QCursor(m_valueToCursorShape[value]);
+ return QCursor();
+}
+#endif
+
+QPixmap QtPropertyBrowserUtils::brushValuePixmap(const QBrush &b)
+{
+ QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);
+ img.fill(0);
+
+ QPainter painter(&img);
+ painter.setCompositionMode(QPainter::CompositionMode_Source);
+ painter.fillRect(0, 0, img.width(), img.height(), b);
+ QColor color = b.color();
+ if (color.alpha() != 255) { // indicate alpha by an inset
+ QBrush opaqueBrush = b;
+ color.setAlpha(255);
+ opaqueBrush.setColor(color);
+ painter.fillRect(img.width() / 4, img.height() / 4,
+ img.width() / 2, img.height() / 2, opaqueBrush);
+ }
+ painter.end();
+ return QPixmap::fromImage(img);
+}
+
+QIcon QtPropertyBrowserUtils::brushValueIcon(const QBrush &b)
+{
+ return QIcon(brushValuePixmap(b));
+}
+
+QString QtPropertyBrowserUtils::colorValueText(const QColor &c)
+{
+ return QCoreApplication::translate("QtPropertyBrowserUtils", "[%1, %2, %3] (%4)")
+ .arg(c.red()).arg(c.green()).arg(c.blue()).arg(c.alpha());
+}
+
+QPixmap QtPropertyBrowserUtils::fontValuePixmap(const QFont &font)
+{
+ QFont f = font;
+ QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);
+ img.fill(0);
+ QPainter p(&img);
+ p.setRenderHint(QPainter::TextAntialiasing, true);
+ p.setRenderHint(QPainter::Antialiasing, true);
+ f.setPointSize(13);
+ p.setFont(f);
+ QTextOption t;
+ t.setAlignment(Qt::AlignCenter);
+ p.drawText(QRect(0, 0, 16, 16), QString(QLatin1Char('A')), t);
+ return QPixmap::fromImage(img);
+}
+
+QIcon QtPropertyBrowserUtils::fontValueIcon(const QFont &f)
+{
+ return QIcon(fontValuePixmap(f));
+}
+
+QString QtPropertyBrowserUtils::fontValueText(const QFont &f)
+{
+ return QCoreApplication::translate("QtPropertyBrowserUtils", "[%1, %2]")
+ .arg(f.family()).arg(f.pointSize());
+}
+
+
+QtBoolEdit::QtBoolEdit(QWidget *parent) :
+ QWidget(parent),
+ m_checkBox(new QCheckBox(this)),
+ m_textVisible(true)
+{
+ QHBoxLayout *lt = new QHBoxLayout;
+ if (QApplication::layoutDirection() == Qt::LeftToRight)
+ lt->setContentsMargins(4, 0, 0, 0);
+ else
+ lt->setContentsMargins(0, 0, 4, 0);
+ lt->addWidget(m_checkBox);
+ setLayout(lt);
+ connect(m_checkBox, SIGNAL(toggled(bool)), this, SIGNAL(toggled(bool)));
+ setFocusProxy(m_checkBox);
+ m_checkBox->setText(tr("True"));
+}
+
+void QtBoolEdit::setTextVisible(bool textVisible)
+{
+ if (m_textVisible == textVisible)
+ return;
+
+ m_textVisible = textVisible;
+ if (m_textVisible)
+ m_checkBox->setText(isChecked() ? tr("True") : tr("False"));
+ else
+ m_checkBox->setText(QString());
+}
+
+Qt::CheckState QtBoolEdit::checkState() const
+{
+ return m_checkBox->checkState();
+}
+
+void QtBoolEdit::setCheckState(Qt::CheckState state)
+{
+ m_checkBox->setCheckState(state);
+}
+
+bool QtBoolEdit::isChecked() const
+{
+ return m_checkBox->isChecked();
+}
+
+void QtBoolEdit::setChecked(bool c)
+{
+ m_checkBox->setChecked(c);
+ if (!m_textVisible)
+ return;
+ m_checkBox->setText(isChecked() ? tr("True") : tr("False"));
+}
+
+bool QtBoolEdit::blockCheckBoxSignals(bool block)
+{
+ return m_checkBox->blockSignals(block);
+}
+
+void QtBoolEdit::mousePressEvent(QMouseEvent *event)
+{
+ if (event->buttons() == Qt::LeftButton) {
+ m_checkBox->click();
+ event->accept();
+ } else {
+ QWidget::mousePressEvent(event);
+ }
+}
+
+void QtBoolEdit::paintEvent(QPaintEvent *)
+{
+ QStyleOption opt;
+ opt.init(this);
+ QPainter p(this);
+ style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
+}
+
+
+
+QtKeySequenceEdit::QtKeySequenceEdit(QWidget *parent)
+ : QWidget(parent), m_num(0), m_lineEdit(new QLineEdit(this))
+{
+ QHBoxLayout *layout = new QHBoxLayout(this);
+ layout->addWidget(m_lineEdit);
+ layout->setMargin(0);
+ m_lineEdit->installEventFilter(this);
+ m_lineEdit->setReadOnly(true);
+ m_lineEdit->setFocusProxy(this);
+ setFocusPolicy(m_lineEdit->focusPolicy());
+ setAttribute(Qt::WA_InputMethodEnabled);
+}
+
+bool QtKeySequenceEdit::eventFilter(QObject *o, QEvent *e)
+{
+ if (o == m_lineEdit && e->type() == QEvent::ContextMenu) {
+ QContextMenuEvent *c = static_cast<QContextMenuEvent *>(e);
+ QMenu *menu = m_lineEdit->createStandardContextMenu();
+ const QList<QAction *> actions = menu->actions();
+ QListIterator<QAction *> itAction(actions);
+ while (itAction.hasNext()) {
+ QAction *action = itAction.next();
+ action->setShortcut(QKeySequence());
+ QString actionString = action->text();
+ const int pos = actionString.lastIndexOf(QLatin1Char('\t'));
+ if (pos > 0)
+ actionString.remove(pos, actionString.length() - pos);
+ action->setText(actionString);
+ }
+ QAction *actionBefore = 0;
+ if (actions.count() > 0)
+ actionBefore = actions[0];
+ QAction *clearAction = new QAction(tr("Clear Shortcut"), menu);
+ menu->insertAction(actionBefore, clearAction);
+ menu->insertSeparator(actionBefore);
+ clearAction->setEnabled(!m_keySequence.isEmpty());
+ connect(clearAction, SIGNAL(triggered()), this, SLOT(slotClearShortcut()));
+ menu->exec(c->globalPos());
+ delete menu;
+ e->accept();
+ return true;
+ }
+
+ return QWidget::eventFilter(o, e);
+}
+
+void QtKeySequenceEdit::slotClearShortcut()
+{
+ if (m_keySequence.isEmpty())
+ return;
+ setKeySequence(QKeySequence());
+ emit keySequenceChanged(m_keySequence);
+}
+
+void QtKeySequenceEdit::handleKeyEvent(QKeyEvent *e)
+{
+ int nextKey = e->key();
+ if (nextKey == Qt::Key_Control || nextKey == Qt::Key_Shift ||
+ nextKey == Qt::Key_Meta || nextKey == Qt::Key_Alt ||
+ nextKey == Qt::Key_Super_L || nextKey == Qt::Key_AltGr)
+ return;
+
+ nextKey |= translateModifiers(e->modifiers(), e->text());
+ int k0 = m_keySequence[0];
+ int k1 = m_keySequence[1];
+ int k2 = m_keySequence[2];
+ int k3 = m_keySequence[3];
+ switch (m_num) {
+ case 0: k0 = nextKey; k1 = 0; k2 = 0; k3 = 0; break;
+ case 1: k1 = nextKey; k2 = 0; k3 = 0; break;
+ case 2: k2 = nextKey; k3 = 0; break;
+ case 3: k3 = nextKey; break;
+ default: break;
+ }
+ ++m_num;
+ if (m_num > 3)
+ m_num = 0;
+ m_keySequence = QKeySequence(k0, k1, k2, k3);
+ m_lineEdit->setText(m_keySequence.toString(QKeySequence::NativeText));
+ e->accept();
+ emit keySequenceChanged(m_keySequence);
+}
+
+void QtKeySequenceEdit::setKeySequence(const QKeySequence &sequence)
+{
+ if (sequence == m_keySequence)
+ return;
+ m_num = 0;
+ m_keySequence = sequence;
+ m_lineEdit->setText(m_keySequence.toString(QKeySequence::NativeText));
+}
+
+QKeySequence QtKeySequenceEdit::keySequence() const
+{
+ return m_keySequence;
+}
+
+int QtKeySequenceEdit::translateModifiers(Qt::KeyboardModifiers state, const QString &text) const
+{
+ int result = 0;
+ if ((state & Qt::ShiftModifier) && (text.size() == 0 || !text.at(0).isPrint() || text.at(0).isLetter() || text.at(0).isSpace()))
+ result |= Qt::SHIFT;
+ if (state & Qt::ControlModifier)
+ result |= Qt::CTRL;
+ if (state & Qt::MetaModifier)
+ result |= Qt::META;
+ if (state & Qt::AltModifier)
+ result |= Qt::ALT;
+ return result;
+}
+
+void QtKeySequenceEdit::focusInEvent(QFocusEvent *e)
+{
+ m_lineEdit->event(e);
+ m_lineEdit->selectAll();
+ QWidget::focusInEvent(e);
+}
+
+void QtKeySequenceEdit::focusOutEvent(QFocusEvent *e)
+{
+ m_num = 0;
+ m_lineEdit->event(e);
+ QWidget::focusOutEvent(e);
+}
+
+void QtKeySequenceEdit::keyPressEvent(QKeyEvent *e)
+{
+ handleKeyEvent(e);
+ e->accept();
+}
+
+void QtKeySequenceEdit::keyReleaseEvent(QKeyEvent *e)
+{
+ m_lineEdit->event(e);
+}
+
+void QtKeySequenceEdit::paintEvent(QPaintEvent *)
+{
+ QStyleOption opt;
+ opt.init(this);
+ QPainter p(this);
+ style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
+}
+
+bool QtKeySequenceEdit::event(QEvent *e)
+{
+ if (e->type() == QEvent::Shortcut ||
+ e->type() == QEvent::ShortcutOverride ||
+ e->type() == QEvent::KeyRelease) {
+ e->accept();
+ return true;
+ }
+ return QWidget::event(e);
+}
+
+
+
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowserutils_p.h b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowserutils_p.h
new file mode 100644
index 0000000000000000000000000000000000000000..5a826d2b590fa3af709d94bdfc01f4ca6002eef4
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtpropertybrowserutils_p.h
@@ -0,0 +1,164 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists for the convenience
+// of Qt Designer. This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#ifndef QTPROPERTYBROWSERUTILS_H
+#define QTPROPERTYBROWSERUTILS_H
+
+#include <QMap>
+#include <QIcon>
+#include <QWidget>
+#include <QStringList>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QMouseEvent;
+class QCheckBox;
+class QLineEdit;
+
+class QtCursorDatabase
+{
+public:
+ QtCursorDatabase();
+ void clear();
+
+ QStringList cursorShapeNames() const;
+ QMap<int, QIcon> cursorShapeIcons() const;
+ QString cursorToShapeName(const QCursor &cursor) const;
+ QIcon cursorToShapeIcon(const QCursor &cursor) const;
+ int cursorToValue(const QCursor &cursor) const;
+#ifndef QT_NO_CURSOR
+ QCursor valueToCursor(int value) const;
+#endif
+private:
+ void appendCursor(Qt::CursorShape shape, const QString &name, const QIcon &icon);
+ QStringList m_cursorNames;
+ QMap<int, QIcon> m_cursorIcons;
+ QMap<int, Qt::CursorShape> m_valueToCursorShape;
+ QMap<Qt::CursorShape, int> m_cursorShapeToValue;
+};
+
+class QtPropertyBrowserUtils
+{
+public:
+ static QPixmap brushValuePixmap(const QBrush &b);
+ static QIcon brushValueIcon(const QBrush &b);
+ static QString colorValueText(const QColor &c);
+ static QPixmap fontValuePixmap(const QFont &f);
+ static QIcon fontValueIcon(const QFont &f);
+ static QString fontValueText(const QFont &f);
+};
+
+class QtBoolEdit : public QWidget {
+ Q_OBJECT
+public:
+ QtBoolEdit(QWidget *parent = 0);
+
+ bool textVisible() const { return m_textVisible; }
+ void setTextVisible(bool textVisible);
+
+ Qt::CheckState checkState() const;
+ void setCheckState(Qt::CheckState state);
+
+ bool isChecked() const;
+ void setChecked(bool c);
+
+ bool blockCheckBoxSignals(bool block);
+
+Q_SIGNALS:
+ void toggled(bool);
+
+protected:
+ void mousePressEvent(QMouseEvent * event);
+ void paintEvent(QPaintEvent *);
+
+private:
+ QCheckBox *m_checkBox;
+ bool m_textVisible;
+};
+
+class QtKeySequenceEdit : public QWidget
+{
+ Q_OBJECT
+public:
+ QtKeySequenceEdit(QWidget *parent = 0);
+
+ QKeySequence keySequence() const;
+ bool eventFilter(QObject *o, QEvent *e);
+public Q_SLOTS:
+ void setKeySequence(const QKeySequence &sequence);
+Q_SIGNALS:
+ void keySequenceChanged(const QKeySequence &sequence);
+protected:
+ void focusInEvent(QFocusEvent *e);
+ void focusOutEvent(QFocusEvent *e);
+ void keyPressEvent(QKeyEvent *e);
+ void keyReleaseEvent(QKeyEvent *e);
+ void paintEvent(QPaintEvent *);
+ bool event(QEvent *e);
+private slots:
+ void slotClearShortcut();
+private:
+ void handleKeyEvent(QKeyEvent *e);
+ int translateModifiers(Qt::KeyboardModifiers state, const QString &text) const;
+
+ int m_num;
+ QKeySequence m_keySequence;
+ QLineEdit *m_lineEdit;
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#endif
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtpropertymanager.cpp b/GUI/coregui/qttools/qtpropertybrowser/qtpropertymanager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cfc54efef0d1dc21538689590cac749c3e06dda2
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtpropertymanager.cpp
@@ -0,0 +1,6602 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtpropertymanager.h"
+#include "qtpropertybrowserutils_p.h"
+#include <QDateTime>
+#include <QLocale>
+#include <QMap>
+#include <QTimer>
+#include <QIcon>
+#include <QMetaEnum>
+#include <QFontDatabase>
+#include <QStyleOption>
+#include <QStyle>
+#include <QApplication>
+#include <QPainter>
+#include <QLabel>
+#include <QCheckBox>
+#include <QLineEdit>
+
+#include <limits.h>
+#include <float.h>
+
+#if defined(Q_CC_MSVC)
+# pragma warning(disable: 4786) /* MS VS 6: truncating debug info after 255 characters */
+#endif
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+template <class PrivateData, class Value>
+static void setSimpleMinimumData(PrivateData *data, const Value &minVal)
+{
+ data->minVal = minVal;
+ if (data->maxVal < data->minVal)
+ data->maxVal = data->minVal;
+
+ if (data->val < data->minVal)
+ data->val = data->minVal;
+}
+
+template <class PrivateData, class Value>
+static void setSimpleMaximumData(PrivateData *data, const Value &maxVal)
+{
+ data->maxVal = maxVal;
+ if (data->minVal > data->maxVal)
+ data->minVal = data->maxVal;
+
+ if (data->val > data->maxVal)
+ data->val = data->maxVal;
+}
+
+template <class PrivateData, class Value>
+static void setSizeMinimumData(PrivateData *data, const Value &newMinVal)
+{
+ data->minVal = newMinVal;
+ if (data->maxVal.width() < data->minVal.width())
+ data->maxVal.setWidth(data->minVal.width());
+ if (data->maxVal.height() < data->minVal.height())
+ data->maxVal.setHeight(data->minVal.height());
+
+ if (data->val.width() < data->minVal.width())
+ data->val.setWidth(data->minVal.width());
+ if (data->val.height() < data->minVal.height())
+ data->val.setHeight(data->minVal.height());
+}
+
+template <class PrivateData, class Value>
+static void setSizeMaximumData(PrivateData *data, const Value &newMaxVal)
+{
+ data->maxVal = newMaxVal;
+ if (data->minVal.width() > data->maxVal.width())
+ data->minVal.setWidth(data->maxVal.width());
+ if (data->minVal.height() > data->maxVal.height())
+ data->minVal.setHeight(data->maxVal.height());
+
+ if (data->val.width() > data->maxVal.width())
+ data->val.setWidth(data->maxVal.width());
+ if (data->val.height() > data->maxVal.height())
+ data->val.setHeight(data->maxVal.height());
+}
+
+template <class SizeValue>
+static SizeValue qBoundSize(const SizeValue &minVal, const SizeValue &val, const SizeValue &maxVal)
+{
+ SizeValue croppedVal = val;
+ if (minVal.width() > val.width())
+ croppedVal.setWidth(minVal.width());
+ else if (maxVal.width() < val.width())
+ croppedVal.setWidth(maxVal.width());
+
+ if (minVal.height() > val.height())
+ croppedVal.setHeight(minVal.height());
+ else if (maxVal.height() < val.height())
+ croppedVal.setHeight(maxVal.height());
+
+ return croppedVal;
+}
+
+// Match the exact signature of qBound for VS 6.
+QSize qBound(QSize minVal, QSize val, QSize maxVal)
+{
+ return qBoundSize(minVal, val, maxVal);
+}
+
+QSizeF qBound(QSizeF minVal, QSizeF val, QSizeF maxVal)
+{
+ return qBoundSize(minVal, val, maxVal);
+}
+
+namespace {
+
+namespace {
+template <class Value>
+void orderBorders(Value &minVal, Value &maxVal)
+{
+ if (minVal > maxVal)
+ qSwap(minVal, maxVal);
+}
+
+template <class Value>
+static void orderSizeBorders(Value &minVal, Value &maxVal)
+{
+ Value fromSize = minVal;
+ Value toSize = maxVal;
+ if (fromSize.width() > toSize.width()) {
+ fromSize.setWidth(maxVal.width());
+ toSize.setWidth(minVal.width());
+ }
+ if (fromSize.height() > toSize.height()) {
+ fromSize.setHeight(maxVal.height());
+ toSize.setHeight(minVal.height());
+ }
+ minVal = fromSize;
+ maxVal = toSize;
+}
+
+void orderBorders(QSize &minVal, QSize &maxVal)
+{
+ orderSizeBorders(minVal, maxVal);
+}
+
+void orderBorders(QSizeF &minVal, QSizeF &maxVal)
+{
+ orderSizeBorders(minVal, maxVal);
+}
+
+}
+}
+////////
+
+template <class Value, class PrivateData>
+static Value getData(const QMap<const QtProperty *, PrivateData> &propertyMap,
+ Value PrivateData::*data,
+ const QtProperty *property, const Value &defaultValue = Value())
+{
+ typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+ typedef typename PropertyToData::const_iterator PropertyToDataConstIterator;
+ const PropertyToDataConstIterator it = propertyMap.constFind(property);
+ if (it == propertyMap.constEnd())
+ return defaultValue;
+ return it.value().*data;
+}
+
+template <class Value, class PrivateData>
+static Value getValue(const QMap<const QtProperty *, PrivateData> &propertyMap,
+ const QtProperty *property, const Value &defaultValue = Value())
+{
+ return getData<Value>(propertyMap, &PrivateData::val, property, defaultValue);
+}
+
+template <class Value, class PrivateData>
+static Value getMinimum(const QMap<const QtProperty *, PrivateData> &propertyMap,
+ const QtProperty *property, const Value &defaultValue = Value())
+{
+ return getData<Value>(propertyMap, &PrivateData::minVal, property, defaultValue);
+}
+
+template <class Value, class PrivateData>
+static Value getMaximum(const QMap<const QtProperty *, PrivateData> &propertyMap,
+ const QtProperty *property, const Value &defaultValue = Value())
+{
+ return getData<Value>(propertyMap, &PrivateData::maxVal, property, defaultValue);
+}
+
+template <class ValueChangeParameter, class Value, class PropertyManager>
+static void setSimpleValue(QMap<const QtProperty *, Value> &propertyMap,
+ PropertyManager *manager,
+ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
+ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
+ QtProperty *property, const Value &val)
+{
+ typedef QMap<const QtProperty *, Value> PropertyToData;
+ typedef typename PropertyToData::iterator PropertyToDataIterator;
+ const PropertyToDataIterator it = propertyMap.find(property);
+ if (it == propertyMap.end())
+ return;
+
+ if (it.value() == val)
+ return;
+
+ it.value() = val;
+
+ emit (manager->*propertyChangedSignal)(property);
+ emit (manager->*valueChangedSignal)(property, val);
+}
+
+template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value>
+static void setValueInRange(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
+ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
+ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
+ QtProperty *property, const Value &val,
+ void (PropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, ValueChangeParameter))
+{
+ typedef typename PropertyManagerPrivate::Data PrivateData;
+ typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+ typedef typename PropertyToData::iterator PropertyToDataIterator;
+ const PropertyToDataIterator it = managerPrivate->m_values.find(property);
+ if (it == managerPrivate->m_values.end())
+ return;
+
+ PrivateData &data = it.value();
+
+ if (data.val == val)
+ return;
+
+ const Value oldVal = data.val;
+
+ data.val = qBound(data.minVal, val, data.maxVal);
+
+ if (data.val == oldVal)
+ return;
+
+ if (setSubPropertyValue)
+ (managerPrivate->*setSubPropertyValue)(property, data.val);
+
+ emit (manager->*propertyChangedSignal)(property);
+ emit (manager->*valueChangedSignal)(property, data.val);
+}
+
+template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value>
+static void setBorderValues(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
+ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
+ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
+ void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),
+ QtProperty *property, const Value &minVal, const Value &maxVal,
+ void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
+ ValueChangeParameter, ValueChangeParameter, ValueChangeParameter))
+{
+ typedef typename PropertyManagerPrivate::Data PrivateData;
+ typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+ typedef typename PropertyToData::iterator PropertyToDataIterator;
+ const PropertyToDataIterator it = managerPrivate->m_values.find(property);
+ if (it == managerPrivate->m_values.end())
+ return;
+
+ Value fromVal = minVal;
+ Value toVal = maxVal;
+ orderBorders(fromVal, toVal);
+
+ PrivateData &data = it.value();
+
+ if (data.minVal == fromVal && data.maxVal == toVal)
+ return;
+
+ const Value oldVal = data.val;
+
+ data.setMinimumValue(fromVal);
+ data.setMaximumValue(toVal);
+
+ emit (manager->*rangeChangedSignal)(property, data.minVal, data.maxVal);
+
+ if (setSubPropertyRange)
+ (managerPrivate->*setSubPropertyRange)(property, data.minVal, data.maxVal, data.val);
+
+ if (data.val == oldVal)
+ return;
+
+ emit (manager->*propertyChangedSignal)(property);
+ emit (manager->*valueChangedSignal)(property, data.val);
+}
+
+template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>
+static void setBorderValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
+ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
+ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
+ void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),
+ QtProperty *property,
+ Value (PrivateData::*getRangeVal)() const,
+ void (PrivateData::*setRangeVal)(ValueChangeParameter), const Value &borderVal,
+ void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
+ ValueChangeParameter, ValueChangeParameter, ValueChangeParameter))
+{
+ typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+ typedef typename PropertyToData::iterator PropertyToDataIterator;
+ const PropertyToDataIterator it = managerPrivate->m_values.find(property);
+ if (it == managerPrivate->m_values.end())
+ return;
+
+ PrivateData &data = it.value();
+
+ if ((data.*getRangeVal)() == borderVal)
+ return;
+
+ const Value oldVal = data.val;
+
+ (data.*setRangeVal)(borderVal);
+
+ emit (manager->*rangeChangedSignal)(property, data.minVal, data.maxVal);
+
+ if (setSubPropertyRange)
+ (managerPrivate->*setSubPropertyRange)(property, data.minVal, data.maxVal, data.val);
+
+ if (data.val == oldVal)
+ return;
+
+ emit (manager->*propertyChangedSignal)(property);
+ emit (manager->*valueChangedSignal)(property, data.val);
+}
+
+template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>
+static void setMinimumValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
+ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
+ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
+ void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),
+ QtProperty *property, const Value &minVal)
+{
+ void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
+ ValueChangeParameter, ValueChangeParameter, ValueChangeParameter) = 0;
+ setBorderValue<ValueChangeParameter, PropertyManagerPrivate, PropertyManager, Value, PrivateData>(manager, managerPrivate,
+ propertyChangedSignal, valueChangedSignal, rangeChangedSignal,
+ property, &PropertyManagerPrivate::Data::minimumValue, &PropertyManagerPrivate::Data::setMinimumValue, minVal, setSubPropertyRange);
+}
+
+template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>
+static void setMaximumValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
+ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
+ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
+ void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),
+ QtProperty *property, const Value &maxVal)
+{
+ void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
+ ValueChangeParameter, ValueChangeParameter, ValueChangeParameter) = 0;
+ setBorderValue<ValueChangeParameter, PropertyManagerPrivate, PropertyManager, Value, PrivateData>(manager, managerPrivate,
+ propertyChangedSignal, valueChangedSignal, rangeChangedSignal,
+ property, &PropertyManagerPrivate::Data::maximumValue, &PropertyManagerPrivate::Data::setMaximumValue, maxVal, setSubPropertyRange);
+}
+
+class QtMetaEnumWrapper : public QObject
+{
+ Q_OBJECT
+ Q_PROPERTY(QSizePolicy::Policy policy READ policy)
+public:
+ QSizePolicy::Policy policy() const { return QSizePolicy::Ignored; }
+private:
+ QtMetaEnumWrapper(QObject *parent) : QObject(parent) {}
+};
+
+class QtMetaEnumProvider
+{
+public:
+ QtMetaEnumProvider();
+
+ QStringList policyEnumNames() const { return m_policyEnumNames; }
+ QStringList languageEnumNames() const { return m_languageEnumNames; }
+ QStringList countryEnumNames(QLocale::Language language) const { return m_countryEnumNames.value(language); }
+
+ QSizePolicy::Policy indexToSizePolicy(int index) const;
+ int sizePolicyToIndex(QSizePolicy::Policy policy) const;
+
+ void indexToLocale(int languageIndex, int countryIndex, QLocale::Language *language, QLocale::Country *country) const;
+ void localeToIndex(QLocale::Language language, QLocale::Country country, int *languageIndex, int *countryIndex) const;
+
+private:
+ void initLocale();
+
+ QStringList m_policyEnumNames;
+ QStringList m_languageEnumNames;
+ QMap<QLocale::Language, QStringList> m_countryEnumNames;
+ QMap<int, QLocale::Language> m_indexToLanguage;
+ QMap<QLocale::Language, int> m_languageToIndex;
+ QMap<int, QMap<int, QLocale::Country> > m_indexToCountry;
+ QMap<QLocale::Language, QMap<QLocale::Country, int> > m_countryToIndex;
+ QMetaEnum m_policyEnum;
+};
+
+#if QT_VERSION < 0x040300
+
+static QList<QLocale::Country> countriesForLanguage(QLocale::Language language)
+{
+ QList<QLocale::Country> countries;
+ QLocale::Country country = QLocale::AnyCountry;
+ while (country <= QLocale::LastCountry) {
+ QLocale locale(language, country);
+ if (locale.language() == language && !countries.contains(locale.country()))
+ countries << locale.country();
+ country = (QLocale::Country)((uint)country + 1); // ++country
+ }
+ return countries;
+}
+
+#endif
+
+static QList<QLocale::Country> sortCountries(const QList<QLocale::Country> &countries)
+{
+ QMultiMap<QString, QLocale::Country> nameToCountry;
+ QListIterator<QLocale::Country> itCountry(countries);
+ while (itCountry.hasNext()) {
+ QLocale::Country country = itCountry.next();
+ nameToCountry.insert(QLocale::countryToString(country), country);
+ }
+ return nameToCountry.values();
+}
+
+void QtMetaEnumProvider::initLocale()
+{
+ QMultiMap<QString, QLocale::Language> nameToLanguage;
+ QLocale::Language language = QLocale::C;
+ while (language <= QLocale::LastLanguage) {
+ QLocale locale(language);
+ if (locale.language() == language)
+ nameToLanguage.insert(QLocale::languageToString(language), language);
+ language = (QLocale::Language)((uint)language + 1); // ++language
+ }
+
+ const QLocale system = QLocale::system();
+ if (!nameToLanguage.contains(QLocale::languageToString(system.language())))
+ nameToLanguage.insert(QLocale::languageToString(system.language()), system.language());
+
+ QList<QLocale::Language> languages = nameToLanguage.values();
+ QListIterator<QLocale::Language> itLang(languages);
+ while (itLang.hasNext()) {
+ QLocale::Language language = itLang.next();
+ QList<QLocale::Country> countries;
+#if QT_VERSION < 0x040300
+ countries = countriesForLanguage(language);
+#else
+ countries = QLocale::countriesForLanguage(language);
+#endif
+ if (countries.isEmpty() && language == system.language())
+ countries << system.country();
+
+ if (!countries.isEmpty() && !m_languageToIndex.contains(language)) {
+ countries = sortCountries(countries);
+ int langIdx = m_languageEnumNames.count();
+ m_indexToLanguage[langIdx] = language;
+ m_languageToIndex[language] = langIdx;
+ QStringList countryNames;
+ QListIterator<QLocale::Country> it(countries);
+ int countryIdx = 0;
+ while (it.hasNext()) {
+ QLocale::Country country = it.next();
+ countryNames << QLocale::countryToString(country);
+ m_indexToCountry[langIdx][countryIdx] = country;
+ m_countryToIndex[language][country] = countryIdx;
+ ++countryIdx;
+ }
+ m_languageEnumNames << QLocale::languageToString(language);
+ m_countryEnumNames[language] = countryNames;
+ }
+ }
+}
+
+QtMetaEnumProvider::QtMetaEnumProvider()
+{
+ QMetaProperty p;
+
+ p = QtMetaEnumWrapper::staticMetaObject.property(
+ QtMetaEnumWrapper::staticMetaObject.propertyOffset() + 0);
+ m_policyEnum = p.enumerator();
+ const int keyCount = m_policyEnum.keyCount();
+ for (int i = 0; i < keyCount; i++)
+ m_policyEnumNames << QLatin1String(m_policyEnum.key(i));
+
+ initLocale();
+}
+
+QSizePolicy::Policy QtMetaEnumProvider::indexToSizePolicy(int index) const
+{
+ return static_cast<QSizePolicy::Policy>(m_policyEnum.value(index));
+}
+
+int QtMetaEnumProvider::sizePolicyToIndex(QSizePolicy::Policy policy) const
+{
+ const int keyCount = m_policyEnum.keyCount();
+ for (int i = 0; i < keyCount; i++)
+ if (indexToSizePolicy(i) == policy)
+ return i;
+ return -1;
+}
+
+void QtMetaEnumProvider::indexToLocale(int languageIndex, int countryIndex, QLocale::Language *language, QLocale::Country *country) const
+{
+ QLocale::Language l = QLocale::C;
+ QLocale::Country c = QLocale::AnyCountry;
+ if (m_indexToLanguage.contains(languageIndex)) {
+ l = m_indexToLanguage[languageIndex];
+ if (m_indexToCountry.contains(languageIndex) && m_indexToCountry[languageIndex].contains(countryIndex))
+ c = m_indexToCountry[languageIndex][countryIndex];
+ }
+ if (language)
+ *language = l;
+ if (country)
+ *country = c;
+}
+
+void QtMetaEnumProvider::localeToIndex(QLocale::Language language, QLocale::Country country, int *languageIndex, int *countryIndex) const
+{
+ int l = -1;
+ int c = -1;
+ if (m_languageToIndex.contains(language)) {
+ l = m_languageToIndex[language];
+ if (m_countryToIndex.contains(language) && m_countryToIndex[language].contains(country))
+ c = m_countryToIndex[language][country];
+ }
+
+ if (languageIndex)
+ *languageIndex = l;
+ if (countryIndex)
+ *countryIndex = c;
+}
+
+Q_GLOBAL_STATIC(QtMetaEnumProvider, metaEnumProvider)
+
+// QtGroupPropertyManager
+
+/*!
+ \class QtGroupPropertyManager
+
+ \brief The QtGroupPropertyManager provides and manages group properties.
+
+ This class is intended to provide a grouping element without any value.
+
+ \sa QtAbstractPropertyManager
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtGroupPropertyManager::QtGroupPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtGroupPropertyManager::~QtGroupPropertyManager()
+{
+
+}
+
+/*!
+ \reimp
+*/
+bool QtGroupPropertyManager::hasValue(const QtProperty *property) const
+{
+ Q_UNUSED(property)
+ return false;
+}
+
+/*!
+ \reimp
+*/
+void QtGroupPropertyManager::initializeProperty(QtProperty *property)
+{
+ Q_UNUSED(property)
+}
+
+/*!
+ \reimp
+*/
+void QtGroupPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ Q_UNUSED(property)
+}
+
+// QtIntPropertyManager
+
+class QtIntPropertyManagerPrivate
+{
+ QtIntPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtIntPropertyManager)
+public:
+
+ struct Data
+ {
+ Data() : val(0), minVal(-INT_MAX), maxVal(INT_MAX), singleStep(1), readOnly(false) {}
+ int val;
+ int minVal;
+ int maxVal;
+ int singleStep;
+ bool readOnly;
+ int minimumValue() const { return minVal; }
+ int maximumValue() const { return maxVal; }
+ void setMinimumValue(int newMinVal) { setSimpleMinimumData(this, newMinVal); }
+ void setMaximumValue(int newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*!
+ \class QtIntPropertyManager
+
+ \brief The QtIntPropertyManager provides and manages int properties.
+
+ An int property has a current value, and a range specifying the
+ valid values. The range is defined by a minimum and a maximum
+ value.
+
+ The property's value and range can be retrieved using the value(),
+ minimum() and maximum() functions, and can be set using the
+ setValue(), setMinimum() and setMaximum() slots. Alternatively,
+ the range can be defined in one go using the setRange() slot.
+
+ In addition, QtIntPropertyManager provides the valueChanged() signal which
+ is emitted whenever a property created by this manager changes,
+ and the rangeChanged() signal which is emitted whenever such a
+ property changes its range of valid values.
+
+ \sa QtAbstractPropertyManager, QtSpinBoxFactory, QtSliderFactory, QtScrollBarFactory
+*/
+
+/*!
+ \fn void QtIntPropertyManager::valueChanged(QtProperty *property, int value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtIntPropertyManager::rangeChanged(QtProperty *property, int minimum, int maximum)
+
+ This signal is emitted whenever a property created by this manager
+ changes its range of valid values, passing a pointer to the
+ \a property and the new \a minimum and \a maximum values.
+
+ \sa setRange()
+*/
+
+/*!
+ \fn void QtIntPropertyManager::singleStepChanged(QtProperty *property, int step)
+
+ This signal is emitted whenever a property created by this manager
+ changes its single step property, passing a pointer to the
+ \a property and the new \a step value
+
+ \sa setSingleStep()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtIntPropertyManager::QtIntPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtIntPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtIntPropertyManager::~QtIntPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns 0.
+
+ \sa setValue()
+*/
+int QtIntPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<int>(d_ptr->m_values, property, 0);
+}
+
+/*!
+ Returns the given \a property's minimum value.
+
+ \sa setMinimum(), maximum(), setRange()
+*/
+int QtIntPropertyManager::minimum(const QtProperty *property) const
+{
+ return getMinimum<int>(d_ptr->m_values, property, 0);
+}
+
+/*!
+ Returns the given \a property's maximum value.
+
+ \sa setMaximum(), minimum(), setRange()
+*/
+int QtIntPropertyManager::maximum(const QtProperty *property) const
+{
+ return getMaximum<int>(d_ptr->m_values, property, 0);
+}
+
+/*!
+ Returns the given \a property's step value.
+
+ The step is typically used to increment or decrement a property value while pressing an arrow key.
+
+ \sa setSingleStep()
+*/
+int QtIntPropertyManager::singleStep(const QtProperty *property) const
+{
+ return getData<int>(d_ptr->m_values, &QtIntPropertyManagerPrivate::Data::singleStep, property, 0);
+}
+
+/*!
+ Returns read-only status of the property.
+
+ When property is read-only it's value can be selected and copied from editor but not modified.
+
+ \sa QtIntPropertyManager::setReadOnly
+*/
+bool QtIntPropertyManager::isReadOnly(const QtProperty *property) const
+{
+ return getData<bool>(d_ptr->m_values, &QtIntPropertyManagerPrivate::Data::readOnly, property, false);
+}
+
+/*!
+ \reimp
+*/
+QString QtIntPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtIntPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ return QString::number(it.value().val);
+}
+
+/*!
+ \fn void QtIntPropertyManager::setValue(QtProperty *property, int value)
+
+ Sets the value of the given \a property to \a value.
+
+ If the specified \a value is not valid according to the given \a
+ property's range, the \a value is adjusted to the nearest valid
+ value within the range.
+
+ \sa value(), setRange(), valueChanged()
+*/
+void QtIntPropertyManager::setValue(QtProperty *property, int val)
+{
+ void (QtIntPropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, int) = 0;
+ setValueInRange<int, QtIntPropertyManagerPrivate, QtIntPropertyManager, int>(this, d_ptr,
+ &QtIntPropertyManager::propertyChanged,
+ &QtIntPropertyManager::valueChanged,
+ property, val, setSubPropertyValue);
+}
+
+/*!
+ Sets the minimum value for the given \a property to \a minVal.
+
+ When setting the minimum value, the maximum and current values are
+ adjusted if necessary (ensuring that the range remains valid and
+ that the current value is within the range).
+
+ \sa minimum(), setRange(), rangeChanged()
+*/
+void QtIntPropertyManager::setMinimum(QtProperty *property, int minVal)
+{
+ setMinimumValue<int, QtIntPropertyManagerPrivate, QtIntPropertyManager, int, QtIntPropertyManagerPrivate::Data>(this, d_ptr,
+ &QtIntPropertyManager::propertyChanged,
+ &QtIntPropertyManager::valueChanged,
+ &QtIntPropertyManager::rangeChanged,
+ property, minVal);
+}
+
+/*!
+ Sets the maximum value for the given \a property to \a maxVal.
+
+ When setting maximum value, the minimum and current values are
+ adjusted if necessary (ensuring that the range remains valid and
+ that the current value is within the range).
+
+ \sa maximum(), setRange(), rangeChanged()
+*/
+void QtIntPropertyManager::setMaximum(QtProperty *property, int maxVal)
+{
+ setMaximumValue<int, QtIntPropertyManagerPrivate, QtIntPropertyManager, int, QtIntPropertyManagerPrivate::Data>(this, d_ptr,
+ &QtIntPropertyManager::propertyChanged,
+ &QtIntPropertyManager::valueChanged,
+ &QtIntPropertyManager::rangeChanged,
+ property, maxVal);
+}
+
+/*!
+ \fn void QtIntPropertyManager::setRange(QtProperty *property, int minimum, int maximum)
+
+ Sets the range of valid values.
+
+ This is a convenience function defining the range of valid values
+ in one go; setting the \a minimum and \a maximum values for the
+ given \a property with a single function call.
+
+ When setting a new range, the current value is adjusted if
+ necessary (ensuring that the value remains within range).
+
+ \sa setMinimum(), setMaximum(), rangeChanged()
+*/
+void QtIntPropertyManager::setRange(QtProperty *property, int minVal, int maxVal)
+{
+ void (QtIntPropertyManagerPrivate::*setSubPropertyRange)(QtProperty *, int, int, int) = 0;
+ setBorderValues<int, QtIntPropertyManagerPrivate, QtIntPropertyManager, int>(this, d_ptr,
+ &QtIntPropertyManager::propertyChanged,
+ &QtIntPropertyManager::valueChanged,
+ &QtIntPropertyManager::rangeChanged,
+ property, minVal, maxVal, setSubPropertyRange);
+}
+
+/*!
+ Sets the step value for the given \a property to \a step.
+
+ The step is typically used to increment or decrement a property value while pressing an arrow key.
+
+ \sa singleStep()
+*/
+void QtIntPropertyManager::setSingleStep(QtProperty *property, int step)
+{
+ const QtIntPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtIntPropertyManagerPrivate::Data data = it.value();
+
+ if (step < 0)
+ step = 0;
+
+ if (data.singleStep == step)
+ return;
+
+ data.singleStep = step;
+
+ it.value() = data;
+
+ emit singleStepChanged(property, data.singleStep);
+}
+
+/*!
+ Sets read-only status of the property.
+
+ \sa QtIntPropertyManager::setReadOnly
+*/
+void QtIntPropertyManager::setReadOnly(QtProperty *property, bool readOnly)
+{
+ const QtIntPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtIntPropertyManagerPrivate::Data data = it.value();
+
+ if (data.readOnly == readOnly)
+ return;
+
+ data.readOnly = readOnly;
+ it.value() = data;
+
+ emit propertyChanged(property);
+ emit readOnlyChanged(property, data.readOnly);
+}
+
+/*!
+ \reimp
+*/
+void QtIntPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtIntPropertyManagerPrivate::Data();
+}
+
+/*!
+ \reimp
+*/
+void QtIntPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtDoublePropertyManager
+
+class QtDoublePropertyManagerPrivate
+{
+ QtDoublePropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtDoublePropertyManager)
+public:
+
+ struct Data
+ {
+ Data() : val(0), minVal(-INT_MAX), maxVal(INT_MAX), singleStep(1), decimals(2), readOnly(false) {}
+ double val;
+ double minVal;
+ double maxVal;
+ double singleStep;
+ int decimals;
+ bool readOnly;
+ double minimumValue() const { return minVal; }
+ double maximumValue() const { return maxVal; }
+ void setMinimumValue(double newMinVal) { setSimpleMinimumData(this, newMinVal); }
+ void setMaximumValue(double newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*!
+ \class QtDoublePropertyManager
+
+ \brief The QtDoublePropertyManager provides and manages double properties.
+
+ A double property has a current value, and a range specifying the
+ valid values. The range is defined by a minimum and a maximum
+ value.
+
+ The property's value and range can be retrieved using the value(),
+ minimum() and maximum() functions, and can be set using the
+ setValue(), setMinimum() and setMaximum() slots.
+ Alternatively, the range can be defined in one go using the
+ setRange() slot.
+
+ In addition, QtDoublePropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes, and the rangeChanged() signal which is emitted whenever
+ such a property changes its range of valid values.
+
+ \sa QtAbstractPropertyManager, QtDoubleSpinBoxFactory
+*/
+
+/*!
+ \fn void QtDoublePropertyManager::valueChanged(QtProperty *property, double value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtDoublePropertyManager::rangeChanged(QtProperty *property, double minimum, double maximum)
+
+ This signal is emitted whenever a property created by this manager
+ changes its range of valid values, passing a pointer to the
+ \a property and the new \a minimum and \a maximum values
+
+ \sa setRange()
+*/
+
+/*!
+ \fn void QtDoublePropertyManager::decimalsChanged(QtProperty *property, int prec)
+
+ This signal is emitted whenever a property created by this manager
+ changes its precision of value, passing a pointer to the
+ \a property and the new \a prec value
+
+ \sa setDecimals()
+*/
+
+/*!
+ \fn void QtDoublePropertyManager::singleStepChanged(QtProperty *property, double step)
+
+ This signal is emitted whenever a property created by this manager
+ changes its single step property, passing a pointer to the
+ \a property and the new \a step value
+
+ \sa setSingleStep()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtDoublePropertyManager::QtDoublePropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtDoublePropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtDoublePropertyManager::~QtDoublePropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns 0.
+
+ \sa setValue()
+*/
+double QtDoublePropertyManager::value(const QtProperty *property) const
+{
+ return getValue<double>(d_ptr->m_values, property, 0.0);
+}
+
+/*!
+ Returns the given \a property's minimum value.
+
+ \sa maximum(), setRange()
+*/
+double QtDoublePropertyManager::minimum(const QtProperty *property) const
+{
+ return getMinimum<double>(d_ptr->m_values, property, 0.0);
+}
+
+/*!
+ Returns the given \a property's maximum value.
+
+ \sa minimum(), setRange()
+*/
+double QtDoublePropertyManager::maximum(const QtProperty *property) const
+{
+ return getMaximum<double>(d_ptr->m_values, property, 0.0);
+}
+
+/*!
+ Returns the given \a property's step value.
+
+ The step is typically used to increment or decrement a property value while pressing an arrow key.
+
+ \sa setSingleStep()
+*/
+double QtDoublePropertyManager::singleStep(const QtProperty *property) const
+{
+ return getData<double>(d_ptr->m_values, &QtDoublePropertyManagerPrivate::Data::singleStep, property, 0);
+}
+
+/*!
+ Returns the given \a property's precision, in decimals.
+
+ \sa setDecimals()
+*/
+int QtDoublePropertyManager::decimals(const QtProperty *property) const
+{
+ return getData<int>(d_ptr->m_values, &QtDoublePropertyManagerPrivate::Data::decimals, property, 0);
+}
+
+/*!
+ Returns read-only status of the property.
+
+ When property is read-only it's value can be selected and copied from editor but not modified.
+
+ \sa QtDoublePropertyManager::setReadOnly
+*/
+bool QtDoublePropertyManager::isReadOnly(const QtProperty *property) const
+{
+ return getData<bool>(d_ptr->m_values, &QtDoublePropertyManagerPrivate::Data::readOnly, property, false);
+}
+
+/*!
+ \reimp
+*/
+QString QtDoublePropertyManager::valueText(const QtProperty *property) const
+{
+ const QtDoublePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ return QLocale::system().toString(it.value().val, 'f', it.value().decimals);
+}
+
+/*!
+ \fn void QtDoublePropertyManager::setValue(QtProperty *property, double value)
+
+ Sets the value of the given \a property to \a value.
+
+ If the specified \a value is not valid according to the given
+ \a property's range, the \a value is adjusted to the nearest valid value
+ within the range.
+
+ \sa value(), setRange(), valueChanged()
+*/
+void QtDoublePropertyManager::setValue(QtProperty *property, double val)
+{
+ void (QtDoublePropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, double) = 0;
+ setValueInRange<double, QtDoublePropertyManagerPrivate, QtDoublePropertyManager, double>(this, d_ptr,
+ &QtDoublePropertyManager::propertyChanged,
+ &QtDoublePropertyManager::valueChanged,
+ property, val, setSubPropertyValue);
+}
+
+/*!
+ Sets the step value for the given \a property to \a step.
+
+ The step is typically used to increment or decrement a property value while pressing an arrow key.
+
+ \sa singleStep()
+*/
+void QtDoublePropertyManager::setSingleStep(QtProperty *property, double step)
+{
+ const QtDoublePropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtDoublePropertyManagerPrivate::Data data = it.value();
+
+ if (step < 0)
+ step = 0;
+
+ if (data.singleStep == step)
+ return;
+
+ data.singleStep = step;
+
+ it.value() = data;
+
+ emit singleStepChanged(property, data.singleStep);
+}
+
+/*!
+ Sets read-only status of the property.
+
+ \sa QtDoublePropertyManager::setReadOnly
+*/
+void QtDoublePropertyManager::setReadOnly(QtProperty *property, bool readOnly)
+{
+ const QtDoublePropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtDoublePropertyManagerPrivate::Data data = it.value();
+
+ if (data.readOnly == readOnly)
+ return;
+
+ data.readOnly = readOnly;
+ it.value() = data;
+
+ emit propertyChanged(property);
+ emit readOnlyChanged(property, data.readOnly);
+}
+
+/*!
+ \fn void QtDoublePropertyManager::setDecimals(QtProperty *property, int prec)
+
+ Sets the precision of the given \a property to \a prec.
+
+ The valid decimal range is 0-13. The default is 2.
+
+ \sa decimals()
+*/
+void QtDoublePropertyManager::setDecimals(QtProperty *property, int prec)
+{
+ const QtDoublePropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtDoublePropertyManagerPrivate::Data data = it.value();
+
+ if (prec > 13)
+ prec = 13;
+ else if (prec < 0)
+ prec = 0;
+
+ if (data.decimals == prec)
+ return;
+
+ data.decimals = prec;
+
+ it.value() = data;
+
+ emit decimalsChanged(property, data.decimals);
+}
+
+/*!
+ Sets the minimum value for the given \a property to \a minVal.
+
+ When setting the minimum value, the maximum and current values are
+ adjusted if necessary (ensuring that the range remains valid and
+ that the current value is within in the range).
+
+ \sa minimum(), setRange(), rangeChanged()
+*/
+void QtDoublePropertyManager::setMinimum(QtProperty *property, double minVal)
+{
+ setMinimumValue<double, QtDoublePropertyManagerPrivate, QtDoublePropertyManager, double, QtDoublePropertyManagerPrivate::Data>(this, d_ptr,
+ &QtDoublePropertyManager::propertyChanged,
+ &QtDoublePropertyManager::valueChanged,
+ &QtDoublePropertyManager::rangeChanged,
+ property, minVal);
+}
+
+/*!
+ Sets the maximum value for the given \a property to \a maxVal.
+
+ When setting the maximum value, the minimum and current values are
+ adjusted if necessary (ensuring that the range remains valid and
+ that the current value is within in the range).
+
+ \sa maximum(), setRange(), rangeChanged()
+*/
+void QtDoublePropertyManager::setMaximum(QtProperty *property, double maxVal)
+{
+ setMaximumValue<double, QtDoublePropertyManagerPrivate, QtDoublePropertyManager, double, QtDoublePropertyManagerPrivate::Data>(this, d_ptr,
+ &QtDoublePropertyManager::propertyChanged,
+ &QtDoublePropertyManager::valueChanged,
+ &QtDoublePropertyManager::rangeChanged,
+ property, maxVal);
+}
+
+/*!
+ \fn void QtDoublePropertyManager::setRange(QtProperty *property, double minimum, double maximum)
+
+ Sets the range of valid values.
+
+ This is a convenience function defining the range of valid values
+ in one go; setting the \a minimum and \a maximum values for the
+ given \a property with a single function call.
+
+ When setting a new range, the current value is adjusted if
+ necessary (ensuring that the value remains within range).
+
+ \sa setMinimum(), setMaximum(), rangeChanged()
+*/
+void QtDoublePropertyManager::setRange(QtProperty *property, double minVal, double maxVal)
+{
+ void (QtDoublePropertyManagerPrivate::*setSubPropertyRange)(QtProperty *, double, double, double) = 0;
+ setBorderValues<double, QtDoublePropertyManagerPrivate, QtDoublePropertyManager, double>(this, d_ptr,
+ &QtDoublePropertyManager::propertyChanged,
+ &QtDoublePropertyManager::valueChanged,
+ &QtDoublePropertyManager::rangeChanged,
+ property, minVal, maxVal, setSubPropertyRange);
+}
+
+/*!
+ \reimp
+*/
+void QtDoublePropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtDoublePropertyManagerPrivate::Data();
+}
+
+/*!
+ \reimp
+*/
+void QtDoublePropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtStringPropertyManager
+
+class QtStringPropertyManagerPrivate
+{
+ QtStringPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtStringPropertyManager)
+public:
+
+ struct Data
+ {
+ Data() : regExp(QString(QLatin1Char('*')), Qt::CaseSensitive, QRegExp::Wildcard),
+ echoMode(QLineEdit::Normal), readOnly(false)
+ {
+ }
+ QString val;
+ QRegExp regExp;
+ int echoMode;
+ bool readOnly;
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ QMap<const QtProperty *, Data> m_values;
+};
+
+/*!
+ \class QtStringPropertyManager
+
+ \brief The QtStringPropertyManager provides and manages QString properties.
+
+ A string property's value can be retrieved using the value()
+ function, and set using the setValue() slot.
+
+ The current value can be checked against a regular expression. To
+ set the regular expression use the setRegExp() slot, use the
+ regExp() function to retrieve the currently set expression.
+
+ In addition, QtStringPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes, and the regExpChanged() signal which is emitted whenever
+ such a property changes its currently set regular expression.
+
+ \sa QtAbstractPropertyManager, QtLineEditFactory
+*/
+
+/*!
+ \fn void QtStringPropertyManager::valueChanged(QtProperty *property, const QString &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtStringPropertyManager::regExpChanged(QtProperty *property, const QRegExp ®Exp)
+
+ This signal is emitted whenever a property created by this manager
+ changes its currenlty set regular expression, passing a pointer to
+ the \a property and the new \a regExp as parameters.
+
+ \sa setRegExp()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtStringPropertyManager::QtStringPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtStringPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtStringPropertyManager::~QtStringPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns an empty string.
+
+ \sa setValue()
+*/
+QString QtStringPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<QString>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's currently set regular expression.
+
+ If the given \a property is not managed by this manager, this
+ function returns an empty expression.
+
+ \sa setRegExp()
+*/
+QRegExp QtStringPropertyManager::regExp(const QtProperty *property) const
+{
+ return getData<QRegExp>(d_ptr->m_values, &QtStringPropertyManagerPrivate::Data::regExp, property, QRegExp());
+}
+
+/*!
+ \reimp
+*/
+EchoMode QtStringPropertyManager::echoMode(const QtProperty *property) const
+{
+ return (EchoMode)getData<int>(d_ptr->m_values, &QtStringPropertyManagerPrivate::Data::echoMode, property, 0);
+}
+
+/*!
+ Returns read-only status of the property.
+
+ When property is read-only it's value can be selected and copied from editor but not modified.
+
+ \sa QtStringPropertyManager::setReadOnly
+*/
+bool QtStringPropertyManager::isReadOnly(const QtProperty *property) const
+{
+ return getData<bool>(d_ptr->m_values, &QtStringPropertyManagerPrivate::Data::readOnly, property, false);
+}
+
+/*!
+ \reimp
+*/
+QString QtStringPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtStringPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ return it.value().val;
+}
+
+/*!
+ \reimp
+*/
+QString QtStringPropertyManager::displayText(const QtProperty *property) const
+{
+ const QtStringPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ QLineEdit edit;
+ edit.setEchoMode((EchoMode)it.value().echoMode);
+ edit.setText(it.value().val);
+ return edit.displayText();
+}
+
+/*!
+ \fn void QtStringPropertyManager::setValue(QtProperty *property, const QString &value)
+
+ Sets the value of the given \a property to \a value.
+
+ If the specified \a value doesn't match the given \a property's
+ regular expression, this function does nothing.
+
+ \sa value(), setRegExp(), valueChanged()
+*/
+void QtStringPropertyManager::setValue(QtProperty *property, const QString &val)
+{
+ const QtStringPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtStringPropertyManagerPrivate::Data data = it.value();
+
+ if (data.val == val)
+ return;
+
+ if (data.regExp.isValid() && !data.regExp.exactMatch(val))
+ return;
+
+ data.val = val;
+
+ it.value() = data;
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ Sets the regular expression of the given \a property to \a regExp.
+
+ \sa regExp(), setValue(), regExpChanged()
+*/
+void QtStringPropertyManager::setRegExp(QtProperty *property, const QRegExp ®Exp)
+{
+ const QtStringPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtStringPropertyManagerPrivate::Data data = it.value() ;
+
+ if (data.regExp == regExp)
+ return;
+
+ data.regExp = regExp;
+
+ it.value() = data;
+
+ emit regExpChanged(property, data.regExp);
+}
+
+
+void QtStringPropertyManager::setEchoMode(QtProperty *property, EchoMode echoMode)
+{
+ const QtStringPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtStringPropertyManagerPrivate::Data data = it.value();
+
+ if (data.echoMode == echoMode)
+ return;
+
+ data.echoMode = echoMode;
+ it.value() = data;
+
+ emit propertyChanged(property);
+ emit echoModeChanged(property, data.echoMode);
+}
+
+/*!
+ Sets read-only status of the property.
+
+ \sa QtStringPropertyManager::setReadOnly
+*/
+void QtStringPropertyManager::setReadOnly(QtProperty *property, bool readOnly)
+{
+ const QtStringPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtStringPropertyManagerPrivate::Data data = it.value();
+
+ if (data.readOnly == readOnly)
+ return;
+
+ data.readOnly = readOnly;
+ it.value() = data;
+
+ emit propertyChanged(property);
+ emit echoModeChanged(property, data.echoMode);
+}
+
+/*!
+ \reimp
+*/
+void QtStringPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtStringPropertyManagerPrivate::Data();
+}
+
+/*!
+ \reimp
+*/
+void QtStringPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtBoolPropertyManager
+// Return an icon containing a check box indicator
+static QIcon drawCheckBox(bool value)
+{
+ QStyleOptionButton opt;
+ opt.state |= value ? QStyle::State_On : QStyle::State_Off;
+ opt.state |= QStyle::State_Enabled;
+ const QStyle *style = QApplication::style();
+ // Figure out size of an indicator and make sure it is not scaled down in a list view item
+ // by making the pixmap as big as a list view icon and centering the indicator in it.
+ // (if it is smaller, it can't be helped)
+ const int indicatorWidth = style->pixelMetric(QStyle::PM_IndicatorWidth, &opt);
+ const int indicatorHeight = style->pixelMetric(QStyle::PM_IndicatorHeight, &opt);
+ const int listViewIconSize = indicatorWidth;
+ const int pixmapWidth = indicatorWidth;
+ const int pixmapHeight = qMax(indicatorHeight, listViewIconSize);
+
+ opt.rect = QRect(0, 0, indicatorWidth, indicatorHeight);
+ QPixmap pixmap = QPixmap(pixmapWidth, pixmapHeight);
+ pixmap.fill(Qt::transparent);
+ {
+ // Center?
+ const int xoff = (pixmapWidth > indicatorWidth) ? (pixmapWidth - indicatorWidth) / 2 : 0;
+ const int yoff = (pixmapHeight > indicatorHeight) ? (pixmapHeight - indicatorHeight) / 2 : 0;
+ QPainter painter(&pixmap);
+ painter.translate(xoff, yoff);
+ style->drawPrimitive(QStyle::PE_IndicatorCheckBox, &opt, &painter);
+ }
+ return QIcon(pixmap);
+}
+
+class QtBoolPropertyManagerPrivate
+{
+ QtBoolPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtBoolPropertyManager)
+public:
+ QtBoolPropertyManagerPrivate();
+
+ QMap<const QtProperty *, bool> m_values;
+ const QIcon m_checkedIcon;
+ const QIcon m_uncheckedIcon;
+};
+
+QtBoolPropertyManagerPrivate::QtBoolPropertyManagerPrivate() :
+ m_checkedIcon(drawCheckBox(true)),
+ m_uncheckedIcon(drawCheckBox(false))
+{
+}
+
+/*!
+ \class QtBoolPropertyManager
+
+ \brief The QtBoolPropertyManager class provides and manages boolean properties.
+
+ The property's value can be retrieved using the value() function,
+ and set using the setValue() slot.
+
+ In addition, QtBoolPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes.
+
+ \sa QtAbstractPropertyManager, QtCheckBoxFactory
+*/
+
+/*!
+ \fn void QtBoolPropertyManager::valueChanged(QtProperty *property, bool value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtBoolPropertyManager::QtBoolPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtBoolPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtBoolPropertyManager::~QtBoolPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by \e this manager, this
+ function returns false.
+
+ \sa setValue()
+*/
+bool QtBoolPropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, false);
+}
+
+/*!
+ \reimp
+*/
+QString QtBoolPropertyManager::valueText(const QtProperty *property) const
+{
+ const QMap<const QtProperty *, bool>::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ static const QString trueText = tr("True");
+ static const QString falseText = tr("False");
+ return it.value() ? trueText : falseText;
+}
+
+/*!
+ \reimp
+*/
+QIcon QtBoolPropertyManager::valueIcon(const QtProperty *property) const
+{
+ const QMap<const QtProperty *, bool>::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QIcon();
+
+ return it.value() ? d_ptr->m_checkedIcon : d_ptr->m_uncheckedIcon;
+}
+
+/*!
+ \fn void QtBoolPropertyManager::setValue(QtProperty *property, bool value)
+
+ Sets the value of the given \a property to \a value.
+
+ \sa value()
+*/
+void QtBoolPropertyManager::setValue(QtProperty *property, bool val)
+{
+ setSimpleValue<bool, bool, QtBoolPropertyManager>(d_ptr->m_values, this,
+ &QtBoolPropertyManager::propertyChanged,
+ &QtBoolPropertyManager::valueChanged,
+ property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtBoolPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = false;
+}
+
+/*!
+ \reimp
+*/
+void QtBoolPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtDatePropertyManager
+
+class QtDatePropertyManagerPrivate
+{
+ QtDatePropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtDatePropertyManager)
+public:
+
+ struct Data
+ {
+ Data() : val(QDate::currentDate()), minVal(QDate(1752, 9, 14)),
+ maxVal(QDate(7999, 12, 31)) {}
+ QDate val;
+ QDate minVal;
+ QDate maxVal;
+ QDate minimumValue() const { return minVal; }
+ QDate maximumValue() const { return maxVal; }
+ void setMinimumValue(const QDate &newMinVal) { setSimpleMinimumData(this, newMinVal); }
+ void setMaximumValue(const QDate &newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
+ };
+
+ QString m_format;
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ QMap<const QtProperty *, Data> m_values;
+};
+
+/*!
+ \class QtDatePropertyManager
+
+ \brief The QtDatePropertyManager provides and manages QDate properties.
+
+ A date property has a current value, and a range specifying the
+ valid dates. The range is defined by a minimum and a maximum
+ value.
+
+ The property's values can be retrieved using the minimum(),
+ maximum() and value() functions, and can be set using the
+ setMinimum(), setMaximum() and setValue() slots. Alternatively,
+ the range can be defined in one go using the setRange() slot.
+
+ In addition, QtDatePropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes, and the rangeChanged() signal which is emitted whenever
+ such a property changes its range of valid dates.
+
+ \sa QtAbstractPropertyManager, QtDateEditFactory, QtDateTimePropertyManager
+*/
+
+/*!
+ \fn void QtDatePropertyManager::valueChanged(QtProperty *property, const QDate &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtDatePropertyManager::rangeChanged(QtProperty *property, const QDate &minimum, const QDate &maximum)
+
+ This signal is emitted whenever a property created by this manager
+ changes its range of valid dates, passing a pointer to the \a
+ property and the new \a minimum and \a maximum dates.
+
+ \sa setRange()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtDatePropertyManager::QtDatePropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtDatePropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ QLocale loc;
+ d_ptr->m_format = loc.dateFormat(QLocale::ShortFormat);
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtDatePropertyManager::~QtDatePropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by \e this manager, this
+ function returns an invalid date.
+
+ \sa setValue()
+*/
+QDate QtDatePropertyManager::value(const QtProperty *property) const
+{
+ return getValue<QDate>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's minimum date.
+
+ \sa maximum(), setRange()
+*/
+QDate QtDatePropertyManager::minimum(const QtProperty *property) const
+{
+ return getMinimum<QDate>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's maximum date.
+
+ \sa minimum(), setRange()
+*/
+QDate QtDatePropertyManager::maximum(const QtProperty *property) const
+{
+ return getMaximum<QDate>(d_ptr->m_values, property);
+}
+
+/*!
+ \reimp
+*/
+QString QtDatePropertyManager::valueText(const QtProperty *property) const
+{
+ const QtDatePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ return it.value().val.toString(d_ptr->m_format);
+}
+
+/*!
+ \fn void QtDatePropertyManager::setValue(QtProperty *property, const QDate &value)
+
+ Sets the value of the given \a property to \a value.
+
+ If the specified \a value is not a valid date according to the
+ given \a property's range, the value is adjusted to the nearest
+ valid value within the range.
+
+ \sa value(), setRange(), valueChanged()
+*/
+void QtDatePropertyManager::setValue(QtProperty *property, const QDate &val)
+{
+ void (QtDatePropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, const QDate &) = 0;
+ setValueInRange<const QDate &, QtDatePropertyManagerPrivate, QtDatePropertyManager, const QDate>(this, d_ptr,
+ &QtDatePropertyManager::propertyChanged,
+ &QtDatePropertyManager::valueChanged,
+ property, val, setSubPropertyValue);
+}
+
+/*!
+ Sets the minimum value for the given \a property to \a minVal.
+
+ When setting the minimum value, the maximum and current values are
+ adjusted if necessary (ensuring that the range remains valid and
+ that the current value is within in the range).
+
+ \sa minimum(), setRange()
+*/
+void QtDatePropertyManager::setMinimum(QtProperty *property, const QDate &minVal)
+{
+ setMinimumValue<const QDate &, QtDatePropertyManagerPrivate, QtDatePropertyManager, QDate, QtDatePropertyManagerPrivate::Data>(this, d_ptr,
+ &QtDatePropertyManager::propertyChanged,
+ &QtDatePropertyManager::valueChanged,
+ &QtDatePropertyManager::rangeChanged,
+ property, minVal);
+}
+
+/*!
+ Sets the maximum value for the given \a property to \a maxVal.
+
+ When setting the maximum value, the minimum and current
+ values are adjusted if necessary (ensuring that the range remains
+ valid and that the current value is within in the range).
+
+ \sa maximum(), setRange()
+*/
+void QtDatePropertyManager::setMaximum(QtProperty *property, const QDate &maxVal)
+{
+ setMaximumValue<const QDate &, QtDatePropertyManagerPrivate, QtDatePropertyManager, QDate, QtDatePropertyManagerPrivate::Data>(this, d_ptr,
+ &QtDatePropertyManager::propertyChanged,
+ &QtDatePropertyManager::valueChanged,
+ &QtDatePropertyManager::rangeChanged,
+ property, maxVal);
+}
+
+/*!
+ \fn void QtDatePropertyManager::setRange(QtProperty *property, const QDate &minimum, const QDate &maximum)
+
+ Sets the range of valid dates.
+
+ This is a convenience function defining the range of valid dates
+ in one go; setting the \a minimum and \a maximum values for the
+ given \a property with a single function call.
+
+ When setting a new date range, the current value is adjusted if
+ necessary (ensuring that the value remains in date range).
+
+ \sa setMinimum(), setMaximum(), rangeChanged()
+*/
+void QtDatePropertyManager::setRange(QtProperty *property, const QDate &minVal, const QDate &maxVal)
+{
+ void (QtDatePropertyManagerPrivate::*setSubPropertyRange)(QtProperty *, const QDate &,
+ const QDate &, const QDate &) = 0;
+ setBorderValues<const QDate &, QtDatePropertyManagerPrivate, QtDatePropertyManager, QDate>(this, d_ptr,
+ &QtDatePropertyManager::propertyChanged,
+ &QtDatePropertyManager::valueChanged,
+ &QtDatePropertyManager::rangeChanged,
+ property, minVal, maxVal, setSubPropertyRange);
+}
+
+/*!
+ \reimp
+*/
+void QtDatePropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtDatePropertyManagerPrivate::Data();
+}
+
+/*!
+ \reimp
+*/
+void QtDatePropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtTimePropertyManager
+
+class QtTimePropertyManagerPrivate
+{
+ QtTimePropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtTimePropertyManager)
+public:
+
+ QString m_format;
+
+ typedef QMap<const QtProperty *, QTime> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*!
+ \class QtTimePropertyManager
+
+ \brief The QtTimePropertyManager provides and manages QTime properties.
+
+ A time property's value can be retrieved using the value()
+ function, and set using the setValue() slot.
+
+ In addition, QtTimePropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes.
+
+ \sa QtAbstractPropertyManager, QtTimeEditFactory
+*/
+
+/*!
+ \fn void QtTimePropertyManager::valueChanged(QtProperty *property, const QTime &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtTimePropertyManager::QtTimePropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtTimePropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ QLocale loc;
+ d_ptr->m_format = loc.timeFormat(QLocale::ShortFormat);
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtTimePropertyManager::~QtTimePropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns an invalid time object.
+
+ \sa setValue()
+*/
+QTime QtTimePropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QTime());
+}
+
+/*!
+ \reimp
+*/
+QString QtTimePropertyManager::valueText(const QtProperty *property) const
+{
+ const QtTimePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ return it.value().toString(d_ptr->m_format);
+}
+
+/*!
+ \fn void QtTimePropertyManager::setValue(QtProperty *property, const QTime &value)
+
+ Sets the value of the given \a property to \a value.
+
+ \sa value(), valueChanged()
+*/
+void QtTimePropertyManager::setValue(QtProperty *property, const QTime &val)
+{
+ setSimpleValue<const QTime &, QTime, QtTimePropertyManager>(d_ptr->m_values, this,
+ &QtTimePropertyManager::propertyChanged,
+ &QtTimePropertyManager::valueChanged,
+ property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtTimePropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QTime::currentTime();
+}
+
+/*!
+ \reimp
+*/
+void QtTimePropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtDateTimePropertyManager
+
+class QtDateTimePropertyManagerPrivate
+{
+ QtDateTimePropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtDateTimePropertyManager)
+public:
+
+ QString m_format;
+
+ typedef QMap<const QtProperty *, QDateTime> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*! \class QtDateTimePropertyManager
+
+ \brief The QtDateTimePropertyManager provides and manages QDateTime properties.
+
+ A date and time property has a current value which can be
+ retrieved using the value() function, and set using the setValue()
+ slot. In addition, QtDateTimePropertyManager provides the
+ valueChanged() signal which is emitted whenever a property created
+ by this manager changes.
+
+ \sa QtAbstractPropertyManager, QtDateTimeEditFactory, QtDatePropertyManager
+*/
+
+/*!
+ \fn void QtDateTimePropertyManager::valueChanged(QtProperty *property, const QDateTime &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtDateTimePropertyManager::QtDateTimePropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtDateTimePropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ QLocale loc;
+ d_ptr->m_format = loc.dateFormat(QLocale::ShortFormat);
+ d_ptr->m_format += QLatin1Char(' ');
+ d_ptr->m_format += loc.timeFormat(QLocale::ShortFormat);
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtDateTimePropertyManager::~QtDateTimePropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns an invalid QDateTime object.
+
+ \sa setValue()
+*/
+QDateTime QtDateTimePropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QDateTime());
+}
+
+/*!
+ \reimp
+*/
+QString QtDateTimePropertyManager::valueText(const QtProperty *property) const
+{
+ const QtDateTimePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ return it.value().toString(d_ptr->m_format);
+}
+
+/*!
+ \fn void QtDateTimePropertyManager::setValue(QtProperty *property, const QDateTime &value)
+
+ Sets the value of the given \a property to \a value.
+
+ \sa value(), valueChanged()
+*/
+void QtDateTimePropertyManager::setValue(QtProperty *property, const QDateTime &val)
+{
+ setSimpleValue<const QDateTime &, QDateTime, QtDateTimePropertyManager>(d_ptr->m_values, this,
+ &QtDateTimePropertyManager::propertyChanged,
+ &QtDateTimePropertyManager::valueChanged,
+ property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtDateTimePropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QDateTime::currentDateTime();
+}
+
+/*!
+ \reimp
+*/
+void QtDateTimePropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtKeySequencePropertyManager
+
+class QtKeySequencePropertyManagerPrivate
+{
+ QtKeySequencePropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtKeySequencePropertyManager)
+public:
+
+ QString m_format;
+
+ typedef QMap<const QtProperty *, QKeySequence> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*! \class QtKeySequencePropertyManager
+
+ \brief The QtKeySequencePropertyManager provides and manages QKeySequence properties.
+
+ A key sequence's value can be retrieved using the value()
+ function, and set using the setValue() slot.
+
+ In addition, QtKeySequencePropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes.
+
+ \sa QtAbstractPropertyManager
+*/
+
+/*!
+ \fn void QtKeySequencePropertyManager::valueChanged(QtProperty *property, const QKeySequence &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtKeySequencePropertyManager::QtKeySequencePropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtKeySequencePropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtKeySequencePropertyManager::~QtKeySequencePropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns an empty QKeySequence object.
+
+ \sa setValue()
+*/
+QKeySequence QtKeySequencePropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QKeySequence());
+}
+
+/*!
+ \reimp
+*/
+QString QtKeySequencePropertyManager::valueText(const QtProperty *property) const
+{
+ const QtKeySequencePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ return it.value().toString(QKeySequence::NativeText);
+}
+
+/*!
+ \fn void QtKeySequencePropertyManager::setValue(QtProperty *property, const QKeySequence &value)
+
+ Sets the value of the given \a property to \a value.
+
+ \sa value(), valueChanged()
+*/
+void QtKeySequencePropertyManager::setValue(QtProperty *property, const QKeySequence &val)
+{
+ setSimpleValue<const QKeySequence &, QKeySequence, QtKeySequencePropertyManager>(d_ptr->m_values, this,
+ &QtKeySequencePropertyManager::propertyChanged,
+ &QtKeySequencePropertyManager::valueChanged,
+ property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtKeySequencePropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QKeySequence();
+}
+
+/*!
+ \reimp
+*/
+void QtKeySequencePropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtCharPropertyManager
+
+class QtCharPropertyManagerPrivate
+{
+ QtCharPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtCharPropertyManager)
+public:
+
+ typedef QMap<const QtProperty *, QChar> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*! \class QtCharPropertyManager
+
+ \brief The QtCharPropertyManager provides and manages QChar properties.
+
+ A char's value can be retrieved using the value()
+ function, and set using the setValue() slot.
+
+ In addition, QtCharPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes.
+
+ \sa QtAbstractPropertyManager
+*/
+
+/*!
+ \fn void QtCharPropertyManager::valueChanged(QtProperty *property, const QChar &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtCharPropertyManager::QtCharPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtCharPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtCharPropertyManager::~QtCharPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns an null QChar object.
+
+ \sa setValue()
+*/
+QChar QtCharPropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QChar());
+}
+
+/*!
+ \reimp
+*/
+QString QtCharPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtCharPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ const QChar c = it.value();
+ return c.isNull() ? QString() : QString(c);
+}
+
+/*!
+ \fn void QtCharPropertyManager::setValue(QtProperty *property, const QChar &value)
+
+ Sets the value of the given \a property to \a value.
+
+ \sa value(), valueChanged()
+*/
+void QtCharPropertyManager::setValue(QtProperty *property, const QChar &val)
+{
+ setSimpleValue<const QChar &, QChar, QtCharPropertyManager>(d_ptr->m_values, this,
+ &QtCharPropertyManager::propertyChanged,
+ &QtCharPropertyManager::valueChanged,
+ property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtCharPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QChar();
+}
+
+/*!
+ \reimp
+*/
+void QtCharPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtLocalePropertyManager
+
+class QtLocalePropertyManagerPrivate
+{
+ QtLocalePropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtLocalePropertyManager)
+public:
+
+ QtLocalePropertyManagerPrivate();
+
+ void slotEnumChanged(QtProperty *property, int value);
+ void slotPropertyDestroyed(QtProperty *property);
+
+ typedef QMap<const QtProperty *, QLocale> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtEnumPropertyManager *m_enumPropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToLanguage;
+ QMap<const QtProperty *, QtProperty *> m_propertyToCountry;
+
+ QMap<const QtProperty *, QtProperty *> m_languageToProperty;
+ QMap<const QtProperty *, QtProperty *> m_countryToProperty;
+};
+
+QtLocalePropertyManagerPrivate::QtLocalePropertyManagerPrivate()
+{
+}
+
+void QtLocalePropertyManagerPrivate::slotEnumChanged(QtProperty *property, int value)
+{
+ if (QtProperty *prop = m_languageToProperty.value(property, 0)) {
+ const QLocale loc = m_values[prop];
+ QLocale::Language newLanguage = loc.language();
+ QLocale::Country newCountry = loc.country();
+ metaEnumProvider()->indexToLocale(value, 0, &newLanguage, 0);
+ QLocale newLoc(newLanguage, newCountry);
+ q_ptr->setValue(prop, newLoc);
+ } else if (QtProperty *prop = m_countryToProperty.value(property, 0)) {
+ const QLocale loc = m_values[prop];
+ QLocale::Language newLanguage = loc.language();
+ QLocale::Country newCountry = loc.country();
+ metaEnumProvider()->indexToLocale(m_enumPropertyManager->value(m_propertyToLanguage.value(prop)), value, &newLanguage, &newCountry);
+ QLocale newLoc(newLanguage, newCountry);
+ q_ptr->setValue(prop, newLoc);
+ }
+}
+
+void QtLocalePropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *subProp = m_languageToProperty.value(property, 0)) {
+ m_propertyToLanguage[subProp] = 0;
+ m_languageToProperty.remove(property);
+ } else if (QtProperty *subProp = m_countryToProperty.value(property, 0)) {
+ m_propertyToCountry[subProp] = 0;
+ m_countryToProperty.remove(property);
+ }
+}
+
+/*!
+ \class QtLocalePropertyManager
+
+ \brief The QtLocalePropertyManager provides and manages QLocale properties.
+
+ A locale property has nested \e language and \e country
+ subproperties. The top-level property's value can be retrieved
+ using the value() function, and set using the setValue() slot.
+
+ The subproperties are created by QtEnumPropertyManager object.
+ These submanager can be retrieved using the subEnumPropertyManager()
+ function. In order to provide editing widgets for the subproperties
+ in a property browser widget, this manager must be associated with editor factory.
+
+ In addition, QtLocalePropertyManager provides the valueChanged()
+ signal which is emitted whenever a property created by this
+ manager changes.
+
+ \sa QtAbstractPropertyManager, QtEnumPropertyManager
+*/
+
+/*!
+ \fn void QtLocalePropertyManager::valueChanged(QtProperty *property, const QLocale &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtLocalePropertyManager::QtLocalePropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtLocalePropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
+ connect(d_ptr->m_enumPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotEnumChanged(QtProperty *, int)));
+
+ connect(d_ptr->m_enumPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtLocalePropertyManager::~QtLocalePropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the nested \e language
+ and \e country subproperties.
+
+ In order to provide editing widgets for the mentioned subproperties
+ in a property browser widget, this manager must be associated with
+ an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtEnumPropertyManager *QtLocalePropertyManager::subEnumPropertyManager() const
+{
+ return d_ptr->m_enumPropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns the default locale.
+
+ \sa setValue()
+*/
+QLocale QtLocalePropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QLocale());
+}
+
+/*!
+ \reimp
+*/
+QString QtLocalePropertyManager::valueText(const QtProperty *property) const
+{
+ const QtLocalePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ QLocale loc = it.value();
+
+ int langIdx = 0;
+ int countryIdx = 0;
+ metaEnumProvider()->localeToIndex(loc.language(), loc.country(), &langIdx, &countryIdx);
+ QString str = tr("%1, %2")
+ .arg(metaEnumProvider()->languageEnumNames().at(langIdx))
+ .arg(metaEnumProvider()->countryEnumNames(loc.language()).at(countryIdx));
+ return str;
+}
+
+/*!
+ \fn void QtLocalePropertyManager::setValue(QtProperty *property, const QLocale &value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ \sa value(), valueChanged()
+*/
+void QtLocalePropertyManager::setValue(QtProperty *property, const QLocale &val)
+{
+ const QtLocalePropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ const QLocale loc = it.value();
+ if (loc == val)
+ return;
+
+ it.value() = val;
+
+ int langIdx = 0;
+ int countryIdx = 0;
+ metaEnumProvider()->localeToIndex(val.language(), val.country(), &langIdx, &countryIdx);
+ if (loc.language() != val.language()) {
+ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToLanguage.value(property), langIdx);
+ d_ptr->m_enumPropertyManager->setEnumNames(d_ptr->m_propertyToCountry.value(property),
+ metaEnumProvider()->countryEnumNames(val.language()));
+ }
+ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToCountry.value(property), countryIdx);
+
+ emit propertyChanged(property);
+ emit valueChanged(property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtLocalePropertyManager::initializeProperty(QtProperty *property)
+{
+ QLocale val;
+ d_ptr->m_values[property] = val;
+
+ int langIdx = 0;
+ int countryIdx = 0;
+ metaEnumProvider()->localeToIndex(val.language(), val.country(), &langIdx, &countryIdx);
+
+ QtProperty *languageProp = d_ptr->m_enumPropertyManager->addProperty();
+ languageProp->setPropertyName(tr("Language"));
+ d_ptr->m_enumPropertyManager->setEnumNames(languageProp, metaEnumProvider()->languageEnumNames());
+ d_ptr->m_enumPropertyManager->setValue(languageProp, langIdx);
+ d_ptr->m_propertyToLanguage[property] = languageProp;
+ d_ptr->m_languageToProperty[languageProp] = property;
+ property->addSubProperty(languageProp);
+
+ QtProperty *countryProp = d_ptr->m_enumPropertyManager->addProperty();
+ countryProp->setPropertyName(tr("Country"));
+ d_ptr->m_enumPropertyManager->setEnumNames(countryProp, metaEnumProvider()->countryEnumNames(val.language()));
+ d_ptr->m_enumPropertyManager->setValue(countryProp, countryIdx);
+ d_ptr->m_propertyToCountry[property] = countryProp;
+ d_ptr->m_countryToProperty[countryProp] = property;
+ property->addSubProperty(countryProp);
+}
+
+/*!
+ \reimp
+*/
+void QtLocalePropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *languageProp = d_ptr->m_propertyToLanguage[property];
+ if (languageProp) {
+ d_ptr->m_languageToProperty.remove(languageProp);
+ delete languageProp;
+ }
+ d_ptr->m_propertyToLanguage.remove(property);
+
+ QtProperty *countryProp = d_ptr->m_propertyToCountry[property];
+ if (countryProp) {
+ d_ptr->m_countryToProperty.remove(countryProp);
+ delete countryProp;
+ }
+ d_ptr->m_propertyToCountry.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtPointPropertyManager
+
+class QtPointPropertyManagerPrivate
+{
+ QtPointPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtPointPropertyManager)
+public:
+
+ void slotIntChanged(QtProperty *property, int value);
+ void slotPropertyDestroyed(QtProperty *property);
+
+ typedef QMap<const QtProperty *, QPoint> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtIntPropertyManager *m_intPropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToX;
+ QMap<const QtProperty *, QtProperty *> m_propertyToY;
+
+ QMap<const QtProperty *, QtProperty *> m_xToProperty;
+ QMap<const QtProperty *, QtProperty *> m_yToProperty;
+};
+
+void QtPointPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+ if (QtProperty *xprop = m_xToProperty.value(property, 0)) {
+ QPoint p = m_values[xprop];
+ p.setX(value);
+ q_ptr->setValue(xprop, p);
+ } else if (QtProperty *yprop = m_yToProperty.value(property, 0)) {
+ QPoint p = m_values[yprop];
+ p.setY(value);
+ q_ptr->setValue(yprop, p);
+ }
+}
+
+void QtPointPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_xToProperty.value(property, 0)) {
+ m_propertyToX[pointProp] = 0;
+ m_xToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_yToProperty.value(property, 0)) {
+ m_propertyToY[pointProp] = 0;
+ m_yToProperty.remove(property);
+ }
+}
+
+/*! \class QtPointPropertyManager
+
+ \brief The QtPointPropertyManager provides and manages QPoint properties.
+
+ A point property has nested \e x and \e y subproperties. The
+ top-level property's value can be retrieved using the value()
+ function, and set using the setValue() slot.
+
+ The subproperties are created by a QtIntPropertyManager object. This
+ manager can be retrieved using the subIntPropertyManager() function. In
+ order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ In addition, QtPointPropertyManager provides the valueChanged() signal which
+ is emitted whenever a property created by this manager changes.
+
+ \sa QtAbstractPropertyManager, QtIntPropertyManager, QtPointFPropertyManager
+*/
+
+/*!
+ \fn void QtPointPropertyManager::valueChanged(QtProperty *property, const QPoint &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtPointPropertyManager::QtPointPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtPointPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
+ connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotIntChanged(QtProperty *, int)));
+ connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtPointPropertyManager::~QtPointPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the nested \e x and \e y
+ subproperties.
+
+ In order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtIntPropertyManager *QtPointPropertyManager::subIntPropertyManager() const
+{
+ return d_ptr->m_intPropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns a point with coordinates (0, 0).
+
+ \sa setValue()
+*/
+QPoint QtPointPropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QPoint());
+}
+
+/*!
+ \reimp
+*/
+QString QtPointPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtPointPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ const QPoint v = it.value();
+ return QString(tr("(%1, %2)").arg(QString::number(v.x()))
+ .arg(QString::number(v.y())));
+}
+
+/*!
+ \fn void QtPointPropertyManager::setValue(QtProperty *property, const QPoint &value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ \sa value(), valueChanged()
+*/
+void QtPointPropertyManager::setValue(QtProperty *property, const QPoint &val)
+{
+ const QtPointPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ if (it.value() == val)
+ return;
+
+ it.value() = val;
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToX[property], val.x());
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToY[property], val.y());
+
+ emit propertyChanged(property);
+ emit valueChanged(property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtPointPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QPoint(0, 0);
+
+ QtProperty *xProp = d_ptr->m_intPropertyManager->addProperty();
+ xProp->setPropertyName(tr("X"));
+ d_ptr->m_intPropertyManager->setValue(xProp, 0);
+ d_ptr->m_propertyToX[property] = xProp;
+ d_ptr->m_xToProperty[xProp] = property;
+ property->addSubProperty(xProp);
+
+ QtProperty *yProp = d_ptr->m_intPropertyManager->addProperty();
+ yProp->setPropertyName(tr("Y"));
+ d_ptr->m_intPropertyManager->setValue(yProp, 0);
+ d_ptr->m_propertyToY[property] = yProp;
+ d_ptr->m_yToProperty[yProp] = property;
+ property->addSubProperty(yProp);
+}
+
+/*!
+ \reimp
+*/
+void QtPointPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *xProp = d_ptr->m_propertyToX[property];
+ if (xProp) {
+ d_ptr->m_xToProperty.remove(xProp);
+ delete xProp;
+ }
+ d_ptr->m_propertyToX.remove(property);
+
+ QtProperty *yProp = d_ptr->m_propertyToY[property];
+ if (yProp) {
+ d_ptr->m_yToProperty.remove(yProp);
+ delete yProp;
+ }
+ d_ptr->m_propertyToY.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtPointFPropertyManager
+
+class QtPointFPropertyManagerPrivate
+{
+ QtPointFPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtPointFPropertyManager)
+public:
+
+ struct Data
+ {
+ Data() : decimals(2) {}
+ QPointF val;
+ int decimals;
+ };
+
+ void slotDoubleChanged(QtProperty *property, double value);
+ void slotPropertyDestroyed(QtProperty *property);
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtDoublePropertyManager *m_doublePropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToX;
+ QMap<const QtProperty *, QtProperty *> m_propertyToY;
+
+ QMap<const QtProperty *, QtProperty *> m_xToProperty;
+ QMap<const QtProperty *, QtProperty *> m_yToProperty;
+};
+
+void QtPointFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
+{
+ if (QtProperty *prop = m_xToProperty.value(property, 0)) {
+ QPointF p = m_values[prop].val;
+ p.setX(value);
+ q_ptr->setValue(prop, p);
+ } else if (QtProperty *prop = m_yToProperty.value(property, 0)) {
+ QPointF p = m_values[prop].val;
+ p.setY(value);
+ q_ptr->setValue(prop, p);
+ }
+}
+
+void QtPointFPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_xToProperty.value(property, 0)) {
+ m_propertyToX[pointProp] = 0;
+ m_xToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_yToProperty.value(property, 0)) {
+ m_propertyToY[pointProp] = 0;
+ m_yToProperty.remove(property);
+ }
+}
+
+/*! \class QtPointFPropertyManager
+
+ \brief The QtPointFPropertyManager provides and manages QPointF properties.
+
+ A point property has nested \e x and \e y subproperties. The
+ top-level property's value can be retrieved using the value()
+ function, and set using the setValue() slot.
+
+ The subproperties are created by a QtDoublePropertyManager object. This
+ manager can be retrieved using the subDoublePropertyManager() function. In
+ order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ In addition, QtPointFPropertyManager provides the valueChanged() signal which
+ is emitted whenever a property created by this manager changes.
+
+ \sa QtAbstractPropertyManager, QtDoublePropertyManager, QtPointPropertyManager
+*/
+
+/*!
+ \fn void QtPointFPropertyManager::valueChanged(QtProperty *property, const QPointF &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtPointFPropertyManager::decimalsChanged(QtProperty *property, int prec)
+
+ This signal is emitted whenever a property created by this manager
+ changes its precision of value, passing a pointer to the
+ \a property and the new \a prec value
+
+ \sa setDecimals()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtPointFPropertyManager::QtPointFPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtPointFPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_doublePropertyManager = new QtDoublePropertyManager(this);
+ connect(d_ptr->m_doublePropertyManager, SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotDoubleChanged(QtProperty *, double)));
+ connect(d_ptr->m_doublePropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtPointFPropertyManager::~QtPointFPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the nested \e x and \e y
+ subproperties.
+
+ In order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtDoublePropertyManager *QtPointFPropertyManager::subDoublePropertyManager() const
+{
+ return d_ptr->m_doublePropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns a point with coordinates (0, 0).
+
+ \sa setValue()
+*/
+QPointF QtPointFPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<QPointF>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's precision, in decimals.
+
+ \sa setDecimals()
+*/
+int QtPointFPropertyManager::decimals(const QtProperty *property) const
+{
+ return getData<int>(d_ptr->m_values, &QtPointFPropertyManagerPrivate::Data::decimals, property, 0);
+}
+
+/*!
+ \reimp
+*/
+QString QtPointFPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtPointFPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ const QPointF v = it.value().val;
+ const int dec = it.value().decimals;
+ return QString(tr("(%1, %2)").arg(QString::number(v.x(), 'f', dec))
+ .arg(QString::number(v.y(), 'f', dec)));
+}
+
+/*!
+ \fn void QtPointFPropertyManager::setValue(QtProperty *property, const QPointF &value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ \sa value(), valueChanged()
+*/
+void QtPointFPropertyManager::setValue(QtProperty *property, const QPointF &val)
+{
+ const QtPointFPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ if (it.value().val == val)
+ return;
+
+ it.value().val = val;
+ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToX[property], val.x());
+ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToY[property], val.y());
+
+ emit propertyChanged(property);
+ emit valueChanged(property, val);
+}
+
+/*!
+ \fn void QtPointFPropertyManager::setDecimals(QtProperty *property, int prec)
+
+ Sets the precision of the given \a property to \a prec.
+
+ The valid decimal range is 0-13. The default is 2.
+
+ \sa decimals()
+*/
+void QtPointFPropertyManager::setDecimals(QtProperty *property, int prec)
+{
+ const QtPointFPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtPointFPropertyManagerPrivate::Data data = it.value();
+
+ if (prec > 13)
+ prec = 13;
+ else if (prec < 0)
+ prec = 0;
+
+ if (data.decimals == prec)
+ return;
+
+ data.decimals = prec;
+ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToX[property], prec);
+ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToY[property], prec);
+
+ it.value() = data;
+
+ emit decimalsChanged(property, data.decimals);
+}
+
+/*!
+ \reimp
+*/
+void QtPointFPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtPointFPropertyManagerPrivate::Data();
+
+ QtProperty *xProp = d_ptr->m_doublePropertyManager->addProperty();
+ xProp->setPropertyName(tr("X"));
+ d_ptr->m_doublePropertyManager->setDecimals(xProp, decimals(property));
+ d_ptr->m_doublePropertyManager->setValue(xProp, 0);
+ d_ptr->m_propertyToX[property] = xProp;
+ d_ptr->m_xToProperty[xProp] = property;
+ property->addSubProperty(xProp);
+
+ QtProperty *yProp = d_ptr->m_doublePropertyManager->addProperty();
+ yProp->setPropertyName(tr("Y"));
+ d_ptr->m_doublePropertyManager->setDecimals(yProp, decimals(property));
+ d_ptr->m_doublePropertyManager->setValue(yProp, 0);
+ d_ptr->m_propertyToY[property] = yProp;
+ d_ptr->m_yToProperty[yProp] = property;
+ property->addSubProperty(yProp);
+}
+
+/*!
+ \reimp
+*/
+void QtPointFPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *xProp = d_ptr->m_propertyToX[property];
+ if (xProp) {
+ d_ptr->m_xToProperty.remove(xProp);
+ delete xProp;
+ }
+ d_ptr->m_propertyToX.remove(property);
+
+ QtProperty *yProp = d_ptr->m_propertyToY[property];
+ if (yProp) {
+ d_ptr->m_yToProperty.remove(yProp);
+ delete yProp;
+ }
+ d_ptr->m_propertyToY.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtSizePropertyManager
+
+class QtSizePropertyManagerPrivate
+{
+ QtSizePropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtSizePropertyManager)
+public:
+
+ void slotIntChanged(QtProperty *property, int value);
+ void slotPropertyDestroyed(QtProperty *property);
+ void setValue(QtProperty *property, const QSize &val);
+ void setRange(QtProperty *property,
+ const QSize &minVal, const QSize &maxVal, const QSize &val);
+
+ struct Data
+ {
+ Data() : val(QSize(0, 0)), minVal(QSize(0, 0)), maxVal(QSize(INT_MAX, INT_MAX)) {}
+ QSize val;
+ QSize minVal;
+ QSize maxVal;
+ QSize minimumValue() const { return minVal; }
+ QSize maximumValue() const { return maxVal; }
+ void setMinimumValue(const QSize &newMinVal) { setSizeMinimumData(this, newMinVal); }
+ void setMaximumValue(const QSize &newMaxVal) { setSizeMaximumData(this, newMaxVal); }
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtIntPropertyManager *m_intPropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToW;
+ QMap<const QtProperty *, QtProperty *> m_propertyToH;
+
+ QMap<const QtProperty *, QtProperty *> m_wToProperty;
+ QMap<const QtProperty *, QtProperty *> m_hToProperty;
+};
+
+void QtSizePropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+ if (QtProperty *prop = m_wToProperty.value(property, 0)) {
+ QSize s = m_values[prop].val;
+ s.setWidth(value);
+ q_ptr->setValue(prop, s);
+ } else if (QtProperty *prop = m_hToProperty.value(property, 0)) {
+ QSize s = m_values[prop].val;
+ s.setHeight(value);
+ q_ptr->setValue(prop, s);
+ }
+}
+
+void QtSizePropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_wToProperty.value(property, 0)) {
+ m_propertyToW[pointProp] = 0;
+ m_wToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_hToProperty.value(property, 0)) {
+ m_propertyToH[pointProp] = 0;
+ m_hToProperty.remove(property);
+ }
+}
+
+void QtSizePropertyManagerPrivate::setValue(QtProperty *property, const QSize &val)
+{
+ m_intPropertyManager->setValue(m_propertyToW.value(property), val.width());
+ m_intPropertyManager->setValue(m_propertyToH.value(property), val.height());
+}
+
+void QtSizePropertyManagerPrivate::setRange(QtProperty *property,
+ const QSize &minVal, const QSize &maxVal, const QSize &val)
+{
+ QtProperty *wProperty = m_propertyToW.value(property);
+ QtProperty *hProperty = m_propertyToH.value(property);
+ m_intPropertyManager->setRange(wProperty, minVal.width(), maxVal.width());
+ m_intPropertyManager->setValue(wProperty, val.width());
+ m_intPropertyManager->setRange(hProperty, minVal.height(), maxVal.height());
+ m_intPropertyManager->setValue(hProperty, val.height());
+}
+
+/*!
+ \class QtSizePropertyManager
+
+ \brief The QtSizePropertyManager provides and manages QSize properties.
+
+ A size property has nested \e width and \e height
+ subproperties. The top-level property's value can be retrieved
+ using the value() function, and set using the setValue() slot.
+
+ The subproperties are created by a QtIntPropertyManager object. This
+ manager can be retrieved using the subIntPropertyManager() function. In
+ order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ A size property also has a range of valid values defined by a
+ minimum size and a maximum size. These sizes can be retrieved
+ using the minimum() and the maximum() functions, and set using the
+ setMinimum() and setMaximum() slots. Alternatively, the range can
+ be defined in one go using the setRange() slot.
+
+ In addition, QtSizePropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes, and the rangeChanged() signal which is emitted whenever
+ such a property changes its range of valid sizes.
+
+ \sa QtAbstractPropertyManager, QtIntPropertyManager, QtSizeFPropertyManager
+*/
+
+/*!
+ \fn void QtSizePropertyManager::valueChanged(QtProperty *property, const QSize &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtSizePropertyManager::rangeChanged(QtProperty *property, const QSize &minimum, const QSize &maximum)
+
+ This signal is emitted whenever a property created by this manager
+ changes its range of valid sizes, passing a pointer to the \a
+ property and the new \a minimum and \a maximum sizes.
+
+ \sa setRange()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtSizePropertyManager::QtSizePropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtSizePropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
+ connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotIntChanged(QtProperty *, int)));
+ connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtSizePropertyManager::~QtSizePropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the nested \e width and \e height
+ subproperties.
+
+ In order to provide editing widgets for the \e width and \e height
+ properties in a property browser widget, this manager must be
+ associated with an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtIntPropertyManager *QtSizePropertyManager::subIntPropertyManager() const
+{
+ return d_ptr->m_intPropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns an invalid size
+
+ \sa setValue()
+*/
+QSize QtSizePropertyManager::value(const QtProperty *property) const
+{
+ return getValue<QSize>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's minimum size value.
+
+ \sa setMinimum(), maximum(), setRange()
+*/
+QSize QtSizePropertyManager::minimum(const QtProperty *property) const
+{
+ return getMinimum<QSize>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's maximum size value.
+
+ \sa setMaximum(), minimum(), setRange()
+*/
+QSize QtSizePropertyManager::maximum(const QtProperty *property) const
+{
+ return getMaximum<QSize>(d_ptr->m_values, property);
+}
+
+/*!
+ \reimp
+*/
+QString QtSizePropertyManager::valueText(const QtProperty *property) const
+{
+ const QtSizePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ const QSize v = it.value().val;
+ return QString(tr("%1 x %2").arg(QString::number(v.width()))
+ .arg(QString::number(v.height())));
+}
+
+/*!
+ \fn void QtSizePropertyManager::setValue(QtProperty *property, const QSize &value)
+
+ Sets the value of the given \a property to \a value.
+
+ If the specified \a value is not valid according to the given \a
+ property's size range, the \a value is adjusted to the nearest
+ valid value within the size range.
+
+ \sa value(), setRange(), valueChanged()
+*/
+void QtSizePropertyManager::setValue(QtProperty *property, const QSize &val)
+{
+ setValueInRange<const QSize &, QtSizePropertyManagerPrivate, QtSizePropertyManager, const QSize>(this, d_ptr,
+ &QtSizePropertyManager::propertyChanged,
+ &QtSizePropertyManager::valueChanged,
+ property, val, &QtSizePropertyManagerPrivate::setValue);
+}
+
+/*!
+ Sets the minimum size value for the given \a property to \a minVal.
+
+ When setting the minimum size value, the maximum and current
+ values are adjusted if necessary (ensuring that the size range
+ remains valid and that the current value is within the range).
+
+ \sa minimum(), setRange(), rangeChanged()
+*/
+void QtSizePropertyManager::setMinimum(QtProperty *property, const QSize &minVal)
+{
+ setBorderValue<const QSize &, QtSizePropertyManagerPrivate, QtSizePropertyManager, QSize, QtSizePropertyManagerPrivate::Data>(this, d_ptr,
+ &QtSizePropertyManager::propertyChanged,
+ &QtSizePropertyManager::valueChanged,
+ &QtSizePropertyManager::rangeChanged,
+ property,
+ &QtSizePropertyManagerPrivate::Data::minimumValue,
+ &QtSizePropertyManagerPrivate::Data::setMinimumValue,
+ minVal, &QtSizePropertyManagerPrivate::setRange);
+}
+
+/*!
+ Sets the maximum size value for the given \a property to \a maxVal.
+
+ When setting the maximum size value, the minimum and current
+ values are adjusted if necessary (ensuring that the size range
+ remains valid and that the current value is within the range).
+
+ \sa maximum(), setRange(), rangeChanged()
+*/
+void QtSizePropertyManager::setMaximum(QtProperty *property, const QSize &maxVal)
+{
+ setBorderValue<const QSize &, QtSizePropertyManagerPrivate, QtSizePropertyManager, QSize, QtSizePropertyManagerPrivate::Data>(this, d_ptr,
+ &QtSizePropertyManager::propertyChanged,
+ &QtSizePropertyManager::valueChanged,
+ &QtSizePropertyManager::rangeChanged,
+ property,
+ &QtSizePropertyManagerPrivate::Data::maximumValue,
+ &QtSizePropertyManagerPrivate::Data::setMaximumValue,
+ maxVal, &QtSizePropertyManagerPrivate::setRange);
+}
+
+/*!
+ \fn void QtSizePropertyManager::setRange(QtProperty *property, const QSize &minimum, const QSize &maximum)
+
+ Sets the range of valid values.
+
+ This is a convenience function defining the range of valid values
+ in one go; setting the \a minimum and \a maximum values for the
+ given \a property with a single function call.
+
+ When setting a new range, the current value is adjusted if
+ necessary (ensuring that the value remains within the range).
+
+ \sa setMinimum(), setMaximum(), rangeChanged()
+*/
+void QtSizePropertyManager::setRange(QtProperty *property, const QSize &minVal, const QSize &maxVal)
+{
+ setBorderValues<const QSize &, QtSizePropertyManagerPrivate, QtSizePropertyManager, QSize>(this, d_ptr,
+ &QtSizePropertyManager::propertyChanged,
+ &QtSizePropertyManager::valueChanged,
+ &QtSizePropertyManager::rangeChanged,
+ property, minVal, maxVal, &QtSizePropertyManagerPrivate::setRange);
+}
+
+/*!
+ \reimp
+*/
+void QtSizePropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtSizePropertyManagerPrivate::Data();
+
+ QtProperty *wProp = d_ptr->m_intPropertyManager->addProperty();
+ wProp->setPropertyName(tr("Width"));
+ d_ptr->m_intPropertyManager->setValue(wProp, 0);
+ d_ptr->m_intPropertyManager->setMinimum(wProp, 0);
+ d_ptr->m_propertyToW[property] = wProp;
+ d_ptr->m_wToProperty[wProp] = property;
+ property->addSubProperty(wProp);
+
+ QtProperty *hProp = d_ptr->m_intPropertyManager->addProperty();
+ hProp->setPropertyName(tr("Height"));
+ d_ptr->m_intPropertyManager->setValue(hProp, 0);
+ d_ptr->m_intPropertyManager->setMinimum(hProp, 0);
+ d_ptr->m_propertyToH[property] = hProp;
+ d_ptr->m_hToProperty[hProp] = property;
+ property->addSubProperty(hProp);
+}
+
+/*!
+ \reimp
+*/
+void QtSizePropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *wProp = d_ptr->m_propertyToW[property];
+ if (wProp) {
+ d_ptr->m_wToProperty.remove(wProp);
+ delete wProp;
+ }
+ d_ptr->m_propertyToW.remove(property);
+
+ QtProperty *hProp = d_ptr->m_propertyToH[property];
+ if (hProp) {
+ d_ptr->m_hToProperty.remove(hProp);
+ delete hProp;
+ }
+ d_ptr->m_propertyToH.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtSizeFPropertyManager
+
+class QtSizeFPropertyManagerPrivate
+{
+ QtSizeFPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtSizeFPropertyManager)
+public:
+
+ void slotDoubleChanged(QtProperty *property, double value);
+ void slotPropertyDestroyed(QtProperty *property);
+ void setValue(QtProperty *property, const QSizeF &val);
+ void setRange(QtProperty *property,
+ const QSizeF &minVal, const QSizeF &maxVal, const QSizeF &val);
+
+ struct Data
+ {
+ Data() : val(QSizeF(0, 0)), minVal(QSizeF(0, 0)), maxVal(QSizeF(INT_MAX, INT_MAX)), decimals(2) {}
+ QSizeF val;
+ QSizeF minVal;
+ QSizeF maxVal;
+ int decimals;
+ QSizeF minimumValue() const { return minVal; }
+ QSizeF maximumValue() const { return maxVal; }
+ void setMinimumValue(const QSizeF &newMinVal) { setSizeMinimumData(this, newMinVal); }
+ void setMaximumValue(const QSizeF &newMaxVal) { setSizeMaximumData(this, newMaxVal); }
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtDoublePropertyManager *m_doublePropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToW;
+ QMap<const QtProperty *, QtProperty *> m_propertyToH;
+
+ QMap<const QtProperty *, QtProperty *> m_wToProperty;
+ QMap<const QtProperty *, QtProperty *> m_hToProperty;
+};
+
+void QtSizeFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
+{
+ if (QtProperty *prop = m_wToProperty.value(property, 0)) {
+ QSizeF s = m_values[prop].val;
+ s.setWidth(value);
+ q_ptr->setValue(prop, s);
+ } else if (QtProperty *prop = m_hToProperty.value(property, 0)) {
+ QSizeF s = m_values[prop].val;
+ s.setHeight(value);
+ q_ptr->setValue(prop, s);
+ }
+}
+
+void QtSizeFPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_wToProperty.value(property, 0)) {
+ m_propertyToW[pointProp] = 0;
+ m_wToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_hToProperty.value(property, 0)) {
+ m_propertyToH[pointProp] = 0;
+ m_hToProperty.remove(property);
+ }
+}
+
+void QtSizeFPropertyManagerPrivate::setValue(QtProperty *property, const QSizeF &val)
+{
+ m_doublePropertyManager->setValue(m_propertyToW.value(property), val.width());
+ m_doublePropertyManager->setValue(m_propertyToH.value(property), val.height());
+}
+
+void QtSizeFPropertyManagerPrivate::setRange(QtProperty *property,
+ const QSizeF &minVal, const QSizeF &maxVal, const QSizeF &val)
+{
+ m_doublePropertyManager->setRange(m_propertyToW[property], minVal.width(), maxVal.width());
+ m_doublePropertyManager->setValue(m_propertyToW[property], val.width());
+ m_doublePropertyManager->setRange(m_propertyToH[property], minVal.height(), maxVal.height());
+ m_doublePropertyManager->setValue(m_propertyToH[property], val.height());
+}
+
+/*!
+ \class QtSizeFPropertyManager
+
+ \brief The QtSizeFPropertyManager provides and manages QSizeF properties.
+
+ A size property has nested \e width and \e height
+ subproperties. The top-level property's value can be retrieved
+ using the value() function, and set using the setValue() slot.
+
+ The subproperties are created by a QtDoublePropertyManager object. This
+ manager can be retrieved using the subDoublePropertyManager() function. In
+ order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ A size property also has a range of valid values defined by a
+ minimum size and a maximum size. These sizes can be retrieved
+ using the minimum() and the maximum() functions, and set using the
+ setMinimum() and setMaximum() slots. Alternatively, the range can
+ be defined in one go using the setRange() slot.
+
+ In addition, QtSizeFPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes, and the rangeChanged() signal which is emitted whenever
+ such a property changes its range of valid sizes.
+
+ \sa QtAbstractPropertyManager, QtDoublePropertyManager, QtSizePropertyManager
+*/
+
+/*!
+ \fn void QtSizeFPropertyManager::valueChanged(QtProperty *property, const QSizeF &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtSizeFPropertyManager::rangeChanged(QtProperty *property, const QSizeF &minimum, const QSizeF &maximum)
+
+ This signal is emitted whenever a property created by this manager
+ changes its range of valid sizes, passing a pointer to the \a
+ property and the new \a minimum and \a maximum sizes.
+
+ \sa setRange()
+*/
+
+/*!
+ \fn void QtSizeFPropertyManager::decimalsChanged(QtProperty *property, int prec)
+
+ This signal is emitted whenever a property created by this manager
+ changes its precision of value, passing a pointer to the
+ \a property and the new \a prec value
+
+ \sa setDecimals()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtSizeFPropertyManager::QtSizeFPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtSizeFPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_doublePropertyManager = new QtDoublePropertyManager(this);
+ connect(d_ptr->m_doublePropertyManager, SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotDoubleChanged(QtProperty *, double)));
+ connect(d_ptr->m_doublePropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtSizeFPropertyManager::~QtSizeFPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the nested \e width and \e height
+ subproperties.
+
+ In order to provide editing widgets for the \e width and \e height
+ properties in a property browser widget, this manager must be
+ associated with an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtDoublePropertyManager *QtSizeFPropertyManager::subDoublePropertyManager() const
+{
+ return d_ptr->m_doublePropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns an invalid size
+
+ \sa setValue()
+*/
+QSizeF QtSizeFPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<QSizeF>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's precision, in decimals.
+
+ \sa setDecimals()
+*/
+int QtSizeFPropertyManager::decimals(const QtProperty *property) const
+{
+ return getData<int>(d_ptr->m_values, &QtSizeFPropertyManagerPrivate::Data::decimals, property, 0);
+}
+
+/*!
+ Returns the given \a property's minimum size value.
+
+ \sa setMinimum(), maximum(), setRange()
+*/
+QSizeF QtSizeFPropertyManager::minimum(const QtProperty *property) const
+{
+ return getMinimum<QSizeF>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's maximum size value.
+
+ \sa setMaximum(), minimum(), setRange()
+*/
+QSizeF QtSizeFPropertyManager::maximum(const QtProperty *property) const
+{
+ return getMaximum<QSizeF>(d_ptr->m_values, property);
+}
+
+/*!
+ \reimp
+*/
+QString QtSizeFPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtSizeFPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ const QSizeF v = it.value().val;
+ const int dec = it.value().decimals;
+ return QString(tr("%1 x %2").arg(QString::number(v.width(), 'f', dec))
+ .arg(QString::number(v.height(), 'f', dec)));
+}
+
+/*!
+ \fn void QtSizeFPropertyManager::setValue(QtProperty *property, const QSizeF &value)
+
+ Sets the value of the given \a property to \a value.
+
+ If the specified \a value is not valid according to the given \a
+ property's size range, the \a value is adjusted to the nearest
+ valid value within the size range.
+
+ \sa value(), setRange(), valueChanged()
+*/
+void QtSizeFPropertyManager::setValue(QtProperty *property, const QSizeF &val)
+{
+ setValueInRange<const QSizeF &, QtSizeFPropertyManagerPrivate, QtSizeFPropertyManager, QSizeF>(this, d_ptr,
+ &QtSizeFPropertyManager::propertyChanged,
+ &QtSizeFPropertyManager::valueChanged,
+ property, val, &QtSizeFPropertyManagerPrivate::setValue);
+}
+
+/*!
+ \fn void QtSizeFPropertyManager::setDecimals(QtProperty *property, int prec)
+
+ Sets the precision of the given \a property to \a prec.
+
+ The valid decimal range is 0-13. The default is 2.
+
+ \sa decimals()
+*/
+void QtSizeFPropertyManager::setDecimals(QtProperty *property, int prec)
+{
+ const QtSizeFPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtSizeFPropertyManagerPrivate::Data data = it.value();
+
+ if (prec > 13)
+ prec = 13;
+ else if (prec < 0)
+ prec = 0;
+
+ if (data.decimals == prec)
+ return;
+
+ data.decimals = prec;
+ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToW[property], prec);
+ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToH[property], prec);
+
+ it.value() = data;
+
+ emit decimalsChanged(property, data.decimals);
+}
+
+/*!
+ Sets the minimum size value for the given \a property to \a minVal.
+
+ When setting the minimum size value, the maximum and current
+ values are adjusted if necessary (ensuring that the size range
+ remains valid and that the current value is within the range).
+
+ \sa minimum(), setRange(), rangeChanged()
+*/
+void QtSizeFPropertyManager::setMinimum(QtProperty *property, const QSizeF &minVal)
+{
+ setBorderValue<const QSizeF &, QtSizeFPropertyManagerPrivate, QtSizeFPropertyManager, QSizeF, QtSizeFPropertyManagerPrivate::Data>(this, d_ptr,
+ &QtSizeFPropertyManager::propertyChanged,
+ &QtSizeFPropertyManager::valueChanged,
+ &QtSizeFPropertyManager::rangeChanged,
+ property,
+ &QtSizeFPropertyManagerPrivate::Data::minimumValue,
+ &QtSizeFPropertyManagerPrivate::Data::setMinimumValue,
+ minVal, &QtSizeFPropertyManagerPrivate::setRange);
+}
+
+/*!
+ Sets the maximum size value for the given \a property to \a maxVal.
+
+ When setting the maximum size value, the minimum and current
+ values are adjusted if necessary (ensuring that the size range
+ remains valid and that the current value is within the range).
+
+ \sa maximum(), setRange(), rangeChanged()
+*/
+void QtSizeFPropertyManager::setMaximum(QtProperty *property, const QSizeF &maxVal)
+{
+ setBorderValue<const QSizeF &, QtSizeFPropertyManagerPrivate, QtSizeFPropertyManager, QSizeF, QtSizeFPropertyManagerPrivate::Data>(this, d_ptr,
+ &QtSizeFPropertyManager::propertyChanged,
+ &QtSizeFPropertyManager::valueChanged,
+ &QtSizeFPropertyManager::rangeChanged,
+ property,
+ &QtSizeFPropertyManagerPrivate::Data::maximumValue,
+ &QtSizeFPropertyManagerPrivate::Data::setMaximumValue,
+ maxVal, &QtSizeFPropertyManagerPrivate::setRange);
+}
+
+/*!
+ \fn void QtSizeFPropertyManager::setRange(QtProperty *property, const QSizeF &minimum, const QSizeF &maximum)
+
+ Sets the range of valid values.
+
+ This is a convenience function defining the range of valid values
+ in one go; setting the \a minimum and \a maximum values for the
+ given \a property with a single function call.
+
+ When setting a new range, the current value is adjusted if
+ necessary (ensuring that the value remains within the range).
+
+ \sa setMinimum(), setMaximum(), rangeChanged()
+*/
+void QtSizeFPropertyManager::setRange(QtProperty *property, const QSizeF &minVal, const QSizeF &maxVal)
+{
+ setBorderValues<const QSizeF &, QtSizeFPropertyManagerPrivate, QtSizeFPropertyManager, QSizeF>(this, d_ptr,
+ &QtSizeFPropertyManager::propertyChanged,
+ &QtSizeFPropertyManager::valueChanged,
+ &QtSizeFPropertyManager::rangeChanged,
+ property, minVal, maxVal, &QtSizeFPropertyManagerPrivate::setRange);
+}
+
+/*!
+ \reimp
+*/
+void QtSizeFPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtSizeFPropertyManagerPrivate::Data();
+
+ QtProperty *wProp = d_ptr->m_doublePropertyManager->addProperty();
+ wProp->setPropertyName(tr("Width"));
+ d_ptr->m_doublePropertyManager->setDecimals(wProp, decimals(property));
+ d_ptr->m_doublePropertyManager->setValue(wProp, 0);
+ d_ptr->m_doublePropertyManager->setMinimum(wProp, 0);
+ d_ptr->m_propertyToW[property] = wProp;
+ d_ptr->m_wToProperty[wProp] = property;
+ property->addSubProperty(wProp);
+
+ QtProperty *hProp = d_ptr->m_doublePropertyManager->addProperty();
+ hProp->setPropertyName(tr("Height"));
+ d_ptr->m_doublePropertyManager->setDecimals(hProp, decimals(property));
+ d_ptr->m_doublePropertyManager->setValue(hProp, 0);
+ d_ptr->m_doublePropertyManager->setMinimum(hProp, 0);
+ d_ptr->m_propertyToH[property] = hProp;
+ d_ptr->m_hToProperty[hProp] = property;
+ property->addSubProperty(hProp);
+}
+
+/*!
+ \reimp
+*/
+void QtSizeFPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *wProp = d_ptr->m_propertyToW[property];
+ if (wProp) {
+ d_ptr->m_wToProperty.remove(wProp);
+ delete wProp;
+ }
+ d_ptr->m_propertyToW.remove(property);
+
+ QtProperty *hProp = d_ptr->m_propertyToH[property];
+ if (hProp) {
+ d_ptr->m_hToProperty.remove(hProp);
+ delete hProp;
+ }
+ d_ptr->m_propertyToH.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtRectPropertyManager
+
+class QtRectPropertyManagerPrivate
+{
+ QtRectPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtRectPropertyManager)
+public:
+
+ void slotIntChanged(QtProperty *property, int value);
+ void slotPropertyDestroyed(QtProperty *property);
+ void setConstraint(QtProperty *property, const QRect &constraint, const QRect &val);
+
+ struct Data
+ {
+ Data() : val(0, 0, 0, 0) {}
+ QRect val;
+ QRect constraint;
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtIntPropertyManager *m_intPropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToX;
+ QMap<const QtProperty *, QtProperty *> m_propertyToY;
+ QMap<const QtProperty *, QtProperty *> m_propertyToW;
+ QMap<const QtProperty *, QtProperty *> m_propertyToH;
+
+ QMap<const QtProperty *, QtProperty *> m_xToProperty;
+ QMap<const QtProperty *, QtProperty *> m_yToProperty;
+ QMap<const QtProperty *, QtProperty *> m_wToProperty;
+ QMap<const QtProperty *, QtProperty *> m_hToProperty;
+};
+
+void QtRectPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+ if (QtProperty *prop = m_xToProperty.value(property, 0)) {
+ QRect r = m_values[prop].val;
+ r.moveLeft(value);
+ q_ptr->setValue(prop, r);
+ } else if (QtProperty *prop = m_yToProperty.value(property)) {
+ QRect r = m_values[prop].val;
+ r.moveTop(value);
+ q_ptr->setValue(prop, r);
+ } else if (QtProperty *prop = m_wToProperty.value(property, 0)) {
+ Data data = m_values[prop];
+ QRect r = data.val;
+ r.setWidth(value);
+ if (!data.constraint.isNull() && data.constraint.x() + data.constraint.width() < r.x() + r.width()) {
+ r.moveLeft(data.constraint.left() + data.constraint.width() - r.width());
+ }
+ q_ptr->setValue(prop, r);
+ } else if (QtProperty *prop = m_hToProperty.value(property, 0)) {
+ Data data = m_values[prop];
+ QRect r = data.val;
+ r.setHeight(value);
+ if (!data.constraint.isNull() && data.constraint.y() + data.constraint.height() < r.y() + r.height()) {
+ r.moveTop(data.constraint.top() + data.constraint.height() - r.height());
+ }
+ q_ptr->setValue(prop, r);
+ }
+}
+
+void QtRectPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_xToProperty.value(property, 0)) {
+ m_propertyToX[pointProp] = 0;
+ m_xToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_yToProperty.value(property, 0)) {
+ m_propertyToY[pointProp] = 0;
+ m_yToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_wToProperty.value(property, 0)) {
+ m_propertyToW[pointProp] = 0;
+ m_wToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_hToProperty.value(property, 0)) {
+ m_propertyToH[pointProp] = 0;
+ m_hToProperty.remove(property);
+ }
+}
+
+void QtRectPropertyManagerPrivate::setConstraint(QtProperty *property,
+ const QRect &constraint, const QRect &val)
+{
+ const bool isNull = constraint.isNull();
+ const int left = isNull ? INT_MIN : constraint.left();
+ const int right = isNull ? INT_MAX : constraint.left() + constraint.width();
+ const int top = isNull ? INT_MIN : constraint.top();
+ const int bottom = isNull ? INT_MAX : constraint.top() + constraint.height();
+ const int width = isNull ? INT_MAX : constraint.width();
+ const int height = isNull ? INT_MAX : constraint.height();
+
+ m_intPropertyManager->setRange(m_propertyToX[property], left, right);
+ m_intPropertyManager->setRange(m_propertyToY[property], top, bottom);
+ m_intPropertyManager->setRange(m_propertyToW[property], 0, width);
+ m_intPropertyManager->setRange(m_propertyToH[property], 0, height);
+
+ m_intPropertyManager->setValue(m_propertyToX[property], val.x());
+ m_intPropertyManager->setValue(m_propertyToY[property], val.y());
+ m_intPropertyManager->setValue(m_propertyToW[property], val.width());
+ m_intPropertyManager->setValue(m_propertyToH[property], val.height());
+}
+
+/*!
+ \class QtRectPropertyManager
+
+ \brief The QtRectPropertyManager provides and manages QRect properties.
+
+ A rectangle property has nested \e x, \e y, \e width and \e height
+ subproperties. The top-level property's value can be retrieved
+ using the value() function, and set using the setValue() slot.
+
+ The subproperties are created by a QtIntPropertyManager object. This
+ manager can be retrieved using the subIntPropertyManager() function. In
+ order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ A rectangle property also has a constraint rectangle which can be
+ retrieved using the constraint() function, and set using the
+ setConstraint() slot.
+
+ In addition, QtRectPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes, and the constraintChanged() signal which is emitted
+ whenever such a property changes its constraint rectangle.
+
+ \sa QtAbstractPropertyManager, QtIntPropertyManager, QtRectFPropertyManager
+*/
+
+/*!
+ \fn void QtRectPropertyManager::valueChanged(QtProperty *property, const QRect &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtRectPropertyManager::constraintChanged(QtProperty *property, const QRect &constraint)
+
+ This signal is emitted whenever property changes its constraint
+ rectangle, passing a pointer to the \a property and the new \a
+ constraint rectangle as parameters.
+
+ \sa setConstraint()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtRectPropertyManager::QtRectPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtRectPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
+ connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotIntChanged(QtProperty *, int)));
+ connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtRectPropertyManager::~QtRectPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the nested \e x, \e y, \e width
+ and \e height subproperties.
+
+ In order to provide editing widgets for the mentioned
+ subproperties in a property browser widget, this manager must be
+ associated with an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtIntPropertyManager *QtRectPropertyManager::subIntPropertyManager() const
+{
+ return d_ptr->m_intPropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns an invalid rectangle.
+
+ \sa setValue(), constraint()
+*/
+QRect QtRectPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<QRect>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's constraining rectangle. If returned value is null QRect it means there is no constraint applied.
+
+ \sa value(), setConstraint()
+*/
+QRect QtRectPropertyManager::constraint(const QtProperty *property) const
+{
+ return getData<QRect>(d_ptr->m_values, &QtRectPropertyManagerPrivate::Data::constraint, property, QRect());
+}
+
+/*!
+ \reimp
+*/
+QString QtRectPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtRectPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ const QRect v = it.value().val;
+ return QString(tr("[(%1, %2), %3 x %4]").arg(QString::number(v.x()))
+ .arg(QString::number(v.y()))
+ .arg(QString::number(v.width()))
+ .arg(QString::number(v.height())));
+}
+
+/*!
+ \fn void QtRectPropertyManager::setValue(QtProperty *property, const QRect &value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ If the specified \a value is not inside the given \a property's
+ constraining rectangle, the value is adjusted accordingly to fit
+ within the constraint.
+
+ \sa value(), setConstraint(), valueChanged()
+*/
+void QtRectPropertyManager::setValue(QtProperty *property, const QRect &val)
+{
+ const QtRectPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtRectPropertyManagerPrivate::Data data = it.value();
+
+ QRect newRect = val.normalized();
+ if (!data.constraint.isNull() && !data.constraint.contains(newRect)) {
+ const QRect r1 = data.constraint;
+ const QRect r2 = newRect;
+ newRect.setLeft(qMax(r1.left(), r2.left()));
+ newRect.setRight(qMin(r1.right(), r2.right()));
+ newRect.setTop(qMax(r1.top(), r2.top()));
+ newRect.setBottom(qMin(r1.bottom(), r2.bottom()));
+ if (newRect.width() < 0 || newRect.height() < 0)
+ return;
+ }
+
+ if (data.val == newRect)
+ return;
+
+ data.val = newRect;
+
+ it.value() = data;
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToX[property], newRect.x());
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToY[property], newRect.y());
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToW[property], newRect.width());
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToH[property], newRect.height());
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ Sets the given \a property's constraining rectangle to \a
+ constraint.
+
+ When setting the constraint, the current value is adjusted if
+ necessary (ensuring that the current rectangle value is inside the
+ constraint). In order to reset the constraint pass a null QRect value.
+
+ \sa setValue(), constraint(), constraintChanged()
+*/
+void QtRectPropertyManager::setConstraint(QtProperty *property, const QRect &constraint)
+{
+ const QtRectPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtRectPropertyManagerPrivate::Data data = it.value();
+
+ QRect newConstraint = constraint.normalized();
+ if (data.constraint == newConstraint)
+ return;
+
+ const QRect oldVal = data.val;
+
+ data.constraint = newConstraint;
+
+ if (!data.constraint.isNull() && !data.constraint.contains(oldVal)) {
+ QRect r1 = data.constraint;
+ QRect r2 = data.val;
+
+ if (r2.width() > r1.width())
+ r2.setWidth(r1.width());
+ if (r2.height() > r1.height())
+ r2.setHeight(r1.height());
+ if (r2.left() < r1.left())
+ r2.moveLeft(r1.left());
+ else if (r2.right() > r1.right())
+ r2.moveRight(r1.right());
+ if (r2.top() < r1.top())
+ r2.moveTop(r1.top());
+ else if (r2.bottom() > r1.bottom())
+ r2.moveBottom(r1.bottom());
+
+ data.val = r2;
+ }
+
+ it.value() = data;
+
+ emit constraintChanged(property, data.constraint);
+
+ d_ptr->setConstraint(property, data.constraint, data.val);
+
+ if (data.val == oldVal)
+ return;
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ \reimp
+*/
+void QtRectPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtRectPropertyManagerPrivate::Data();
+
+ QtProperty *xProp = d_ptr->m_intPropertyManager->addProperty();
+ xProp->setPropertyName(tr("X"));
+ d_ptr->m_intPropertyManager->setValue(xProp, 0);
+ d_ptr->m_propertyToX[property] = xProp;
+ d_ptr->m_xToProperty[xProp] = property;
+ property->addSubProperty(xProp);
+
+ QtProperty *yProp = d_ptr->m_intPropertyManager->addProperty();
+ yProp->setPropertyName(tr("Y"));
+ d_ptr->m_intPropertyManager->setValue(yProp, 0);
+ d_ptr->m_propertyToY[property] = yProp;
+ d_ptr->m_yToProperty[yProp] = property;
+ property->addSubProperty(yProp);
+
+ QtProperty *wProp = d_ptr->m_intPropertyManager->addProperty();
+ wProp->setPropertyName(tr("Width"));
+ d_ptr->m_intPropertyManager->setValue(wProp, 0);
+ d_ptr->m_intPropertyManager->setMinimum(wProp, 0);
+ d_ptr->m_propertyToW[property] = wProp;
+ d_ptr->m_wToProperty[wProp] = property;
+ property->addSubProperty(wProp);
+
+ QtProperty *hProp = d_ptr->m_intPropertyManager->addProperty();
+ hProp->setPropertyName(tr("Height"));
+ d_ptr->m_intPropertyManager->setValue(hProp, 0);
+ d_ptr->m_intPropertyManager->setMinimum(hProp, 0);
+ d_ptr->m_propertyToH[property] = hProp;
+ d_ptr->m_hToProperty[hProp] = property;
+ property->addSubProperty(hProp);
+}
+
+/*!
+ \reimp
+*/
+void QtRectPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *xProp = d_ptr->m_propertyToX[property];
+ if (xProp) {
+ d_ptr->m_xToProperty.remove(xProp);
+ delete xProp;
+ }
+ d_ptr->m_propertyToX.remove(property);
+
+ QtProperty *yProp = d_ptr->m_propertyToY[property];
+ if (yProp) {
+ d_ptr->m_yToProperty.remove(yProp);
+ delete yProp;
+ }
+ d_ptr->m_propertyToY.remove(property);
+
+ QtProperty *wProp = d_ptr->m_propertyToW[property];
+ if (wProp) {
+ d_ptr->m_wToProperty.remove(wProp);
+ delete wProp;
+ }
+ d_ptr->m_propertyToW.remove(property);
+
+ QtProperty *hProp = d_ptr->m_propertyToH[property];
+ if (hProp) {
+ d_ptr->m_hToProperty.remove(hProp);
+ delete hProp;
+ }
+ d_ptr->m_propertyToH.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtRectFPropertyManager
+
+class QtRectFPropertyManagerPrivate
+{
+ QtRectFPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtRectFPropertyManager)
+public:
+
+ void slotDoubleChanged(QtProperty *property, double value);
+ void slotPropertyDestroyed(QtProperty *property);
+ void setConstraint(QtProperty *property, const QRectF &constraint, const QRectF &val);
+
+ struct Data
+ {
+ Data() : val(0, 0, 0, 0), decimals(2) {}
+ QRectF val;
+ QRectF constraint;
+ int decimals;
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtDoublePropertyManager *m_doublePropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToX;
+ QMap<const QtProperty *, QtProperty *> m_propertyToY;
+ QMap<const QtProperty *, QtProperty *> m_propertyToW;
+ QMap<const QtProperty *, QtProperty *> m_propertyToH;
+
+ QMap<const QtProperty *, QtProperty *> m_xToProperty;
+ QMap<const QtProperty *, QtProperty *> m_yToProperty;
+ QMap<const QtProperty *, QtProperty *> m_wToProperty;
+ QMap<const QtProperty *, QtProperty *> m_hToProperty;
+};
+
+void QtRectFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
+{
+ if (QtProperty *prop = m_xToProperty.value(property, 0)) {
+ QRectF r = m_values[prop].val;
+ r.moveLeft(value);
+ q_ptr->setValue(prop, r);
+ } else if (QtProperty *prop = m_yToProperty.value(property, 0)) {
+ QRectF r = m_values[prop].val;
+ r.moveTop(value);
+ q_ptr->setValue(prop, r);
+ } else if (QtProperty *prop = m_wToProperty.value(property, 0)) {
+ Data data = m_values[prop];
+ QRectF r = data.val;
+ r.setWidth(value);
+ if (!data.constraint.isNull() && data.constraint.x() + data.constraint.width() < r.x() + r.width()) {
+ r.moveLeft(data.constraint.left() + data.constraint.width() - r.width());
+ }
+ q_ptr->setValue(prop, r);
+ } else if (QtProperty *prop = m_hToProperty.value(property, 0)) {
+ Data data = m_values[prop];
+ QRectF r = data.val;
+ r.setHeight(value);
+ if (!data.constraint.isNull() && data.constraint.y() + data.constraint.height() < r.y() + r.height()) {
+ r.moveTop(data.constraint.top() + data.constraint.height() - r.height());
+ }
+ q_ptr->setValue(prop, r);
+ }
+}
+
+void QtRectFPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_xToProperty.value(property, 0)) {
+ m_propertyToX[pointProp] = 0;
+ m_xToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_yToProperty.value(property, 0)) {
+ m_propertyToY[pointProp] = 0;
+ m_yToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_wToProperty.value(property, 0)) {
+ m_propertyToW[pointProp] = 0;
+ m_wToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_hToProperty.value(property, 0)) {
+ m_propertyToH[pointProp] = 0;
+ m_hToProperty.remove(property);
+ }
+}
+
+void QtRectFPropertyManagerPrivate::setConstraint(QtProperty *property,
+ const QRectF &constraint, const QRectF &val)
+{
+ const bool isNull = constraint.isNull();
+ const float left = isNull ? FLT_MIN : constraint.left();
+ const float right = isNull ? FLT_MAX : constraint.left() + constraint.width();
+ const float top = isNull ? FLT_MIN : constraint.top();
+ const float bottom = isNull ? FLT_MAX : constraint.top() + constraint.height();
+ const float width = isNull ? FLT_MAX : constraint.width();
+ const float height = isNull ? FLT_MAX : constraint.height();
+
+ m_doublePropertyManager->setRange(m_propertyToX[property], left, right);
+ m_doublePropertyManager->setRange(m_propertyToY[property], top, bottom);
+ m_doublePropertyManager->setRange(m_propertyToW[property], 0, width);
+ m_doublePropertyManager->setRange(m_propertyToH[property], 0, height);
+
+ m_doublePropertyManager->setValue(m_propertyToX[property], val.x());
+ m_doublePropertyManager->setValue(m_propertyToY[property], val.y());
+ m_doublePropertyManager->setValue(m_propertyToW[property], val.width());
+ m_doublePropertyManager->setValue(m_propertyToH[property], val.height());
+}
+
+/*!
+ \class QtRectFPropertyManager
+
+ \brief The QtRectFPropertyManager provides and manages QRectF properties.
+
+ A rectangle property has nested \e x, \e y, \e width and \e height
+ subproperties. The top-level property's value can be retrieved
+ using the value() function, and set using the setValue() slot.
+
+ The subproperties are created by a QtDoublePropertyManager object. This
+ manager can be retrieved using the subDoublePropertyManager() function. In
+ order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ A rectangle property also has a constraint rectangle which can be
+ retrieved using the constraint() function, and set using the
+ setConstraint() slot.
+
+ In addition, QtRectFPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes, and the constraintChanged() signal which is emitted
+ whenever such a property changes its constraint rectangle.
+
+ \sa QtAbstractPropertyManager, QtDoublePropertyManager, QtRectPropertyManager
+*/
+
+/*!
+ \fn void QtRectFPropertyManager::valueChanged(QtProperty *property, const QRectF &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtRectFPropertyManager::constraintChanged(QtProperty *property, const QRectF &constraint)
+
+ This signal is emitted whenever property changes its constraint
+ rectangle, passing a pointer to the \a property and the new \a
+ constraint rectangle as parameters.
+
+ \sa setConstraint()
+*/
+
+/*!
+ \fn void QtRectFPropertyManager::decimalsChanged(QtProperty *property, int prec)
+
+ This signal is emitted whenever a property created by this manager
+ changes its precision of value, passing a pointer to the
+ \a property and the new \a prec value
+
+ \sa setDecimals()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtRectFPropertyManager::QtRectFPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtRectFPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_doublePropertyManager = new QtDoublePropertyManager(this);
+ connect(d_ptr->m_doublePropertyManager, SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotDoubleChanged(QtProperty *, double)));
+ connect(d_ptr->m_doublePropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtRectFPropertyManager::~QtRectFPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the nested \e x, \e y, \e width
+ and \e height subproperties.
+
+ In order to provide editing widgets for the mentioned
+ subproperties in a property browser widget, this manager must be
+ associated with an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtDoublePropertyManager *QtRectFPropertyManager::subDoublePropertyManager() const
+{
+ return d_ptr->m_doublePropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns an invalid rectangle.
+
+ \sa setValue(), constraint()
+*/
+QRectF QtRectFPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<QRectF>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's precision, in decimals.
+
+ \sa setDecimals()
+*/
+int QtRectFPropertyManager::decimals(const QtProperty *property) const
+{
+ return getData<int>(d_ptr->m_values, &QtRectFPropertyManagerPrivate::Data::decimals, property, 0);
+}
+
+/*!
+ Returns the given \a property's constraining rectangle. If returned value is null QRectF it means there is no constraint applied.
+
+ \sa value(), setConstraint()
+*/
+QRectF QtRectFPropertyManager::constraint(const QtProperty *property) const
+{
+ return getData<QRectF>(d_ptr->m_values, &QtRectFPropertyManagerPrivate::Data::constraint, property, QRect());
+}
+
+/*!
+ \reimp
+*/
+QString QtRectFPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtRectFPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+ const QRectF v = it.value().val;
+ const int dec = it.value().decimals;
+ return QString(tr("[(%1, %2), %3 x %4]").arg(QString::number(v.x(), 'f', dec))
+ .arg(QString::number(v.y(), 'f', dec))
+ .arg(QString::number(v.width(), 'f', dec))
+ .arg(QString::number(v.height(), 'f', dec)));
+}
+
+/*!
+ \fn void QtRectFPropertyManager::setValue(QtProperty *property, const QRectF &value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ If the specified \a value is not inside the given \a property's
+ constraining rectangle, the value is adjusted accordingly to fit
+ within the constraint.
+
+ \sa value(), setConstraint(), valueChanged()
+*/
+void QtRectFPropertyManager::setValue(QtProperty *property, const QRectF &val)
+{
+ const QtRectFPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtRectFPropertyManagerPrivate::Data data = it.value();
+
+ QRectF newRect = val.normalized();
+ if (!data.constraint.isNull() && !data.constraint.contains(newRect)) {
+ const QRectF r1 = data.constraint;
+ const QRectF r2 = newRect;
+ newRect.setLeft(qMax(r1.left(), r2.left()));
+ newRect.setRight(qMin(r1.right(), r2.right()));
+ newRect.setTop(qMax(r1.top(), r2.top()));
+ newRect.setBottom(qMin(r1.bottom(), r2.bottom()));
+ if (newRect.width() < 0 || newRect.height() < 0)
+ return;
+ }
+
+ if (data.val == newRect)
+ return;
+
+ data.val = newRect;
+
+ it.value() = data;
+ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToX[property], newRect.x());
+ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToY[property], newRect.y());
+ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToW[property], newRect.width());
+ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToH[property], newRect.height());
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ Sets the given \a property's constraining rectangle to \a
+ constraint.
+
+ When setting the constraint, the current value is adjusted if
+ necessary (ensuring that the current rectangle value is inside the
+ constraint). In order to reset the constraint pass a null QRectF value.
+
+ \sa setValue(), constraint(), constraintChanged()
+*/
+void QtRectFPropertyManager::setConstraint(QtProperty *property, const QRectF &constraint)
+{
+ const QtRectFPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtRectFPropertyManagerPrivate::Data data = it.value();
+
+ QRectF newConstraint = constraint.normalized();
+ if (data.constraint == newConstraint)
+ return;
+
+ const QRectF oldVal = data.val;
+
+ data.constraint = newConstraint;
+
+ if (!data.constraint.isNull() && !data.constraint.contains(oldVal)) {
+ QRectF r1 = data.constraint;
+ QRectF r2 = data.val;
+
+ if (r2.width() > r1.width())
+ r2.setWidth(r1.width());
+ if (r2.height() > r1.height())
+ r2.setHeight(r1.height());
+ if (r2.left() < r1.left())
+ r2.moveLeft(r1.left());
+ else if (r2.right() > r1.right())
+ r2.moveRight(r1.right());
+ if (r2.top() < r1.top())
+ r2.moveTop(r1.top());
+ else if (r2.bottom() > r1.bottom())
+ r2.moveBottom(r1.bottom());
+
+ data.val = r2;
+ }
+
+ it.value() = data;
+
+ emit constraintChanged(property, data.constraint);
+
+ d_ptr->setConstraint(property, data.constraint, data.val);
+
+ if (data.val == oldVal)
+ return;
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ \fn void QtRectFPropertyManager::setDecimals(QtProperty *property, int prec)
+
+ Sets the precision of the given \a property to \a prec.
+
+ The valid decimal range is 0-13. The default is 2.
+
+ \sa decimals()
+*/
+void QtRectFPropertyManager::setDecimals(QtProperty *property, int prec)
+{
+ const QtRectFPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtRectFPropertyManagerPrivate::Data data = it.value();
+
+ if (prec > 13)
+ prec = 13;
+ else if (prec < 0)
+ prec = 0;
+
+ if (data.decimals == prec)
+ return;
+
+ data.decimals = prec;
+ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToX[property], prec);
+ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToY[property], prec);
+ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToW[property], prec);
+ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToH[property], prec);
+
+ it.value() = data;
+
+ emit decimalsChanged(property, data.decimals);
+}
+
+/*!
+ \reimp
+*/
+void QtRectFPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtRectFPropertyManagerPrivate::Data();
+
+ QtProperty *xProp = d_ptr->m_doublePropertyManager->addProperty();
+ xProp->setPropertyName(tr("X"));
+ d_ptr->m_doublePropertyManager->setDecimals(xProp, decimals(property));
+ d_ptr->m_doublePropertyManager->setValue(xProp, 0);
+ d_ptr->m_propertyToX[property] = xProp;
+ d_ptr->m_xToProperty[xProp] = property;
+ property->addSubProperty(xProp);
+
+ QtProperty *yProp = d_ptr->m_doublePropertyManager->addProperty();
+ yProp->setPropertyName(tr("Y"));
+ d_ptr->m_doublePropertyManager->setDecimals(yProp, decimals(property));
+ d_ptr->m_doublePropertyManager->setValue(yProp, 0);
+ d_ptr->m_propertyToY[property] = yProp;
+ d_ptr->m_yToProperty[yProp] = property;
+ property->addSubProperty(yProp);
+
+ QtProperty *wProp = d_ptr->m_doublePropertyManager->addProperty();
+ wProp->setPropertyName(tr("Width"));
+ d_ptr->m_doublePropertyManager->setDecimals(wProp, decimals(property));
+ d_ptr->m_doublePropertyManager->setValue(wProp, 0);
+ d_ptr->m_doublePropertyManager->setMinimum(wProp, 0);
+ d_ptr->m_propertyToW[property] = wProp;
+ d_ptr->m_wToProperty[wProp] = property;
+ property->addSubProperty(wProp);
+
+ QtProperty *hProp = d_ptr->m_doublePropertyManager->addProperty();
+ hProp->setPropertyName(tr("Height"));
+ d_ptr->m_doublePropertyManager->setDecimals(hProp, decimals(property));
+ d_ptr->m_doublePropertyManager->setValue(hProp, 0);
+ d_ptr->m_doublePropertyManager->setMinimum(hProp, 0);
+ d_ptr->m_propertyToH[property] = hProp;
+ d_ptr->m_hToProperty[hProp] = property;
+ property->addSubProperty(hProp);
+}
+
+/*!
+ \reimp
+*/
+void QtRectFPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *xProp = d_ptr->m_propertyToX[property];
+ if (xProp) {
+ d_ptr->m_xToProperty.remove(xProp);
+ delete xProp;
+ }
+ d_ptr->m_propertyToX.remove(property);
+
+ QtProperty *yProp = d_ptr->m_propertyToY[property];
+ if (yProp) {
+ d_ptr->m_yToProperty.remove(yProp);
+ delete yProp;
+ }
+ d_ptr->m_propertyToY.remove(property);
+
+ QtProperty *wProp = d_ptr->m_propertyToW[property];
+ if (wProp) {
+ d_ptr->m_wToProperty.remove(wProp);
+ delete wProp;
+ }
+ d_ptr->m_propertyToW.remove(property);
+
+ QtProperty *hProp = d_ptr->m_propertyToH[property];
+ if (hProp) {
+ d_ptr->m_hToProperty.remove(hProp);
+ delete hProp;
+ }
+ d_ptr->m_propertyToH.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtEnumPropertyManager
+
+class QtEnumPropertyManagerPrivate
+{
+ QtEnumPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtEnumPropertyManager)
+public:
+
+ struct Data
+ {
+ Data() : val(-1) {}
+ int val;
+ QStringList enumNames;
+ QMap<int, QIcon> enumIcons;
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*!
+ \class QtEnumPropertyManager
+
+ \brief The QtEnumPropertyManager provides and manages enum properties.
+
+ Each enum property has an associated list of enum names which can
+ be retrieved using the enumNames() function, and set using the
+ corresponding setEnumNames() function. An enum property's value is
+ represented by an index in this list, and can be retrieved and set
+ using the value() and setValue() slots respectively.
+
+ Each enum value can also have an associated icon. The mapping from
+ values to icons can be set using the setEnumIcons() function and
+ queried with the enumIcons() function.
+
+ In addition, QtEnumPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes. The enumNamesChanged() or enumIconsChanged() signal is emitted
+ whenever the list of enum names or icons is altered.
+
+ \sa QtAbstractPropertyManager, QtEnumEditorFactory
+*/
+
+/*!
+ \fn void QtEnumPropertyManager::valueChanged(QtProperty *property, int value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtEnumPropertyManager::enumNamesChanged(QtProperty *property, const QStringList &names)
+
+ This signal is emitted whenever a property created by this manager
+ changes its enum names, passing a pointer to the \a property and
+ the new \a names as parameters.
+
+ \sa setEnumNames()
+*/
+
+/*!
+ \fn void QtEnumPropertyManager::enumIconsChanged(QtProperty *property, const QMap<int, QIcon> &icons)
+
+ This signal is emitted whenever a property created by this manager
+ changes its enum icons, passing a pointer to the \a property and
+ the new mapping of values to \a icons as parameters.
+
+ \sa setEnumIcons()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtEnumPropertyManager::QtEnumPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtEnumPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtEnumPropertyManager::~QtEnumPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value which is an index in the
+ list returned by enumNames()
+
+ If the given property is not managed by this manager, this
+ function returns -1.
+
+ \sa enumNames(), setValue()
+*/
+int QtEnumPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<int>(d_ptr->m_values, property, -1);
+}
+
+/*!
+ Returns the given \a property's list of enum names.
+
+ \sa value(), setEnumNames()
+*/
+QStringList QtEnumPropertyManager::enumNames(const QtProperty *property) const
+{
+ return getData<QStringList>(d_ptr->m_values, &QtEnumPropertyManagerPrivate::Data::enumNames, property, QStringList());
+}
+
+/*!
+ Returns the given \a property's map of enum values to their icons.
+
+ \sa value(), setEnumIcons()
+*/
+QMap<int, QIcon> QtEnumPropertyManager::enumIcons(const QtProperty *property) const
+{
+ return getData<QMap<int, QIcon> >(d_ptr->m_values, &QtEnumPropertyManagerPrivate::Data::enumIcons, property, QMap<int, QIcon>());
+}
+
+/*!
+ \reimp
+*/
+QString QtEnumPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtEnumPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ const QtEnumPropertyManagerPrivate::Data &data = it.value();
+
+ const int v = data.val;
+ if (v >= 0 && v < data.enumNames.count())
+ return data.enumNames.at(v);
+ return QString();
+}
+
+/*!
+ \reimp
+*/
+QIcon QtEnumPropertyManager::valueIcon(const QtProperty *property) const
+{
+ const QtEnumPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QIcon();
+
+ const QtEnumPropertyManagerPrivate::Data &data = it.value();
+
+ const int v = data.val;
+ return data.enumIcons.value(v);
+}
+
+/*!
+ \fn void QtEnumPropertyManager::setValue(QtProperty *property, int value)
+
+ Sets the value of the given \a property to \a value.
+
+ The specified \a value must be less than the size of the given \a
+ property's enumNames() list, and larger than (or equal to) 0.
+
+ \sa value(), valueChanged()
+*/
+void QtEnumPropertyManager::setValue(QtProperty *property, int val)
+{
+ const QtEnumPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtEnumPropertyManagerPrivate::Data data = it.value();
+
+ if (val >= data.enumNames.count())
+ return;
+
+ if (val < 0 && data.enumNames.count() > 0)
+ return;
+
+ if (val < 0)
+ val = -1;
+
+ if (data.val == val)
+ return;
+
+ data.val = val;
+
+ it.value() = data;
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ Sets the given \a property's list of enum names to \a
+ enumNames. The \a property's current value is reset to 0
+ indicating the first item of the list.
+
+ If the specified \a enumNames list is empty, the \a property's
+ current value is set to -1.
+
+ \sa enumNames(), enumNamesChanged()
+*/
+void QtEnumPropertyManager::setEnumNames(QtProperty *property, const QStringList &enumNames)
+{
+ const QtEnumPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtEnumPropertyManagerPrivate::Data data = it.value();
+
+ if (data.enumNames == enumNames)
+ return;
+
+ data.enumNames = enumNames;
+
+ data.val = -1;
+
+ if (enumNames.count() > 0)
+ data.val = 0;
+
+ it.value() = data;
+
+ emit enumNamesChanged(property, data.enumNames);
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ Sets the given \a property's map of enum values to their icons to \a
+ enumIcons.
+
+ Each enum value can have associated icon. This association is represented with passed \a enumIcons map.
+
+ \sa enumNames(), enumNamesChanged()
+*/
+void QtEnumPropertyManager::setEnumIcons(QtProperty *property, const QMap<int, QIcon> &enumIcons)
+{
+ const QtEnumPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ it.value().enumIcons = enumIcons;
+
+ emit enumIconsChanged(property, it.value().enumIcons);
+
+ emit propertyChanged(property);
+}
+
+/*!
+ \reimp
+*/
+void QtEnumPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtEnumPropertyManagerPrivate::Data();
+}
+
+/*!
+ \reimp
+*/
+void QtEnumPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+// QtFlagPropertyManager
+
+class QtFlagPropertyManagerPrivate
+{
+ QtFlagPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtFlagPropertyManager)
+public:
+
+ void slotBoolChanged(QtProperty *property, bool value);
+ void slotPropertyDestroyed(QtProperty *property);
+
+ struct Data
+ {
+ Data() : val(-1) {}
+ int val;
+ QStringList flagNames;
+ };
+
+ typedef QMap<const QtProperty *, Data> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtBoolPropertyManager *m_boolPropertyManager;
+
+ QMap<const QtProperty *, QList<QtProperty *> > m_propertyToFlags;
+
+ QMap<const QtProperty *, QtProperty *> m_flagToProperty;
+};
+
+void QtFlagPropertyManagerPrivate::slotBoolChanged(QtProperty *property, bool value)
+{
+ QtProperty *prop = m_flagToProperty.value(property, 0);
+ if (prop == 0)
+ return;
+
+ QListIterator<QtProperty *> itProp(m_propertyToFlags[prop]);
+ int level = 0;
+ while (itProp.hasNext()) {
+ QtProperty *p = itProp.next();
+ if (p == property) {
+ int v = m_values[prop].val;
+ if (value) {
+ v |= (1 << level);
+ } else {
+ v &= ~(1 << level);
+ }
+ q_ptr->setValue(prop, v);
+ return;
+ }
+ level++;
+ }
+}
+
+void QtFlagPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ QtProperty *flagProperty = m_flagToProperty.value(property, 0);
+ if (flagProperty == 0)
+ return;
+
+ m_propertyToFlags[flagProperty].replace(m_propertyToFlags[flagProperty].indexOf(property), 0);
+ m_flagToProperty.remove(property);
+}
+
+/*!
+ \class QtFlagPropertyManager
+
+ \brief The QtFlagPropertyManager provides and manages flag properties.
+
+ Each flag property has an associated list of flag names which can
+ be retrieved using the flagNames() function, and set using the
+ corresponding setFlagNames() function.
+
+ The flag manager provides properties with nested boolean
+ subproperties representing each flag, i.e. a flag property's value
+ is the binary combination of the subproperties' values. A
+ property's value can be retrieved and set using the value() and
+ setValue() slots respectively. The combination of flags is represented
+ by single int value - that's why it's possible to store up to
+ 32 independent flags in one flag property.
+
+ The subproperties are created by a QtBoolPropertyManager object. This
+ manager can be retrieved using the subBoolPropertyManager() function. In
+ order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ In addition, QtFlagPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes, and the flagNamesChanged() signal which is emitted
+ whenever the list of flag names is altered.
+
+ \sa QtAbstractPropertyManager, QtBoolPropertyManager
+*/
+
+/*!
+ \fn void QtFlagPropertyManager::valueChanged(QtProperty *property, int value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtFlagPropertyManager::flagNamesChanged(QtProperty *property, const QStringList &names)
+
+ This signal is emitted whenever a property created by this manager
+ changes its flag names, passing a pointer to the \a property and the
+ new \a names as parameters.
+
+ \sa setFlagNames()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtFlagPropertyManager::QtFlagPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtFlagPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_boolPropertyManager = new QtBoolPropertyManager(this);
+ connect(d_ptr->m_boolPropertyManager, SIGNAL(valueChanged(QtProperty *, bool)),
+ this, SLOT(slotBoolChanged(QtProperty *, bool)));
+ connect(d_ptr->m_boolPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtFlagPropertyManager::~QtFlagPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that produces the nested boolean subproperties
+ representing each flag.
+
+ In order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtBoolPropertyManager *QtFlagPropertyManager::subBoolPropertyManager() const
+{
+ return d_ptr->m_boolPropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns 0.
+
+ \sa flagNames(), setValue()
+*/
+int QtFlagPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<int>(d_ptr->m_values, property, 0);
+}
+
+/*!
+ Returns the given \a property's list of flag names.
+
+ \sa value(), setFlagNames()
+*/
+QStringList QtFlagPropertyManager::flagNames(const QtProperty *property) const
+{
+ return getData<QStringList>(d_ptr->m_values, &QtFlagPropertyManagerPrivate::Data::flagNames, property, QStringList());
+}
+
+/*!
+ \reimp
+*/
+QString QtFlagPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtFlagPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ const QtFlagPropertyManagerPrivate::Data &data = it.value();
+
+ QString str;
+ int level = 0;
+ const QChar bar = QLatin1Char('|');
+ const QStringList::const_iterator fncend = data.flagNames.constEnd();
+ for (QStringList::const_iterator it = data.flagNames.constBegin(); it != fncend; ++it) {
+ if (data.val & (1 << level)) {
+ if (!str.isEmpty())
+ str += bar;
+ str += *it;
+ }
+
+ level++;
+ }
+ return str;
+}
+
+/*!
+ \fn void QtFlagPropertyManager::setValue(QtProperty *property, int value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ The specified \a value must be less than the binary combination of
+ the property's flagNames() list size (i.e. less than 2\sup n,
+ where \c n is the size of the list) and larger than (or equal to)
+ 0.
+
+ \sa value(), valueChanged()
+*/
+void QtFlagPropertyManager::setValue(QtProperty *property, int val)
+{
+ const QtFlagPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtFlagPropertyManagerPrivate::Data data = it.value();
+
+ if (data.val == val)
+ return;
+
+ if (val > (1 << data.flagNames.count()) - 1)
+ return;
+
+ if (val < 0)
+ return;
+
+ data.val = val;
+
+ it.value() = data;
+
+ QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
+ int level = 0;
+ while (itProp.hasNext()) {
+ QtProperty *prop = itProp.next();
+ if (prop)
+ d_ptr->m_boolPropertyManager->setValue(prop, val & (1 << level));
+ level++;
+ }
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ Sets the given \a property's list of flag names to \a flagNames. The
+ property's current value is reset to 0 indicating the first item
+ of the list.
+
+ \sa flagNames(), flagNamesChanged()
+*/
+void QtFlagPropertyManager::setFlagNames(QtProperty *property, const QStringList &flagNames)
+{
+ const QtFlagPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ QtFlagPropertyManagerPrivate::Data data = it.value();
+
+ if (data.flagNames == flagNames)
+ return;
+
+ data.flagNames = flagNames;
+ data.val = 0;
+
+ it.value() = data;
+
+ QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
+ while (itProp.hasNext()) {
+ QtProperty *prop = itProp.next();
+ if (prop) {
+ delete prop;
+ d_ptr->m_flagToProperty.remove(prop);
+ }
+ }
+ d_ptr->m_propertyToFlags[property].clear();
+
+ QStringListIterator itFlag(flagNames);
+ while (itFlag.hasNext()) {
+ const QString flagName = itFlag.next();
+ QtProperty *prop = d_ptr->m_boolPropertyManager->addProperty();
+ prop->setPropertyName(flagName);
+ property->addSubProperty(prop);
+ d_ptr->m_propertyToFlags[property].append(prop);
+ d_ptr->m_flagToProperty[prop] = property;
+ }
+
+ emit flagNamesChanged(property, data.flagNames);
+
+ emit propertyChanged(property);
+ emit valueChanged(property, data.val);
+}
+
+/*!
+ \reimp
+*/
+void QtFlagPropertyManager::initializeProperty(QtProperty *property)
+{
+ d_ptr->m_values[property] = QtFlagPropertyManagerPrivate::Data();
+
+ d_ptr->m_propertyToFlags[property] = QList<QtProperty *>();
+}
+
+/*!
+ \reimp
+*/
+void QtFlagPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
+ while (itProp.hasNext()) {
+ QtProperty *prop = itProp.next();
+ if (prop) {
+ delete prop;
+ d_ptr->m_flagToProperty.remove(prop);
+ }
+ }
+ d_ptr->m_propertyToFlags.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtSizePolicyPropertyManager
+
+class QtSizePolicyPropertyManagerPrivate
+{
+ QtSizePolicyPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtSizePolicyPropertyManager)
+public:
+
+ QtSizePolicyPropertyManagerPrivate();
+
+ void slotIntChanged(QtProperty *property, int value);
+ void slotEnumChanged(QtProperty *property, int value);
+ void slotPropertyDestroyed(QtProperty *property);
+
+ typedef QMap<const QtProperty *, QSizePolicy> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtIntPropertyManager *m_intPropertyManager;
+ QtEnumPropertyManager *m_enumPropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToHPolicy;
+ QMap<const QtProperty *, QtProperty *> m_propertyToVPolicy;
+ QMap<const QtProperty *, QtProperty *> m_propertyToHStretch;
+ QMap<const QtProperty *, QtProperty *> m_propertyToVStretch;
+
+ QMap<const QtProperty *, QtProperty *> m_hPolicyToProperty;
+ QMap<const QtProperty *, QtProperty *> m_vPolicyToProperty;
+ QMap<const QtProperty *, QtProperty *> m_hStretchToProperty;
+ QMap<const QtProperty *, QtProperty *> m_vStretchToProperty;
+};
+
+QtSizePolicyPropertyManagerPrivate::QtSizePolicyPropertyManagerPrivate()
+{
+}
+
+void QtSizePolicyPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+ if (QtProperty *prop = m_hStretchToProperty.value(property, 0)) {
+ QSizePolicy sp = m_values[prop];
+ sp.setHorizontalStretch(value);
+ q_ptr->setValue(prop, sp);
+ } else if (QtProperty *prop = m_vStretchToProperty.value(property, 0)) {
+ QSizePolicy sp = m_values[prop];
+ sp.setVerticalStretch(value);
+ q_ptr->setValue(prop, sp);
+ }
+}
+
+void QtSizePolicyPropertyManagerPrivate::slotEnumChanged(QtProperty *property, int value)
+{
+ if (QtProperty *prop = m_hPolicyToProperty.value(property, 0)) {
+ QSizePolicy sp = m_values[prop];
+ sp.setHorizontalPolicy(metaEnumProvider()->indexToSizePolicy(value));
+ q_ptr->setValue(prop, sp);
+ } else if (QtProperty *prop = m_vPolicyToProperty.value(property, 0)) {
+ QSizePolicy sp = m_values[prop];
+ sp.setVerticalPolicy(metaEnumProvider()->indexToSizePolicy(value));
+ q_ptr->setValue(prop, sp);
+ }
+}
+
+void QtSizePolicyPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_hStretchToProperty.value(property, 0)) {
+ m_propertyToHStretch[pointProp] = 0;
+ m_hStretchToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_vStretchToProperty.value(property, 0)) {
+ m_propertyToVStretch[pointProp] = 0;
+ m_vStretchToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_hPolicyToProperty.value(property, 0)) {
+ m_propertyToHPolicy[pointProp] = 0;
+ m_hPolicyToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_vPolicyToProperty.value(property, 0)) {
+ m_propertyToVPolicy[pointProp] = 0;
+ m_vPolicyToProperty.remove(property);
+ }
+}
+
+/*!
+ \class QtSizePolicyPropertyManager
+
+ \brief The QtSizePolicyPropertyManager provides and manages QSizePolicy properties.
+
+ A size policy property has nested \e horizontalPolicy, \e
+ verticalPolicy, \e horizontalStretch and \e verticalStretch
+ subproperties. The top-level property's value can be retrieved
+ using the value() function, and set using the setValue() slot.
+
+ The subproperties are created by QtIntPropertyManager and QtEnumPropertyManager
+ objects. These managers can be retrieved using the subIntPropertyManager()
+ and subEnumPropertyManager() functions respectively. In order to provide
+ editing widgets for the subproperties in a property browser widget,
+ these managers must be associated with editor factories.
+
+ In addition, QtSizePolicyPropertyManager provides the valueChanged()
+ signal which is emitted whenever a property created by this
+ manager changes.
+
+ \sa QtAbstractPropertyManager, QtIntPropertyManager, QtEnumPropertyManager
+*/
+
+/*!
+ \fn void QtSizePolicyPropertyManager::valueChanged(QtProperty *property, const QSizePolicy &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtSizePolicyPropertyManager::QtSizePolicyPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtSizePolicyPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
+ connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotIntChanged(QtProperty *, int)));
+ d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
+ connect(d_ptr->m_enumPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotEnumChanged(QtProperty *, int)));
+
+ connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+ connect(d_ptr->m_enumPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtSizePolicyPropertyManager::~QtSizePolicyPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the nested \e horizontalStretch
+ and \e verticalStretch subproperties.
+
+ In order to provide editing widgets for the mentioned subproperties
+ in a property browser widget, this manager must be associated with
+ an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtIntPropertyManager *QtSizePolicyPropertyManager::subIntPropertyManager() const
+{
+ return d_ptr->m_intPropertyManager;
+}
+
+/*!
+ Returns the manager that creates the nested \e horizontalPolicy
+ and \e verticalPolicy subproperties.
+
+ In order to provide editing widgets for the mentioned subproperties
+ in a property browser widget, this manager must be associated with
+ an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtEnumPropertyManager *QtSizePolicyPropertyManager::subEnumPropertyManager() const
+{
+ return d_ptr->m_enumPropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns the default size policy.
+
+ \sa setValue()
+*/
+QSizePolicy QtSizePolicyPropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QSizePolicy());
+}
+
+/*!
+ \reimp
+*/
+QString QtSizePolicyPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtSizePolicyPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ const QSizePolicy sp = it.value();
+ const QtMetaEnumProvider *mep = metaEnumProvider();
+ const int hIndex = mep->sizePolicyToIndex(sp.horizontalPolicy());
+ const int vIndex = mep->sizePolicyToIndex(sp.verticalPolicy());
+ //! Unknown size policy on reading invalid uic3 files
+ const QString hPolicy = hIndex != -1 ? mep->policyEnumNames().at(hIndex) : tr("<Invalid>");
+ const QString vPolicy = vIndex != -1 ? mep->policyEnumNames().at(vIndex) : tr("<Invalid>");
+ const QString str = tr("[%1, %2, %3, %4]").arg(hPolicy, vPolicy).arg(sp.horizontalStretch()).arg(sp.verticalStretch());
+ return str;
+}
+
+/*!
+ \fn void QtSizePolicyPropertyManager::setValue(QtProperty *property, const QSizePolicy &value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ \sa value(), valueChanged()
+*/
+void QtSizePolicyPropertyManager::setValue(QtProperty *property, const QSizePolicy &val)
+{
+ const QtSizePolicyPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ if (it.value() == val)
+ return;
+
+ it.value() = val;
+
+ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToHPolicy[property],
+ metaEnumProvider()->sizePolicyToIndex(val.horizontalPolicy()));
+ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToVPolicy[property],
+ metaEnumProvider()->sizePolicyToIndex(val.verticalPolicy()));
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToHStretch[property],
+ val.horizontalStretch());
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToVStretch[property],
+ val.verticalStretch());
+
+ emit propertyChanged(property);
+ emit valueChanged(property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtSizePolicyPropertyManager::initializeProperty(QtProperty *property)
+{
+ QSizePolicy val;
+ d_ptr->m_values[property] = val;
+
+ QtProperty *hPolicyProp = d_ptr->m_enumPropertyManager->addProperty();
+ hPolicyProp->setPropertyName(tr("Horizontal Policy"));
+ d_ptr->m_enumPropertyManager->setEnumNames(hPolicyProp, metaEnumProvider()->policyEnumNames());
+ d_ptr->m_enumPropertyManager->setValue(hPolicyProp,
+ metaEnumProvider()->sizePolicyToIndex(val.horizontalPolicy()));
+ d_ptr->m_propertyToHPolicy[property] = hPolicyProp;
+ d_ptr->m_hPolicyToProperty[hPolicyProp] = property;
+ property->addSubProperty(hPolicyProp);
+
+ QtProperty *vPolicyProp = d_ptr->m_enumPropertyManager->addProperty();
+ vPolicyProp->setPropertyName(tr("Vertical Policy"));
+ d_ptr->m_enumPropertyManager->setEnumNames(vPolicyProp, metaEnumProvider()->policyEnumNames());
+ d_ptr->m_enumPropertyManager->setValue(vPolicyProp,
+ metaEnumProvider()->sizePolicyToIndex(val.verticalPolicy()));
+ d_ptr->m_propertyToVPolicy[property] = vPolicyProp;
+ d_ptr->m_vPolicyToProperty[vPolicyProp] = property;
+ property->addSubProperty(vPolicyProp);
+
+ QtProperty *hStretchProp = d_ptr->m_intPropertyManager->addProperty();
+ hStretchProp->setPropertyName(tr("Horizontal Stretch"));
+ d_ptr->m_intPropertyManager->setValue(hStretchProp, val.horizontalStretch());
+ d_ptr->m_intPropertyManager->setRange(hStretchProp, 0, 0xff);
+ d_ptr->m_propertyToHStretch[property] = hStretchProp;
+ d_ptr->m_hStretchToProperty[hStretchProp] = property;
+ property->addSubProperty(hStretchProp);
+
+ QtProperty *vStretchProp = d_ptr->m_intPropertyManager->addProperty();
+ vStretchProp->setPropertyName(tr("Vertical Stretch"));
+ d_ptr->m_intPropertyManager->setValue(vStretchProp, val.verticalStretch());
+ d_ptr->m_intPropertyManager->setRange(vStretchProp, 0, 0xff);
+ d_ptr->m_propertyToVStretch[property] = vStretchProp;
+ d_ptr->m_vStretchToProperty[vStretchProp] = property;
+ property->addSubProperty(vStretchProp);
+
+}
+
+/*!
+ \reimp
+*/
+void QtSizePolicyPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *hPolicyProp = d_ptr->m_propertyToHPolicy[property];
+ if (hPolicyProp) {
+ d_ptr->m_hPolicyToProperty.remove(hPolicyProp);
+ delete hPolicyProp;
+ }
+ d_ptr->m_propertyToHPolicy.remove(property);
+
+ QtProperty *vPolicyProp = d_ptr->m_propertyToVPolicy[property];
+ if (vPolicyProp) {
+ d_ptr->m_vPolicyToProperty.remove(vPolicyProp);
+ delete vPolicyProp;
+ }
+ d_ptr->m_propertyToVPolicy.remove(property);
+
+ QtProperty *hStretchProp = d_ptr->m_propertyToHStretch[property];
+ if (hStretchProp) {
+ d_ptr->m_hStretchToProperty.remove(hStretchProp);
+ delete hStretchProp;
+ }
+ d_ptr->m_propertyToHStretch.remove(property);
+
+ QtProperty *vStretchProp = d_ptr->m_propertyToVStretch[property];
+ if (vStretchProp) {
+ d_ptr->m_vStretchToProperty.remove(vStretchProp);
+ delete vStretchProp;
+ }
+ d_ptr->m_propertyToVStretch.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtFontPropertyManager:
+// QtFontPropertyManagerPrivate has a mechanism for reacting
+// to QApplication::fontDatabaseChanged() [4.5], which is emitted
+// when someone loads an application font. The signals are compressed
+// using a timer with interval 0, which then causes the family
+// enumeration manager to re-set its strings and index values
+// for each property.
+
+Q_GLOBAL_STATIC(QFontDatabase, fontDatabase)
+
+class QtFontPropertyManagerPrivate
+{
+ QtFontPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtFontPropertyManager)
+public:
+
+ QtFontPropertyManagerPrivate();
+
+ void slotIntChanged(QtProperty *property, int value);
+ void slotEnumChanged(QtProperty *property, int value);
+ void slotBoolChanged(QtProperty *property, bool value);
+ void slotPropertyDestroyed(QtProperty *property);
+ void slotFontDatabaseChanged();
+ void slotFontDatabaseDelayedChange();
+
+ QStringList m_familyNames;
+
+ typedef QMap<const QtProperty *, QFont> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtIntPropertyManager *m_intPropertyManager;
+ QtEnumPropertyManager *m_enumPropertyManager;
+ QtBoolPropertyManager *m_boolPropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToFamily;
+ QMap<const QtProperty *, QtProperty *> m_propertyToPointSize;
+ QMap<const QtProperty *, QtProperty *> m_propertyToBold;
+ QMap<const QtProperty *, QtProperty *> m_propertyToItalic;
+ QMap<const QtProperty *, QtProperty *> m_propertyToUnderline;
+ QMap<const QtProperty *, QtProperty *> m_propertyToStrikeOut;
+ QMap<const QtProperty *, QtProperty *> m_propertyToKerning;
+
+ QMap<const QtProperty *, QtProperty *> m_familyToProperty;
+ QMap<const QtProperty *, QtProperty *> m_pointSizeToProperty;
+ QMap<const QtProperty *, QtProperty *> m_boldToProperty;
+ QMap<const QtProperty *, QtProperty *> m_italicToProperty;
+ QMap<const QtProperty *, QtProperty *> m_underlineToProperty;
+ QMap<const QtProperty *, QtProperty *> m_strikeOutToProperty;
+ QMap<const QtProperty *, QtProperty *> m_kerningToProperty;
+
+ bool m_settingValue;
+ QTimer *m_fontDatabaseChangeTimer;
+};
+
+QtFontPropertyManagerPrivate::QtFontPropertyManagerPrivate() :
+ m_settingValue(false),
+ m_fontDatabaseChangeTimer(0)
+{
+}
+
+void QtFontPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+ if (m_settingValue)
+ return;
+ if (QtProperty *prop = m_pointSizeToProperty.value(property, 0)) {
+ QFont f = m_values[prop];
+ f.setPointSize(value);
+ q_ptr->setValue(prop, f);
+ }
+}
+
+void QtFontPropertyManagerPrivate::slotEnumChanged(QtProperty *property, int value)
+{
+ if (m_settingValue)
+ return;
+ if (QtProperty *prop = m_familyToProperty.value(property, 0)) {
+ QFont f = m_values[prop];
+ f.setFamily(m_familyNames.at(value));
+ q_ptr->setValue(prop, f);
+ }
+}
+
+void QtFontPropertyManagerPrivate::slotBoolChanged(QtProperty *property, bool value)
+{
+ if (m_settingValue)
+ return;
+ if (QtProperty *prop = m_boldToProperty.value(property, 0)) {
+ QFont f = m_values[prop];
+ f.setBold(value);
+ q_ptr->setValue(prop, f);
+ } else if (QtProperty *prop = m_italicToProperty.value(property, 0)) {
+ QFont f = m_values[prop];
+ f.setItalic(value);
+ q_ptr->setValue(prop, f);
+ } else if (QtProperty *prop = m_underlineToProperty.value(property, 0)) {
+ QFont f = m_values[prop];
+ f.setUnderline(value);
+ q_ptr->setValue(prop, f);
+ } else if (QtProperty *prop = m_strikeOutToProperty.value(property, 0)) {
+ QFont f = m_values[prop];
+ f.setStrikeOut(value);
+ q_ptr->setValue(prop, f);
+ } else if (QtProperty *prop = m_kerningToProperty.value(property, 0)) {
+ QFont f = m_values[prop];
+ f.setKerning(value);
+ q_ptr->setValue(prop, f);
+ }
+}
+
+void QtFontPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_pointSizeToProperty.value(property, 0)) {
+ m_propertyToPointSize[pointProp] = 0;
+ m_pointSizeToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_familyToProperty.value(property, 0)) {
+ m_propertyToFamily[pointProp] = 0;
+ m_familyToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_boldToProperty.value(property, 0)) {
+ m_propertyToBold[pointProp] = 0;
+ m_boldToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_italicToProperty.value(property, 0)) {
+ m_propertyToItalic[pointProp] = 0;
+ m_italicToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_underlineToProperty.value(property, 0)) {
+ m_propertyToUnderline[pointProp] = 0;
+ m_underlineToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_strikeOutToProperty.value(property, 0)) {
+ m_propertyToStrikeOut[pointProp] = 0;
+ m_strikeOutToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_kerningToProperty.value(property, 0)) {
+ m_propertyToKerning[pointProp] = 0;
+ m_kerningToProperty.remove(property);
+ }
+}
+
+void QtFontPropertyManagerPrivate::slotFontDatabaseChanged()
+{
+ if (!m_fontDatabaseChangeTimer) {
+ m_fontDatabaseChangeTimer = new QTimer(q_ptr);
+ m_fontDatabaseChangeTimer->setInterval(0);
+ m_fontDatabaseChangeTimer->setSingleShot(true);
+ QObject::connect(m_fontDatabaseChangeTimer, SIGNAL(timeout()), q_ptr, SLOT(slotFontDatabaseDelayedChange()));
+ }
+ if (!m_fontDatabaseChangeTimer->isActive())
+ m_fontDatabaseChangeTimer->start();
+}
+
+void QtFontPropertyManagerPrivate::slotFontDatabaseDelayedChange()
+{
+ typedef QMap<const QtProperty *, QtProperty *> PropertyPropertyMap;
+ // rescan available font names
+ const QStringList oldFamilies = m_familyNames;
+ m_familyNames = fontDatabase()->families();
+
+ // Adapt all existing properties
+ if (!m_propertyToFamily.empty()) {
+ PropertyPropertyMap::const_iterator cend = m_propertyToFamily.constEnd();
+ for (PropertyPropertyMap::const_iterator it = m_propertyToFamily.constBegin(); it != cend; ++it) {
+ QtProperty *familyProp = it.value();
+ const int oldIdx = m_enumPropertyManager->value(familyProp);
+ int newIdx = m_familyNames.indexOf(oldFamilies.at(oldIdx));
+ if (newIdx < 0)
+ newIdx = 0;
+ m_enumPropertyManager->setEnumNames(familyProp, m_familyNames);
+ m_enumPropertyManager->setValue(familyProp, newIdx);
+ }
+ }
+}
+
+/*!
+ \class QtFontPropertyManager
+
+ \brief The QtFontPropertyManager provides and manages QFont properties.
+
+ A font property has nested \e family, \e pointSize, \e bold, \e
+ italic, \e underline, \e strikeOut and \e kerning subproperties. The top-level
+ property's value can be retrieved using the value() function, and
+ set using the setValue() slot.
+
+ The subproperties are created by QtIntPropertyManager, QtEnumPropertyManager and
+ QtBoolPropertyManager objects. These managers can be retrieved using the
+ corresponding subIntPropertyManager(), subEnumPropertyManager() and
+ subBoolPropertyManager() functions. In order to provide editing widgets
+ for the subproperties in a property browser widget, these managers
+ must be associated with editor factories.
+
+ In addition, QtFontPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes.
+
+ \sa QtAbstractPropertyManager, QtEnumPropertyManager, QtIntPropertyManager, QtBoolPropertyManager
+*/
+
+/*!
+ \fn void QtFontPropertyManager::valueChanged(QtProperty *property, const QFont &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtFontPropertyManager::QtFontPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtFontPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+#if QT_VERSION >= 0x040500
+ QObject::connect(qApp, SIGNAL(fontDatabaseChanged()), this, SLOT(slotFontDatabaseChanged()));
+#endif
+
+ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
+ connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotIntChanged(QtProperty *, int)));
+ d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
+ connect(d_ptr->m_enumPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotEnumChanged(QtProperty *, int)));
+ d_ptr->m_boolPropertyManager = new QtBoolPropertyManager(this);
+ connect(d_ptr->m_boolPropertyManager, SIGNAL(valueChanged(QtProperty *, bool)),
+ this, SLOT(slotBoolChanged(QtProperty *, bool)));
+
+ connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+ connect(d_ptr->m_enumPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+ connect(d_ptr->m_boolPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtFontPropertyManager::~QtFontPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that creates the \e pointSize subproperty.
+
+ In order to provide editing widgets for the \e pointSize property
+ in a property browser widget, this manager must be associated
+ with an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtIntPropertyManager *QtFontPropertyManager::subIntPropertyManager() const
+{
+ return d_ptr->m_intPropertyManager;
+}
+
+/*!
+ Returns the manager that create the \e family subproperty.
+
+ In order to provide editing widgets for the \e family property
+ in a property browser widget, this manager must be associated
+ with an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtEnumPropertyManager *QtFontPropertyManager::subEnumPropertyManager() const
+{
+ return d_ptr->m_enumPropertyManager;
+}
+
+/*!
+ Returns the manager that creates the \e bold, \e italic, \e underline,
+ \e strikeOut and \e kerning subproperties.
+
+ In order to provide editing widgets for the mentioned properties
+ in a property browser widget, this manager must be associated with
+ an editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtBoolPropertyManager *QtFontPropertyManager::subBoolPropertyManager() const
+{
+ return d_ptr->m_boolPropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns a font object that uses the application's default
+ font.
+
+ \sa setValue()
+*/
+QFont QtFontPropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QFont());
+}
+
+/*!
+ \reimp
+*/
+QString QtFontPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtFontPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ return QtPropertyBrowserUtils::fontValueText(it.value());
+}
+
+/*!
+ \reimp
+*/
+QIcon QtFontPropertyManager::valueIcon(const QtProperty *property) const
+{
+ const QtFontPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QIcon();
+
+ return QtPropertyBrowserUtils::fontValueIcon(it.value());
+}
+
+/*!
+ \fn void QtFontPropertyManager::setValue(QtProperty *property, const QFont &value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ \sa value(), valueChanged()
+*/
+void QtFontPropertyManager::setValue(QtProperty *property, const QFont &val)
+{
+ const QtFontPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ const QFont oldVal = it.value();
+ if (oldVal == val && oldVal.resolve() == val.resolve())
+ return;
+
+ it.value() = val;
+
+ int idx = d_ptr->m_familyNames.indexOf(val.family());
+ if (idx == -1)
+ idx = 0;
+ bool settingValue = d_ptr->m_settingValue;
+ d_ptr->m_settingValue = true;
+ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToFamily[property], idx);
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToPointSize[property], val.pointSize());
+ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToBold[property], val.bold());
+ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToItalic[property], val.italic());
+ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToUnderline[property], val.underline());
+ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToStrikeOut[property], val.strikeOut());
+ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToKerning[property], val.kerning());
+ d_ptr->m_settingValue = settingValue;
+
+ emit propertyChanged(property);
+ emit valueChanged(property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtFontPropertyManager::initializeProperty(QtProperty *property)
+{
+ QFont val;
+ d_ptr->m_values[property] = val;
+
+ QtProperty *familyProp = d_ptr->m_enumPropertyManager->addProperty();
+ familyProp->setPropertyName(tr("Family"));
+ if (d_ptr->m_familyNames.empty())
+ d_ptr->m_familyNames = fontDatabase()->families();
+ d_ptr->m_enumPropertyManager->setEnumNames(familyProp, d_ptr->m_familyNames);
+ int idx = d_ptr->m_familyNames.indexOf(val.family());
+ if (idx == -1)
+ idx = 0;
+ d_ptr->m_enumPropertyManager->setValue(familyProp, idx);
+ d_ptr->m_propertyToFamily[property] = familyProp;
+ d_ptr->m_familyToProperty[familyProp] = property;
+ property->addSubProperty(familyProp);
+
+ QtProperty *pointSizeProp = d_ptr->m_intPropertyManager->addProperty();
+ pointSizeProp->setPropertyName(tr("Point Size"));
+ d_ptr->m_intPropertyManager->setValue(pointSizeProp, val.pointSize());
+ d_ptr->m_intPropertyManager->setMinimum(pointSizeProp, 1);
+ d_ptr->m_propertyToPointSize[property] = pointSizeProp;
+ d_ptr->m_pointSizeToProperty[pointSizeProp] = property;
+ property->addSubProperty(pointSizeProp);
+
+ QtProperty *boldProp = d_ptr->m_boolPropertyManager->addProperty();
+ boldProp->setPropertyName(tr("Bold"));
+ d_ptr->m_boolPropertyManager->setValue(boldProp, val.bold());
+ d_ptr->m_propertyToBold[property] = boldProp;
+ d_ptr->m_boldToProperty[boldProp] = property;
+ property->addSubProperty(boldProp);
+
+ QtProperty *italicProp = d_ptr->m_boolPropertyManager->addProperty();
+ italicProp->setPropertyName(tr("Italic"));
+ d_ptr->m_boolPropertyManager->setValue(italicProp, val.italic());
+ d_ptr->m_propertyToItalic[property] = italicProp;
+ d_ptr->m_italicToProperty[italicProp] = property;
+ property->addSubProperty(italicProp);
+
+ QtProperty *underlineProp = d_ptr->m_boolPropertyManager->addProperty();
+ underlineProp->setPropertyName(tr("Underline"));
+ d_ptr->m_boolPropertyManager->setValue(underlineProp, val.underline());
+ d_ptr->m_propertyToUnderline[property] = underlineProp;
+ d_ptr->m_underlineToProperty[underlineProp] = property;
+ property->addSubProperty(underlineProp);
+
+ QtProperty *strikeOutProp = d_ptr->m_boolPropertyManager->addProperty();
+ strikeOutProp->setPropertyName(tr("Strikeout"));
+ d_ptr->m_boolPropertyManager->setValue(strikeOutProp, val.strikeOut());
+ d_ptr->m_propertyToStrikeOut[property] = strikeOutProp;
+ d_ptr->m_strikeOutToProperty[strikeOutProp] = property;
+ property->addSubProperty(strikeOutProp);
+
+ QtProperty *kerningProp = d_ptr->m_boolPropertyManager->addProperty();
+ kerningProp->setPropertyName(tr("Kerning"));
+ d_ptr->m_boolPropertyManager->setValue(kerningProp, val.kerning());
+ d_ptr->m_propertyToKerning[property] = kerningProp;
+ d_ptr->m_kerningToProperty[kerningProp] = property;
+ property->addSubProperty(kerningProp);
+}
+
+/*!
+ \reimp
+*/
+void QtFontPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *familyProp = d_ptr->m_propertyToFamily[property];
+ if (familyProp) {
+ d_ptr->m_familyToProperty.remove(familyProp);
+ delete familyProp;
+ }
+ d_ptr->m_propertyToFamily.remove(property);
+
+ QtProperty *pointSizeProp = d_ptr->m_propertyToPointSize[property];
+ if (pointSizeProp) {
+ d_ptr->m_pointSizeToProperty.remove(pointSizeProp);
+ delete pointSizeProp;
+ }
+ d_ptr->m_propertyToPointSize.remove(property);
+
+ QtProperty *boldProp = d_ptr->m_propertyToBold[property];
+ if (boldProp) {
+ d_ptr->m_boldToProperty.remove(boldProp);
+ delete boldProp;
+ }
+ d_ptr->m_propertyToBold.remove(property);
+
+ QtProperty *italicProp = d_ptr->m_propertyToItalic[property];
+ if (italicProp) {
+ d_ptr->m_italicToProperty.remove(italicProp);
+ delete italicProp;
+ }
+ d_ptr->m_propertyToItalic.remove(property);
+
+ QtProperty *underlineProp = d_ptr->m_propertyToUnderline[property];
+ if (underlineProp) {
+ d_ptr->m_underlineToProperty.remove(underlineProp);
+ delete underlineProp;
+ }
+ d_ptr->m_propertyToUnderline.remove(property);
+
+ QtProperty *strikeOutProp = d_ptr->m_propertyToStrikeOut[property];
+ if (strikeOutProp) {
+ d_ptr->m_strikeOutToProperty.remove(strikeOutProp);
+ delete strikeOutProp;
+ }
+ d_ptr->m_propertyToStrikeOut.remove(property);
+
+ QtProperty *kerningProp = d_ptr->m_propertyToKerning[property];
+ if (kerningProp) {
+ d_ptr->m_kerningToProperty.remove(kerningProp);
+ delete kerningProp;
+ }
+ d_ptr->m_propertyToKerning.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtColorPropertyManager
+
+class QtColorPropertyManagerPrivate
+{
+ QtColorPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtColorPropertyManager)
+public:
+
+ void slotIntChanged(QtProperty *property, int value);
+ void slotPropertyDestroyed(QtProperty *property);
+
+ typedef QMap<const QtProperty *, QColor> PropertyValueMap;
+ PropertyValueMap m_values;
+
+ QtIntPropertyManager *m_intPropertyManager;
+
+ QMap<const QtProperty *, QtProperty *> m_propertyToR;
+ QMap<const QtProperty *, QtProperty *> m_propertyToG;
+ QMap<const QtProperty *, QtProperty *> m_propertyToB;
+ QMap<const QtProperty *, QtProperty *> m_propertyToA;
+
+ QMap<const QtProperty *, QtProperty *> m_rToProperty;
+ QMap<const QtProperty *, QtProperty *> m_gToProperty;
+ QMap<const QtProperty *, QtProperty *> m_bToProperty;
+ QMap<const QtProperty *, QtProperty *> m_aToProperty;
+};
+
+void QtColorPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+ if (QtProperty *prop = m_rToProperty.value(property, 0)) {
+ QColor c = m_values[prop];
+ c.setRed(value);
+ q_ptr->setValue(prop, c);
+ } else if (QtProperty *prop = m_gToProperty.value(property, 0)) {
+ QColor c = m_values[prop];
+ c.setGreen(value);
+ q_ptr->setValue(prop, c);
+ } else if (QtProperty *prop = m_bToProperty.value(property, 0)) {
+ QColor c = m_values[prop];
+ c.setBlue(value);
+ q_ptr->setValue(prop, c);
+ } else if (QtProperty *prop = m_aToProperty.value(property, 0)) {
+ QColor c = m_values[prop];
+ c.setAlpha(value);
+ q_ptr->setValue(prop, c);
+ }
+}
+
+void QtColorPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+ if (QtProperty *pointProp = m_rToProperty.value(property, 0)) {
+ m_propertyToR[pointProp] = 0;
+ m_rToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_gToProperty.value(property, 0)) {
+ m_propertyToG[pointProp] = 0;
+ m_gToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_bToProperty.value(property, 0)) {
+ m_propertyToB[pointProp] = 0;
+ m_bToProperty.remove(property);
+ } else if (QtProperty *pointProp = m_aToProperty.value(property, 0)) {
+ m_propertyToA[pointProp] = 0;
+ m_aToProperty.remove(property);
+ }
+}
+
+/*!
+ \class QtColorPropertyManager
+
+ \brief The QtColorPropertyManager provides and manages QColor properties.
+
+ A color property has nested \e red, \e green and \e blue
+ subproperties. The top-level property's value can be retrieved
+ using the value() function, and set using the setValue() slot.
+
+ The subproperties are created by a QtIntPropertyManager object. This
+ manager can be retrieved using the subIntPropertyManager() function. In
+ order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ In addition, QtColorPropertyManager provides the valueChanged() signal
+ which is emitted whenever a property created by this manager
+ changes.
+
+ \sa QtAbstractPropertyManager, QtAbstractPropertyBrowser, QtIntPropertyManager
+*/
+
+/*!
+ \fn void QtColorPropertyManager::valueChanged(QtProperty *property, const QColor &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtColorPropertyManager::QtColorPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtColorPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
+ connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotIntChanged(QtProperty *, int)));
+
+ connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty *)),
+ this, SLOT(slotPropertyDestroyed(QtProperty *)));
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtColorPropertyManager::~QtColorPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the manager that produces the nested \e red, \e green and
+ \e blue subproperties.
+
+ In order to provide editing widgets for the subproperties in a
+ property browser widget, this manager must be associated with an
+ editor factory.
+
+ \sa QtAbstractPropertyBrowser::setFactoryForManager()
+*/
+QtIntPropertyManager *QtColorPropertyManager::subIntPropertyManager() const
+{
+ return d_ptr->m_intPropertyManager;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by \e this manager, this
+ function returns an invalid color.
+
+ \sa setValue()
+*/
+QColor QtColorPropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QColor());
+}
+
+/*!
+ \reimp
+*/
+
+QString QtColorPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtColorPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ return QtPropertyBrowserUtils::colorValueText(it.value());
+}
+
+/*!
+ \reimp
+*/
+
+QIcon QtColorPropertyManager::valueIcon(const QtProperty *property) const
+{
+ const QtColorPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QIcon();
+ return QtPropertyBrowserUtils::brushValueIcon(QBrush(it.value()));
+}
+
+/*!
+ \fn void QtColorPropertyManager::setValue(QtProperty *property, const QColor &value)
+
+ Sets the value of the given \a property to \a value. Nested
+ properties are updated automatically.
+
+ \sa value(), valueChanged()
+*/
+void QtColorPropertyManager::setValue(QtProperty *property, const QColor &val)
+{
+ const QtColorPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ if (it.value() == val)
+ return;
+
+ it.value() = val;
+
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToR[property], val.red());
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToG[property], val.green());
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToB[property], val.blue());
+ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToA[property], val.alpha());
+
+ emit propertyChanged(property);
+ emit valueChanged(property, val);
+}
+
+/*!
+ \reimp
+*/
+void QtColorPropertyManager::initializeProperty(QtProperty *property)
+{
+ QColor val;
+ d_ptr->m_values[property] = val;
+
+ QtProperty *rProp = d_ptr->m_intPropertyManager->addProperty();
+ rProp->setPropertyName(tr("Red"));
+ d_ptr->m_intPropertyManager->setValue(rProp, val.red());
+ d_ptr->m_intPropertyManager->setRange(rProp, 0, 0xFF);
+ d_ptr->m_propertyToR[property] = rProp;
+ d_ptr->m_rToProperty[rProp] = property;
+ property->addSubProperty(rProp);
+
+ QtProperty *gProp = d_ptr->m_intPropertyManager->addProperty();
+ gProp->setPropertyName(tr("Green"));
+ d_ptr->m_intPropertyManager->setValue(gProp, val.green());
+ d_ptr->m_intPropertyManager->setRange(gProp, 0, 0xFF);
+ d_ptr->m_propertyToG[property] = gProp;
+ d_ptr->m_gToProperty[gProp] = property;
+ property->addSubProperty(gProp);
+
+ QtProperty *bProp = d_ptr->m_intPropertyManager->addProperty();
+ bProp->setPropertyName(tr("Blue"));
+ d_ptr->m_intPropertyManager->setValue(bProp, val.blue());
+ d_ptr->m_intPropertyManager->setRange(bProp, 0, 0xFF);
+ d_ptr->m_propertyToB[property] = bProp;
+ d_ptr->m_bToProperty[bProp] = property;
+ property->addSubProperty(bProp);
+
+ QtProperty *aProp = d_ptr->m_intPropertyManager->addProperty();
+ aProp->setPropertyName(tr("Alpha"));
+ d_ptr->m_intPropertyManager->setValue(aProp, val.alpha());
+ d_ptr->m_intPropertyManager->setRange(aProp, 0, 0xFF);
+ d_ptr->m_propertyToA[property] = aProp;
+ d_ptr->m_aToProperty[aProp] = property;
+ property->addSubProperty(aProp);
+}
+
+/*!
+ \reimp
+*/
+void QtColorPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ QtProperty *rProp = d_ptr->m_propertyToR[property];
+ if (rProp) {
+ d_ptr->m_rToProperty.remove(rProp);
+ delete rProp;
+ }
+ d_ptr->m_propertyToR.remove(property);
+
+ QtProperty *gProp = d_ptr->m_propertyToG[property];
+ if (gProp) {
+ d_ptr->m_gToProperty.remove(gProp);
+ delete gProp;
+ }
+ d_ptr->m_propertyToG.remove(property);
+
+ QtProperty *bProp = d_ptr->m_propertyToB[property];
+ if (bProp) {
+ d_ptr->m_bToProperty.remove(bProp);
+ delete bProp;
+ }
+ d_ptr->m_propertyToB.remove(property);
+
+ QtProperty *aProp = d_ptr->m_propertyToA[property];
+ if (aProp) {
+ d_ptr->m_aToProperty.remove(aProp);
+ delete aProp;
+ }
+ d_ptr->m_propertyToA.remove(property);
+
+ d_ptr->m_values.remove(property);
+}
+
+// QtCursorPropertyManager
+
+// Make sure icons are removed as soon as QApplication is destroyed, otherwise,
+// handles are leaked on X11.
+static void clearCursorDatabase();
+namespace {
+struct CursorDatabase : public QtCursorDatabase
+{
+ CursorDatabase()
+ {
+ qAddPostRoutine(clearCursorDatabase);
+ }
+};
+}
+Q_GLOBAL_STATIC(QtCursorDatabase, cursorDatabase)
+
+static void clearCursorDatabase()
+{
+ cursorDatabase()->clear();
+}
+
+class QtCursorPropertyManagerPrivate
+{
+ QtCursorPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtCursorPropertyManager)
+public:
+ typedef QMap<const QtProperty *, QCursor> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*!
+ \class QtCursorPropertyManager
+
+ \brief The QtCursorPropertyManager provides and manages QCursor properties.
+
+ A cursor property has a current value which can be
+ retrieved using the value() function, and set using the setValue()
+ slot. In addition, QtCursorPropertyManager provides the
+ valueChanged() signal which is emitted whenever a property created
+ by this manager changes.
+
+ \sa QtAbstractPropertyManager
+*/
+
+/*!
+ \fn void QtCursorPropertyManager::valueChanged(QtProperty *property, const QCursor &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the new
+ \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtCursorPropertyManager::QtCursorPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtCursorPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtCursorPropertyManager::~QtCursorPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns a default QCursor object.
+
+ \sa setValue()
+*/
+#ifndef QT_NO_CURSOR
+QCursor QtCursorPropertyManager::value(const QtProperty *property) const
+{
+ return d_ptr->m_values.value(property, QCursor());
+}
+#endif
+
+/*!
+ \reimp
+*/
+QString QtCursorPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtCursorPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QString();
+
+ return cursorDatabase()->cursorToShapeName(it.value());
+}
+
+/*!
+ \reimp
+*/
+QIcon QtCursorPropertyManager::valueIcon(const QtProperty *property) const
+{
+ const QtCursorPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+ if (it == d_ptr->m_values.constEnd())
+ return QIcon();
+
+ return cursorDatabase()->cursorToShapeIcon(it.value());
+}
+
+/*!
+ \fn void QtCursorPropertyManager::setValue(QtProperty *property, const QCursor &value)
+
+ Sets the value of the given \a property to \a value.
+
+ \sa value(), valueChanged()
+*/
+void QtCursorPropertyManager::setValue(QtProperty *property, const QCursor &value)
+{
+#ifndef QT_NO_CURSOR
+ const QtCursorPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+ if (it == d_ptr->m_values.end())
+ return;
+
+ if (it.value().shape() == value.shape() && value.shape() != Qt::BitmapCursor)
+ return;
+
+ it.value() = value;
+
+ emit propertyChanged(property);
+ emit valueChanged(property, value);
+#endif
+}
+
+/*!
+ \reimp
+*/
+void QtCursorPropertyManager::initializeProperty(QtProperty *property)
+{
+#ifndef QT_NO_CURSOR
+ d_ptr->m_values[property] = QCursor();
+#endif
+}
+
+/*!
+ \reimp
+*/
+void QtCursorPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ d_ptr->m_values.remove(property);
+}
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#include "moc_qtpropertymanager.cpp"
+#include "qtpropertymanager.moc"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtpropertymanager.h b/GUI/coregui/qttools/qtpropertybrowser/qtpropertymanager.h
new file mode 100644
index 0000000000000000000000000000000000000000..6eff26eea9e36b96bd5eaff578d6a47d712a7b22
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtpropertymanager.h
@@ -0,0 +1,766 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QTPROPERTYMANAGER_H
+#define QTPROPERTYMANAGER_H
+
+#include "qtpropertybrowser.h"
+#include <QLineEdit>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QDate;
+class QTime;
+class QDateTime;
+class QLocale;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtGroupPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtGroupPropertyManager(QObject *parent = 0);
+ ~QtGroupPropertyManager();
+
+protected:
+ virtual bool hasValue(const QtProperty *property) const;
+
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+};
+
+class QtIntPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtIntPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtIntPropertyManager(QObject *parent = 0);
+ ~QtIntPropertyManager();
+
+ int value(const QtProperty *property) const;
+ int minimum(const QtProperty *property) const;
+ int maximum(const QtProperty *property) const;
+ int singleStep(const QtProperty *property) const;
+ bool isReadOnly(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, int val);
+ void setMinimum(QtProperty *property, int minVal);
+ void setMaximum(QtProperty *property, int maxVal);
+ void setRange(QtProperty *property, int minVal, int maxVal);
+ void setSingleStep(QtProperty *property, int step);
+ void setReadOnly(QtProperty *property, bool readOnly);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, int val);
+ void rangeChanged(QtProperty *property, int minVal, int maxVal);
+ void singleStepChanged(QtProperty *property, int step);
+ void readOnlyChanged(QtProperty *property, bool readOnly);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtIntPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtIntPropertyManager)
+ Q_DISABLE_COPY(QtIntPropertyManager)
+};
+
+class QtBoolPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtBoolPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtBoolPropertyManager(QObject *parent = 0);
+ ~QtBoolPropertyManager();
+
+ bool value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, bool val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, bool val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ QIcon valueIcon(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtBoolPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtBoolPropertyManager)
+ Q_DISABLE_COPY(QtBoolPropertyManager)
+};
+
+class QtDoublePropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtDoublePropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtDoublePropertyManager(QObject *parent = 0);
+ ~QtDoublePropertyManager();
+
+ double value(const QtProperty *property) const;
+ double minimum(const QtProperty *property) const;
+ double maximum(const QtProperty *property) const;
+ double singleStep(const QtProperty *property) const;
+ int decimals(const QtProperty *property) const;
+ bool isReadOnly(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, double val);
+ void setMinimum(QtProperty *property, double minVal);
+ void setMaximum(QtProperty *property, double maxVal);
+ void setRange(QtProperty *property, double minVal, double maxVal);
+ void setSingleStep(QtProperty *property, double step);
+ void setDecimals(QtProperty *property, int prec);
+ void setReadOnly(QtProperty *property, bool readOnly);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, double val);
+ void rangeChanged(QtProperty *property, double minVal, double maxVal);
+ void singleStepChanged(QtProperty *property, double step);
+ void decimalsChanged(QtProperty *property, int prec);
+ void readOnlyChanged(QtProperty *property, bool readOnly);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtDoublePropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtDoublePropertyManager)
+ Q_DISABLE_COPY(QtDoublePropertyManager)
+};
+
+class QtStringPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtStringPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtStringPropertyManager(QObject *parent = 0);
+ ~QtStringPropertyManager();
+
+ QString value(const QtProperty *property) const;
+ QRegExp regExp(const QtProperty *property) const;
+ EchoMode echoMode(const QtProperty *property) const;
+ bool isReadOnly(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QString &val);
+ void setRegExp(QtProperty *property, const QRegExp ®Exp);
+ void setEchoMode(QtProperty *property, EchoMode echoMode);
+ void setReadOnly(QtProperty *property, bool readOnly);
+
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QString &val);
+ void regExpChanged(QtProperty *property, const QRegExp ®Exp);
+ void echoModeChanged(QtProperty *property, const int);
+ void readOnlyChanged(QtProperty *property, bool);
+
+protected:
+ QString valueText(const QtProperty *property) const;
+ QString displayText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtStringPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtStringPropertyManager)
+ Q_DISABLE_COPY(QtStringPropertyManager)
+};
+
+class QtDatePropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtDatePropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtDatePropertyManager(QObject *parent = 0);
+ ~QtDatePropertyManager();
+
+ QDate value(const QtProperty *property) const;
+ QDate minimum(const QtProperty *property) const;
+ QDate maximum(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QDate &val);
+ void setMinimum(QtProperty *property, const QDate &minVal);
+ void setMaximum(QtProperty *property, const QDate &maxVal);
+ void setRange(QtProperty *property, const QDate &minVal, const QDate &maxVal);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QDate &val);
+ void rangeChanged(QtProperty *property, const QDate &minVal, const QDate &maxVal);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtDatePropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtDatePropertyManager)
+ Q_DISABLE_COPY(QtDatePropertyManager)
+};
+
+class QtTimePropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtTimePropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtTimePropertyManager(QObject *parent = 0);
+ ~QtTimePropertyManager();
+
+ QTime value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QTime &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QTime &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtTimePropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtTimePropertyManager)
+ Q_DISABLE_COPY(QtTimePropertyManager)
+};
+
+class QtDateTimePropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtDateTimePropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtDateTimePropertyManager(QObject *parent = 0);
+ ~QtDateTimePropertyManager();
+
+ QDateTime value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QDateTime &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QDateTime &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtDateTimePropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtDateTimePropertyManager)
+ Q_DISABLE_COPY(QtDateTimePropertyManager)
+};
+
+class QtKeySequencePropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtKeySequencePropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtKeySequencePropertyManager(QObject *parent = 0);
+ ~QtKeySequencePropertyManager();
+
+ QKeySequence value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QKeySequence &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QKeySequence &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtKeySequencePropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtKeySequencePropertyManager)
+ Q_DISABLE_COPY(QtKeySequencePropertyManager)
+};
+
+class QtCharPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtCharPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtCharPropertyManager(QObject *parent = 0);
+ ~QtCharPropertyManager();
+
+ QChar value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QChar &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QChar &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtCharPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtCharPropertyManager)
+ Q_DISABLE_COPY(QtCharPropertyManager)
+};
+
+class QtEnumPropertyManager;
+class QtLocalePropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtLocalePropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtLocalePropertyManager(QObject *parent = 0);
+ ~QtLocalePropertyManager();
+
+ QtEnumPropertyManager *subEnumPropertyManager() const;
+
+ QLocale value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QLocale &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QLocale &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtLocalePropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtLocalePropertyManager)
+ Q_DISABLE_COPY(QtLocalePropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtPointPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtPointPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtPointPropertyManager(QObject *parent = 0);
+ ~QtPointPropertyManager();
+
+ QtIntPropertyManager *subIntPropertyManager() const;
+
+ QPoint value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QPoint &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QPoint &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtPointPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtPointPropertyManager)
+ Q_DISABLE_COPY(QtPointPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtPointFPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtPointFPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtPointFPropertyManager(QObject *parent = 0);
+ ~QtPointFPropertyManager();
+
+ QtDoublePropertyManager *subDoublePropertyManager() const;
+
+ QPointF value(const QtProperty *property) const;
+ int decimals(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QPointF &val);
+ void setDecimals(QtProperty *property, int prec);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QPointF &val);
+ void decimalsChanged(QtProperty *property, int prec);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtPointFPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtPointFPropertyManager)
+ Q_DISABLE_COPY(QtPointFPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtSizePropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtSizePropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtSizePropertyManager(QObject *parent = 0);
+ ~QtSizePropertyManager();
+
+ QtIntPropertyManager *subIntPropertyManager() const;
+
+ QSize value(const QtProperty *property) const;
+ QSize minimum(const QtProperty *property) const;
+ QSize maximum(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QSize &val);
+ void setMinimum(QtProperty *property, const QSize &minVal);
+ void setMaximum(QtProperty *property, const QSize &maxVal);
+ void setRange(QtProperty *property, const QSize &minVal, const QSize &maxVal);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QSize &val);
+ void rangeChanged(QtProperty *property, const QSize &minVal, const QSize &maxVal);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtSizePropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtSizePropertyManager)
+ Q_DISABLE_COPY(QtSizePropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtSizeFPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtSizeFPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtSizeFPropertyManager(QObject *parent = 0);
+ ~QtSizeFPropertyManager();
+
+ QtDoublePropertyManager *subDoublePropertyManager() const;
+
+ QSizeF value(const QtProperty *property) const;
+ QSizeF minimum(const QtProperty *property) const;
+ QSizeF maximum(const QtProperty *property) const;
+ int decimals(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QSizeF &val);
+ void setMinimum(QtProperty *property, const QSizeF &minVal);
+ void setMaximum(QtProperty *property, const QSizeF &maxVal);
+ void setRange(QtProperty *property, const QSizeF &minVal, const QSizeF &maxVal);
+ void setDecimals(QtProperty *property, int prec);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QSizeF &val);
+ void rangeChanged(QtProperty *property, const QSizeF &minVal, const QSizeF &maxVal);
+ void decimalsChanged(QtProperty *property, int prec);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtSizeFPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtSizeFPropertyManager)
+ Q_DISABLE_COPY(QtSizeFPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtRectPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtRectPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtRectPropertyManager(QObject *parent = 0);
+ ~QtRectPropertyManager();
+
+ QtIntPropertyManager *subIntPropertyManager() const;
+
+ QRect value(const QtProperty *property) const;
+ QRect constraint(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QRect &val);
+ void setConstraint(QtProperty *property, const QRect &constraint);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QRect &val);
+ void constraintChanged(QtProperty *property, const QRect &constraint);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtRectPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtRectPropertyManager)
+ Q_DISABLE_COPY(QtRectPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtRectFPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtRectFPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtRectFPropertyManager(QObject *parent = 0);
+ ~QtRectFPropertyManager();
+
+ QtDoublePropertyManager *subDoublePropertyManager() const;
+
+ QRectF value(const QtProperty *property) const;
+ QRectF constraint(const QtProperty *property) const;
+ int decimals(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QRectF &val);
+ void setConstraint(QtProperty *property, const QRectF &constraint);
+ void setDecimals(QtProperty *property, int prec);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QRectF &val);
+ void constraintChanged(QtProperty *property, const QRectF &constraint);
+ void decimalsChanged(QtProperty *property, int prec);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtRectFPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtRectFPropertyManager)
+ Q_DISABLE_COPY(QtRectFPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtEnumPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtEnumPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtEnumPropertyManager(QObject *parent = 0);
+ ~QtEnumPropertyManager();
+
+ int value(const QtProperty *property) const;
+ QStringList enumNames(const QtProperty *property) const;
+ QMap<int, QIcon> enumIcons(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, int val);
+ void setEnumNames(QtProperty *property, const QStringList &names);
+ void setEnumIcons(QtProperty *property, const QMap<int, QIcon> &icons);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, int val);
+ void enumNamesChanged(QtProperty *property, const QStringList &names);
+ void enumIconsChanged(QtProperty *property, const QMap<int, QIcon> &icons);
+protected:
+ QString valueText(const QtProperty *property) const;
+ QIcon valueIcon(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtEnumPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtEnumPropertyManager)
+ Q_DISABLE_COPY(QtEnumPropertyManager)
+};
+
+class QtFlagPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtFlagPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtFlagPropertyManager(QObject *parent = 0);
+ ~QtFlagPropertyManager();
+
+ QtBoolPropertyManager *subBoolPropertyManager() const;
+
+ int value(const QtProperty *property) const;
+ QStringList flagNames(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, int val);
+ void setFlagNames(QtProperty *property, const QStringList &names);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, int val);
+ void flagNamesChanged(QtProperty *property, const QStringList &names);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtFlagPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtFlagPropertyManager)
+ Q_DISABLE_COPY(QtFlagPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotBoolChanged(QtProperty *, bool))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtSizePolicyPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtSizePolicyPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtSizePolicyPropertyManager(QObject *parent = 0);
+ ~QtSizePolicyPropertyManager();
+
+ QtIntPropertyManager *subIntPropertyManager() const;
+ QtEnumPropertyManager *subEnumPropertyManager() const;
+
+ QSizePolicy value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QSizePolicy &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QSizePolicy &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtSizePolicyPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtSizePolicyPropertyManager)
+ Q_DISABLE_COPY(QtSizePolicyPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtFontPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtFontPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtFontPropertyManager(QObject *parent = 0);
+ ~QtFontPropertyManager();
+
+ QtIntPropertyManager *subIntPropertyManager() const;
+ QtEnumPropertyManager *subEnumPropertyManager() const;
+ QtBoolPropertyManager *subBoolPropertyManager() const;
+
+ QFont value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QFont &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QFont &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ QIcon valueIcon(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtFontPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtFontPropertyManager)
+ Q_DISABLE_COPY(QtFontPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotBoolChanged(QtProperty *, bool))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+ Q_PRIVATE_SLOT(d_func(), void slotFontDatabaseChanged())
+ Q_PRIVATE_SLOT(d_func(), void slotFontDatabaseDelayedChange())
+};
+
+class QtColorPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtColorPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtColorPropertyManager(QObject *parent = 0);
+ ~QtColorPropertyManager();
+
+ QtIntPropertyManager *subIntPropertyManager() const;
+
+ QColor value(const QtProperty *property) const;
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QColor &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QColor &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ QIcon valueIcon(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtColorPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtColorPropertyManager)
+ Q_DISABLE_COPY(QtColorPropertyManager)
+ Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
+};
+
+class QtCursorPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtCursorPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtCursorPropertyManager(QObject *parent = 0);
+ ~QtCursorPropertyManager();
+
+#ifndef QT_NO_CURSOR
+ QCursor value(const QtProperty *property) const;
+#endif
+
+public Q_SLOTS:
+ void setValue(QtProperty *property, const QCursor &val);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QCursor &val);
+protected:
+ QString valueText(const QtProperty *property) const;
+ QIcon valueIcon(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+private:
+ QtCursorPropertyManagerPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtCursorPropertyManager)
+ Q_DISABLE_COPY(QtCursorPropertyManager)
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#endif
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qttreepropertybrowser.cpp b/GUI/coregui/qttools/qtpropertybrowser/qttreepropertybrowser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..97818e1c85c09e585089b9bab6c30ac293807481
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qttreepropertybrowser.cpp
@@ -0,0 +1,1079 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qttreepropertybrowser.h"
+#include <QSet>
+#include <QIcon>
+#include <QTreeWidget>
+#include <QItemDelegate>
+#include <QHBoxLayout>
+#include <QHeaderView>
+#include <QPainter>
+#include <QApplication>
+#include <QFocusEvent>
+#include <QStyle>
+#include <QPalette>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QtPropertyEditorView;
+
+class QtTreePropertyBrowserPrivate
+{
+ QtTreePropertyBrowser *q_ptr;
+ Q_DECLARE_PUBLIC(QtTreePropertyBrowser)
+
+public:
+ QtTreePropertyBrowserPrivate();
+ void init(QWidget *parent);
+
+ void propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex);
+ void propertyRemoved(QtBrowserItem *index);
+ void propertyChanged(QtBrowserItem *index);
+ QWidget *createEditor(QtProperty *property, QWidget *parent) const
+ { return q_ptr->createEditor(property, parent); }
+ QtProperty *indexToProperty(const QModelIndex &index) const;
+ QTreeWidgetItem *indexToItem(const QModelIndex &index) const;
+ QtBrowserItem *indexToBrowserItem(const QModelIndex &index) const;
+ bool lastColumn(int column) const;
+ void disableItem(QTreeWidgetItem *item) const;
+ void enableItem(QTreeWidgetItem *item) const;
+ bool hasValue(QTreeWidgetItem *item) const;
+
+ void slotCollapsed(const QModelIndex &index);
+ void slotExpanded(const QModelIndex &index);
+
+ QColor calculatedBackgroundColor(QtBrowserItem *item) const;
+
+ QtPropertyEditorView *treeWidget() const { return m_treeWidget; }
+ bool markPropertiesWithoutValue() const { return m_markPropertiesWithoutValue; }
+
+ QtBrowserItem *currentItem() const;
+ void setCurrentItem(QtBrowserItem *browserItem, bool block);
+ void editItem(QtBrowserItem *browserItem);
+
+ void slotCurrentBrowserItemChanged(QtBrowserItem *item);
+ void slotCurrentTreeItemChanged(QTreeWidgetItem *newItem, QTreeWidgetItem *);
+
+ QTreeWidgetItem *editedItem() const;
+
+private:
+ void updateItem(QTreeWidgetItem *item);
+
+ QMap<QtBrowserItem *, QTreeWidgetItem *> m_indexToItem;
+ QMap<QTreeWidgetItem *, QtBrowserItem *> m_itemToIndex;
+
+ QMap<QtBrowserItem *, QColor> m_indexToBackgroundColor;
+
+ QtPropertyEditorView *m_treeWidget;
+
+ bool m_headerVisible;
+ QtTreePropertyBrowser::ResizeMode m_resizeMode;
+ class QtPropertyEditorDelegate *m_delegate;
+ bool m_markPropertiesWithoutValue;
+ bool m_browserChangedBlocked;
+ QIcon m_expandIcon;
+};
+
+// ------------ QtPropertyEditorView
+class QtPropertyEditorView : public QTreeWidget
+{
+ Q_OBJECT
+public:
+ QtPropertyEditorView(QWidget *parent = 0);
+
+ void setEditorPrivate(QtTreePropertyBrowserPrivate *editorPrivate)
+ { m_editorPrivate = editorPrivate; }
+
+ QTreeWidgetItem *indexToItem(const QModelIndex &index) const
+ { return itemFromIndex(index); }
+
+protected:
+ void keyPressEvent(QKeyEvent *event);
+ void mousePressEvent(QMouseEvent *event);
+ void drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;
+
+private:
+ QtTreePropertyBrowserPrivate *m_editorPrivate;
+};
+
+QtPropertyEditorView::QtPropertyEditorView(QWidget *parent) :
+ QTreeWidget(parent),
+ m_editorPrivate(0)
+{
+ connect(header(), SIGNAL(sectionDoubleClicked(int)), this, SLOT(resizeColumnToContents(int)));
+}
+
+void QtPropertyEditorView::drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+ QStyleOptionViewItemV3 opt = option;
+ bool hasValue = true;
+ if (m_editorPrivate) {
+ QtProperty *property = m_editorPrivate->indexToProperty(index);
+ if (property)
+ hasValue = property->hasValue();
+ }
+ if (!hasValue && m_editorPrivate->markPropertiesWithoutValue()) {
+ const QColor c = option.palette.color(QPalette::Dark);
+ painter->fillRect(option.rect, c);
+ opt.palette.setColor(QPalette::AlternateBase, c);
+ } else {
+ const QColor c = m_editorPrivate->calculatedBackgroundColor(m_editorPrivate->indexToBrowserItem(index));
+ if (c.isValid()) {
+ painter->fillRect(option.rect, c);
+ opt.palette.setColor(QPalette::AlternateBase, c.lighter(112));
+ }
+ }
+ QTreeWidget::drawRow(painter, opt, index);
+ QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &opt));
+ painter->save();
+ painter->setPen(QPen(color));
+ painter->drawLine(opt.rect.x(), opt.rect.bottom(), opt.rect.right(), opt.rect.bottom());
+ painter->restore();
+}
+
+void QtPropertyEditorView::keyPressEvent(QKeyEvent *event)
+{
+ switch (event->key()) {
+ case Qt::Key_Return:
+ case Qt::Key_Enter:
+ case Qt::Key_Space: // Trigger Edit
+ if (!m_editorPrivate->editedItem())
+ if (const QTreeWidgetItem *item = currentItem())
+ if (item->columnCount() >= 2 && ((item->flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled))) {
+ event->accept();
+ // If the current position is at column 0, move to 1.
+ QModelIndex index = currentIndex();
+ if (index.column() == 0) {
+ index = index.sibling(index.row(), 1);
+ setCurrentIndex(index);
+ }
+ edit(index);
+ return;
+ }
+ break;
+ default:
+ break;
+ }
+ QTreeWidget::keyPressEvent(event);
+}
+
+void QtPropertyEditorView::mousePressEvent(QMouseEvent *event)
+{
+ QTreeWidget::mousePressEvent(event);
+ QTreeWidgetItem *item = itemAt(event->pos());
+
+ if (item) {
+ if ((item != m_editorPrivate->editedItem()) && (event->button() == Qt::LeftButton)
+ && (header()->logicalIndexAt(event->pos().x()) == 1)
+ && ((item->flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled))) {
+ editItem(item, 1);
+ } else if (!m_editorPrivate->hasValue(item) && m_editorPrivate->markPropertiesWithoutValue() && !rootIsDecorated()) {
+ if (event->pos().x() + header()->offset() < 20)
+ item->setExpanded(!item->isExpanded());
+ }
+ }
+}
+
+// ------------ QtPropertyEditorDelegate
+class QtPropertyEditorDelegate : public QItemDelegate
+{
+ Q_OBJECT
+public:
+ QtPropertyEditorDelegate(QObject *parent = 0)
+ : QItemDelegate(parent), m_editorPrivate(0), m_editedItem(0), m_editedWidget(0), m_disablePainting(false)
+ {}
+
+ void setEditorPrivate(QtTreePropertyBrowserPrivate *editorPrivate)
+ { m_editorPrivate = editorPrivate; }
+
+ QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
+ const QModelIndex &index) const;
+
+ void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option,
+ const QModelIndex &index) const;
+
+ void paint(QPainter *painter, const QStyleOptionViewItem &option,
+ const QModelIndex &index) const;
+
+ QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const;
+
+ void setModelData(QWidget *, QAbstractItemModel *,
+ const QModelIndex &) const {}
+
+ void setEditorData(QWidget *, const QModelIndex &) const {}
+
+ bool eventFilter(QObject *object, QEvent *event);
+ void closeEditor(QtProperty *property);
+
+ QTreeWidgetItem *editedItem() const { return m_editedItem; }
+
+protected:
+
+ void drawDecoration(QPainter *painter, const QStyleOptionViewItem &option,
+ const QRect &rect, const QPixmap &pixmap) const;
+ void drawDisplay(QPainter *painter, const QStyleOptionViewItem &option,
+ const QRect &rect, const QString &text) const;
+
+private slots:
+ void slotEditorDestroyed(QObject *object);
+
+private:
+ int indentation(const QModelIndex &index) const;
+
+ typedef QMap<QWidget *, QtProperty *> EditorToPropertyMap;
+ mutable EditorToPropertyMap m_editorToProperty;
+
+ typedef QMap<QtProperty *, QWidget *> PropertyToEditorMap;
+ mutable PropertyToEditorMap m_propertyToEditor;
+ QtTreePropertyBrowserPrivate *m_editorPrivate;
+ mutable QTreeWidgetItem *m_editedItem;
+ mutable QWidget *m_editedWidget;
+ mutable bool m_disablePainting;
+};
+
+int QtPropertyEditorDelegate::indentation(const QModelIndex &index) const
+{
+ if (!m_editorPrivate)
+ return 0;
+
+ QTreeWidgetItem *item = m_editorPrivate->indexToItem(index);
+ int indent = 0;
+ while (item->parent()) {
+ item = item->parent();
+ ++indent;
+ }
+ if (m_editorPrivate->treeWidget()->rootIsDecorated())
+ ++indent;
+ return indent * m_editorPrivate->treeWidget()->indentation();
+}
+
+void QtPropertyEditorDelegate::slotEditorDestroyed(QObject *object)
+{
+ if (QWidget *w = qobject_cast<QWidget *>(object)) {
+ const EditorToPropertyMap::iterator it = m_editorToProperty.find(w);
+ if (it != m_editorToProperty.end()) {
+ m_propertyToEditor.remove(it.value());
+ m_editorToProperty.erase(it);
+ }
+ if (m_editedWidget == w) {
+ m_editedWidget = 0;
+ m_editedItem = 0;
+ }
+ }
+}
+
+void QtPropertyEditorDelegate::closeEditor(QtProperty *property)
+{
+ if (QWidget *w = m_propertyToEditor.value(property, 0))
+ w->deleteLater();
+}
+
+QWidget *QtPropertyEditorDelegate::createEditor(QWidget *parent,
+ const QStyleOptionViewItem &, const QModelIndex &index) const
+{
+ if (index.column() == 1 && m_editorPrivate) {
+ QtProperty *property = m_editorPrivate->indexToProperty(index);
+ QTreeWidgetItem *item = m_editorPrivate->indexToItem(index);
+ if (property && item && (item->flags() & Qt::ItemIsEnabled)) {
+ QWidget *editor = m_editorPrivate->createEditor(property, parent);
+ if (editor) {
+ editor->setAutoFillBackground(true);
+ editor->installEventFilter(const_cast<QtPropertyEditorDelegate *>(this));
+ connect(editor, SIGNAL(destroyed(QObject *)), this, SLOT(slotEditorDestroyed(QObject *)));
+ m_propertyToEditor[property] = editor;
+ m_editorToProperty[editor] = property;
+ m_editedItem = item;
+ m_editedWidget = editor;
+ }
+ return editor;
+ }
+ }
+ return 0;
+}
+
+void QtPropertyEditorDelegate::updateEditorGeometry(QWidget *editor,
+ const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+ Q_UNUSED(index)
+ editor->setGeometry(option.rect.adjusted(0, 0, 0, -1));
+}
+
+void QtPropertyEditorDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
+ const QModelIndex &index) const
+{
+ bool hasValue = true;
+ if (m_editorPrivate) {
+ QtProperty *property = m_editorPrivate->indexToProperty(index);
+ if (property)
+ hasValue = property->hasValue();
+ }
+ QStyleOptionViewItemV3 opt = option;
+ if ((m_editorPrivate && index.column() == 0) || !hasValue) {
+ QtProperty *property = m_editorPrivate->indexToProperty(index);
+ if (property && property->isModified()) {
+ opt.font.setBold(true);
+ opt.fontMetrics = QFontMetrics(opt.font);
+ }
+ }
+ QColor c;
+ if (!hasValue && m_editorPrivate->markPropertiesWithoutValue()) {
+ c = opt.palette.color(QPalette::Dark);
+ opt.palette.setColor(QPalette::Text, opt.palette.color(QPalette::BrightText));
+ } else {
+ c = m_editorPrivate->calculatedBackgroundColor(m_editorPrivate->indexToBrowserItem(index));
+ if (c.isValid() && (opt.features & QStyleOptionViewItemV2::Alternate))
+ c = c.lighter(112);
+ }
+ if (c.isValid())
+ painter->fillRect(option.rect, c);
+ opt.state &= ~QStyle::State_HasFocus;
+ if (index.column() == 1) {
+ QTreeWidgetItem *item = m_editorPrivate->indexToItem(index);
+ if (m_editedItem && m_editedItem == item)
+ m_disablePainting = true;
+ }
+ QItemDelegate::paint(painter, opt, index);
+ if (option.type)
+ m_disablePainting = false;
+
+ opt.palette.setCurrentColorGroup(QPalette::Active);
+ QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &opt));
+ painter->save();
+ painter->setPen(QPen(color));
+ if (!m_editorPrivate || (!m_editorPrivate->lastColumn(index.column()) && hasValue)) {
+ int right = (option.direction == Qt::LeftToRight) ? option.rect.right() : option.rect.left();
+ painter->drawLine(right, option.rect.y(), right, option.rect.bottom());
+ }
+ painter->restore();
+}
+
+void QtPropertyEditorDelegate::drawDecoration(QPainter *painter, const QStyleOptionViewItem &option,
+ const QRect &rect, const QPixmap &pixmap) const
+{
+ if (m_disablePainting)
+ return;
+
+ QItemDelegate::drawDecoration(painter, option, rect, pixmap);
+}
+
+void QtPropertyEditorDelegate::drawDisplay(QPainter *painter, const QStyleOptionViewItem &option,
+ const QRect &rect, const QString &text) const
+{
+ if (m_disablePainting)
+ return;
+
+ QItemDelegate::drawDisplay(painter, option, rect, text);
+}
+
+QSize QtPropertyEditorDelegate::sizeHint(const QStyleOptionViewItem &option,
+ const QModelIndex &index) const
+{
+ return QItemDelegate::sizeHint(option, index) + QSize(3, 4);
+}
+
+bool QtPropertyEditorDelegate::eventFilter(QObject *object, QEvent *event)
+{
+ if (event->type() == QEvent::FocusOut) {
+ QFocusEvent *fe = static_cast<QFocusEvent *>(event);
+ if (fe->reason() == Qt::ActiveWindowFocusReason)
+ return false;
+ }
+ return QItemDelegate::eventFilter(object, event);
+}
+
+// -------- QtTreePropertyBrowserPrivate implementation
+QtTreePropertyBrowserPrivate::QtTreePropertyBrowserPrivate() :
+ m_treeWidget(0),
+ m_headerVisible(true),
+ m_resizeMode(QtTreePropertyBrowser::Stretch),
+ m_delegate(0),
+ m_markPropertiesWithoutValue(false),
+ m_browserChangedBlocked(false)
+{
+}
+
+// Draw an icon indicating opened/closing branches
+static QIcon drawIndicatorIcon(const QPalette &palette, QStyle *style)
+{
+ QPixmap pix(14, 14);
+ pix.fill(Qt::transparent);
+ QStyleOption branchOption;
+ QRect r(QPoint(0, 0), pix.size());
+ branchOption.rect = QRect(2, 2, 9, 9); // ### hardcoded in qcommonstyle.cpp
+ branchOption.palette = palette;
+ branchOption.state = QStyle::State_Children;
+
+ QPainter p;
+ // Draw closed state
+ p.begin(&pix);
+ style->drawPrimitive(QStyle::PE_IndicatorBranch, &branchOption, &p);
+ p.end();
+ QIcon rc = pix;
+ rc.addPixmap(pix, QIcon::Selected, QIcon::Off);
+ // Draw opened state
+ branchOption.state |= QStyle::State_Open;
+ pix.fill(Qt::transparent);
+ p.begin(&pix);
+ style->drawPrimitive(QStyle::PE_IndicatorBranch, &branchOption, &p);
+ p.end();
+
+ rc.addPixmap(pix, QIcon::Normal, QIcon::On);
+ rc.addPixmap(pix, QIcon::Selected, QIcon::On);
+ return rc;
+}
+
+void QtTreePropertyBrowserPrivate::init(QWidget *parent)
+{
+ QHBoxLayout *layout = new QHBoxLayout(parent);
+ layout->setMargin(0);
+ m_treeWidget = new QtPropertyEditorView(parent);
+ m_treeWidget->setEditorPrivate(this);
+ m_treeWidget->setIconSize(QSize(18, 18));
+ layout->addWidget(m_treeWidget);
+ parent->setFocusProxy(m_treeWidget);
+
+ m_treeWidget->setColumnCount(2);
+ QStringList labels;
+ labels.append(QCoreApplication::translate("QtTreePropertyBrowser", "Property"));
+ labels.append(QCoreApplication::translate("QtTreePropertyBrowser", "Value"));
+ m_treeWidget->setHeaderLabels(labels);
+ m_treeWidget->setAlternatingRowColors(true);
+ m_treeWidget->setEditTriggers(QAbstractItemView::EditKeyPressed);
+ m_delegate = new QtPropertyEditorDelegate(parent);
+ m_delegate->setEditorPrivate(this);
+ m_treeWidget->setItemDelegate(m_delegate);
+ m_treeWidget->header()->setMovable(false);
+ m_treeWidget->header()->setResizeMode(QHeaderView::Stretch);
+
+ m_expandIcon = drawIndicatorIcon(q_ptr->palette(), q_ptr->style());
+
+ QObject::connect(m_treeWidget, SIGNAL(collapsed(const QModelIndex &)), q_ptr, SLOT(slotCollapsed(const QModelIndex &)));
+ QObject::connect(m_treeWidget, SIGNAL(expanded(const QModelIndex &)), q_ptr, SLOT(slotExpanded(const QModelIndex &)));
+ QObject::connect(m_treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), q_ptr, SLOT(slotCurrentTreeItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));
+}
+
+QtBrowserItem *QtTreePropertyBrowserPrivate::currentItem() const
+{
+ if (QTreeWidgetItem *treeItem = m_treeWidget->currentItem())
+ return m_itemToIndex.value(treeItem);
+ return 0;
+}
+
+void QtTreePropertyBrowserPrivate::setCurrentItem(QtBrowserItem *browserItem, bool block)
+{
+ const bool blocked = block ? m_treeWidget->blockSignals(true) : false;
+ if (browserItem == 0)
+ m_treeWidget->setCurrentItem(0);
+ else
+ m_treeWidget->setCurrentItem(m_indexToItem.value(browserItem));
+ if (block)
+ m_treeWidget->blockSignals(blocked);
+}
+
+QtProperty *QtTreePropertyBrowserPrivate::indexToProperty(const QModelIndex &index) const
+{
+ QTreeWidgetItem *item = m_treeWidget->indexToItem(index);
+ QtBrowserItem *idx = m_itemToIndex.value(item);
+ if (idx)
+ return idx->property();
+ return 0;
+}
+
+QtBrowserItem *QtTreePropertyBrowserPrivate::indexToBrowserItem(const QModelIndex &index) const
+{
+ QTreeWidgetItem *item = m_treeWidget->indexToItem(index);
+ return m_itemToIndex.value(item);
+}
+
+QTreeWidgetItem *QtTreePropertyBrowserPrivate::indexToItem(const QModelIndex &index) const
+{
+ return m_treeWidget->indexToItem(index);
+}
+
+bool QtTreePropertyBrowserPrivate::lastColumn(int column) const
+{
+ return m_treeWidget->header()->visualIndex(column) == m_treeWidget->columnCount() - 1;
+}
+
+void QtTreePropertyBrowserPrivate::disableItem(QTreeWidgetItem *item) const
+{
+ Qt::ItemFlags flags = item->flags();
+ if (flags & Qt::ItemIsEnabled) {
+ flags &= ~Qt::ItemIsEnabled;
+ item->setFlags(flags);
+ m_delegate->closeEditor(m_itemToIndex[item]->property());
+ const int childCount = item->childCount();
+ for (int i = 0; i < childCount; i++) {
+ QTreeWidgetItem *child = item->child(i);
+ disableItem(child);
+ }
+ }
+}
+
+void QtTreePropertyBrowserPrivate::enableItem(QTreeWidgetItem *item) const
+{
+ Qt::ItemFlags flags = item->flags();
+ flags |= Qt::ItemIsEnabled;
+ item->setFlags(flags);
+ const int childCount = item->childCount();
+ for (int i = 0; i < childCount; i++) {
+ QTreeWidgetItem *child = item->child(i);
+ QtProperty *property = m_itemToIndex[child]->property();
+ if (property->isEnabled()) {
+ enableItem(child);
+ }
+ }
+}
+
+bool QtTreePropertyBrowserPrivate::hasValue(QTreeWidgetItem *item) const
+{
+ QtBrowserItem *browserItem = m_itemToIndex.value(item);
+ if (browserItem)
+ return browserItem->property()->hasValue();
+ return false;
+}
+
+void QtTreePropertyBrowserPrivate::propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex)
+{
+ QTreeWidgetItem *afterItem = m_indexToItem.value(afterIndex);
+ QTreeWidgetItem *parentItem = m_indexToItem.value(index->parent());
+
+ QTreeWidgetItem *newItem = 0;
+ if (parentItem) {
+ newItem = new QTreeWidgetItem(parentItem, afterItem);
+ } else {
+ newItem = new QTreeWidgetItem(m_treeWidget, afterItem);
+ }
+ m_itemToIndex[newItem] = index;
+ m_indexToItem[index] = newItem;
+
+ newItem->setFlags(newItem->flags() | Qt::ItemIsEditable);
+ m_treeWidget->setItemExpanded(newItem, true);
+
+ updateItem(newItem);
+}
+
+void QtTreePropertyBrowserPrivate::propertyRemoved(QtBrowserItem *index)
+{
+ QTreeWidgetItem *item = m_indexToItem.value(index);
+
+ if (m_treeWidget->currentItem() == item) {
+ m_treeWidget->setCurrentItem(0);
+ }
+
+ delete item;
+
+ m_indexToItem.remove(index);
+ m_itemToIndex.remove(item);
+ m_indexToBackgroundColor.remove(index);
+}
+
+void QtTreePropertyBrowserPrivate::propertyChanged(QtBrowserItem *index)
+{
+ QTreeWidgetItem *item = m_indexToItem.value(index);
+
+ updateItem(item);
+}
+
+void QtTreePropertyBrowserPrivate::updateItem(QTreeWidgetItem *item)
+{
+ QtProperty *property = m_itemToIndex[item]->property();
+ QIcon expandIcon;
+ if (property->hasValue()) {
+ QString toolTip = property->toolTip();
+ if (toolTip.isEmpty())
+ toolTip = property->displayText();
+ item->setToolTip(1, toolTip);
+ item->setIcon(1, property->valueIcon());
+ property->displayText().isEmpty() ? item->setText(1, property->valueText()) : item->setText(1, property->displayText());
+ } else if (markPropertiesWithoutValue() && !m_treeWidget->rootIsDecorated()) {
+ expandIcon = m_expandIcon;
+ }
+ item->setIcon(0, expandIcon);
+ item->setFirstColumnSpanned(!property->hasValue());
+ item->setToolTip(0, property->propertyName());
+ item->setStatusTip(0, property->statusTip());
+ item->setWhatsThis(0, property->whatsThis());
+ item->setText(0, property->propertyName());
+ bool wasEnabled = item->flags() & Qt::ItemIsEnabled;
+ bool isEnabled = wasEnabled;
+ if (property->isEnabled()) {
+ QTreeWidgetItem *parent = item->parent();
+ if (!parent || (parent->flags() & Qt::ItemIsEnabled))
+ isEnabled = true;
+ else
+ isEnabled = false;
+ } else {
+ isEnabled = false;
+ }
+ if (wasEnabled != isEnabled) {
+ if (isEnabled)
+ enableItem(item);
+ else
+ disableItem(item);
+ }
+ m_treeWidget->viewport()->update();
+}
+
+QColor QtTreePropertyBrowserPrivate::calculatedBackgroundColor(QtBrowserItem *item) const
+{
+ QtBrowserItem *i = item;
+ const QMap<QtBrowserItem *, QColor>::const_iterator itEnd = m_indexToBackgroundColor.constEnd();
+ while (i) {
+ QMap<QtBrowserItem *, QColor>::const_iterator it = m_indexToBackgroundColor.constFind(i);
+ if (it != itEnd)
+ return it.value();
+ i = i->parent();
+ }
+ return QColor();
+}
+
+void QtTreePropertyBrowserPrivate::slotCollapsed(const QModelIndex &index)
+{
+ QTreeWidgetItem *item = indexToItem(index);
+ QtBrowserItem *idx = m_itemToIndex.value(item);
+ if (item)
+ emit q_ptr->collapsed(idx);
+}
+
+void QtTreePropertyBrowserPrivate::slotExpanded(const QModelIndex &index)
+{
+ QTreeWidgetItem *item = indexToItem(index);
+ QtBrowserItem *idx = m_itemToIndex.value(item);
+ if (item)
+ emit q_ptr->expanded(idx);
+}
+
+void QtTreePropertyBrowserPrivate::slotCurrentBrowserItemChanged(QtBrowserItem *item)
+{
+ if (!m_browserChangedBlocked && item != currentItem())
+ setCurrentItem(item, true);
+}
+
+void QtTreePropertyBrowserPrivate::slotCurrentTreeItemChanged(QTreeWidgetItem *newItem, QTreeWidgetItem *)
+{
+ QtBrowserItem *browserItem = newItem ? m_itemToIndex.value(newItem) : 0;
+ m_browserChangedBlocked = true;
+ q_ptr->setCurrentItem(browserItem);
+ m_browserChangedBlocked = false;
+}
+
+QTreeWidgetItem *QtTreePropertyBrowserPrivate::editedItem() const
+{
+ return m_delegate->editedItem();
+}
+
+void QtTreePropertyBrowserPrivate::editItem(QtBrowserItem *browserItem)
+{
+ if (QTreeWidgetItem *treeItem = m_indexToItem.value(browserItem, 0)) {
+ m_treeWidget->setCurrentItem (treeItem, 1);
+ m_treeWidget->editItem(treeItem, 1);
+ }
+}
+
+/*!
+ \class QtTreePropertyBrowser
+
+ \brief The QtTreePropertyBrowser class provides QTreeWidget based
+ property browser.
+
+ A property browser is a widget that enables the user to edit a
+ given set of properties. Each property is represented by a label
+ specifying the property's name, and an editing widget (e.g. a line
+ edit or a combobox) holding its value. A property can have zero or
+ more subproperties.
+
+ QtTreePropertyBrowser provides a tree based view for all nested
+ properties, i.e. properties that have subproperties can be in an
+ expanded (subproperties are visible) or collapsed (subproperties
+ are hidden) state. For example:
+
+ \image qttreepropertybrowser.png
+
+ Use the QtAbstractPropertyBrowser API to add, insert and remove
+ properties from an instance of the QtTreePropertyBrowser class.
+ The properties themselves are created and managed by
+ implementations of the QtAbstractPropertyManager class.
+
+ \sa QtGroupBoxPropertyBrowser, QtAbstractPropertyBrowser
+*/
+
+/*!
+ \fn void QtTreePropertyBrowser::collapsed(QtBrowserItem *item)
+
+ This signal is emitted when the \a item is collapsed.
+
+ \sa expanded(), setExpanded()
+*/
+
+/*!
+ \fn void QtTreePropertyBrowser::expanded(QtBrowserItem *item)
+
+ This signal is emitted when the \a item is expanded.
+
+ \sa collapsed(), setExpanded()
+*/
+
+/*!
+ Creates a property browser with the given \a parent.
+*/
+QtTreePropertyBrowser::QtTreePropertyBrowser(QWidget *parent)
+ : QtAbstractPropertyBrowser(parent)
+{
+ d_ptr = new QtTreePropertyBrowserPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->init(this);
+ connect(this, SIGNAL(currentItemChanged(QtBrowserItem*)), this, SLOT(slotCurrentBrowserItemChanged(QtBrowserItem*)));
+}
+
+/*!
+ Destroys this property browser.
+
+ Note that the properties that were inserted into this browser are
+ \e not destroyed since they may still be used in other
+ browsers. The properties are owned by the manager that created
+ them.
+
+ \sa QtProperty, QtAbstractPropertyManager
+*/
+QtTreePropertyBrowser::~QtTreePropertyBrowser()
+{
+ delete d_ptr;
+}
+
+/*!
+ \property QtTreePropertyBrowser::indentation
+ \brief indentation of the items in the tree view.
+*/
+int QtTreePropertyBrowser::indentation() const
+{
+ return d_ptr->m_treeWidget->indentation();
+}
+
+void QtTreePropertyBrowser::setIndentation(int i)
+{
+ d_ptr->m_treeWidget->setIndentation(i);
+}
+
+/*!
+ \property QtTreePropertyBrowser::rootIsDecorated
+ \brief whether to show controls for expanding and collapsing root items.
+*/
+bool QtTreePropertyBrowser::rootIsDecorated() const
+{
+ return d_ptr->m_treeWidget->rootIsDecorated();
+}
+
+void QtTreePropertyBrowser::setRootIsDecorated(bool show)
+{
+ d_ptr->m_treeWidget->setRootIsDecorated(show);
+ QMapIterator<QTreeWidgetItem *, QtBrowserItem *> it(d_ptr->m_itemToIndex);
+ while (it.hasNext()) {
+ QtProperty *property = it.next().value()->property();
+ if (!property->hasValue())
+ d_ptr->updateItem(it.key());
+ }
+}
+
+/*!
+ \property QtTreePropertyBrowser::alternatingRowColors
+ \brief whether to draw the background using alternating colors.
+ By default this property is set to true.
+*/
+bool QtTreePropertyBrowser::alternatingRowColors() const
+{
+ return d_ptr->m_treeWidget->alternatingRowColors();
+}
+
+void QtTreePropertyBrowser::setAlternatingRowColors(bool enable)
+{
+ d_ptr->m_treeWidget->setAlternatingRowColors(enable);
+ QMapIterator<QTreeWidgetItem *, QtBrowserItem *> it(d_ptr->m_itemToIndex);
+}
+
+/*!
+ \property QtTreePropertyBrowser::headerVisible
+ \brief whether to show the header.
+*/
+bool QtTreePropertyBrowser::isHeaderVisible() const
+{
+ return d_ptr->m_headerVisible;
+}
+
+void QtTreePropertyBrowser::setHeaderVisible(bool visible)
+{
+ if (d_ptr->m_headerVisible == visible)
+ return;
+
+ d_ptr->m_headerVisible = visible;
+ d_ptr->m_treeWidget->header()->setVisible(visible);
+}
+
+/*!
+ \enum QtTreePropertyBrowser::ResizeMode
+
+ The resize mode specifies the behavior of the header sections.
+
+ \value Interactive The user can resize the sections.
+ The sections can also be resized programmatically using setSplitterPosition().
+
+ \value Fixed The user cannot resize the section.
+ The section can only be resized programmatically using setSplitterPosition().
+
+ \value Stretch QHeaderView will automatically resize the section to fill the available space.
+ The size cannot be changed by the user or programmatically.
+
+ \value ResizeToContents QHeaderView will automatically resize the section to its optimal
+ size based on the contents of the entire column.
+ The size cannot be changed by the user or programmatically.
+
+ \sa setResizeMode()
+*/
+
+/*!
+ \property QtTreePropertyBrowser::resizeMode
+ \brief the resize mode of setions in the header.
+*/
+
+QtTreePropertyBrowser::ResizeMode QtTreePropertyBrowser::resizeMode() const
+{
+ return d_ptr->m_resizeMode;
+}
+
+void QtTreePropertyBrowser::setResizeMode(QtTreePropertyBrowser::ResizeMode mode)
+{
+ if (d_ptr->m_resizeMode == mode)
+ return;
+
+ d_ptr->m_resizeMode = mode;
+ QHeaderView::ResizeMode m = QHeaderView::Stretch;
+ switch (mode) {
+ case QtTreePropertyBrowser::Interactive: m = QHeaderView::Interactive; break;
+ case QtTreePropertyBrowser::Fixed: m = QHeaderView::Fixed; break;
+ case QtTreePropertyBrowser::ResizeToContents: m = QHeaderView::ResizeToContents; break;
+ case QtTreePropertyBrowser::Stretch:
+ default: m = QHeaderView::Stretch; break;
+ }
+ d_ptr->m_treeWidget->header()->setResizeMode(m);
+}
+
+/*!
+ \property QtTreePropertyBrowser::splitterPosition
+ \brief the position of the splitter between the colunms.
+*/
+
+int QtTreePropertyBrowser::splitterPosition() const
+{
+ return d_ptr->m_treeWidget->header()->sectionSize(0);
+}
+
+void QtTreePropertyBrowser::setSplitterPosition(int position)
+{
+ d_ptr->m_treeWidget->header()->resizeSection(0, position);
+}
+
+/*!
+ Sets the \a item to either collapse or expanded, depending on the value of \a expanded.
+
+ \sa isExpanded(), expanded(), collapsed()
+*/
+
+void QtTreePropertyBrowser::setExpanded(QtBrowserItem *item, bool expanded)
+{
+ QTreeWidgetItem *treeItem = d_ptr->m_indexToItem.value(item);
+ if (treeItem)
+ treeItem->setExpanded(expanded);
+}
+
+/*!
+ Returns true if the \a item is expanded; otherwise returns false.
+
+ \sa setExpanded()
+*/
+
+bool QtTreePropertyBrowser::isExpanded(QtBrowserItem *item) const
+{
+ QTreeWidgetItem *treeItem = d_ptr->m_indexToItem.value(item);
+ if (treeItem)
+ return treeItem->isExpanded();
+ return false;
+}
+
+/*!
+ Returns true if the \a item is visible; otherwise returns false.
+
+ \sa setItemVisible()
+ \since 4.5
+*/
+
+bool QtTreePropertyBrowser::isItemVisible(QtBrowserItem *item) const
+{
+ if (const QTreeWidgetItem *treeItem = d_ptr->m_indexToItem.value(item))
+ return !treeItem->isHidden();
+ return false;
+}
+
+/*!
+ Sets the \a item to be visible, depending on the value of \a visible.
+
+ \sa isItemVisible()
+ \since 4.5
+*/
+
+void QtTreePropertyBrowser::setItemVisible(QtBrowserItem *item, bool visible)
+{
+ if (QTreeWidgetItem *treeItem = d_ptr->m_indexToItem.value(item))
+ treeItem->setHidden(!visible);
+}
+
+/*!
+ Sets the \a item's background color to \a color. Note that while item's background
+ is rendered every second row is being drawn with alternate color (which is a bit lighter than items \a color)
+
+ \sa backgroundColor(), calculatedBackgroundColor()
+*/
+
+void QtTreePropertyBrowser::setBackgroundColor(QtBrowserItem *item, const QColor &color)
+{
+ if (!d_ptr->m_indexToItem.contains(item))
+ return;
+ if (color.isValid())
+ d_ptr->m_indexToBackgroundColor[item] = color;
+ else
+ d_ptr->m_indexToBackgroundColor.remove(item);
+ d_ptr->m_treeWidget->viewport()->update();
+}
+
+/*!
+ Returns the \a item's color. If there is no color set for item it returns invalid color.
+
+ \sa calculatedBackgroundColor(), setBackgroundColor()
+*/
+
+QColor QtTreePropertyBrowser::backgroundColor(QtBrowserItem *item) const
+{
+ return d_ptr->m_indexToBackgroundColor.value(item);
+}
+
+/*!
+ Returns the \a item's color. If there is no color set for item it returns parent \a item's
+ color (if there is no color set for parent it returns grandparent's color and so on). In case
+ the color is not set for \a item and it's top level item it returns invalid color.
+
+ \sa backgroundColor(), setBackgroundColor()
+*/
+
+QColor QtTreePropertyBrowser::calculatedBackgroundColor(QtBrowserItem *item) const
+{
+ return d_ptr->calculatedBackgroundColor(item);
+}
+
+/*!
+ \property QtTreePropertyBrowser::propertiesWithoutValueMarked
+ \brief whether to enable or disable marking properties without value.
+
+ When marking is enabled the item's background is rendered in dark color and item's
+ foreground is rendered with light color.
+
+ \sa propertiesWithoutValueMarked()
+*/
+void QtTreePropertyBrowser::setPropertiesWithoutValueMarked(bool mark)
+{
+ if (d_ptr->m_markPropertiesWithoutValue == mark)
+ return;
+
+ d_ptr->m_markPropertiesWithoutValue = mark;
+ QMapIterator<QTreeWidgetItem *, QtBrowserItem *> it(d_ptr->m_itemToIndex);
+ while (it.hasNext()) {
+ QtProperty *property = it.next().value()->property();
+ if (!property->hasValue())
+ d_ptr->updateItem(it.key());
+ }
+ d_ptr->m_treeWidget->viewport()->update();
+}
+
+bool QtTreePropertyBrowser::propertiesWithoutValueMarked() const
+{
+ return d_ptr->m_markPropertiesWithoutValue;
+}
+
+/*!
+ \reimp
+*/
+void QtTreePropertyBrowser::itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem)
+{
+ d_ptr->propertyInserted(item, afterItem);
+}
+
+/*!
+ \reimp
+*/
+void QtTreePropertyBrowser::itemRemoved(QtBrowserItem *item)
+{
+ d_ptr->propertyRemoved(item);
+}
+
+/*!
+ \reimp
+*/
+void QtTreePropertyBrowser::itemChanged(QtBrowserItem *item)
+{
+ d_ptr->propertyChanged(item);
+}
+
+/*!
+ Sets the current item to \a item and opens the relevant editor for it.
+*/
+void QtTreePropertyBrowser::editItem(QtBrowserItem *item)
+{
+ d_ptr->editItem(item);
+}
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#include "moc_qttreepropertybrowser.cpp"
+#include "qttreepropertybrowser.moc"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qttreepropertybrowser.h b/GUI/coregui/qttools/qtpropertybrowser/qttreepropertybrowser.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a3057f7c311d1508f82cb746d5da544d897cfb5
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qttreepropertybrowser.h
@@ -0,0 +1,138 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QTTREEPROPERTYBROWSER_H
+#define QTTREEPROPERTYBROWSER_H
+
+#include "qtpropertybrowser.h"
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QTreeWidgetItem;
+class QtTreePropertyBrowserPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtTreePropertyBrowser : public QtAbstractPropertyBrowser
+{
+ Q_OBJECT
+ Q_ENUMS(ResizeMode)
+ Q_PROPERTY(int indentation READ indentation WRITE setIndentation)
+ Q_PROPERTY(bool rootIsDecorated READ rootIsDecorated WRITE setRootIsDecorated)
+ Q_PROPERTY(bool alternatingRowColors READ alternatingRowColors WRITE setAlternatingRowColors)
+ Q_PROPERTY(bool headerVisible READ isHeaderVisible WRITE setHeaderVisible)
+ Q_PROPERTY(ResizeMode resizeMode READ resizeMode WRITE setResizeMode)
+ Q_PROPERTY(int splitterPosition READ splitterPosition WRITE setSplitterPosition)
+ Q_PROPERTY(bool propertiesWithoutValueMarked READ propertiesWithoutValueMarked WRITE setPropertiesWithoutValueMarked)
+public:
+
+ enum ResizeMode
+ {
+ Interactive,
+ Stretch,
+ Fixed,
+ ResizeToContents
+ };
+
+ QtTreePropertyBrowser(QWidget *parent = 0);
+ ~QtTreePropertyBrowser();
+
+ int indentation() const;
+ void setIndentation(int i);
+
+ bool rootIsDecorated() const;
+ void setRootIsDecorated(bool show);
+
+ bool alternatingRowColors() const;
+ void setAlternatingRowColors(bool enable);
+
+ bool isHeaderVisible() const;
+ void setHeaderVisible(bool visible);
+
+ ResizeMode resizeMode() const;
+ void setResizeMode(ResizeMode mode);
+
+ int splitterPosition() const;
+ void setSplitterPosition(int position);
+
+ void setExpanded(QtBrowserItem *item, bool expanded);
+ bool isExpanded(QtBrowserItem *item) const;
+
+ bool isItemVisible(QtBrowserItem *item) const;
+ void setItemVisible(QtBrowserItem *item, bool visible);
+
+ void setBackgroundColor(QtBrowserItem *item, const QColor &color);
+ QColor backgroundColor(QtBrowserItem *item) const;
+ QColor calculatedBackgroundColor(QtBrowserItem *item) const;
+
+ void setPropertiesWithoutValueMarked(bool mark);
+ bool propertiesWithoutValueMarked() const;
+
+ void editItem(QtBrowserItem *item);
+
+Q_SIGNALS:
+
+ void collapsed(QtBrowserItem *item);
+ void expanded(QtBrowserItem *item);
+
+protected:
+ virtual void itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem);
+ virtual void itemRemoved(QtBrowserItem *item);
+ virtual void itemChanged(QtBrowserItem *item);
+
+private:
+
+ QtTreePropertyBrowserPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtTreePropertyBrowser)
+ Q_DISABLE_COPY(QtTreePropertyBrowser)
+
+ Q_PRIVATE_SLOT(d_func(), void slotCollapsed(const QModelIndex &))
+ Q_PRIVATE_SLOT(d_func(), void slotExpanded(const QModelIndex &))
+ Q_PRIVATE_SLOT(d_func(), void slotCurrentBrowserItemChanged(QtBrowserItem *))
+ Q_PRIVATE_SLOT(d_func(), void slotCurrentTreeItemChanged(QTreeWidgetItem *, QTreeWidgetItem *))
+
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#endif
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtvariantproperty.cpp b/GUI/coregui/qttools/qtpropertybrowser/qtvariantproperty.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d2c02e998f3cb81d174d0b3496bdf22ff0d59b24
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtvariantproperty.cpp
@@ -0,0 +1,2338 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtvariantproperty.h"
+#include "qtpropertymanager.h"
+#include "qteditorfactory.h"
+#include <QVariant>
+#include <QIcon>
+#include <QDate>
+#include <QLocale>
+
+#if defined(Q_CC_MSVC)
+# pragma warning(disable: 4786) /* MS VS 6: truncating debug info after 255 characters */
+#endif
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QtEnumPropertyType
+{
+};
+
+
+class QtFlagPropertyType
+{
+};
+
+
+class QtGroupPropertyType
+{
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+Q_DECLARE_METATYPE(QtEnumPropertyType)
+Q_DECLARE_METATYPE(QtFlagPropertyType)
+Q_DECLARE_METATYPE(QtGroupPropertyType)
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+/*!
+ Returns the type id for an enum property.
+
+ Note that the property's value type can be retrieved using the
+ valueType() function (which is QVariant::Int for the enum property
+ type).
+
+ \sa propertyType(), valueType()
+*/
+int QtVariantPropertyManager::enumTypeId()
+{
+ return qMetaTypeId<QtEnumPropertyType>();
+}
+
+/*!
+ Returns the type id for a flag property.
+
+ Note that the property's value type can be retrieved using the
+ valueType() function (which is QVariant::Int for the flag property
+ type).
+
+ \sa propertyType(), valueType()
+*/
+int QtVariantPropertyManager::flagTypeId()
+{
+ return qMetaTypeId<QtFlagPropertyType>();
+}
+
+/*!
+ Returns the type id for a group property.
+
+ Note that the property's value type can be retrieved using the
+ valueType() function (which is QVariant::Invalid for the group
+ property type, since it doesn't provide any value).
+
+ \sa propertyType(), valueType()
+*/
+int QtVariantPropertyManager::groupTypeId()
+{
+ return qMetaTypeId<QtGroupPropertyType>();
+}
+
+/*!
+ Returns the type id for a icon map attribute.
+
+ Note that the property's attribute type can be retrieved using the
+ attributeType() function.
+
+ \sa attributeType(), QtEnumPropertyManager::enumIcons()
+*/
+int QtVariantPropertyManager::iconMapTypeId()
+{
+ return qMetaTypeId<QtIconMap>();
+}
+
+typedef QMap<const QtProperty *, QtProperty *> PropertyMap;
+Q_GLOBAL_STATIC(PropertyMap, propertyToWrappedProperty)
+
+static QtProperty *wrappedProperty(QtProperty *property)
+{
+ return propertyToWrappedProperty()->value(property, 0);
+}
+
+class QtVariantPropertyPrivate
+{
+ QtVariantProperty *q_ptr;
+public:
+ QtVariantPropertyPrivate(QtVariantPropertyManager *m) : manager(m) {}
+
+ QtVariantPropertyManager *manager;
+};
+
+/*!
+ \class QtVariantProperty
+
+ \brief The QtVariantProperty class is a convenience class handling
+ QVariant based properties.
+
+ QtVariantProperty provides additional API: A property's type,
+ value type, attribute values and current value can easily be
+ retrieved using the propertyType(), valueType(), attributeValue()
+ and value() functions respectively. In addition, the attribute
+ values and the current value can be set using the corresponding
+ setValue() and setAttribute() functions.
+
+ For example, instead of writing:
+
+ \code
+ QtVariantPropertyManager *variantPropertyManager;
+ QtProperty *property;
+
+ variantPropertyManager->setValue(property, 10);
+ \endcode
+
+ you can write:
+
+ \code
+ QtVariantPropertyManager *variantPropertyManager;
+ QtVariantProperty *property;
+
+ property->setValue(10);
+ \endcode
+
+ QtVariantProperty instances can only be created by the
+ QtVariantPropertyManager class.
+
+ \sa QtProperty, QtVariantPropertyManager, QtVariantEditorFactory
+*/
+
+/*!
+ Creates a variant property using the given \a manager.
+
+ Do not use this constructor to create variant property instances;
+ use the QtVariantPropertyManager::addProperty() function
+ instead. This constructor is used internally by the
+ QtVariantPropertyManager::createProperty() function.
+
+ \sa QtVariantPropertyManager
+*/
+QtVariantProperty::QtVariantProperty(QtVariantPropertyManager *manager)
+ : QtProperty(manager), d_ptr(new QtVariantPropertyPrivate(manager))
+{
+
+}
+
+/*!
+ Destroys this property.
+
+ \sa QtProperty::~QtProperty()
+*/
+QtVariantProperty::~QtVariantProperty()
+{
+ delete d_ptr;
+}
+
+/*!
+ Returns the property's current value.
+
+ \sa valueType(), setValue()
+*/
+QVariant QtVariantProperty::value() const
+{
+ return d_ptr->manager->value(this);
+}
+
+/*!
+ Returns this property's value for the specified \a attribute.
+
+ QtVariantPropertyManager provides a couple of related functions:
+ \l{QtVariantPropertyManager::attributes()}{attributes()} and
+ \l{QtVariantPropertyManager::attributeType()}{attributeType()}.
+
+ \sa setAttribute()
+*/
+QVariant QtVariantProperty::attributeValue(const QString &attribute) const
+{
+ return d_ptr->manager->attributeValue(this, attribute);
+}
+
+/*!
+ Returns the type of this property's value.
+
+ \sa propertyType()
+*/
+int QtVariantProperty::valueType() const
+{
+ return d_ptr->manager->valueType(this);
+}
+
+/*!
+ Returns this property's type.
+
+ QtVariantPropertyManager provides several related functions:
+ \l{QtVariantPropertyManager::enumTypeId()}{enumTypeId()},
+ \l{QtVariantPropertyManager::flagTypeId()}{flagTypeId()} and
+ \l{QtVariantPropertyManager::groupTypeId()}{groupTypeId()}.
+
+ \sa valueType()
+*/
+int QtVariantProperty::propertyType() const
+{
+ return d_ptr->manager->propertyType(this);
+}
+
+/*!
+ Sets the value of this property to \a value.
+
+ The specified \a value must be of the type returned by
+ valueType(), or of a type that can be converted to valueType()
+ using the QVariant::canConvert() function; otherwise this function
+ does nothing.
+
+ \sa value()
+*/
+void QtVariantProperty::setValue(const QVariant &value)
+{
+ d_ptr->manager->setValue(this, value);
+}
+
+/*!
+ Sets the \a attribute of property to \a value.
+
+ QtVariantPropertyManager provides the related
+ \l{QtVariantPropertyManager::setAttribute()}{setAttribute()}
+ function.
+
+ \sa attributeValue()
+*/
+void QtVariantProperty::setAttribute(const QString &attribute, const QVariant &value)
+{
+ d_ptr->manager->setAttribute(this, attribute, value);
+}
+
+class QtVariantPropertyManagerPrivate
+{
+ QtVariantPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtVariantPropertyManager)
+public:
+ QtVariantPropertyManagerPrivate();
+
+ bool m_creatingProperty;
+ bool m_creatingSubProperties;
+ bool m_destroyingSubProperties;
+ int m_propertyType;
+
+ void slotValueChanged(QtProperty *property, int val);
+ void slotRangeChanged(QtProperty *property, int min, int max);
+ void slotSingleStepChanged(QtProperty *property, int step);
+ void slotValueChanged(QtProperty *property, double val);
+ void slotRangeChanged(QtProperty *property, double min, double max);
+ void slotSingleStepChanged(QtProperty *property, double step);
+ void slotDecimalsChanged(QtProperty *property, int prec);
+ void slotValueChanged(QtProperty *property, bool val);
+ void slotValueChanged(QtProperty *property, const QString &val);
+ void slotRegExpChanged(QtProperty *property, const QRegExp ®Exp);
+ void slotEchoModeChanged(QtProperty *property, int);
+ void slotValueChanged(QtProperty *property, const QDate &val);
+ void slotRangeChanged(QtProperty *property, const QDate &min, const QDate &max);
+ void slotValueChanged(QtProperty *property, const QTime &val);
+ void slotValueChanged(QtProperty *property, const QDateTime &val);
+ void slotValueChanged(QtProperty *property, const QKeySequence &val);
+ void slotValueChanged(QtProperty *property, const QChar &val);
+ void slotValueChanged(QtProperty *property, const QLocale &val);
+ void slotValueChanged(QtProperty *property, const QPoint &val);
+ void slotValueChanged(QtProperty *property, const QPointF &val);
+ void slotValueChanged(QtProperty *property, const QSize &val);
+ void slotRangeChanged(QtProperty *property, const QSize &min, const QSize &max);
+ void slotValueChanged(QtProperty *property, const QSizeF &val);
+ void slotRangeChanged(QtProperty *property, const QSizeF &min, const QSizeF &max);
+ void slotValueChanged(QtProperty *property, const QRect &val);
+ void slotConstraintChanged(QtProperty *property, const QRect &val);
+ void slotValueChanged(QtProperty *property, const QRectF &val);
+ void slotConstraintChanged(QtProperty *property, const QRectF &val);
+ void slotValueChanged(QtProperty *property, const QColor &val);
+ void slotEnumChanged(QtProperty *property, int val);
+ void slotEnumNamesChanged(QtProperty *property, const QStringList &enumNames);
+ void slotEnumIconsChanged(QtProperty *property, const QMap<int, QIcon> &enumIcons);
+ void slotValueChanged(QtProperty *property, const QSizePolicy &val);
+ void slotValueChanged(QtProperty *property, const QFont &val);
+ void slotValueChanged(QtProperty *property, const QCursor &val);
+ void slotFlagChanged(QtProperty *property, int val);
+ void slotFlagNamesChanged(QtProperty *property, const QStringList &flagNames);
+ void slotReadOnlyChanged(QtProperty *property, bool readOnly);
+ void slotPropertyInserted(QtProperty *property, QtProperty *parent, QtProperty *after);
+ void slotPropertyRemoved(QtProperty *property, QtProperty *parent);
+
+ void valueChanged(QtProperty *property, const QVariant &val);
+
+ int internalPropertyToType(QtProperty *property) const;
+ QtVariantProperty *createSubProperty(QtVariantProperty *parent, QtVariantProperty *after,
+ QtProperty *internal);
+ void removeSubProperty(QtVariantProperty *property);
+
+ QMap<int, QtAbstractPropertyManager *> m_typeToPropertyManager;
+ QMap<int, QMap<QString, int> > m_typeToAttributeToAttributeType;
+
+ QMap<const QtProperty *, QPair<QtVariantProperty *, int> > m_propertyToType;
+
+ QMap<int, int> m_typeToValueType;
+
+
+ QMap<QtProperty *, QtVariantProperty *> m_internalToProperty;
+
+ const QString m_constraintAttribute;
+ const QString m_singleStepAttribute;
+ const QString m_decimalsAttribute;
+ const QString m_enumIconsAttribute;
+ const QString m_enumNamesAttribute;
+ const QString m_flagNamesAttribute;
+ const QString m_maximumAttribute;
+ const QString m_minimumAttribute;
+ const QString m_regExpAttribute;
+ const QString m_echoModeAttribute;
+ const QString m_readOnlyAttribute;
+};
+
+QtVariantPropertyManagerPrivate::QtVariantPropertyManagerPrivate() :
+ m_constraintAttribute(QLatin1String("constraint")),
+ m_singleStepAttribute(QLatin1String("singleStep")),
+ m_decimalsAttribute(QLatin1String("decimals")),
+ m_enumIconsAttribute(QLatin1String("enumIcons")),
+ m_enumNamesAttribute(QLatin1String("enumNames")),
+ m_flagNamesAttribute(QLatin1String("flagNames")),
+ m_maximumAttribute(QLatin1String("maximum")),
+ m_minimumAttribute(QLatin1String("minimum")),
+ m_regExpAttribute(QLatin1String("regExp")),
+ m_echoModeAttribute(QLatin1String("echoMode")),
+ m_readOnlyAttribute(QLatin1String("readOnly"))
+{
+}
+
+int QtVariantPropertyManagerPrivate::internalPropertyToType(QtProperty *property) const
+{
+ int type = 0;
+ QtAbstractPropertyManager *internPropertyManager = property->propertyManager();
+ if (qobject_cast<QtIntPropertyManager *>(internPropertyManager))
+ type = QVariant::Int;
+ else if (qobject_cast<QtEnumPropertyManager *>(internPropertyManager))
+ type = QtVariantPropertyManager::enumTypeId();
+ else if (qobject_cast<QtBoolPropertyManager *>(internPropertyManager))
+ type = QVariant::Bool;
+ else if (qobject_cast<QtDoublePropertyManager *>(internPropertyManager))
+ type = QVariant::Double;
+ return type;
+}
+
+QtVariantProperty *QtVariantPropertyManagerPrivate::createSubProperty(QtVariantProperty *parent,
+ QtVariantProperty *after, QtProperty *internal)
+{
+ int type = internalPropertyToType(internal);
+ if (!type)
+ return 0;
+
+ bool wasCreatingSubProperties = m_creatingSubProperties;
+ m_creatingSubProperties = true;
+
+ QtVariantProperty *varChild = q_ptr->addProperty(type, internal->propertyName());
+
+ m_creatingSubProperties = wasCreatingSubProperties;
+
+ varChild->setPropertyName(internal->propertyName());
+ varChild->setToolTip(internal->toolTip());
+ varChild->setStatusTip(internal->statusTip());
+ varChild->setWhatsThis(internal->whatsThis());
+
+ parent->insertSubProperty(varChild, after);
+
+ m_internalToProperty[internal] = varChild;
+ propertyToWrappedProperty()->insert(varChild, internal);
+ return varChild;
+}
+
+void QtVariantPropertyManagerPrivate::removeSubProperty(QtVariantProperty *property)
+{
+ QtProperty *internChild = wrappedProperty(property);
+ bool wasDestroyingSubProperties = m_destroyingSubProperties;
+ m_destroyingSubProperties = true;
+ delete property;
+ m_destroyingSubProperties = wasDestroyingSubProperties;
+ m_internalToProperty.remove(internChild);
+ propertyToWrappedProperty()->remove(property);
+}
+
+void QtVariantPropertyManagerPrivate::slotPropertyInserted(QtProperty *property,
+ QtProperty *parent, QtProperty *after)
+{
+ if (m_creatingProperty)
+ return;
+
+ QtVariantProperty *varParent = m_internalToProperty.value(parent, 0);
+ if (!varParent)
+ return;
+
+ QtVariantProperty *varAfter = 0;
+ if (after) {
+ varAfter = m_internalToProperty.value(after, 0);
+ if (!varAfter)
+ return;
+ }
+
+ createSubProperty(varParent, varAfter, property);
+}
+
+void QtVariantPropertyManagerPrivate::slotPropertyRemoved(QtProperty *property, QtProperty *parent)
+{
+ Q_UNUSED(parent)
+
+ QtVariantProperty *varProperty = m_internalToProperty.value(property, 0);
+ if (!varProperty)
+ return;
+
+ removeSubProperty(varProperty);
+}
+
+void QtVariantPropertyManagerPrivate::valueChanged(QtProperty *property, const QVariant &val)
+{
+ QtVariantProperty *varProp = m_internalToProperty.value(property, 0);
+ if (!varProp)
+ return;
+ emit q_ptr->valueChanged(varProp, val);
+ emit q_ptr->propertyChanged(varProp);
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, int val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, int min, int max)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {
+ emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
+ emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
+ }
+}
+
+void QtVariantPropertyManagerPrivate::slotSingleStepChanged(QtProperty *property, int step)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_singleStepAttribute, QVariant(step));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, double val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, double min, double max)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {
+ emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
+ emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
+ }
+}
+
+void QtVariantPropertyManagerPrivate::slotSingleStepChanged(QtProperty *property, double step)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_singleStepAttribute, QVariant(step));
+}
+
+void QtVariantPropertyManagerPrivate::slotDecimalsChanged(QtProperty *property, int prec)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_decimalsAttribute, QVariant(prec));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, bool val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QString &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotRegExpChanged(QtProperty *property, const QRegExp ®Exp)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_regExpAttribute, QVariant(regExp));
+}
+
+void QtVariantPropertyManagerPrivate::slotEchoModeChanged(QtProperty *property, int mode)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_echoModeAttribute, QVariant(mode));
+}
+
+void QtVariantPropertyManagerPrivate::slotReadOnlyChanged(QtProperty *property, bool readOnly)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_readOnlyAttribute, QVariant(readOnly));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QDate &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, const QDate &min, const QDate &max)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {
+ emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
+ emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
+ }
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QTime &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QDateTime &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QKeySequence &val)
+{
+ QVariant v;
+ qVariantSetValue(v, val);
+ valueChanged(property, v);
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QChar &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QLocale &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QPoint &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QPointF &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QSize &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, const QSize &min, const QSize &max)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {
+ emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
+ emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
+ }
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QSizeF &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, const QSizeF &min, const QSizeF &max)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {
+ emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
+ emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
+ }
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QRect &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotConstraintChanged(QtProperty *property, const QRect &constraint)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_constraintAttribute, QVariant(constraint));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QRectF &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotConstraintChanged(QtProperty *property, const QRectF &constraint)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_constraintAttribute, QVariant(constraint));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QColor &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotEnumNamesChanged(QtProperty *property, const QStringList &enumNames)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_enumNamesAttribute, QVariant(enumNames));
+}
+
+void QtVariantPropertyManagerPrivate::slotEnumIconsChanged(QtProperty *property, const QMap<int, QIcon> &enumIcons)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {
+ QVariant v;
+ qVariantSetValue(v, enumIcons);
+ emit q_ptr->attributeChanged(varProp, m_enumIconsAttribute, v);
+ }
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QSizePolicy &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QFont &val)
+{
+ valueChanged(property, QVariant(val));
+}
+
+void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QCursor &val)
+{
+#ifndef QT_NO_CURSOR
+ valueChanged(property, QVariant(val));
+#endif
+}
+
+void QtVariantPropertyManagerPrivate::slotFlagNamesChanged(QtProperty *property, const QStringList &flagNames)
+{
+ if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+ emit q_ptr->attributeChanged(varProp, m_flagNamesAttribute, QVariant(flagNames));
+}
+
+/*!
+ \class QtVariantPropertyManager
+
+ \brief The QtVariantPropertyManager class provides and manages QVariant based properties.
+
+ QtVariantPropertyManager provides the addProperty() function which
+ creates QtVariantProperty objects. The QtVariantProperty class is
+ a convenience class handling QVariant based properties inheriting
+ QtProperty. A QtProperty object created by a
+ QtVariantPropertyManager instance can be converted into a
+ QtVariantProperty object using the variantProperty() function.
+
+ The property's value can be retrieved using the value(), and set
+ using the setValue() slot. In addition the property's type, and
+ the type of its value, can be retrieved using the propertyType()
+ and valueType() functions respectively.
+
+ A property's type is a QVariant::Type enumerator value, and
+ usually a property's type is the same as its value type. But for
+ some properties the types differ, for example for enums, flags and
+ group types in which case QtVariantPropertyManager provides the
+ enumTypeId(), flagTypeId() and groupTypeId() functions,
+ respectively, to identify their property type (the value types are
+ QVariant::Int for the enum and flag types, and QVariant::Invalid
+ for the group type).
+
+ Use the isPropertyTypeSupported() function to check if a particular
+ property type is supported. The currently supported property types
+ are:
+
+ \table
+ \header
+ \o Property Type
+ \o Property Type Id
+ \row
+ \o int
+ \o QVariant::Int
+ \row
+ \o double
+ \o QVariant::Double
+ \row
+ \o bool
+ \o QVariant::Bool
+ \row
+ \o QString
+ \o QVariant::String
+ \row
+ \o QDate
+ \o QVariant::Date
+ \row
+ \o QTime
+ \o QVariant::Time
+ \row
+ \o QDateTime
+ \o QVariant::DateTime
+ \row
+ \o QKeySequence
+ \o QVariant::KeySequence
+ \row
+ \o QChar
+ \o QVariant::Char
+ \row
+ \o QLocale
+ \o QVariant::Locale
+ \row
+ \o QPoint
+ \o QVariant::Point
+ \row
+ \o QPointF
+ \o QVariant::PointF
+ \row
+ \o QSize
+ \o QVariant::Size
+ \row
+ \o QSizeF
+ \o QVariant::SizeF
+ \row
+ \o QRect
+ \o QVariant::Rect
+ \row
+ \o QRectF
+ \o QVariant::RectF
+ \row
+ \o QColor
+ \o QVariant::Color
+ \row
+ \o QSizePolicy
+ \o QVariant::SizePolicy
+ \row
+ \o QFont
+ \o QVariant::Font
+ \row
+ \o QCursor
+ \o QVariant::Cursor
+ \row
+ \o enum
+ \o enumTypeId()
+ \row
+ \o flag
+ \o flagTypeId()
+ \row
+ \o group
+ \o groupTypeId()
+ \endtable
+
+ Each property type can provide additional attributes,
+ e.g. QVariant::Int and QVariant::Double provides minimum and
+ maximum values. The currently supported attributes are:
+
+ \table
+ \header
+ \o Property Type
+ \o Attribute Name
+ \o Attribute Type
+ \row
+ \o \c int
+ \o minimum
+ \o QVariant::Int
+ \row
+ \o
+ \o maximum
+ \o QVariant::Int
+ \row
+ \o
+ \o singleStep
+ \o QVariant::Int
+ \row
+ \o \c double
+ \o minimum
+ \o QVariant::Double
+ \row
+ \o
+ \o maximum
+ \o QVariant::Double
+ \row
+ \o
+ \o singleStep
+ \o QVariant::Double
+ \row
+ \o
+ \o decimals
+ \o QVariant::Int
+ \row
+ \o QString
+ \o regExp
+ \o QVariant::RegExp
+ \row
+ \o
+ \o echoMode
+ \o QVariant::Int
+ \row
+ \o QDate
+ \o minimum
+ \o QVariant::Date
+ \row
+ \o
+ \o maximum
+ \o QVariant::Date
+ \row
+ \o QPointF
+ \o decimals
+ \o QVariant::Int
+ \row
+ \o QSize
+ \o minimum
+ \o QVariant::Size
+ \row
+ \o
+ \o maximum
+ \o QVariant::Size
+ \row
+ \o QSizeF
+ \o minimum
+ \o QVariant::SizeF
+ \row
+ \o
+ \o maximum
+ \o QVariant::SizeF
+ \row
+ \o
+ \o decimals
+ \o QVariant::Int
+ \row
+ \o QRect
+ \o constraint
+ \o QVariant::Rect
+ \row
+ \o QRectF
+ \o constraint
+ \o QVariant::RectF
+ \row
+ \o
+ \o decimals
+ \o QVariant::Int
+ \row
+ \o \c enum
+ \o enumNames
+ \o QVariant::StringList
+ \row
+ \o
+ \o enumIcons
+ \o iconMapTypeId()
+ \row
+ \o \c flag
+ \o flagNames
+ \o QVariant::StringList
+ \endtable
+
+ The attributes for a given property type can be retrieved using
+ the attributes() function. Each attribute has a value type which
+ can be retrieved using the attributeType() function, and a value
+ accessible through the attributeValue() function. In addition, the
+ value can be set using the setAttribute() slot.
+
+ QtVariantManager also provides the valueChanged() signal which is
+ emitted whenever a property created by this manager change, and
+ the attributeChanged() signal which is emitted whenever an
+ attribute of such a property changes.
+
+ \sa QtVariantProperty, QtVariantEditorFactory
+*/
+
+/*!
+ \fn void QtVariantPropertyManager::valueChanged(QtProperty *property, const QVariant &value)
+
+ This signal is emitted whenever a property created by this manager
+ changes its value, passing a pointer to the \a property and the
+ new \a value as parameters.
+
+ \sa setValue()
+*/
+
+/*!
+ \fn void QtVariantPropertyManager::attributeChanged(QtProperty *property,
+ const QString &attribute, const QVariant &value)
+
+ This signal is emitted whenever an attribute of a property created
+ by this manager changes its value, passing a pointer to the \a
+ property, the \a attribute and the new \a value as parameters.
+
+ \sa setAttribute()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtVariantPropertyManager::QtVariantPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent)
+{
+ d_ptr = new QtVariantPropertyManagerPrivate;
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_creatingProperty = false;
+ d_ptr->m_creatingSubProperties = false;
+ d_ptr->m_destroyingSubProperties = false;
+ d_ptr->m_propertyType = 0;
+
+ // IntPropertyManager
+ QtIntPropertyManager *intPropertyManager = new QtIntPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Int] = intPropertyManager;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Int][d_ptr->m_minimumAttribute] = QVariant::Int;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Int][d_ptr->m_maximumAttribute] = QVariant::Int;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Int][d_ptr->m_singleStepAttribute] = QVariant::Int;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Int][d_ptr->m_readOnlyAttribute] = QVariant::Bool;
+ d_ptr->m_typeToValueType[QVariant::Int] = QVariant::Int;
+ connect(intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(intPropertyManager, SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ connect(intPropertyManager, SIGNAL(singleStepChanged(QtProperty *, int)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, int)));
+ // DoublePropertyManager
+ QtDoublePropertyManager *doublePropertyManager = new QtDoublePropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Double] = doublePropertyManager;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_minimumAttribute] =
+ QVariant::Double;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_maximumAttribute] =
+ QVariant::Double;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_singleStepAttribute] =
+ QVariant::Double;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_decimalsAttribute] =
+ QVariant::Int;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_readOnlyAttribute] =
+ QVariant::Bool;
+ d_ptr->m_typeToValueType[QVariant::Double] = QVariant::Double;
+ connect(doublePropertyManager, SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotValueChanged(QtProperty *, double)));
+ connect(doublePropertyManager, SIGNAL(rangeChanged(QtProperty *, double, double)),
+ this, SLOT(slotRangeChanged(QtProperty *, double, double)));
+ connect(doublePropertyManager, SIGNAL(singleStepChanged(QtProperty *, double)),
+ this, SLOT(slotSingleStepChanged(QtProperty *, double)));
+ connect(doublePropertyManager, SIGNAL(decimalsChanged(QtProperty *, int)),
+ this, SLOT(slotDecimalsChanged(QtProperty *, int)));
+ // BoolPropertyManager
+ QtBoolPropertyManager *boolPropertyManager = new QtBoolPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Bool] = boolPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Bool] = QVariant::Bool;
+ connect(boolPropertyManager, SIGNAL(valueChanged(QtProperty *, bool)),
+ this, SLOT(slotValueChanged(QtProperty *, bool)));
+ // StringPropertyManager
+ QtStringPropertyManager *stringPropertyManager = new QtStringPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::String] = stringPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::String] = QVariant::String;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::String][d_ptr->m_regExpAttribute] =
+ QVariant::RegExp;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::String][d_ptr->m_echoModeAttribute] =
+ QVariant::Int;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::String][d_ptr->m_readOnlyAttribute] =
+ QVariant::Bool;
+
+ connect(stringPropertyManager, SIGNAL(valueChanged(QtProperty *, const QString &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QString &)));
+ connect(stringPropertyManager, SIGNAL(regExpChanged(QtProperty *, const QRegExp &)),
+ this, SLOT(slotRegExpChanged(QtProperty *, const QRegExp &)));
+ connect(stringPropertyManager, SIGNAL(echoModeChanged(QtProperty*,int)),
+ this, SLOT(slotEchoModeChanged(QtProperty*, int)));
+ connect(stringPropertyManager, SIGNAL(readOnlyChanged(QtProperty*, bool)),
+ this, SLOT(slotReadOnlyChanged(QtProperty*, bool)));
+
+ // DatePropertyManager
+ QtDatePropertyManager *datePropertyManager = new QtDatePropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Date] = datePropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Date] = QVariant::Date;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Date][d_ptr->m_minimumAttribute] =
+ QVariant::Date;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Date][d_ptr->m_maximumAttribute] =
+ QVariant::Date;
+ connect(datePropertyManager, SIGNAL(valueChanged(QtProperty *, const QDate &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QDate &)));
+ connect(datePropertyManager, SIGNAL(rangeChanged(QtProperty *, const QDate &, const QDate &)),
+ this, SLOT(slotRangeChanged(QtProperty *, const QDate &, const QDate &)));
+ // TimePropertyManager
+ QtTimePropertyManager *timePropertyManager = new QtTimePropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Time] = timePropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Time] = QVariant::Time;
+ connect(timePropertyManager, SIGNAL(valueChanged(QtProperty *, const QTime &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QTime &)));
+ // DateTimePropertyManager
+ QtDateTimePropertyManager *dateTimePropertyManager = new QtDateTimePropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::DateTime] = dateTimePropertyManager;
+ d_ptr->m_typeToValueType[QVariant::DateTime] = QVariant::DateTime;
+ connect(dateTimePropertyManager, SIGNAL(valueChanged(QtProperty *, const QDateTime &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QDateTime &)));
+ // KeySequencePropertyManager
+ QtKeySequencePropertyManager *keySequencePropertyManager = new QtKeySequencePropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::KeySequence] = keySequencePropertyManager;
+ d_ptr->m_typeToValueType[QVariant::KeySequence] = QVariant::KeySequence;
+ connect(keySequencePropertyManager, SIGNAL(valueChanged(QtProperty *, const QKeySequence &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QKeySequence &)));
+ // CharPropertyManager
+ QtCharPropertyManager *charPropertyManager = new QtCharPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Char] = charPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Char] = QVariant::Char;
+ connect(charPropertyManager, SIGNAL(valueChanged(QtProperty *, const QChar &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QChar &)));
+ // LocalePropertyManager
+ QtLocalePropertyManager *localePropertyManager = new QtLocalePropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Locale] = localePropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Locale] = QVariant::Locale;
+ connect(localePropertyManager, SIGNAL(valueChanged(QtProperty *, const QLocale &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QLocale &)));
+ connect(localePropertyManager->subEnumPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(localePropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(localePropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // PointPropertyManager
+ QtPointPropertyManager *pointPropertyManager = new QtPointPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Point] = pointPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Point] = QVariant::Point;
+ connect(pointPropertyManager, SIGNAL(valueChanged(QtProperty *, const QPoint &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QPoint &)));
+ connect(pointPropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(pointPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(pointPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // PointFPropertyManager
+ QtPointFPropertyManager *pointFPropertyManager = new QtPointFPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::PointF] = pointFPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::PointF] = QVariant::PointF;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::PointF][d_ptr->m_decimalsAttribute] =
+ QVariant::Int;
+ connect(pointFPropertyManager, SIGNAL(valueChanged(QtProperty *, const QPointF &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QPointF &)));
+ connect(pointFPropertyManager, SIGNAL(decimalsChanged(QtProperty *, int)),
+ this, SLOT(slotDecimalsChanged(QtProperty *, int)));
+ connect(pointFPropertyManager->subDoublePropertyManager(), SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotValueChanged(QtProperty *, double)));
+ connect(pointFPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(pointFPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // SizePropertyManager
+ QtSizePropertyManager *sizePropertyManager = new QtSizePropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Size] = sizePropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Size] = QVariant::Size;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Size][d_ptr->m_minimumAttribute] =
+ QVariant::Size;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Size][d_ptr->m_maximumAttribute] =
+ QVariant::Size;
+ connect(sizePropertyManager, SIGNAL(valueChanged(QtProperty *, const QSize &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QSize &)));
+ connect(sizePropertyManager, SIGNAL(rangeChanged(QtProperty *, const QSize &, const QSize &)),
+ this, SLOT(slotRangeChanged(QtProperty *, const QSize &, const QSize &)));
+ connect(sizePropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(sizePropertyManager->subIntPropertyManager(), SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ connect(sizePropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(sizePropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // SizeFPropertyManager
+ QtSizeFPropertyManager *sizeFPropertyManager = new QtSizeFPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::SizeF] = sizeFPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::SizeF] = QVariant::SizeF;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::SizeF][d_ptr->m_minimumAttribute] =
+ QVariant::SizeF;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::SizeF][d_ptr->m_maximumAttribute] =
+ QVariant::SizeF;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::SizeF][d_ptr->m_decimalsAttribute] =
+ QVariant::Int;
+ connect(sizeFPropertyManager, SIGNAL(valueChanged(QtProperty *, const QSizeF &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QSizeF &)));
+ connect(sizeFPropertyManager, SIGNAL(rangeChanged(QtProperty *, const QSizeF &, const QSizeF &)),
+ this, SLOT(slotRangeChanged(QtProperty *, const QSizeF &, const QSizeF &)));
+ connect(sizeFPropertyManager, SIGNAL(decimalsChanged(QtProperty *, int)),
+ this, SLOT(slotDecimalsChanged(QtProperty *, int)));
+ connect(sizeFPropertyManager->subDoublePropertyManager(), SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotValueChanged(QtProperty *, double)));
+ connect(sizeFPropertyManager->subDoublePropertyManager(), SIGNAL(rangeChanged(QtProperty *, double, double)),
+ this, SLOT(slotRangeChanged(QtProperty *, double, double)));
+ connect(sizeFPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(sizeFPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // RectPropertyManager
+ QtRectPropertyManager *rectPropertyManager = new QtRectPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Rect] = rectPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Rect] = QVariant::Rect;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::Rect][d_ptr->m_constraintAttribute] =
+ QVariant::Rect;
+ connect(rectPropertyManager, SIGNAL(valueChanged(QtProperty *, const QRect &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QRect &)));
+ connect(rectPropertyManager, SIGNAL(constraintChanged(QtProperty *, const QRect &)),
+ this, SLOT(slotConstraintChanged(QtProperty *, const QRect &)));
+ connect(rectPropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(rectPropertyManager->subIntPropertyManager(), SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ connect(rectPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(rectPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // RectFPropertyManager
+ QtRectFPropertyManager *rectFPropertyManager = new QtRectFPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::RectF] = rectFPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::RectF] = QVariant::RectF;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::RectF][d_ptr->m_constraintAttribute] =
+ QVariant::RectF;
+ d_ptr->m_typeToAttributeToAttributeType[QVariant::RectF][d_ptr->m_decimalsAttribute] =
+ QVariant::Int;
+ connect(rectFPropertyManager, SIGNAL(valueChanged(QtProperty *, const QRectF &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QRectF &)));
+ connect(rectFPropertyManager, SIGNAL(constraintChanged(QtProperty *, const QRectF &)),
+ this, SLOT(slotConstraintChanged(QtProperty *, const QRectF &)));
+ connect(rectFPropertyManager, SIGNAL(decimalsChanged(QtProperty *, int)),
+ this, SLOT(slotDecimalsChanged(QtProperty *, int)));
+ connect(rectFPropertyManager->subDoublePropertyManager(), SIGNAL(valueChanged(QtProperty *, double)),
+ this, SLOT(slotValueChanged(QtProperty *, double)));
+ connect(rectFPropertyManager->subDoublePropertyManager(), SIGNAL(rangeChanged(QtProperty *, double, double)),
+ this, SLOT(slotRangeChanged(QtProperty *, double, double)));
+ connect(rectFPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(rectFPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // ColorPropertyManager
+ QtColorPropertyManager *colorPropertyManager = new QtColorPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Color] = colorPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Color] = QVariant::Color;
+ connect(colorPropertyManager, SIGNAL(valueChanged(QtProperty *, const QColor &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QColor &)));
+ connect(colorPropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(colorPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(colorPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // EnumPropertyManager
+ int enumId = enumTypeId();
+ QtEnumPropertyManager *enumPropertyManager = new QtEnumPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[enumId] = enumPropertyManager;
+ d_ptr->m_typeToValueType[enumId] = QVariant::Int;
+ d_ptr->m_typeToAttributeToAttributeType[enumId][d_ptr->m_enumNamesAttribute] =
+ QVariant::StringList;
+ d_ptr->m_typeToAttributeToAttributeType[enumId][d_ptr->m_enumIconsAttribute] =
+ iconMapTypeId();
+ connect(enumPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(enumPropertyManager, SIGNAL(enumNamesChanged(QtProperty *, const QStringList &)),
+ this, SLOT(slotEnumNamesChanged(QtProperty *, const QStringList &)));
+ connect(enumPropertyManager, SIGNAL(enumIconsChanged(QtProperty *, const QMap<int, QIcon> &)),
+ this, SLOT(slotEnumIconsChanged(QtProperty *, const QMap<int, QIcon> &)));
+ // SizePolicyPropertyManager
+ QtSizePolicyPropertyManager *sizePolicyPropertyManager = new QtSizePolicyPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::SizePolicy] = sizePolicyPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::SizePolicy] = QVariant::SizePolicy;
+ connect(sizePolicyPropertyManager, SIGNAL(valueChanged(QtProperty *, const QSizePolicy &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QSizePolicy &)));
+ connect(sizePolicyPropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(sizePolicyPropertyManager->subIntPropertyManager(), SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ connect(sizePolicyPropertyManager->subEnumPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(sizePolicyPropertyManager->subEnumPropertyManager(),
+ SIGNAL(enumNamesChanged(QtProperty *, const QStringList &)),
+ this, SLOT(slotEnumNamesChanged(QtProperty *, const QStringList &)));
+ connect(sizePolicyPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(sizePolicyPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // FontPropertyManager
+ QtFontPropertyManager *fontPropertyManager = new QtFontPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Font] = fontPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Font] = QVariant::Font;
+ connect(fontPropertyManager, SIGNAL(valueChanged(QtProperty *, const QFont &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QFont &)));
+ connect(fontPropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(fontPropertyManager->subIntPropertyManager(), SIGNAL(rangeChanged(QtProperty *, int, int)),
+ this, SLOT(slotRangeChanged(QtProperty *, int, int)));
+ connect(fontPropertyManager->subEnumPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(fontPropertyManager->subEnumPropertyManager(),
+ SIGNAL(enumNamesChanged(QtProperty *, const QStringList &)),
+ this, SLOT(slotEnumNamesChanged(QtProperty *, const QStringList &)));
+ connect(fontPropertyManager->subBoolPropertyManager(), SIGNAL(valueChanged(QtProperty *, bool)),
+ this, SLOT(slotValueChanged(QtProperty *, bool)));
+ connect(fontPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(fontPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // CursorPropertyManager
+ QtCursorPropertyManager *cursorPropertyManager = new QtCursorPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[QVariant::Cursor] = cursorPropertyManager;
+ d_ptr->m_typeToValueType[QVariant::Cursor] = QVariant::Cursor;
+ connect(cursorPropertyManager, SIGNAL(valueChanged(QtProperty *, const QCursor &)),
+ this, SLOT(slotValueChanged(QtProperty *, const QCursor &)));
+ // FlagPropertyManager
+ int flagId = flagTypeId();
+ QtFlagPropertyManager *flagPropertyManager = new QtFlagPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[flagId] = flagPropertyManager;
+ d_ptr->m_typeToValueType[flagId] = QVariant::Int;
+ d_ptr->m_typeToAttributeToAttributeType[flagId][d_ptr->m_flagNamesAttribute] =
+ QVariant::StringList;
+ connect(flagPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),
+ this, SLOT(slotValueChanged(QtProperty *, int)));
+ connect(flagPropertyManager, SIGNAL(flagNamesChanged(QtProperty *, const QStringList &)),
+ this, SLOT(slotFlagNamesChanged(QtProperty *, const QStringList &)));
+ connect(flagPropertyManager->subBoolPropertyManager(), SIGNAL(valueChanged(QtProperty *, bool)),
+ this, SLOT(slotValueChanged(QtProperty *, bool)));
+ connect(flagPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));
+ connect(flagPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),
+ this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));
+ // FlagPropertyManager
+ int groupId = groupTypeId();
+ QtGroupPropertyManager *groupPropertyManager = new QtGroupPropertyManager(this);
+ d_ptr->m_typeToPropertyManager[groupId] = groupPropertyManager;
+ d_ptr->m_typeToValueType[groupId] = QVariant::Invalid;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtVariantPropertyManager::~QtVariantPropertyManager()
+{
+ clear();
+ delete d_ptr;
+}
+
+/*!
+ Returns the given \a property converted into a QtVariantProperty.
+
+ If the \a property was not created by this variant manager, the
+ function returns 0.
+
+ \sa createProperty()
+*/
+QtVariantProperty *QtVariantPropertyManager::variantProperty(const QtProperty *property) const
+{
+ const QMap<const QtProperty *, QPair<QtVariantProperty *, int> >::const_iterator it = d_ptr->m_propertyToType.constFind(property);
+ if (it == d_ptr->m_propertyToType.constEnd())
+ return 0;
+ return it.value().first;
+}
+
+/*!
+ Returns true if the given \a propertyType is supported by this
+ variant manager; otherwise false.
+
+ \sa propertyType()
+*/
+bool QtVariantPropertyManager::isPropertyTypeSupported(int propertyType) const
+{
+ if (d_ptr->m_typeToValueType.contains(propertyType))
+ return true;
+ return false;
+}
+
+/*!
+ Creates and returns a variant property of the given \a propertyType
+ with the given \a name.
+
+ If the specified \a propertyType is not supported by this variant
+ manager, this function returns 0.
+
+ Do not use the inherited
+ QtAbstractPropertyManager::addProperty() function to create a
+ variant property (that function will always return 0 since it will
+ not be clear what type the property should have).
+
+ \sa isPropertyTypeSupported()
+*/
+QtVariantProperty *QtVariantPropertyManager::addProperty(int propertyType, const QString &name)
+{
+ if (!isPropertyTypeSupported(propertyType))
+ return 0;
+
+ bool wasCreating = d_ptr->m_creatingProperty;
+ d_ptr->m_creatingProperty = true;
+ d_ptr->m_propertyType = propertyType;
+ QtProperty *property = QtAbstractPropertyManager::addProperty(name);
+ d_ptr->m_creatingProperty = wasCreating;
+ d_ptr->m_propertyType = 0;
+
+ if (!property)
+ return 0;
+
+ return variantProperty(property);
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given \a property is not managed by this manager, this
+ function returns an invalid variant.
+
+ \sa setValue()
+*/
+QVariant QtVariantPropertyManager::value(const QtProperty *property) const
+{
+ QtProperty *internProp = propertyToWrappedProperty()->value(property, 0);
+ if (internProp == 0)
+ return QVariant();
+
+ QtAbstractPropertyManager *manager = internProp->propertyManager();
+ if (QtIntPropertyManager *intManager = qobject_cast<QtIntPropertyManager *>(manager)) {
+ return intManager->value(internProp);
+ } else if (QtDoublePropertyManager *doubleManager = qobject_cast<QtDoublePropertyManager *>(manager)) {
+ return doubleManager->value(internProp);
+ } else if (QtBoolPropertyManager *boolManager = qobject_cast<QtBoolPropertyManager *>(manager)) {
+ return boolManager->value(internProp);
+ } else if (QtStringPropertyManager *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
+ return stringManager->value(internProp);
+ } else if (QtDatePropertyManager *dateManager = qobject_cast<QtDatePropertyManager *>(manager)) {
+ return dateManager->value(internProp);
+ } else if (QtTimePropertyManager *timeManager = qobject_cast<QtTimePropertyManager *>(manager)) {
+ return timeManager->value(internProp);
+ } else if (QtDateTimePropertyManager *dateTimeManager = qobject_cast<QtDateTimePropertyManager *>(manager)) {
+ return dateTimeManager->value(internProp);
+ } else if (QtKeySequencePropertyManager *keySequenceManager = qobject_cast<QtKeySequencePropertyManager *>(manager)) {
+#if QT_VERSION < 0x050000
+ return keySequenceManager->value(internProp);
+#else
+ return QVariant::fromValue(keySequenceManager->value(internProp));
+#endif
+ } else if (QtCharPropertyManager *charManager = qobject_cast<QtCharPropertyManager *>(manager)) {
+ return charManager->value(internProp);
+ } else if (QtLocalePropertyManager *localeManager = qobject_cast<QtLocalePropertyManager *>(manager)) {
+ return localeManager->value(internProp);
+ } else if (QtPointPropertyManager *pointManager = qobject_cast<QtPointPropertyManager *>(manager)) {
+ return pointManager->value(internProp);
+ } else if (QtPointFPropertyManager *pointFManager = qobject_cast<QtPointFPropertyManager *>(manager)) {
+ return pointFManager->value(internProp);
+ } else if (QtSizePropertyManager *sizeManager = qobject_cast<QtSizePropertyManager *>(manager)) {
+ return sizeManager->value(internProp);
+ } else if (QtSizeFPropertyManager *sizeFManager = qobject_cast<QtSizeFPropertyManager *>(manager)) {
+ return sizeFManager->value(internProp);
+ } else if (QtRectPropertyManager *rectManager = qobject_cast<QtRectPropertyManager *>(manager)) {
+ return rectManager->value(internProp);
+ } else if (QtRectFPropertyManager *rectFManager = qobject_cast<QtRectFPropertyManager *>(manager)) {
+ return rectFManager->value(internProp);
+ } else if (QtColorPropertyManager *colorManager = qobject_cast<QtColorPropertyManager *>(manager)) {
+ return colorManager->value(internProp);
+ } else if (QtEnumPropertyManager *enumManager = qobject_cast<QtEnumPropertyManager *>(manager)) {
+ return enumManager->value(internProp);
+ } else if (QtSizePolicyPropertyManager *sizePolicyManager =
+ qobject_cast<QtSizePolicyPropertyManager *>(manager)) {
+ return sizePolicyManager->value(internProp);
+ } else if (QtFontPropertyManager *fontManager = qobject_cast<QtFontPropertyManager *>(manager)) {
+ return fontManager->value(internProp);
+#ifndef QT_NO_CURSOR
+ } else if (QtCursorPropertyManager *cursorManager = qobject_cast<QtCursorPropertyManager *>(manager)) {
+ return cursorManager->value(internProp);
+#endif
+ } else if (QtFlagPropertyManager *flagManager = qobject_cast<QtFlagPropertyManager *>(manager)) {
+ return flagManager->value(internProp);
+ }
+ return QVariant();
+}
+
+/*!
+ Returns the given \a property's value type.
+
+ \sa propertyType()
+*/
+int QtVariantPropertyManager::valueType(const QtProperty *property) const
+{
+ int propType = propertyType(property);
+ return valueType(propType);
+}
+
+/*!
+ \overload
+
+ Returns the value type associated with the given \a propertyType.
+*/
+int QtVariantPropertyManager::valueType(int propertyType) const
+{
+ if (d_ptr->m_typeToValueType.contains(propertyType))
+ return d_ptr->m_typeToValueType[propertyType];
+ return 0;
+}
+
+/*!
+ Returns the given \a property's type.
+
+ \sa valueType()
+*/
+int QtVariantPropertyManager::propertyType(const QtProperty *property) const
+{
+ const QMap<const QtProperty *, QPair<QtVariantProperty *, int> >::const_iterator it = d_ptr->m_propertyToType.constFind(property);
+ if (it == d_ptr->m_propertyToType.constEnd())
+ return 0;
+ return it.value().second;
+}
+
+/*!
+ Returns the given \a property's value for the specified \a
+ attribute
+
+ If the given \a property was not created by \e this manager, or if
+ the specified \a attribute does not exist, this function returns
+ an invalid variant.
+
+ \sa attributes(), attributeType(), setAttribute()
+*/
+QVariant QtVariantPropertyManager::attributeValue(const QtProperty *property, const QString &attribute) const
+{
+ int propType = propertyType(property);
+ if (!propType)
+ return QVariant();
+
+ QMap<int, QMap<QString, int> >::ConstIterator it =
+ d_ptr->m_typeToAttributeToAttributeType.find(propType);
+ if (it == d_ptr->m_typeToAttributeToAttributeType.constEnd())
+ return QVariant();
+
+ QMap<QString, int> attributes = it.value();
+ QMap<QString, int>::ConstIterator itAttr = attributes.find(attribute);
+ if (itAttr == attributes.constEnd())
+ return QVariant();
+
+ QtProperty *internProp = propertyToWrappedProperty()->value(property, 0);
+ if (internProp == 0)
+ return QVariant();
+
+ QtAbstractPropertyManager *manager = internProp->propertyManager();
+ if (QtIntPropertyManager *intManager = qobject_cast<QtIntPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ return intManager->maximum(internProp);
+ if (attribute == d_ptr->m_minimumAttribute)
+ return intManager->minimum(internProp);
+ if (attribute == d_ptr->m_singleStepAttribute)
+ return intManager->singleStep(internProp);
+ if (attribute == d_ptr->m_readOnlyAttribute)
+ return intManager->isReadOnly(internProp);
+ return QVariant();
+ } else if (QtDoublePropertyManager *doubleManager = qobject_cast<QtDoublePropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ return doubleManager->maximum(internProp);
+ if (attribute == d_ptr->m_minimumAttribute)
+ return doubleManager->minimum(internProp);
+ if (attribute == d_ptr->m_singleStepAttribute)
+ return doubleManager->singleStep(internProp);
+ if (attribute == d_ptr->m_decimalsAttribute)
+ return doubleManager->decimals(internProp);
+ if (attribute == d_ptr->m_readOnlyAttribute)
+ return doubleManager->isReadOnly(internProp);
+ return QVariant();
+ } else if (QtStringPropertyManager *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_regExpAttribute)
+ return stringManager->regExp(internProp);
+ if (attribute == d_ptr->m_echoModeAttribute)
+ return stringManager->echoMode(internProp);
+ if (attribute == d_ptr->m_readOnlyAttribute)
+ return stringManager->isReadOnly(internProp);
+ return QVariant();
+ } else if (QtDatePropertyManager *dateManager = qobject_cast<QtDatePropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ return dateManager->maximum(internProp);
+ if (attribute == d_ptr->m_minimumAttribute)
+ return dateManager->minimum(internProp);
+ return QVariant();
+ } else if (QtPointFPropertyManager *pointFManager = qobject_cast<QtPointFPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_decimalsAttribute)
+ return pointFManager->decimals(internProp);
+ return QVariant();
+ } else if (QtSizePropertyManager *sizeManager = qobject_cast<QtSizePropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ return sizeManager->maximum(internProp);
+ if (attribute == d_ptr->m_minimumAttribute)
+ return sizeManager->minimum(internProp);
+ return QVariant();
+ } else if (QtSizeFPropertyManager *sizeFManager = qobject_cast<QtSizeFPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ return sizeFManager->maximum(internProp);
+ if (attribute == d_ptr->m_minimumAttribute)
+ return sizeFManager->minimum(internProp);
+ if (attribute == d_ptr->m_decimalsAttribute)
+ return sizeFManager->decimals(internProp);
+ return QVariant();
+ } else if (QtRectPropertyManager *rectManager = qobject_cast<QtRectPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_constraintAttribute)
+ return rectManager->constraint(internProp);
+ return QVariant();
+ } else if (QtRectFPropertyManager *rectFManager = qobject_cast<QtRectFPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_constraintAttribute)
+ return rectFManager->constraint(internProp);
+ if (attribute == d_ptr->m_decimalsAttribute)
+ return rectFManager->decimals(internProp);
+ return QVariant();
+ } else if (QtEnumPropertyManager *enumManager = qobject_cast<QtEnumPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_enumNamesAttribute)
+ return enumManager->enumNames(internProp);
+ if (attribute == d_ptr->m_enumIconsAttribute) {
+ QVariant v;
+ qVariantSetValue(v, enumManager->enumIcons(internProp));
+ return v;
+ }
+ return QVariant();
+ } else if (QtFlagPropertyManager *flagManager = qobject_cast<QtFlagPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_flagNamesAttribute)
+ return flagManager->flagNames(internProp);
+ return QVariant();
+ }
+ return QVariant();
+}
+
+/*!
+ Returns a list of the given \a propertyType 's attributes.
+
+ \sa attributeValue(), attributeType()
+*/
+QStringList QtVariantPropertyManager::attributes(int propertyType) const
+{
+ QMap<int, QMap<QString, int> >::ConstIterator it =
+ d_ptr->m_typeToAttributeToAttributeType.find(propertyType);
+ if (it == d_ptr->m_typeToAttributeToAttributeType.constEnd())
+ return QStringList();
+ return it.value().keys();
+}
+
+/*!
+ Returns the type of the specified \a attribute of the given \a
+ propertyType.
+
+ If the given \a propertyType is not supported by \e this manager,
+ or if the given \a propertyType does not possess the specified \a
+ attribute, this function returns QVariant::Invalid.
+
+ \sa attributes(), valueType()
+*/
+int QtVariantPropertyManager::attributeType(int propertyType, const QString &attribute) const
+{
+ QMap<int, QMap<QString, int> >::ConstIterator it =
+ d_ptr->m_typeToAttributeToAttributeType.find(propertyType);
+ if (it == d_ptr->m_typeToAttributeToAttributeType.constEnd())
+ return 0;
+
+ QMap<QString, int> attributes = it.value();
+ QMap<QString, int>::ConstIterator itAttr = attributes.find(attribute);
+ if (itAttr == attributes.constEnd())
+ return 0;
+ return itAttr.value();
+}
+
+/*!
+ \fn void QtVariantPropertyManager::setValue(QtProperty *property, const QVariant &value)
+
+ Sets the value of the given \a property to \a value.
+
+ The specified \a value must be of a type returned by valueType(),
+ or of type that can be converted to valueType() using the
+ QVariant::canConvert() function, otherwise this function does
+ nothing.
+
+ \sa value(), QtVariantProperty::setValue(), valueChanged()
+*/
+void QtVariantPropertyManager::setValue(QtProperty *property, const QVariant &val)
+{
+ int propType = val.userType();
+ if (!propType)
+ return;
+
+ int valType = valueType(property);
+
+ if (propType != valType && !val.canConvert(static_cast<QVariant::Type>(valType)))
+ return;
+
+ QtProperty *internProp = propertyToWrappedProperty()->value(property, 0);
+ if (internProp == 0)
+ return;
+
+
+ QtAbstractPropertyManager *manager = internProp->propertyManager();
+ if (QtIntPropertyManager *intManager = qobject_cast<QtIntPropertyManager *>(manager)) {
+ intManager->setValue(internProp, qVariantValue<int>(val));
+ return;
+ } else if (QtDoublePropertyManager *doubleManager = qobject_cast<QtDoublePropertyManager *>(manager)) {
+ doubleManager->setValue(internProp, qVariantValue<double>(val));
+ return;
+ } else if (QtBoolPropertyManager *boolManager = qobject_cast<QtBoolPropertyManager *>(manager)) {
+ boolManager->setValue(internProp, qVariantValue<bool>(val));
+ return;
+ } else if (QtStringPropertyManager *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
+ stringManager->setValue(internProp, qVariantValue<QString>(val));
+ return;
+ } else if (QtDatePropertyManager *dateManager = qobject_cast<QtDatePropertyManager *>(manager)) {
+ dateManager->setValue(internProp, qVariantValue<QDate>(val));
+ return;
+ } else if (QtTimePropertyManager *timeManager = qobject_cast<QtTimePropertyManager *>(manager)) {
+ timeManager->setValue(internProp, qVariantValue<QTime>(val));
+ return;
+ } else if (QtDateTimePropertyManager *dateTimeManager = qobject_cast<QtDateTimePropertyManager *>(manager)) {
+ dateTimeManager->setValue(internProp, qVariantValue<QDateTime>(val));
+ return;
+ } else if (QtKeySequencePropertyManager *keySequenceManager = qobject_cast<QtKeySequencePropertyManager *>(manager)) {
+ keySequenceManager->setValue(internProp, qVariantValue<QKeySequence>(val));
+ return;
+ } else if (QtCharPropertyManager *charManager = qobject_cast<QtCharPropertyManager *>(manager)) {
+ charManager->setValue(internProp, qVariantValue<QChar>(val));
+ return;
+ } else if (QtLocalePropertyManager *localeManager = qobject_cast<QtLocalePropertyManager *>(manager)) {
+ localeManager->setValue(internProp, qVariantValue<QLocale>(val));
+ return;
+ } else if (QtPointPropertyManager *pointManager = qobject_cast<QtPointPropertyManager *>(manager)) {
+ pointManager->setValue(internProp, qVariantValue<QPoint>(val));
+ return;
+ } else if (QtPointFPropertyManager *pointFManager = qobject_cast<QtPointFPropertyManager *>(manager)) {
+ pointFManager->setValue(internProp, qVariantValue<QPointF>(val));
+ return;
+ } else if (QtSizePropertyManager *sizeManager = qobject_cast<QtSizePropertyManager *>(manager)) {
+ sizeManager->setValue(internProp, qVariantValue<QSize>(val));
+ return;
+ } else if (QtSizeFPropertyManager *sizeFManager = qobject_cast<QtSizeFPropertyManager *>(manager)) {
+ sizeFManager->setValue(internProp, qVariantValue<QSizeF>(val));
+ return;
+ } else if (QtRectPropertyManager *rectManager = qobject_cast<QtRectPropertyManager *>(manager)) {
+ rectManager->setValue(internProp, qVariantValue<QRect>(val));
+ return;
+ } else if (QtRectFPropertyManager *rectFManager = qobject_cast<QtRectFPropertyManager *>(manager)) {
+ rectFManager->setValue(internProp, qVariantValue<QRectF>(val));
+ return;
+ } else if (QtColorPropertyManager *colorManager = qobject_cast<QtColorPropertyManager *>(manager)) {
+ colorManager->setValue(internProp, qVariantValue<QColor>(val));
+ return;
+ } else if (QtEnumPropertyManager *enumManager = qobject_cast<QtEnumPropertyManager *>(manager)) {
+ enumManager->setValue(internProp, qVariantValue<int>(val));
+ return;
+ } else if (QtSizePolicyPropertyManager *sizePolicyManager =
+ qobject_cast<QtSizePolicyPropertyManager *>(manager)) {
+ sizePolicyManager->setValue(internProp, qVariantValue<QSizePolicy>(val));
+ return;
+ } else if (QtFontPropertyManager *fontManager = qobject_cast<QtFontPropertyManager *>(manager)) {
+ fontManager->setValue(internProp, qVariantValue<QFont>(val));
+ return;
+#ifndef QT_NO_CURSOR
+ } else if (QtCursorPropertyManager *cursorManager = qobject_cast<QtCursorPropertyManager *>(manager)) {
+ cursorManager->setValue(internProp, qVariantValue<QCursor>(val));
+ return;
+#endif
+ } else if (QtFlagPropertyManager *flagManager = qobject_cast<QtFlagPropertyManager *>(manager)) {
+ flagManager->setValue(internProp, qVariantValue<int>(val));
+ return;
+ }
+}
+
+/*!
+ Sets the value of the specified \a attribute of the given \a
+ property, to \a value.
+
+ The new \a value's type must be of the type returned by
+ attributeType(), or of a type that can be converted to
+ attributeType() using the QVariant::canConvert() function,
+ otherwise this function does nothing.
+
+ \sa attributeValue(), QtVariantProperty::setAttribute(), attributeChanged()
+*/
+void QtVariantPropertyManager::setAttribute(QtProperty *property,
+ const QString &attribute, const QVariant &value)
+{
+ QVariant oldAttr = attributeValue(property, attribute);
+ if (!oldAttr.isValid())
+ return;
+
+ int attrType = value.userType();
+ if (!attrType)
+ return;
+
+ if (attrType != attributeType(propertyType(property), attribute) &&
+ !value.canConvert((QVariant::Type)attrType))
+ return;
+
+ QtProperty *internProp = propertyToWrappedProperty()->value(property, 0);
+ if (internProp == 0)
+ return;
+
+ QtAbstractPropertyManager *manager = internProp->propertyManager();
+ if (QtIntPropertyManager *intManager = qobject_cast<QtIntPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ intManager->setMaximum(internProp, qVariantValue<int>(value));
+ else if (attribute == d_ptr->m_minimumAttribute)
+ intManager->setMinimum(internProp, qVariantValue<int>(value));
+ else if (attribute == d_ptr->m_singleStepAttribute)
+ intManager->setSingleStep(internProp, qVariantValue<int>(value));
+ else if (attribute == d_ptr->m_readOnlyAttribute)
+ intManager->setReadOnly(internProp, qVariantValue<bool>(value));
+ return;
+ } else if (QtDoublePropertyManager *doubleManager = qobject_cast<QtDoublePropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ doubleManager->setMaximum(internProp, qVariantValue<double>(value));
+ if (attribute == d_ptr->m_minimumAttribute)
+ doubleManager->setMinimum(internProp, qVariantValue<double>(value));
+ if (attribute == d_ptr->m_singleStepAttribute)
+ doubleManager->setSingleStep(internProp, qVariantValue<double>(value));
+ if (attribute == d_ptr->m_decimalsAttribute)
+ doubleManager->setDecimals(internProp, qVariantValue<int>(value));
+ if (attribute == d_ptr->m_readOnlyAttribute)
+ doubleManager->setReadOnly(internProp, qVariantValue<bool>(value));
+ return;
+ } else if (QtStringPropertyManager *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_regExpAttribute)
+ stringManager->setRegExp(internProp, qVariantValue<QRegExp>(value));
+ if (attribute == d_ptr->m_echoModeAttribute)
+ stringManager->setEchoMode(internProp, (EchoMode)qVariantValue<int>(value));
+ if (attribute == d_ptr->m_readOnlyAttribute)
+ stringManager->setReadOnly(internProp, (EchoMode)qVariantValue<bool>(value));
+ return;
+ } else if (QtDatePropertyManager *dateManager = qobject_cast<QtDatePropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ dateManager->setMaximum(internProp, qVariantValue<QDate>(value));
+ if (attribute == d_ptr->m_minimumAttribute)
+ dateManager->setMinimum(internProp, qVariantValue<QDate>(value));
+ return;
+ } else if (QtPointFPropertyManager *pointFManager = qobject_cast<QtPointFPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_decimalsAttribute)
+ pointFManager->setDecimals(internProp, qVariantValue<int>(value));
+ return;
+ } else if (QtSizePropertyManager *sizeManager = qobject_cast<QtSizePropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ sizeManager->setMaximum(internProp, qVariantValue<QSize>(value));
+ if (attribute == d_ptr->m_minimumAttribute)
+ sizeManager->setMinimum(internProp, qVariantValue<QSize>(value));
+ return;
+ } else if (QtSizeFPropertyManager *sizeFManager = qobject_cast<QtSizeFPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_maximumAttribute)
+ sizeFManager->setMaximum(internProp, qVariantValue<QSizeF>(value));
+ if (attribute == d_ptr->m_minimumAttribute)
+ sizeFManager->setMinimum(internProp, qVariantValue<QSizeF>(value));
+ if (attribute == d_ptr->m_decimalsAttribute)
+ sizeFManager->setDecimals(internProp, qVariantValue<int>(value));
+ return;
+ } else if (QtRectPropertyManager *rectManager = qobject_cast<QtRectPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_constraintAttribute)
+ rectManager->setConstraint(internProp, qVariantValue<QRect>(value));
+ return;
+ } else if (QtRectFPropertyManager *rectFManager = qobject_cast<QtRectFPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_constraintAttribute)
+ rectFManager->setConstraint(internProp, qVariantValue<QRectF>(value));
+ if (attribute == d_ptr->m_decimalsAttribute)
+ rectFManager->setDecimals(internProp, qVariantValue<int>(value));
+ return;
+ } else if (QtEnumPropertyManager *enumManager = qobject_cast<QtEnumPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_enumNamesAttribute)
+ enumManager->setEnumNames(internProp, qVariantValue<QStringList>(value));
+ if (attribute == d_ptr->m_enumIconsAttribute)
+ enumManager->setEnumIcons(internProp, qVariantValue<QtIconMap>(value));
+ return;
+ } else if (QtFlagPropertyManager *flagManager = qobject_cast<QtFlagPropertyManager *>(manager)) {
+ if (attribute == d_ptr->m_flagNamesAttribute)
+ flagManager->setFlagNames(internProp, qVariantValue<QStringList>(value));
+ return;
+ }
+}
+
+/*!
+ \reimp
+*/
+bool QtVariantPropertyManager::hasValue(const QtProperty *property) const
+{
+ if (propertyType(property) == groupTypeId())
+ return false;
+ return true;
+}
+
+/*!
+ \reimp
+*/
+QString QtVariantPropertyManager::valueText(const QtProperty *property) const
+{
+ const QtProperty *internProp = propertyToWrappedProperty()->value(property, 0);
+ return internProp ? !internProp->displayText().isEmpty() ? internProp->displayText() : internProp->valueText() : QString();
+}
+
+/*!
+ \reimp
+*/
+QIcon QtVariantPropertyManager::valueIcon(const QtProperty *property) const
+{
+ const QtProperty *internProp = propertyToWrappedProperty()->value(property, 0);
+ return internProp ? internProp->valueIcon() : QIcon();
+}
+
+/*!
+ \reimp
+*/
+void QtVariantPropertyManager::initializeProperty(QtProperty *property)
+{
+ QtVariantProperty *varProp = variantProperty(property);
+ if (!varProp)
+ return;
+
+ QMap<int, QtAbstractPropertyManager *>::ConstIterator it =
+ d_ptr->m_typeToPropertyManager.find(d_ptr->m_propertyType);
+ if (it != d_ptr->m_typeToPropertyManager.constEnd()) {
+ QtProperty *internProp = 0;
+ if (!d_ptr->m_creatingSubProperties) {
+ QtAbstractPropertyManager *manager = it.value();
+ internProp = manager->addProperty();
+ d_ptr->m_internalToProperty[internProp] = varProp;
+ }
+ propertyToWrappedProperty()->insert(varProp, internProp);
+ if (internProp) {
+ QList<QtProperty *> children = internProp->subProperties();
+ QListIterator<QtProperty *> itChild(children);
+ QtVariantProperty *lastProperty = 0;
+ while (itChild.hasNext()) {
+ QtVariantProperty *prop = d_ptr->createSubProperty(varProp, lastProperty, itChild.next());
+ lastProperty = prop ? prop : lastProperty;
+ }
+ }
+ }
+}
+
+/*!
+ \reimp
+*/
+void QtVariantPropertyManager::uninitializeProperty(QtProperty *property)
+{
+ const QMap<const QtProperty *, QPair<QtVariantProperty *, int> >::iterator type_it = d_ptr->m_propertyToType.find(property);
+ if (type_it == d_ptr->m_propertyToType.end())
+ return;
+
+ PropertyMap::iterator it = propertyToWrappedProperty()->find(property);
+ if (it != propertyToWrappedProperty()->end()) {
+ QtProperty *internProp = it.value();
+ if (internProp) {
+ d_ptr->m_internalToProperty.remove(internProp);
+ if (!d_ptr->m_destroyingSubProperties) {
+ delete internProp;
+ }
+ }
+ propertyToWrappedProperty()->erase(it);
+ }
+ d_ptr->m_propertyToType.erase(type_it);
+}
+
+/*!
+ \reimp
+*/
+QtProperty *QtVariantPropertyManager::createProperty()
+{
+ if (!d_ptr->m_creatingProperty)
+ return 0;
+
+ QtVariantProperty *property = new QtVariantProperty(this);
+ d_ptr->m_propertyToType.insert(property, qMakePair(property, d_ptr->m_propertyType));
+
+ return property;
+}
+
+/////////////////////////////
+
+class QtVariantEditorFactoryPrivate
+{
+ QtVariantEditorFactory *q_ptr;
+ Q_DECLARE_PUBLIC(QtVariantEditorFactory)
+public:
+
+ QtSpinBoxFactory *m_spinBoxFactory;
+ QtDoubleSpinBoxFactory *m_doubleSpinBoxFactory;
+ QtCheckBoxFactory *m_checkBoxFactory;
+ QtLineEditFactory *m_lineEditFactory;
+ QtDateEditFactory *m_dateEditFactory;
+ QtTimeEditFactory *m_timeEditFactory;
+ QtDateTimeEditFactory *m_dateTimeEditFactory;
+ QtKeySequenceEditorFactory *m_keySequenceEditorFactory;
+ QtCharEditorFactory *m_charEditorFactory;
+ QtEnumEditorFactory *m_comboBoxFactory;
+ QtCursorEditorFactory *m_cursorEditorFactory;
+ QtColorEditorFactory *m_colorEditorFactory;
+ QtFontEditorFactory *m_fontEditorFactory;
+
+ QMap<QtAbstractEditorFactoryBase *, int> m_factoryToType;
+ QMap<int, QtAbstractEditorFactoryBase *> m_typeToFactory;
+};
+
+/*!
+ \class QtVariantEditorFactory
+
+ \brief The QtVariantEditorFactory class provides widgets for properties
+ created by QtVariantPropertyManager objects.
+
+ The variant factory provides the following widgets for the
+ specified property types:
+
+ \table
+ \header
+ \o Property Type
+ \o Widget
+ \row
+ \o \c int
+ \o QSpinBox
+ \row
+ \o \c double
+ \o QDoubleSpinBox
+ \row
+ \o \c bool
+ \o QCheckBox
+ \row
+ \o QString
+ \o QLineEdit
+ \row
+ \o QDate
+ \o QDateEdit
+ \row
+ \o QTime
+ \o QTimeEdit
+ \row
+ \o QDateTime
+ \o QDateTimeEdit
+ \row
+ \o QKeySequence
+ \o customized editor
+ \row
+ \o QChar
+ \o customized editor
+ \row
+ \o \c enum
+ \o QComboBox
+ \row
+ \o QCursor
+ \o QComboBox
+ \endtable
+
+ Note that QtVariantPropertyManager supports several additional property
+ types for which the QtVariantEditorFactory class does not provide
+ editing widgets, e.g. QPoint and QSize. To provide widgets for other
+ types using the variant approach, derive from the QtVariantEditorFactory
+ class.
+
+ \sa QtAbstractEditorFactory, QtVariantPropertyManager
+*/
+
+/*!
+ Creates a factory with the given \a parent.
+*/
+QtVariantEditorFactory::QtVariantEditorFactory(QObject *parent)
+ : QtAbstractEditorFactory<QtVariantPropertyManager>(parent)
+{
+ d_ptr = new QtVariantEditorFactoryPrivate();
+ d_ptr->q_ptr = this;
+
+ d_ptr->m_spinBoxFactory = new QtSpinBoxFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_spinBoxFactory] = QVariant::Int;
+ d_ptr->m_typeToFactory[QVariant::Int] = d_ptr->m_spinBoxFactory;
+
+ d_ptr->m_doubleSpinBoxFactory = new QtDoubleSpinBoxFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_doubleSpinBoxFactory] = QVariant::Double;
+ d_ptr->m_typeToFactory[QVariant::Double] = d_ptr->m_doubleSpinBoxFactory;
+
+ d_ptr->m_checkBoxFactory = new QtCheckBoxFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_checkBoxFactory] = QVariant::Bool;
+ d_ptr->m_typeToFactory[QVariant::Bool] = d_ptr->m_checkBoxFactory;
+
+ d_ptr->m_lineEditFactory = new QtLineEditFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_lineEditFactory] = QVariant::String;
+ d_ptr->m_typeToFactory[QVariant::String] = d_ptr->m_lineEditFactory;
+
+ d_ptr->m_dateEditFactory = new QtDateEditFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_dateEditFactory] = QVariant::Date;
+ d_ptr->m_typeToFactory[QVariant::Date] = d_ptr->m_dateEditFactory;
+
+ d_ptr->m_timeEditFactory = new QtTimeEditFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_timeEditFactory] = QVariant::Time;
+ d_ptr->m_typeToFactory[QVariant::Time] = d_ptr->m_timeEditFactory;
+
+ d_ptr->m_dateTimeEditFactory = new QtDateTimeEditFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_dateTimeEditFactory] = QVariant::DateTime;
+ d_ptr->m_typeToFactory[QVariant::DateTime] = d_ptr->m_dateTimeEditFactory;
+
+ d_ptr->m_keySequenceEditorFactory = new QtKeySequenceEditorFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_keySequenceEditorFactory] = QVariant::KeySequence;
+ d_ptr->m_typeToFactory[QVariant::KeySequence] = d_ptr->m_keySequenceEditorFactory;
+
+ d_ptr->m_charEditorFactory = new QtCharEditorFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_charEditorFactory] = QVariant::Char;
+ d_ptr->m_typeToFactory[QVariant::Char] = d_ptr->m_charEditorFactory;
+
+ d_ptr->m_cursorEditorFactory = new QtCursorEditorFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_cursorEditorFactory] = QVariant::Cursor;
+ d_ptr->m_typeToFactory[QVariant::Cursor] = d_ptr->m_cursorEditorFactory;
+
+ d_ptr->m_colorEditorFactory = new QtColorEditorFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_colorEditorFactory] = QVariant::Color;
+ d_ptr->m_typeToFactory[QVariant::Color] = d_ptr->m_colorEditorFactory;
+
+ d_ptr->m_fontEditorFactory = new QtFontEditorFactory(this);
+ d_ptr->m_factoryToType[d_ptr->m_fontEditorFactory] = QVariant::Font;
+ d_ptr->m_typeToFactory[QVariant::Font] = d_ptr->m_fontEditorFactory;
+
+ d_ptr->m_comboBoxFactory = new QtEnumEditorFactory(this);
+ const int enumId = QtVariantPropertyManager::enumTypeId();
+ d_ptr->m_factoryToType[d_ptr->m_comboBoxFactory] = enumId;
+ d_ptr->m_typeToFactory[enumId] = d_ptr->m_comboBoxFactory;
+}
+
+/*!
+ Destroys this factory, and all the widgets it has created.
+*/
+QtVariantEditorFactory::~QtVariantEditorFactory()
+{
+ delete d_ptr;
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtVariantEditorFactory::connectPropertyManager(QtVariantPropertyManager *manager)
+{
+ QList<QtIntPropertyManager *> intPropertyManagers = qFindChildren<QtIntPropertyManager *>(manager);
+ QListIterator<QtIntPropertyManager *> itInt(intPropertyManagers);
+ while (itInt.hasNext())
+ d_ptr->m_spinBoxFactory->addPropertyManager(itInt.next());
+
+ QList<QtDoublePropertyManager *> doublePropertyManagers = qFindChildren<QtDoublePropertyManager *>(manager);
+ QListIterator<QtDoublePropertyManager *> itDouble(doublePropertyManagers);
+ while (itDouble.hasNext())
+ d_ptr->m_doubleSpinBoxFactory->addPropertyManager(itDouble.next());
+
+ QList<QtBoolPropertyManager *> boolPropertyManagers = qFindChildren<QtBoolPropertyManager *>(manager);
+ QListIterator<QtBoolPropertyManager *> itBool(boolPropertyManagers);
+ while (itBool.hasNext())
+ d_ptr->m_checkBoxFactory->addPropertyManager(itBool.next());
+
+ QList<QtStringPropertyManager *> stringPropertyManagers = qFindChildren<QtStringPropertyManager *>(manager);
+ QListIterator<QtStringPropertyManager *> itString(stringPropertyManagers);
+ while (itString.hasNext())
+ d_ptr->m_lineEditFactory->addPropertyManager(itString.next());
+
+ QList<QtDatePropertyManager *> datePropertyManagers = qFindChildren<QtDatePropertyManager *>(manager);
+ QListIterator<QtDatePropertyManager *> itDate(datePropertyManagers);
+ while (itDate.hasNext())
+ d_ptr->m_dateEditFactory->addPropertyManager(itDate.next());
+
+ QList<QtTimePropertyManager *> timePropertyManagers = qFindChildren<QtTimePropertyManager *>(manager);
+ QListIterator<QtTimePropertyManager *> itTime(timePropertyManagers);
+ while (itTime.hasNext())
+ d_ptr->m_timeEditFactory->addPropertyManager(itTime.next());
+
+ QList<QtDateTimePropertyManager *> dateTimePropertyManagers = qFindChildren<QtDateTimePropertyManager *>(manager);
+ QListIterator<QtDateTimePropertyManager *> itDateTime(dateTimePropertyManagers);
+ while (itDateTime.hasNext())
+ d_ptr->m_dateTimeEditFactory->addPropertyManager(itDateTime.next());
+
+ QList<QtKeySequencePropertyManager *> keySequencePropertyManagers = qFindChildren<QtKeySequencePropertyManager *>(manager);
+ QListIterator<QtKeySequencePropertyManager *> itKeySequence(keySequencePropertyManagers);
+ while (itKeySequence.hasNext())
+ d_ptr->m_keySequenceEditorFactory->addPropertyManager(itKeySequence.next());
+
+ QList<QtCharPropertyManager *> charPropertyManagers = qFindChildren<QtCharPropertyManager *>(manager);
+ QListIterator<QtCharPropertyManager *> itChar(charPropertyManagers);
+ while (itChar.hasNext())
+ d_ptr->m_charEditorFactory->addPropertyManager(itChar.next());
+
+ QList<QtLocalePropertyManager *> localePropertyManagers = qFindChildren<QtLocalePropertyManager *>(manager);
+ QListIterator<QtLocalePropertyManager *> itLocale(localePropertyManagers);
+ while (itLocale.hasNext())
+ d_ptr->m_comboBoxFactory->addPropertyManager(itLocale.next()->subEnumPropertyManager());
+
+ QList<QtPointPropertyManager *> pointPropertyManagers = qFindChildren<QtPointPropertyManager *>(manager);
+ QListIterator<QtPointPropertyManager *> itPoint(pointPropertyManagers);
+ while (itPoint.hasNext())
+ d_ptr->m_spinBoxFactory->addPropertyManager(itPoint.next()->subIntPropertyManager());
+
+ QList<QtPointFPropertyManager *> pointFPropertyManagers = qFindChildren<QtPointFPropertyManager *>(manager);
+ QListIterator<QtPointFPropertyManager *> itPointF(pointFPropertyManagers);
+ while (itPointF.hasNext())
+ d_ptr->m_doubleSpinBoxFactory->addPropertyManager(itPointF.next()->subDoublePropertyManager());
+
+ QList<QtSizePropertyManager *> sizePropertyManagers = qFindChildren<QtSizePropertyManager *>(manager);
+ QListIterator<QtSizePropertyManager *> itSize(sizePropertyManagers);
+ while (itSize.hasNext())
+ d_ptr->m_spinBoxFactory->addPropertyManager(itSize.next()->subIntPropertyManager());
+
+ QList<QtSizeFPropertyManager *> sizeFPropertyManagers = qFindChildren<QtSizeFPropertyManager *>(manager);
+ QListIterator<QtSizeFPropertyManager *> itSizeF(sizeFPropertyManagers);
+ while (itSizeF.hasNext())
+ d_ptr->m_doubleSpinBoxFactory->addPropertyManager(itSizeF.next()->subDoublePropertyManager());
+
+ QList<QtRectPropertyManager *> rectPropertyManagers = qFindChildren<QtRectPropertyManager *>(manager);
+ QListIterator<QtRectPropertyManager *> itRect(rectPropertyManagers);
+ while (itRect.hasNext())
+ d_ptr->m_spinBoxFactory->addPropertyManager(itRect.next()->subIntPropertyManager());
+
+ QList<QtRectFPropertyManager *> rectFPropertyManagers = qFindChildren<QtRectFPropertyManager *>(manager);
+ QListIterator<QtRectFPropertyManager *> itRectF(rectFPropertyManagers);
+ while (itRectF.hasNext())
+ d_ptr->m_doubleSpinBoxFactory->addPropertyManager(itRectF.next()->subDoublePropertyManager());
+
+ QList<QtColorPropertyManager *> colorPropertyManagers = qFindChildren<QtColorPropertyManager *>(manager);
+ QListIterator<QtColorPropertyManager *> itColor(colorPropertyManagers);
+ while (itColor.hasNext()) {
+ QtColorPropertyManager *manager = itColor.next();
+ d_ptr->m_colorEditorFactory->addPropertyManager(manager);
+ d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
+ }
+
+ QList<QtEnumPropertyManager *> enumPropertyManagers = qFindChildren<QtEnumPropertyManager *>(manager);
+ QListIterator<QtEnumPropertyManager *> itEnum(enumPropertyManagers);
+ while (itEnum.hasNext())
+ d_ptr->m_comboBoxFactory->addPropertyManager(itEnum.next());
+
+ QList<QtSizePolicyPropertyManager *> sizePolicyPropertyManagers = qFindChildren<QtSizePolicyPropertyManager *>(manager);
+ QListIterator<QtSizePolicyPropertyManager *> itSizePolicy(sizePolicyPropertyManagers);
+ while (itSizePolicy.hasNext()) {
+ QtSizePolicyPropertyManager *manager = itSizePolicy.next();
+ d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
+ d_ptr->m_comboBoxFactory->addPropertyManager(manager->subEnumPropertyManager());
+ }
+
+ QList<QtFontPropertyManager *> fontPropertyManagers = qFindChildren<QtFontPropertyManager *>(manager);
+ QListIterator<QtFontPropertyManager *> itFont(fontPropertyManagers);
+ while (itFont.hasNext()) {
+ QtFontPropertyManager *manager = itFont.next();
+ d_ptr->m_fontEditorFactory->addPropertyManager(manager);
+ d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
+ d_ptr->m_comboBoxFactory->addPropertyManager(manager->subEnumPropertyManager());
+ d_ptr->m_checkBoxFactory->addPropertyManager(manager->subBoolPropertyManager());
+ }
+
+ QList<QtCursorPropertyManager *> cursorPropertyManagers = qFindChildren<QtCursorPropertyManager *>(manager);
+ QListIterator<QtCursorPropertyManager *> itCursor(cursorPropertyManagers);
+ while (itCursor.hasNext())
+ d_ptr->m_cursorEditorFactory->addPropertyManager(itCursor.next());
+
+ QList<QtFlagPropertyManager *> flagPropertyManagers = qFindChildren<QtFlagPropertyManager *>(manager);
+ QListIterator<QtFlagPropertyManager *> itFlag(flagPropertyManagers);
+ while (itFlag.hasNext())
+ d_ptr->m_checkBoxFactory->addPropertyManager(itFlag.next()->subBoolPropertyManager());
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtVariantEditorFactory::createEditor(QtVariantPropertyManager *manager, QtProperty *property,
+ QWidget *parent)
+{
+ const int propType = manager->propertyType(property);
+ QtAbstractEditorFactoryBase *factory = d_ptr->m_typeToFactory.value(propType, 0);
+ if (!factory)
+ return 0;
+ return factory->createEditor(wrappedProperty(property), parent);
+}
+
+/*!
+ \internal
+
+ Reimplemented from the QtAbstractEditorFactory class.
+*/
+void QtVariantEditorFactory::disconnectPropertyManager(QtVariantPropertyManager *manager)
+{
+ QList<QtIntPropertyManager *> intPropertyManagers = qFindChildren<QtIntPropertyManager *>(manager);
+ QListIterator<QtIntPropertyManager *> itInt(intPropertyManagers);
+ while (itInt.hasNext())
+ d_ptr->m_spinBoxFactory->removePropertyManager(itInt.next());
+
+ QList<QtDoublePropertyManager *> doublePropertyManagers = qFindChildren<QtDoublePropertyManager *>(manager);
+ QListIterator<QtDoublePropertyManager *> itDouble(doublePropertyManagers);
+ while (itDouble.hasNext())
+ d_ptr->m_doubleSpinBoxFactory->removePropertyManager(itDouble.next());
+
+ QList<QtBoolPropertyManager *> boolPropertyManagers = qFindChildren<QtBoolPropertyManager *>(manager);
+ QListIterator<QtBoolPropertyManager *> itBool(boolPropertyManagers);
+ while (itBool.hasNext())
+ d_ptr->m_checkBoxFactory->removePropertyManager(itBool.next());
+
+ QList<QtStringPropertyManager *> stringPropertyManagers = qFindChildren<QtStringPropertyManager *>(manager);
+ QListIterator<QtStringPropertyManager *> itString(stringPropertyManagers);
+ while (itString.hasNext())
+ d_ptr->m_lineEditFactory->removePropertyManager(itString.next());
+
+ QList<QtDatePropertyManager *> datePropertyManagers = qFindChildren<QtDatePropertyManager *>(manager);
+ QListIterator<QtDatePropertyManager *> itDate(datePropertyManagers);
+ while (itDate.hasNext())
+ d_ptr->m_dateEditFactory->removePropertyManager(itDate.next());
+
+ QList<QtTimePropertyManager *> timePropertyManagers = qFindChildren<QtTimePropertyManager *>(manager);
+ QListIterator<QtTimePropertyManager *> itTime(timePropertyManagers);
+ while (itTime.hasNext())
+ d_ptr->m_timeEditFactory->removePropertyManager(itTime.next());
+
+ QList<QtDateTimePropertyManager *> dateTimePropertyManagers = qFindChildren<QtDateTimePropertyManager *>(manager);
+ QListIterator<QtDateTimePropertyManager *> itDateTime(dateTimePropertyManagers);
+ while (itDateTime.hasNext())
+ d_ptr->m_dateTimeEditFactory->removePropertyManager(itDateTime.next());
+
+ QList<QtKeySequencePropertyManager *> keySequencePropertyManagers = qFindChildren<QtKeySequencePropertyManager *>(manager);
+ QListIterator<QtKeySequencePropertyManager *> itKeySequence(keySequencePropertyManagers);
+ while (itKeySequence.hasNext())
+ d_ptr->m_keySequenceEditorFactory->removePropertyManager(itKeySequence.next());
+
+ QList<QtCharPropertyManager *> charPropertyManagers = qFindChildren<QtCharPropertyManager *>(manager);
+ QListIterator<QtCharPropertyManager *> itChar(charPropertyManagers);
+ while (itChar.hasNext())
+ d_ptr->m_charEditorFactory->removePropertyManager(itChar.next());
+
+ QList<QtLocalePropertyManager *> localePropertyManagers = qFindChildren<QtLocalePropertyManager *>(manager);
+ QListIterator<QtLocalePropertyManager *> itLocale(localePropertyManagers);
+ while (itLocale.hasNext())
+ d_ptr->m_comboBoxFactory->removePropertyManager(itLocale.next()->subEnumPropertyManager());
+
+ QList<QtPointPropertyManager *> pointPropertyManagers = qFindChildren<QtPointPropertyManager *>(manager);
+ QListIterator<QtPointPropertyManager *> itPoint(pointPropertyManagers);
+ while (itPoint.hasNext())
+ d_ptr->m_spinBoxFactory->removePropertyManager(itPoint.next()->subIntPropertyManager());
+
+ QList<QtPointFPropertyManager *> pointFPropertyManagers = qFindChildren<QtPointFPropertyManager *>(manager);
+ QListIterator<QtPointFPropertyManager *> itPointF(pointFPropertyManagers);
+ while (itPointF.hasNext())
+ d_ptr->m_doubleSpinBoxFactory->removePropertyManager(itPointF.next()->subDoublePropertyManager());
+
+ QList<QtSizePropertyManager *> sizePropertyManagers = qFindChildren<QtSizePropertyManager *>(manager);
+ QListIterator<QtSizePropertyManager *> itSize(sizePropertyManagers);
+ while (itSize.hasNext())
+ d_ptr->m_spinBoxFactory->removePropertyManager(itSize.next()->subIntPropertyManager());
+
+ QList<QtSizeFPropertyManager *> sizeFPropertyManagers = qFindChildren<QtSizeFPropertyManager *>(manager);
+ QListIterator<QtSizeFPropertyManager *> itSizeF(sizeFPropertyManagers);
+ while (itSizeF.hasNext())
+ d_ptr->m_doubleSpinBoxFactory->removePropertyManager(itSizeF.next()->subDoublePropertyManager());
+
+ QList<QtRectPropertyManager *> rectPropertyManagers = qFindChildren<QtRectPropertyManager *>(manager);
+ QListIterator<QtRectPropertyManager *> itRect(rectPropertyManagers);
+ while (itRect.hasNext())
+ d_ptr->m_spinBoxFactory->removePropertyManager(itRect.next()->subIntPropertyManager());
+
+ QList<QtRectFPropertyManager *> rectFPropertyManagers = qFindChildren<QtRectFPropertyManager *>(manager);
+ QListIterator<QtRectFPropertyManager *> itRectF(rectFPropertyManagers);
+ while (itRectF.hasNext())
+ d_ptr->m_doubleSpinBoxFactory->removePropertyManager(itRectF.next()->subDoublePropertyManager());
+
+ QList<QtColorPropertyManager *> colorPropertyManagers = qFindChildren<QtColorPropertyManager *>(manager);
+ QListIterator<QtColorPropertyManager *> itColor(colorPropertyManagers);
+ while (itColor.hasNext()) {
+ QtColorPropertyManager *manager = itColor.next();
+ d_ptr->m_colorEditorFactory->removePropertyManager(manager);
+ d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
+ }
+
+ QList<QtEnumPropertyManager *> enumPropertyManagers = qFindChildren<QtEnumPropertyManager *>(manager);
+ QListIterator<QtEnumPropertyManager *> itEnum(enumPropertyManagers);
+ while (itEnum.hasNext())
+ d_ptr->m_comboBoxFactory->removePropertyManager(itEnum.next());
+
+ QList<QtSizePolicyPropertyManager *> sizePolicyPropertyManagers = qFindChildren<QtSizePolicyPropertyManager *>(manager);
+ QListIterator<QtSizePolicyPropertyManager *> itSizePolicy(sizePolicyPropertyManagers);
+ while (itSizePolicy.hasNext()) {
+ QtSizePolicyPropertyManager *manager = itSizePolicy.next();
+ d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
+ d_ptr->m_comboBoxFactory->removePropertyManager(manager->subEnumPropertyManager());
+ }
+
+ QList<QtFontPropertyManager *> fontPropertyManagers = qFindChildren<QtFontPropertyManager *>(manager);
+ QListIterator<QtFontPropertyManager *> itFont(fontPropertyManagers);
+ while (itFont.hasNext()) {
+ QtFontPropertyManager *manager = itFont.next();
+ d_ptr->m_fontEditorFactory->removePropertyManager(manager);
+ d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
+ d_ptr->m_comboBoxFactory->removePropertyManager(manager->subEnumPropertyManager());
+ d_ptr->m_checkBoxFactory->removePropertyManager(manager->subBoolPropertyManager());
+ }
+
+ QList<QtCursorPropertyManager *> cursorPropertyManagers = qFindChildren<QtCursorPropertyManager *>(manager);
+ QListIterator<QtCursorPropertyManager *> itCursor(cursorPropertyManagers);
+ while (itCursor.hasNext())
+ d_ptr->m_cursorEditorFactory->removePropertyManager(itCursor.next());
+
+ QList<QtFlagPropertyManager *> flagPropertyManagers = qFindChildren<QtFlagPropertyManager *>(manager);
+ QListIterator<QtFlagPropertyManager *> itFlag(flagPropertyManagers);
+ while (itFlag.hasNext())
+ d_ptr->m_checkBoxFactory->removePropertyManager(itFlag.next()->subBoolPropertyManager());
+}
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+#include "moc_qtvariantproperty.cpp"
diff --git a/GUI/coregui/qttools/qtpropertybrowser/qtvariantproperty.h b/GUI/coregui/qttools/qtpropertybrowser/qtvariantproperty.h
new file mode 100644
index 0000000000000000000000000000000000000000..41b28a6136a2bd1eae49918d9ed5c0ea289bc94f
--- /dev/null
+++ b/GUI/coregui/qttools/qtpropertybrowser/qtvariantproperty.h
@@ -0,0 +1,187 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+** of its contributors may be used to endorse or promote products derived
+** from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QTVARIANTPROPERTY_H
+#define QTVARIANTPROPERTY_H
+
+#include "qtpropertybrowser.h"
+#include <QVariant>
+#include <QIcon>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+typedef QMap<int, QIcon> QtIconMap;
+
+class QtVariantPropertyManager;
+class QtVariantPropertyPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtVariantProperty : public QtProperty
+{
+public:
+ ~QtVariantProperty();
+ QVariant value() const;
+ QVariant attributeValue(const QString &attribute) const;
+ int valueType() const;
+ int propertyType() const;
+
+ void setValue(const QVariant &value);
+ void setAttribute(const QString &attribute, const QVariant &value);
+protected:
+ QtVariantProperty(QtVariantPropertyManager *manager);
+private:
+ friend class QtVariantPropertyManager;
+ QtVariantPropertyPrivate *d_ptr;
+};
+
+class QtVariantPropertyManagerPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtVariantPropertyManager : public QtAbstractPropertyManager
+{
+ Q_OBJECT
+public:
+ QtVariantPropertyManager(QObject *parent = 0);
+ ~QtVariantPropertyManager();
+
+ virtual QtVariantProperty *addProperty(int propertyType, const QString &name = QString());
+
+ int propertyType(const QtProperty *property) const;
+ int valueType(const QtProperty *property) const;
+ QtVariantProperty *variantProperty(const QtProperty *property) const;
+
+ virtual bool isPropertyTypeSupported(int propertyType) const;
+ virtual int valueType(int propertyType) const;
+ virtual QStringList attributes(int propertyType) const;
+ virtual int attributeType(int propertyType, const QString &attribute) const;
+
+ virtual QVariant value(const QtProperty *property) const;
+ virtual QVariant attributeValue(const QtProperty *property, const QString &attribute) const;
+
+ static int enumTypeId();
+ static int flagTypeId();
+ static int groupTypeId();
+ static int iconMapTypeId();
+public Q_SLOTS:
+ virtual void setValue(QtProperty *property, const QVariant &val);
+ virtual void setAttribute(QtProperty *property,
+ const QString &attribute, const QVariant &value);
+Q_SIGNALS:
+ void valueChanged(QtProperty *property, const QVariant &val);
+ void attributeChanged(QtProperty *property,
+ const QString &attribute, const QVariant &val);
+protected:
+ virtual bool hasValue(const QtProperty *property) const;
+ QString valueText(const QtProperty *property) const;
+ QIcon valueIcon(const QtProperty *property) const;
+ virtual void initializeProperty(QtProperty *property);
+ virtual void uninitializeProperty(QtProperty *property);
+ virtual QtProperty *createProperty();
+private:
+ QtVariantPropertyManagerPrivate *d_ptr;
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))
+ Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, double))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, double, double))
+ Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, double))
+ Q_PRIVATE_SLOT(d_func(), void slotDecimalsChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, bool))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QString &))
+ Q_PRIVATE_SLOT(d_func(), void slotRegExpChanged(QtProperty *, const QRegExp &))
+ Q_PRIVATE_SLOT(d_func(), void slotEchoModeChanged(QtProperty *, int))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QDate &))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, const QDate &, const QDate &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QTime &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QDateTime &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QKeySequence &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QChar &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QLocale &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QPoint &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QPointF &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QSize &))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, const QSize &, const QSize &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QSizeF &))
+ Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, const QSizeF &, const QSizeF &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QRect &))
+ Q_PRIVATE_SLOT(d_func(), void slotConstraintChanged(QtProperty *, const QRect &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QRectF &))
+ Q_PRIVATE_SLOT(d_func(), void slotConstraintChanged(QtProperty *, const QRectF &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QColor &))
+ Q_PRIVATE_SLOT(d_func(), void slotEnumNamesChanged(QtProperty *, const QStringList &))
+ Q_PRIVATE_SLOT(d_func(), void slotEnumIconsChanged(QtProperty *, const QMap<int, QIcon> &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QSizePolicy &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QFont &))
+ Q_PRIVATE_SLOT(d_func(), void slotValueChanged(QtProperty *, const QCursor &))
+ Q_PRIVATE_SLOT(d_func(), void slotFlagNamesChanged(QtProperty *, const QStringList &))
+ Q_PRIVATE_SLOT(d_func(), void slotReadOnlyChanged(QtProperty *, bool))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *))
+ Q_PRIVATE_SLOT(d_func(), void slotPropertyRemoved(QtProperty *, QtProperty *))
+ Q_DECLARE_PRIVATE(QtVariantPropertyManager)
+ Q_DISABLE_COPY(QtVariantPropertyManager)
+};
+
+class QtVariantEditorFactoryPrivate;
+
+class QT_QTPROPERTYBROWSER_EXPORT QtVariantEditorFactory : public QtAbstractEditorFactory<QtVariantPropertyManager>
+{
+ Q_OBJECT
+public:
+ QtVariantEditorFactory(QObject *parent = 0);
+ ~QtVariantEditorFactory();
+protected:
+ void connectPropertyManager(QtVariantPropertyManager *manager);
+ QWidget *createEditor(QtVariantPropertyManager *manager, QtProperty *property,
+ QWidget *parent);
+ void disconnectPropertyManager(QtVariantPropertyManager *manager);
+private:
+ QtVariantEditorFactoryPrivate *d_ptr;
+ Q_DECLARE_PRIVATE(QtVariantEditorFactory)
+ Q_DISABLE_COPY(QtVariantEditorFactory)
+};
+
+#if QT_VERSION >= 0x040400
+QT_END_NAMESPACE
+#endif
+
+Q_DECLARE_METATYPE(QIcon)
+Q_DECLARE_METATYPE(QtIconMap)
+#endif