diff --git a/code/CMakeModules/nel.cmake b/code/CMakeModules/nel.cmake
index d2a5cb014..14a78d721 100644
--- a/code/CMakeModules/nel.cmake
+++ b/code/CMakeModules/nel.cmake
@@ -529,8 +529,8 @@ MACRO(SETUP_EXTERNAL)
         SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
       ELSE(WITH_STATIC_EXTERNAL)
         SET(CMAKE_FIND_LIBRARY_SUFFIXES ".so")
-      ENDIF(WITH_STATIC_EXTERNAL AND NOT APPLE)
-    ENDIF(CMAKE_FIND_LIBRARY_SUFFIXES)
+      ENDIF(WITH_STATIC_EXTERNAL)
+    ENDIF(CMAKE_FIND_LIBRARY_SUFFIXES AND NOT APPLE)
   ENDIF(WIN32)
 
   IF(WITH_STLPORT)
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/CMakeLists.txt b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/CMakeLists.txt
new file mode 100644
index 000000000..2caaa1be7
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/CMakeLists.txt
@@ -0,0 +1 @@
+ADD_SUBDIRECTORY(qtpropertybrowser)
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/CMakeLists.txt b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/CMakeLists.txt
new file mode 100644
index 000000000..8fb0881af
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/CMakeLists.txt
@@ -0,0 +1,89 @@
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR} ${QT_INCLUDES})
+INCLUDE(${QT_USE_FILE})
+
+FILE(GLOB SRC *.cpp *.h)
+
+SET(QT_PROPERTY_EDITOR_HDR	qtpropertybrowser.h
+				qtpropertymanager.h
+				qteditorfactory.h
+				qtvariantproperty.h
+				qttreepropertybrowser.h
+				qtbuttonpropertybrowser.h
+				qtgroupboxpropertybrowser.h
+				qtpropertybrowserutils_p.h)
+
+SET(QT_PROPERTY_EDITOR_RCS	qtpropertybrowser.qrc)
+
+SET(QT_USE_QTGUI TRUE)
+
+QT4_ADD_RESOURCES(QT_PROPERTY_EDITOR_RC_SRCS ${QT_PROPERTY_EDITOR_RCS})
+QT4_WRAP_CPP(QT_PROPERTY_EDITOR_MOC_SRC ${QT_PROPERTY_EDITOR_HDR})
+
+SOURCE_GROUP(QtResources FILES ${QT_PROPERTY_EDITOR_RCS})
+SOURCE_GROUP(QtGeneratedMocSrc FILES ${QT_PROPERTY_EDITOR_MOC_SRC})
+SOURCE_GROUP("Qt Property Editor Source" FILES ${SRC})
+
+qt4_generate_moc(qtpropertymanager.cpp ${CMAKE_CURRENT_BINARY_DIR}/qtpropertymanager.moc)
+qt4_generate_moc(qteditorfactory.cpp ${CMAKE_CURRENT_BINARY_DIR}/qteditorfactory.moc)
+qt4_generate_moc(qttreepropertybrowser.cpp ${CMAKE_CURRENT_BINARY_DIR}/qttreepropertybrowser.moc)
+
+# Need to remove these so that they are not linked as they are inline included.
+LIST(REMOVE_ITEM QT_PROPERTY_EDITOR_MOC_SRC	${CMAKE_CURRENT_BINARY_DIR}/moc_qtbuttonpropertybrowser.cxx
+						${CMAKE_CURRENT_BINARY_DIR}/moc_qteditorfactory.cxx
+						${CMAKE_CURRENT_BINARY_DIR}/moc_qtgroupboxpropertybrowser.cxx
+						${CMAKE_CURRENT_BINARY_DIR}/moc_qtpropertybrowser.cxx
+						${CMAKE_CURRENT_BINARY_DIR}/moc_qtpropertymanager.cxx
+						${CMAKE_CURRENT_BINARY_DIR}/moc_qttreepropertybrowser.cxx
+						${CMAKE_CURRENT_BINARY_DIR}/moc_qtvariantproperty.cxx)
+
+#set(
+#  qtpropertyeditor_HEADERS_ONLY_MOC
+#  ${CMAKE_CURRENT_BINARY_DIR}/moc_qtpropertybrowser.cpp
+#  ${CMAKE_CURRENT_BINARY_DIR}/moc_qtpropertymanager.cpp
+#  ${CMAKE_CURRENT_BINARY_DIR}/moc_qteditorfactory.cpp
+#  ${CMAKE_CURRENT_BINARY_DIR}/moc_qtvariantproperty.cpp
+#  ${CMAKE_CURRENT_BINARY_DIR}/moc_qttreepropertybrowser.cpp
+#  ${CMAKE_CURRENT_BINARY_DIR}/moc_qtbuttonpropertybrowser.cpp
+#  ${CMAKE_CURRENT_BINARY_DIR}/moc_qtgroupboxpropertybrowser.cpp
+#  ${CMAKE_CURRENT_BINARY_DIR}/qtpropertymanager.moc
+#  ${CMAKE_CURRENT_BINARY_DIR}/qteditorfactory.moc
+#  ${CMAKE_CURRENT_BINARY_DIR}/qttreepropertybrowser.moc
+#)
+#
+#set_source_files_properties(
+#  ${qtpropertyeditor_HEADERS_ONLY_MOC}
+#  PROPERTIES
+#    HEADER_FILE_ONLY true
+#)
+#
+
+#set(
+#  qtpropertyeditor_HEADERS_MOC
+#  ${CMAKE_CURRENT_BINARY_DIR}/moc_qtpropertybrowserutils_p.cpp
+#)
+
+#set(
+#  qtpropertyeditor_MOC
+#  ${qtpropertyeditor_HEADERS_MOC}
+#  ${qtpropertyeditor_HEADERS_ONLY_MOC}
+#)
+
+ADD_LIBRARY(qt_property_browser SHARED	${SRC}
+					${QT_PROPERTY_EDITOR_MOC_SRC}
+					${QT_PROPERTY_EDITOR_RC_SRCS}
+					${CMAKE_CURRENT_BINARY_DIR}/qtpropertymanager.moc
+					${CMAKE_CURRENT_BINARY_DIR}/qttreepropertybrowser.moc
+					${CMAKE_CURRENT_BINARY_DIR}/qteditorfactory.moc)
+
+TARGET_LINK_LIBRARIES(qt_property_browser ${QT_LIBRARIES})
+
+ADD_DEFINITIONS(${QT_DEFINITIONS})
+ADD_DEFINITIONS(-DQT_DLL)
+#ADD_DEFINITIONS(-DQT_QTPROPERTYBROWSER_EXPORT)
+ADD_DEFINITIONS(-DQT_PLUGIN)
+#ADD_DEFINITIONS(-DQT_NO_DEBUG)
+ADD_DEFINITIONS(-DQT_SHARED)
+
+NL_DEFAULT_PROPS(qt_property_browser "3rdParty: Qt Property Browser 2.5")
+NL_ADD_RUNTIME_FLAGS(qt_property_browser)
+NL_ADD_LIB_SUFFIX(qt_property_browser)
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LGPL_EXCEPTION.txt b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LGPL_EXCEPTION.txt
new file mode 100644
index 000000000..0b56ff1ef
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LGPL_EXCEPTION.txt
@@ -0,0 +1,10 @@
+Nokia Qt LGPL Exception version 1.0
+
+As a special exception to the GNU Lesser General Public License
+version 2.1, the object code form of a "work that uses the Library"
+may incorporate material from a header file that is part of the
+Library.  You may distribute such object code under terms of your
+choice, provided that the incorporated material (i) does not exceed
+more than 5% of the total size of the Library; and (ii) is limited to
+numerical parameters, data structure layouts, accessors, macros,
+inline functions and templates.
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LICENSE.GPL3 b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LICENSE.GPL3
new file mode 100644
index 000000000..94a9ed024
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LICENSE.GPL3
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LICENSE.LGPL b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LICENSE.LGPL
new file mode 100644
index 000000000..5ab7695ab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/LICENSE.LGPL
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractEditorFactoryBase b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractEditorFactoryBase
new file mode 100644
index 000000000..ab4e7104a
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractEditorFactoryBase
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractPropertyBrowser b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractPropertyBrowser
new file mode 100644
index 000000000..ab4e7104a
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractPropertyBrowser
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractPropertyManager
new file mode 100644
index 000000000..ab4e7104a
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtAbstractPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtBoolPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtBoolPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtBoolPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtBrowserItem b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtBrowserItem
new file mode 100644
index 000000000..ab4e7104a
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtBrowserItem
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtButtonPropertyBrowser b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtButtonPropertyBrowser
new file mode 100644
index 000000000..56e089704
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtButtonPropertyBrowser
@@ -0,0 +1 @@
+#include "qtbuttonpropertybrowser.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCharEditorFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCharEditorFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCharEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCharPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCharPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCharPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCheckBoxFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCheckBoxFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCheckBoxFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtColorEditorFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtColorEditorFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtColorEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtColorPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtColorPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtColorPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCursorEditorFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCursorEditorFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCursorEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCursorPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCursorPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtCursorPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateEditFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateEditFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateEditFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDatePropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDatePropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDatePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateTimeEditFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateTimeEditFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateTimeEditFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateTimePropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateTimePropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDateTimePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDoublePropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDoublePropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDoublePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDoubleSpinBoxFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDoubleSpinBoxFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtDoubleSpinBoxFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtEnumEditorFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtEnumEditorFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtEnumEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtEnumPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtEnumPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtEnumPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFlagPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFlagPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFlagPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFontEditorFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFontEditorFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFontEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFontPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFontPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtFontPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtGroupBoxPropertyBrowser b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtGroupBoxPropertyBrowser
new file mode 100644
index 000000000..27964c080
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtGroupBoxPropertyBrowser
@@ -0,0 +1 @@
+#include "qtgroupboxpropertybrowser.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtGroupPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtGroupPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtGroupPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtIntPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtIntPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtIntPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtKeySequenceEditorFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtKeySequenceEditorFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtKeySequenceEditorFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtKeySequencePropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtKeySequencePropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtKeySequencePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtLineEditFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtLineEditFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtLineEditFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtLocalePropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtLocalePropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtLocalePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtPointFPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtPointFPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtPointFPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtPointPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtPointPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtPointPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtProperty b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtProperty
new file mode 100644
index 000000000..ab4e7104a
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtProperty
@@ -0,0 +1 @@
+#include "qtpropertybrowser.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtRectFPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtRectFPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtRectFPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtRectPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtRectPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtRectPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtScrollBarFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtScrollBarFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtScrollBarFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizeFPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizeFPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizeFPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizePolicyPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizePolicyPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizePolicyPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizePropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizePropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSizePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSliderFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSliderFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSliderFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSpinBoxFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSpinBoxFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtSpinBoxFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtStringPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtStringPropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtStringPropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTimeEditFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTimeEditFactory
new file mode 100644
index 000000000..75f35adab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTimeEditFactory
@@ -0,0 +1 @@
+#include "qteditorfactory.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTimePropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTimePropertyManager
new file mode 100644
index 000000000..1842e431d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTimePropertyManager
@@ -0,0 +1 @@
+#include "qtpropertymanager.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTreePropertyBrowser b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTreePropertyBrowser
new file mode 100644
index 000000000..aab106c75
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtTreePropertyBrowser
@@ -0,0 +1 @@
+#include "qttreepropertybrowser.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantEditorFactory b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantEditorFactory
new file mode 100644
index 000000000..8118190d5
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantEditorFactory
@@ -0,0 +1 @@
+#include "qtvariantproperty.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantProperty b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantProperty
new file mode 100644
index 000000000..8118190d5
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantProperty
@@ -0,0 +1 @@
+#include "qtvariantproperty.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantPropertyManager b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantPropertyManager
new file mode 100644
index 000000000..8118190d5
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/QtVariantPropertyManager
@@ -0,0 +1 @@
+#include "qtvariantproperty.h"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/README.TXT b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/README.TXT
new file mode 100644
index 000000000..d9452cfc1
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/README.TXT
@@ -0,0 +1,19 @@
+Property Browser v2.5
+
+A property browser framework enabling the user to edit a set of
+properties.
+
+The framework provides a browser widget that displays the given
+properties with labels and corresponding editing widgets (e.g.
+line edits or comboboxes). The various types of editing widgets
+are provided by the framework's editor factories: For each
+property type, the framework provides a property manager (e.g.
+QtIntPropertyManager and QtStringPropertyManager) which can be
+associated with the preferred editor factory (e.g.
+QtSpinBoxFactory and QtLineEditFactory). The framework also
+provides a variant based property type with corresponding variant
+manager and factory. Finally, the framework provides three
+ready-made implementations of the browser widget:
+QtTreePropertyBrowser, QtButtonPropertyBrowser and
+QtGroupBoxPropertyBrowser.
+
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-arrow.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-arrow.png
new file mode 100644
index 000000000..a69ef4eb6
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-arrow.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-busy.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-busy.png
new file mode 100644
index 000000000..53717e499
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-busy.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-closedhand.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-closedhand.png
new file mode 100644
index 000000000..b78dd1dac
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-closedhand.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-cross.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-cross.png
new file mode 100644
index 000000000..fe38e7448
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-cross.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-forbidden.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-forbidden.png
new file mode 100644
index 000000000..2b08c4e2a
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-forbidden.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-hand.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-hand.png
new file mode 100644
index 000000000..d2004aefa
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-hand.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-hsplit.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-hsplit.png
new file mode 100644
index 000000000..a5667e3ff
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-hsplit.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-ibeam.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-ibeam.png
new file mode 100644
index 000000000..097fc5fa7
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-ibeam.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-openhand.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-openhand.png
new file mode 100644
index 000000000..9181c859e
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-openhand.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeall.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeall.png
new file mode 100644
index 000000000..69f13eb34
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeall.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeb.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeb.png
new file mode 100644
index 000000000..f37d7b91e
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeb.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizef.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizef.png
new file mode 100644
index 000000000..3b127a05d
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizef.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeh.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeh.png
new file mode 100644
index 000000000..a9f40cbc3
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizeh.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizev.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizev.png
new file mode 100644
index 000000000..1edbab27a
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-sizev.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-uparrow.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-uparrow.png
new file mode 100644
index 000000000..d3e70ef4c
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-uparrow.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-vsplit.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-vsplit.png
new file mode 100644
index 000000000..1beda2570
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-vsplit.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-wait.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-wait.png
new file mode 100644
index 000000000..69056c479
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-wait.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-whatsthis.png b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-whatsthis.png
new file mode 100644
index 000000000..b47601c37
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/images/cursor-whatsthis.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtbuttonpropertybrowser.cpp b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtbuttonpropertybrowser.cpp
new file mode 100644
index 000000000..d5ebd4fc2
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtbuttonpropertybrowser.cpp
@@ -0,0 +1,676 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtbuttonpropertybrowser.h"
+#include <QtCore/QSet>
+#include <QtGui/QGridLayout>
+#include <QtGui/QLabel>
+#include <QtCore/QTimer>
+#include <QtCore/QMap>
+#include <QtGui/QToolButton>
+#include <QtGui/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;
+            QWidget *w = 0;
+            QGridLayout *l = 0;
+            const int oldRow = gridRow(parentItem);
+            if (grandParent) {
+                w = grandParent->container;
+                l = grandParent->layout;
+            } else {
+                w = q_ptr;
+                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.cxx"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtbuttonpropertybrowser.h b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtbuttonpropertybrowser.h
new file mode 100644
index 000000000..518e047e8
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtbuttonpropertybrowser.h
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qteditorfactory.cpp b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qteditorfactory.cpp
new file mode 100644
index 000000000..e619cf8cb
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qteditorfactory.cpp
@@ -0,0 +1,2609 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qteditorfactory.h"
+#include "qtpropertybrowserutils_p.h"
+#include <QtGui/QSpinBox>
+#include <QtGui/QScrollBar>
+#include <QtGui/QComboBox>
+#include <QtGui/QAbstractItemView>
+#include <QtGui/QLineEdit>
+#include <QtGui/QDateTimeEdit>
+#include <QtGui/QHBoxLayout>
+#include <QtGui/QMenu>
+#include <QtGui/QKeyEvent>
+#include <QtGui/QApplication>
+#include <QtGui/QLabel>
+#include <QtGui/QToolButton>
+#include <QtGui/QColorDialog>
+#include <QtGui/QFontDialog>
+#include <QtGui/QSpacerItem>
+#include <QtCore/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)
+{
+    Q_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 Q_TYPENAME EditorToPropertyMap::iterator ecend = m_editorToProperty.end();
+    for (Q_TYPENAME EditorToPropertyMap::iterator itEditor = m_editorToProperty.begin(); itEditor !=  ecend; ++itEditor) {
+        if (itEditor.key() == object) {
+            Editor *editor = itEditor.key();
+            QtProperty *property = itEditor.value();
+            const Q_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 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::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)));
+}
+
+/*!
+    \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);
+
+    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)));
+}
+
+// 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 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::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)));
+}
+
+/*!
+    \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(6);
+    editor->setRange(manager->minimum(property), manager->maximum(property));
+    editor->setValue(manager->value(property));
+    editor->setKeyboardTracking(false);
+
+    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)));
+}
+
+// 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 &regExp);
+    void slotSetValue(const QString &value);
+    void slotEditingFinished();
+};
+
+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->setText(value);
+    }
+}
+
+void QtLineEditFactoryPrivate::slotRegExpChanged(QtProperty *property,
+            const QRegExp &regExp)
+{
+    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::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;
+        }
+}
+
+void QtLineEditFactoryPrivate::slotEditingFinished()
+{
+    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;
+            QString value = static_cast<QLineEdit*>(itEditor.key())->text();
+            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 &)));
+}
+
+/*!
+    \internal
+
+    Reimplemented from the QtAbstractEditorFactory class.
+*/
+QWidget *QtLineEditFactory::createEditor(QtStringPropertyManager *manager,
+        QtProperty *property, QWidget *parent)
+{
+
+    QLineEdit *editor = d_ptr->createEditor(property, parent);
+    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(editingFinished()),
+                this, SLOT(slotEditingFinished()));
+    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 &)));
+}
+
+// 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);
+    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);
+}
+
+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->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
+    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);
+
+private Q_SLOTS:
+    void buttonClicked();
+
+Q_SIGNALS:
+    void valueChanged(const QColor &value);
+
+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);
+}
+
+// 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);
+
+private Q_SLOTS:
+    void buttonClicked();
+
+Q_SIGNALS:
+    void valueChanged(const QFont &value);
+
+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);
+}
+
+// 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.cxx"
+#include "qteditorfactory.moc"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qteditorfactory.h b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qteditorfactory.h
new file mode 100644
index 000000000..47e7b507f
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qteditorfactory.h
@@ -0,0 +1,448 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $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 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 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 slotSetValue(const QString &))
+    Q_PRIVATE_SLOT(d_func(), void slotEditingFinished())
+    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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtgroupboxpropertybrowser.cpp b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtgroupboxpropertybrowser.cpp
new file mode 100644
index 000000000..d789c8695
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtgroupboxpropertybrowser.cpp
@@ -0,0 +1,578 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtgroupboxpropertybrowser.h"
+#include <QtCore/QSet>
+#include <QtGui/QGridLayout>
+#include <QtGui/QLabel>
+#include <QtGui/QGroupBox>
+#include <QtCore/QTimer>
+#include <QtCore/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);
+        }
+        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);
+    } 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;
+        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;
+        }
+
+        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->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.cxx"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtgroupboxpropertybrowser.h b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtgroupboxpropertybrowser.h
new file mode 100644
index 000000000..075f3286e
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtgroupboxpropertybrowser.h
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.cpp b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.cpp
new file mode 100644
index 000000000..e8c103d9b
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.cpp
@@ -0,0 +1,2053 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtpropertybrowser.h"
+#include <QtCore/QSet>
+#include <QtCore/QMap>
+#include <QtGui/QIcon>
+
+#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_bold(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;
+	bool m_bold;
+
+    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 is displayed as bold.
+
+    \sa setBold()
+*/
+bool QtProperty::isBold() const
+{
+    return d_ptr->m_bold;
+}
+
+/*!
+    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);
+}
+
+/*!
+    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();
+}
+
+/*!
+    Sets the property's bold state according to the passed \a bold value.
+
+    \sa isBold()
+*/
+void QtProperty::setBold(bool bold)
+{
+    if (d_ptr->m_bold == bold)
+        return;
+
+    d_ptr->m_bold = bold;
+    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();
+}
+
+/*!
+    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;
+    QtProperty *properAfterProperty = 0;
+    while (pos < pendingList.count()) {
+        QtProperty *prop = pendingList.at(pos);
+        if (prop == property)
+            return 0;
+        if (prop == afterProperty) {
+            newPos = pos + 1;
+            properAfterProperty = afterProperty;
+        }
+        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.cxx"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.h b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.h
new file mode 100644
index 000000000..35b7ac0f8
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.h
@@ -0,0 +1,379 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTPROPERTYBROWSER_H
+#define QTPROPERTYBROWSER_H
+
+#include <QtGui/QWidget>
+#include <QtCore/QSet>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+#if defined(Q_WS_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
+
+
+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 isBold() const;
+
+    bool hasValue() const;
+    QIcon valueIcon() const;
+    QString valueText() 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 setBold(bool bold);
+
+    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 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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.pri b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.pri
new file mode 100644
index 000000000..6a6050c75
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.pri
@@ -0,0 +1,30 @@
+include(../common.pri)
+INCLUDEPATH += $$PWD
+DEPENDPATH += $$PWD
+
+qtpropertybrowser-uselib:!qtpropertybrowser-buildlib {
+    LIBS += -L$$QTPROPERTYBROWSER_LIBDIR -l$$QTPROPERTYBROWSER_LIBNAME
+} else {
+    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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.qrc b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.qrc
new file mode 100644
index 000000000..4f91ab782
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowser.qrc
@@ -0,0 +1,23 @@
+<RCC version="1.0">
+    <qresource prefix="/trolltech/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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowserutils.cpp b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowserutils.cpp
new file mode 100644
index 000000000..ce198bfca
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowserutils.cpp
@@ -0,0 +1,477 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtpropertybrowserutils_p.h"
+#include <QtGui/QApplication>
+#include <QtGui/QPainter>
+#include <QtGui/QHBoxLayout>
+#include <QtGui/QMouseEvent>
+#include <QtGui/QCheckBox>
+#include <QtGui/QLineEdit>
+#include <QtGui/QMenu>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+QtCursorDatabase::QtCursorDatabase()
+{
+    appendCursor(Qt::ArrowCursor, QApplication::translate("QtCursorDatabase", "Arrow", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-arrow.png")));
+    appendCursor(Qt::UpArrowCursor, QApplication::translate("QtCursorDatabase", "Up Arrow", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-uparrow.png")));
+    appendCursor(Qt::CrossCursor, QApplication::translate("QtCursorDatabase", "Cross", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-cross.png")));
+    appendCursor(Qt::WaitCursor, QApplication::translate("QtCursorDatabase", "Wait", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-wait.png")));
+    appendCursor(Qt::IBeamCursor, QApplication::translate("QtCursorDatabase", "IBeam", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-ibeam.png")));
+    appendCursor(Qt::SizeVerCursor, QApplication::translate("QtCursorDatabase", "Size Vertical", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-sizev.png")));
+    appendCursor(Qt::SizeHorCursor, QApplication::translate("QtCursorDatabase", "Size Horizontal", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-sizeh.png")));
+    appendCursor(Qt::SizeFDiagCursor, QApplication::translate("QtCursorDatabase", "Size Backslash", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-sizef.png")));
+    appendCursor(Qt::SizeBDiagCursor, QApplication::translate("QtCursorDatabase", "Size Slash", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-sizeb.png")));
+    appendCursor(Qt::SizeAllCursor, QApplication::translate("QtCursorDatabase", "Size All", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-sizeall.png")));
+    appendCursor(Qt::BlankCursor, QApplication::translate("QtCursorDatabase", "Blank", 0,
+                        QApplication::UnicodeUTF8), QIcon());
+    appendCursor(Qt::SplitVCursor, QApplication::translate("QtCursorDatabase", "Split Vertical", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-vsplit.png")));
+    appendCursor(Qt::SplitHCursor, QApplication::translate("QtCursorDatabase", "Split Horizontal", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-hsplit.png")));
+    appendCursor(Qt::PointingHandCursor, QApplication::translate("QtCursorDatabase", "Pointing Hand", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-hand.png")));
+    appendCursor(Qt::ForbiddenCursor, QApplication::translate("QtCursorDatabase", "Forbidden", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-forbidden.png")));
+    appendCursor(Qt::OpenHandCursor, QApplication::translate("QtCursorDatabase", "Open Hand", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-openhand.png")));
+    appendCursor(Qt::ClosedHandCursor, QApplication::translate("QtCursorDatabase", "Closed Hand", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-closedhand.png")));
+    appendCursor(Qt::WhatsThisCursor, QApplication::translate("QtCursorDatabase", "What's This", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-whatsthis.png")));
+    appendCursor(Qt::BusyCursor, QApplication::translate("QtCursorDatabase", "Busy", 0,
+                        QApplication::UnicodeUTF8), QIcon(QLatin1String(":/trolltech/qtpropertybrowser/images/cursor-busy.png")));
+}
+
+void QtCursorDatabase::appendCursor(Qt::CursorShape shape, const QString &name, const QIcon &icon)
+{
+    if (m_cursorShapeToValue.contains(shape))
+        return;
+    int value = m_cursorNames.count();
+    m_cursorNames.append(name);
+    m_cursorIcons[value] = icon;
+    m_valueToCursorShape[value] = shape;
+    m_cursorShapeToValue[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 QApplication::translate("QtPropertyBrowserUtils", "[%1, %2, %3] (%4)", 0, QApplication::UnicodeUTF8)
+                                  .arg(QString::number(c.red()))
+                                  .arg(QString::number(c.green()))
+                                  .arg(QString::number(c.blue()))
+                                  .arg(QString::number(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 QApplication::translate("QtPropertyBrowserUtils", "[%1, %2]", 0, QApplication::UnicodeUTF8)
+                                  .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(QString());
+}
+
+void QtBoolEdit::setTextVisible(bool textVisible)
+{
+    if (m_textVisible == textVisible)
+        return;
+
+    m_textVisible = textVisible;
+    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(QString());
+}
+
+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);
+    }
+}
+
+
+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);
+}
+
+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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowserutils_p.h b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowserutils_p.h
new file mode 100644
index 000000000..dca4b8c37
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertybrowserutils_p.h
@@ -0,0 +1,207 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $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 <QtCore/QMap>
+#include <QtGui/QIcon>
+#include <QtGui/QWidget>
+#include <QtCore/QStringList>
+
+#if QT_VERSION >= 0x040400
+QT_BEGIN_NAMESPACE
+#endif
+
+class QMouseEvent;
+class QCheckBox;
+class QLineEdit;
+
+class QtCursorDatabase
+{
+public:
+    QtCursorDatabase();
+
+    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);
+
+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);
+    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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertymanager.cpp b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertymanager.cpp
new file mode 100644
index 000000000..20de19786
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertymanager.cpp
@@ -0,0 +1,6465 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtpropertymanager.h"
+#include "qtpropertybrowserutils_p.h"
+#include <QtCore/QDateTime>
+#include <QtCore/QLocale>
+#include <QtCore/QMap>
+#include <QtCore/QTimer>
+#include <QtGui/QIcon>
+#include <QtCore/QMetaEnum>
+#include <QtGui/QFontDatabase>
+#include <QtGui/QStyleOption>
+#include <QtGui/QStyle>
+#include <QtGui/QApplication>
+#include <QtGui/QPainter>
+#include <QtGui/QLabel>
+
+#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 Q_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 Q_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 Q_TYPENAME PropertyManagerPrivate::Data PrivateData;
+    typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+    typedef Q_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 Q_TYPENAME PropertyManagerPrivate::Data PrivateData;
+    typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+    typedef Q_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 Q_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) {}
+        int val;
+        int minVal;
+        int maxVal;
+        int singleStep;
+        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);
+}
+
+/*!
+    \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);
+}
+
+/*!
+    \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) {}
+        double val;
+        double minVal;
+        double maxVal;
+        double singleStep;
+        int decimals;
+        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);
+}
+
+/*!
+    \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 QString("%1").arg(it.value().val);
+}
+
+/*!
+    \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);
+}
+
+/*!
+    \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)
+        {
+        }
+        QString val;
+        QRegExp regExp;
+    };
+
+    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 &regExp)
+
+    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
+*/
+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;
+}
+
+/*!
+    \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 &regExp)
+{
+    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);
+}
+
+/*!
+    \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
+
+class QtBoolPropertyManagerPrivate
+{
+    QtBoolPropertyManager *q_ptr;
+    Q_DECLARE_PUBLIC(QtBoolPropertyManager)
+public:
+
+    QMap<const QtProperty *, bool> m_values;
+};
+
+/*!
+    \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
+{
+    return QString();
+}
+
+// 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);
+}
+
+/*!
+    \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();
+
+    static const QIcon checkedIcon = drawCheckBox(true);
+    static const QIcon uncheckedIcon = drawCheckBox(false);
+    return it.value() ? checkedIcon : 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
+
+Q_GLOBAL_STATIC(QtCursorDatabase, cursorDatabase)
+
+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.cxx"
+#include "qtpropertymanager.moc"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertymanager.h b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertymanager.h
new file mode 100644
index 000000000..709f2abf7
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtpropertymanager.h
@@ -0,0 +1,796 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTPROPERTYMANAGER_H
+#define QTPROPERTYMANAGER_H
+
+#include "qtpropertybrowser.h"
+
+#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;
+
+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);
+Q_SIGNALS:
+    void valueChanged(QtProperty *property, int val);
+    void rangeChanged(QtProperty *property, int minVal, int maxVal);
+    void singleStepChanged(QtProperty *property, int step);
+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;
+
+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);
+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);
+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;
+
+public Q_SLOTS:
+    void setValue(QtProperty *property, const QString &val);
+    void setRegExp(QtProperty *property, const QRegExp &regExp);
+Q_SIGNALS:
+    void valueChanged(QtProperty *property, const QString &val);
+    void regExpChanged(QtProperty *property, const QRegExp &regExp);
+protected:
+    QString valueText(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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qttreepropertybrowser.cpp b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qttreepropertybrowser.cpp
new file mode 100644
index 000000000..eb9b37515
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qttreepropertybrowser.cpp
@@ -0,0 +1,1095 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qttreepropertybrowser.h"
+#include <QtCore/QSet>
+#include <QtGui/QIcon>
+#include <QtGui/QTreeWidget>
+#include <QtGui/QItemDelegate>
+#include <QtGui/QHBoxLayout>
+#include <QtGui/QHeaderView>
+#include <QtGui/QPainter>
+#include <QtGui/QApplication>
+#include <QtGui/QFocusEvent>
+#include <QtGui/QStyle>
+#include <QtGui/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();
+			opt.font.setBold(property->isBold());
+		}
+    }
+    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)
+        {}
+
+    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; }
+
+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;
+};
+
+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;
+    QItemDelegate::paint(painter, opt, index);
+
+    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();
+}
+
+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);
+
+    m_treeWidget->setColumnCount(2);
+    QStringList labels;
+    labels.append(QApplication::translate("QtTreePropertyBrowser", "Property", 0, QApplication::UnicodeUTF8));
+    labels.append(QApplication::translate("QtTreePropertyBrowser", "Value", 0, QApplication::UnicodeUTF8));
+    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->valueText();
+        item->setToolTip(1, toolTip);
+        item->setIcon(1, property->valueIcon());
+        item->setText(1, property->valueText());
+    } 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.cxx"
+#include "qttreepropertybrowser.moc"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qttreepropertybrowser.h b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qttreepropertybrowser.h
new file mode 100644
index 000000000..f664609d7
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qttreepropertybrowser.h
@@ -0,0 +1,184 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $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/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtvariantproperty.cpp b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtvariantproperty.cpp
new file mode 100644
index 000000000..820e6e2f1
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtvariantproperty.cpp
@@ -0,0 +1,2329 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtvariantproperty.h"
+#include "qtpropertymanager.h"
+#include "qteditorfactory.h"
+#include <QtCore/QVariant>
+#include <QtGui/QIcon>
+#include <QtCore/QDate>
+#include <QtCore/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 &regExp);
+    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 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;
+};
+
+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"))
+{
+}
+
+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 &regExp)
+{
+    if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))
+        emit q_ptr->attributeChanged(varProp, m_regExpAttribute, QVariant(regExp));
+}
+
+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 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_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_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;
+    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 &)));
+    // 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)) {
+        return keySequenceManager->value(internProp);
+    } 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);
+        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);
+        return QVariant();
+    } else if (QtStringPropertyManager *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
+        if (attribute == d_ptr->m_regExpAttribute)
+            return stringManager->regExp(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));
+        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));
+        return;
+    } else if (QtStringPropertyManager *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
+        if (attribute == d_ptr->m_regExpAttribute)
+            stringManager->setRegExp(internProp, qVariantValue<QRegExp>(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->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.cxx"
diff --git a/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtvariantproperty.h b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtvariantproperty.h
new file mode 100644
index 000000000..9f20d3dd4
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/3rdparty/qtpropertybrowser/qtvariantproperty.h
@@ -0,0 +1,232 @@
+/****************************************************************************
+**
+** This file is part of a Qt Solutions component.
+** 
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** 
+** Contact:  Qt Software Information (qt-info@nokia.com)
+** 
+** Commercial Usage  
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Solutions Commercial License Agreement provided
+** with the Software or, alternatively, in accordance with the terms
+** contained in a written agreement between you and Nokia.
+** 
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** 
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 
+** GNU General Public License Usage 
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+** 
+** Please note Third Party Software included with Qt Solutions may impose
+** additional restrictions and it is the user's responsibility to ensure
+** that they have met the licensing requirements of the GPL, LGPL, or Qt
+** Solutions Commercial license and the relevant license of the Third
+** Party Software they are using.
+** 
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** 
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTVARIANTPROPERTY_H
+#define QTVARIANTPROPERTY_H
+
+#include "qtpropertybrowser.h"
+#include <QtCore/QVariant>
+#include <QtGui/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 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 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
diff --git a/code/nel/tools/3d/object_viewer_qt/src/CMakeLists.txt b/code/nel/tools/3d/object_viewer_qt/src/CMakeLists.txt
index 3cbe745af..7dc1445bb 100644
--- a/code/nel/tools/3d/object_viewer_qt/src/CMakeLists.txt
+++ b/code/nel/tools/3d/object_viewer_qt/src/CMakeLists.txt
@@ -1,3 +1,5 @@
+ADD_SUBDIRECTORY(3rdparty)
+
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR} ${LIBXML2_INCLUDE_DIR} ${NEL_INCLUDE_DIR} ${QT_INCLUDES})
 INCLUDE( ${QT_USE_FILE} )
 
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/CMakeLists.txt b/code/nel/tools/3d/object_viewer_qt/src/plugins/CMakeLists.txt
index 880f49c74..8e0a89e22 100644
--- a/code/nel/tools/3d/object_viewer_qt/src/plugins/CMakeLists.txt
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/CMakeLists.txt
@@ -1,10 +1,15 @@
-ADD_SUBDIRECTORY(core)
-ADD_SUBDIRECTORY(example)
-ADD_SUBDIRECTORY(ovqt_sheet_builder)
+ADD_SUBDIRECTORY(core)
+ADD_SUBDIRECTORY(example)
+ADD_SUBDIRECTORY(ovqt_sheet_builder)
 ADD_SUBDIRECTORY(landscape_editor)
-ADD_SUBDIRECTORY(log)
-ADD_SUBDIRECTORY(disp_sheet_id)
-ADD_SUBDIRECTORY(object_viewer)
-ADD_SUBDIRECTORY(zone_painter)
-ADD_SUBDIRECTORY(georges_editor)
-ADD_SUBDIRECTORY(world_editor)
\ No newline at end of file
+ADD_SUBDIRECTORY(log)
+ADD_SUBDIRECTORY(disp_sheet_id)
+ADD_SUBDIRECTORY(object_viewer)
+ADD_SUBDIRECTORY(zone_painter)
+ADD_SUBDIRECTORY(georges_editor)
+
+ADD_SUBDIRECTORY(world_editor)
+# Ryzom Specific Plugins
+IF(WITH_RYZOM AND WITH_RYZOM_TOOLS)
+  ADD_SUBDIRECTORY(mission_compiler)
+ENDIF(WITH_RYZOM AND WITH_RYZOM_TOOLS)
\ No newline at end of file
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/core/core_constants.h b/code/nel/tools/3d/object_viewer_qt/src/plugins/core/core_constants.h
index be6e666a7..65327ae38 100644
--- a/code/nel/tools/3d/object_viewer_qt/src/plugins/core/core_constants.h
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/core/core_constants.h
@@ -92,6 +92,8 @@ const char * const SEARCH_PATHS = "SearchPaths";
 const char * const RECURSIVE_SEARCH_PATHS = "RecursiveSearchPathes";
 const char * const LEVELDESIGN_PATH = "LevelDesignPath";
 const char * const ASSETS_PATH = "AssetsPath";
+const char * const PRIMITIVES_PATH = "PrimitivesPath";
+const char * const LIGOCONFIG_FILE = "LigoConfigFile";
 const char * const REMAP_EXTENSIONS = "RemapExtensions";
 
 const char * const LOG_SECTION = "LogSettings";
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.cpp b/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.cpp
index 51da80f67..a050f4789 100644
--- a/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.cpp
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.cpp
@@ -82,6 +82,15 @@ void GeneralSettingsPage::applyGeneralSettings()
 	else
 		QApplication::setPalette(m_originalPalette);
 	settings->endGroup();
+
+	// Add primitives path and ligo config file to CPath
+	settings->beginGroup(Core::Constants::DATA_PATH_SECTION);
+	QString primitivePath = settings->value(Core::Constants::PRIMITIVES_PATH, "l:/primitives").toString();
+	QString ligoConfigFile = settings->value(Core::Constants::LIGOCONFIG_FILE, "l:/leveldesign/world_editor_files/world_editor_classes.xml").toString();
+	NLMISC::CPath::addSearchPath(primitivePath.toStdString(), true, false);
+	NLMISC::CPath::display();
+	NLMISC::CPath::addSearchFile(ligoConfigFile.toStdString());
+	settings->endGroup();
 }
 
 QWidget *GeneralSettingsPage::createPage(QWidget *parent)
@@ -94,6 +103,8 @@ QWidget *GeneralSettingsPage::createPage(QWidget *parent)
 	connect(m_ui.pluginsPathButton, SIGNAL(clicked()), this, SLOT(setPluginsPath()));
 	connect(m_ui.leveldesignPathButton, SIGNAL(clicked()), this, SLOT(setLevelDesignPath()));
 	connect(m_ui.assetsPathButton, SIGNAL(clicked()), this, SLOT(setAssetsPath()));
+	connect(m_ui.primitivesPathButton, SIGNAL(clicked()), this, SLOT(setPrimitivesPath()));
+	connect(m_ui.ligoConfigFileButton, SIGNAL(clicked()), this, SLOT(setLigoConfigFile()));
 	return m_page;
 }
 
@@ -135,6 +146,27 @@ void GeneralSettingsPage::setLevelDesignPath()
 	}
 }
 
+void GeneralSettingsPage::setPrimitivesPath()
+{
+	QString newPath = QFileDialog::getExistingDirectory(0, tr("Set the primitives path"),
+					  m_ui.primitivesPathLineEdit->text());
+	if (!newPath.isEmpty())
+	{
+		m_ui.primitivesPathLineEdit->setText(newPath);
+	}
+}
+
+void GeneralSettingsPage::setLigoConfigFile()
+{
+	QString newFile = QFileDialog::getOpenFileName(0, tr("Set the ligo config file"), 
+		m_ui.ligoConfigFileLineEdit->text());
+	if (!newFile.isEmpty())
+	{
+		m_ui.ligoConfigFileLineEdit->setText(newFile);
+	}
+}
+
+
 void GeneralSettingsPage::setAssetsPath()
 {
 	QString newPath = QFileDialog::getExistingDirectory(0, tr("Set the assets path"),
@@ -165,6 +197,8 @@ void GeneralSettingsPage::readSettings()
 	settings->beginGroup(Core::Constants::DATA_PATH_SECTION);
 	m_ui.leveldesignPathLineEdit->setText(settings->value(Core::Constants::LEVELDESIGN_PATH, "l:/leveldesign").toString());
 	m_ui.assetsPathLineEdit->setText(settings->value(Core::Constants::ASSETS_PATH, "w:/database").toString());
+	m_ui.primitivesPathLineEdit->setText(settings->value(Core::Constants::PRIMITIVES_PATH, "l:/primitives").toString());
+	m_ui.ligoConfigFileLineEdit->setText(settings->value(Core::Constants::LIGOCONFIG_FILE, "l:/leveldesign/world_editor_files/world_editor_classes.xml").toString());
 	settings->endGroup();
 }
 
@@ -185,6 +219,8 @@ void GeneralSettingsPage::writeSettings()
 	settings->beginGroup(Core::Constants::DATA_PATH_SECTION);
 	settings->setValue(Core::Constants::LEVELDESIGN_PATH, m_ui.leveldesignPathLineEdit->text());
 	settings->setValue(Core::Constants::ASSETS_PATH, m_ui.assetsPathLineEdit->text());
+	settings->setValue(Core::Constants::PRIMITIVES_PATH, m_ui.primitivesPathLineEdit->text());
+	settings->setValue(Core::Constants::LIGOCONFIG_FILE, m_ui.ligoConfigFileLineEdit->text());
 	settings->endGroup();
 	settings->sync();
 }
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.h b/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.h
index 2fbcb842a..22ab30e45 100644
--- a/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.h
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.h
@@ -57,6 +57,8 @@ private Q_SLOTS:
 	void setPluginsPath();
 	void setLevelDesignPath();
 	void setAssetsPath();
+	void setPrimitivesPath();
+	void setLigoConfigFile();
 
 private:
 	void readSettings();
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.ui b/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.ui
index d2aa042e3..7d40b65df 100644
--- a/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.ui
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/core/general_settings_page.ui
@@ -105,7 +105,7 @@
       <item row="0" column="0">
        <widget class="QLabel" name="pluginsPathLabel">
         <property name="text">
-         <string>Plugins path:</string>
+         <string>Plugins</string>
         </property>
        </widget>
       </item>
@@ -129,7 +129,7 @@
       <item row="1" column="0">
        <widget class="QLabel" name="leveldesignPathLabel">
         <property name="text">
-         <string>Level design path:</string>
+         <string>Sheets</string>
         </property>
        </widget>
       </item>
@@ -153,7 +153,7 @@
       <item row="2" column="0">
        <widget class="QLabel" name="assetsPathLabel">
         <property name="text">
-         <string>Assets path:</string>
+         <string>Assets Database:</string>
         </property>
        </widget>
       </item>
@@ -174,6 +174,40 @@
         </property>
        </widget>
       </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="primitivesPathLabel">
+        <property name="text">
+         <string>Primitives</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QLineEdit" name="primitivesPathLineEdit"/>
+      </item>
+      <item row="3" column="2">
+       <widget class="QToolButton" name="primitivesPathButton">
+        <property name="text">
+         <string>...</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="1">
+       <widget class="QLineEdit" name="ligoConfigFileLineEdit"/>
+      </item>
+      <item row="4" column="0">
+       <widget class="QLabel" name="ligoConfigFileLabel">
+        <property name="text">
+         <string>Ligo Config File</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="2">
+       <widget class="QToolButton" name="ligoConfigFileButton">
+        <property name="text">
+         <string>...</string>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/log/log_plugin.cpp b/code/nel/tools/3d/object_viewer_qt/src/plugins/log/log_plugin.cpp
index f31a63924..4eb02bd31 100644
--- a/code/nel/tools/3d/object_viewer_qt/src/plugins/log/log_plugin.cpp
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/log/log_plugin.cpp
@@ -103,7 +103,7 @@ namespace Plugin
 
 	QString CLogPlugin::name() const
 	{
-		return "NeL Log";
+		return "LogPlugin";
 	}
 
 	QString CLogPlugin::version() const
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/CMakeLists.txt b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/CMakeLists.txt
new file mode 100644
index 000000000..f277a4b14
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/CMakeLists.txt
@@ -0,0 +1,49 @@
+INCLUDE_DIRECTORIES(	${CMAKE_CURRENT_BINARY_DIR}
+						${CMAKE_CURRENT_SOURCE_DIR}
+						${LIBXML2_INCLUDE_DIR}
+						${QT_INCLUDES})
+
+FILE(GLOB SRC *.cpp *.h)
+
+SET(OVQT_EXT_SYS_SRC	${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin.h
+						${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_manager.h
+						${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_spec.h)
+
+SET(OVQT_PLUG_MISSION_COMPILER_HDR 	mission_compiler_plugin.h
+							mission_compiler_main_window.h
+							mission_compiler_settings_page.h
+							server_entry_dialog.h)
+
+SET(OVQT_PLUG_MISSION_COMPILER_UIS	mission_compiler_main_window.ui server_entry_dialog.ui mission_compiler_settings_page.ui)
+
+SET(OVQT_PLUG_MISSION_COMPILER_RCS mission_compiler.qrc)
+
+SET(QT_USE_QTGUI TRUE)
+
+QT4_WRAP_CPP(OVQT_PLUG_MISSION_COMPILER_MOC_SRC ${OVQT_PLUG_MISSION_COMPILER_HDR})
+QT4_ADD_RESOURCES( OVQT_PLUG_MISSION_COMPILER_RC_SRCS ${OVQT_PLUG_MISSION_COMPILER_RCS})
+QT4_WRAP_UI(OVQT_PLUG_MISSION_COMPILER_UI_HDRS ${OVQT_PLUG_MISSION_COMPILER_UIS})
+
+SOURCE_GROUP(QtResources FILES ${OVQT_PLUG_MISSION_COMPILER_UIS} ${OVQT_PLUG_MISSION_COMPILER_RCS})
+SOURCE_GROUP(QtGeneratedUiHdr FILES ${OVQT_PLUG_MISSION_COMPILER_UI_HDRS})
+SOURCE_GROUP(QtGeneratedMocSrc FILES ${OVQT_PLUG_MISSION_COMPILER_MOC_SRC} ${OVQT_PLUG_MISSION_COMPILER_RC_SRCS})
+SOURCE_GROUP("Mission Compiler Plugin" FILES ${SRC})
+SOURCE_GROUP("OVQT Extension System" FILES ${OVQT_EXT_SYS_SRC})
+
+# Mission Compiler Library
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/ryzom/tools/leveldesign/mission_compiler_lib)
+
+# Game Share Library
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/common/src)
+
+ADD_LIBRARY(ovqt_plugin_mission_compiler MODULE ${SRC} ${OVQT_PLUG_MISSION_COMPILER_MOC_SRC} ${OVQT_PLUG_MISSION_COMPILER_RC_SRCS} ${OVQT_EXT_SYS_SRC} ${OVQT_PLUG_MISSION_COMPILER_UI_HDRS})
+
+TARGET_LINK_LIBRARIES(ovqt_plugin_mission_compiler ovqt_plugin_core nelmisc nelligo ryzom_mission_compiler_lib ${QT_LIBRARIES} ${QT_QTOPENGL_LIBRARY})
+
+NL_DEFAULT_PROPS(ovqt_plugin_mission_compiler "NeL, Tools, 3D: Object Viewer Qt Plugin: Mission Compiler")
+NL_ADD_RUNTIME_FLAGS(ovqt_plugin_mission_compiler)
+NL_ADD_LIB_SUFFIX(ovqt_plugin_mission_compiler)
+
+ADD_DEFINITIONS(${LIBXML2_DEFINITIONS} -DQT_PLUGIN -DQT_SHARED ${QT_DEFINITIONS})
+
+INSTALL(TARGETS ovqt_plugin_mission_compiler LIBRARY DESTINATION lib RUNTIME DESTINATION bin ARCHIVE DESTINATION lib COMPONENT tools3d)
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-left-2.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-left-2.png
new file mode 100644
index 000000000..8f153292c
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-left-2.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-left-double-2.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-left-double-2.png
new file mode 100644
index 000000000..8b6d62c7a
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-left-double-2.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-right-2.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-right-2.png
new file mode 100644
index 000000000..d4016e2c7
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-right-2.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-right-double-2.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-right-double-2.png
new file mode 100644
index 000000000..1fe9feb28
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/arrow-right-double-2.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/document-export-4.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/document-export-4.png
new file mode 100644
index 000000000..bc7688858
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/document-export-4.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_add_item.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_add_item.png
new file mode 100644
index 000000000..bde338f78
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_add_item.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_delete_item.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_delete_item.png
new file mode 100644
index 000000000..a5a1787d5
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_delete_item.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_down_item.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_down_item.png
new file mode 100644
index 000000000..fc86c4f6d
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_down_item.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_generic_settings.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_generic_settings.png
new file mode 100644
index 000000000..799bacb28
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_generic_settings.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_reset_all.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_reset_all.png
new file mode 100644
index 000000000..aea193c70
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_reset_all.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_up_item.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_up_item.png
new file mode 100644
index 000000000..ee471023e
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/ic_nel_up_item.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/news-subscribe-2.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/news-subscribe-2.png
new file mode 100644
index 000000000..d5259a76b
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/news-subscribe-2.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/run-build-2.png b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/run-build-2.png
new file mode 100644
index 000000000..5fea6c540
Binary files /dev/null and b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/images/run-build-2.png differ
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler.qrc b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler.qrc
new file mode 100644
index 000000000..eed07d969
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler.qrc
@@ -0,0 +1,17 @@
+<RCC>
+  <qresource prefix="buttons">
+    <file>images/ic_nel_reset_all.png</file>
+    <file>images/ic_nel_add_item.png</file>
+    <file>images/ic_nel_delete_item.png</file>
+    <file>images/ic_nel_down_item.png</file>
+    <file>images/ic_nel_generic_settings.png</file>
+    <file>images/ic_nel_up_item.png</file>
+    <file>images/arrow-left-2.png</file>
+    <file>images/arrow-left-double-2.png</file>
+    <file>images/arrow-right-2.png</file>
+    <file>images/arrow-right-double-2.png</file>
+    <file>images/document-export-4.png</file>
+    <file>images/news-subscribe-2.png</file>
+    <file>images/run-build-2.png</file>
+  </qresource>
+</RCC>
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.cpp b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.cpp
new file mode 100644
index 000000000..bb4e783a7
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.cpp
@@ -0,0 +1,508 @@
+#include "mission_compiler_main_window.h"
+#include "ui_mission_compiler_main_window.h"
+#include "validation_file.h"
+#include "mission_compiler.h"
+#include "mission_compiler_plugin_constants.h"
+
+#include <QMenu>
+#include <QSignalMapper>
+#include <QColor>
+#include <QColorDialog>
+#include <QSettings>
+#include <QTextStream>
+#include <QFileDialog>
+#include <QDirIterator>
+#include <QTableWidget>
+#include <QTableWidgetItem>
+
+#include "../core/icore.h"
+#include "../core/imenu_manager.h"
+#include "../core/core_constants.h"
+
+#include <nel/misc/common.h>
+
+#include <nel/misc/path.h>
+#include <nel/ligo/primitive_utils.h>
+#include <nel/ligo/primitive.h>
+#include <nel/ligo/ligo_config.h>
+
+using namespace MissionCompiler::Constants;
+
+MissionCompilerMainWindow::MissionCompilerMainWindow(QWidget *parent) :
+    QMainWindow(parent),
+    ui(new Ui::MissionCompilerMainWindow)
+{
+    ui->setupUi(this);
+
+	m_lastDir = ".";
+	m_compileLog = "";
+	updateCompileLog();
+
+	// Load the settings.
+	loadConfig();
+
+	m_undoStack = new QUndoStack(this);
+
+	m_regexpFilter = new QRegExp();
+	m_regexpFilter->setPatternSyntax(QRegExp::FixedString);
+	m_regexpFilter->setCaseSensitivity(Qt::CaseInsensitive);
+	
+	m_allPrimitivesModel = new QStringListModel(this);
+	m_filteredProxyModel = new QSortFilterProxyModel(this);
+	m_filteredProxyModel->setSourceModel(m_allPrimitivesModel);
+	m_filteredProxyModel->setDynamicSortFilter(true);
+	m_filteredProxyModel->setFilterRegExp(*m_regexpFilter);
+	ui->allPrimitivesList->setModel(m_filteredProxyModel);
+	m_selectedPrimitivesModel = new QStringListModel(this);
+	ui->selectedPrimitivesList->setModel(m_selectedPrimitivesModel);
+	
+	// Connections for toolbar buttons.
+	connect(ui->actionValidate, SIGNAL(triggered()), this, SLOT(handleValidation()));
+	connect(ui->actionCompile, SIGNAL(triggered()), this, SLOT(handleCompile()));
+	connect(ui->actionPublish, SIGNAL(triggered()), this, SLOT(handlePublish()));
+	
+	// Connections for selected item moves.
+	connect(ui->allPrimitivesList, SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(handleAllDoubleClick(const QModelIndex &)));
+	connect(ui->selectedPrimitivesList, SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(handleSelDoubleClick(const QModelIndex &)));
+	connect(ui->addSelectedButton, SIGNAL(clicked()), this, SLOT(handleMoveSelectedRight()));
+	connect(ui->removeSelectedButton, SIGNAL(clicked()), this, SLOT(handleMoveSelectedLeft()));
+	connect(ui->addAllButton, SIGNAL(clicked()), this, SLOT(handleMoveAllRight()));
+	connect(ui->removeAllButton, SIGNAL(clicked()), this, SLOT(handleMoveAllLeft()));
+
+	// Connections for the filter group box.
+	connect(ui->dataDirButton, SIGNAL(clicked()), this, SLOT(handleDataDirButton()));
+	connect(ui->dataDirEdit, SIGNAL(textChanged(const QString &)), this, SLOT(handleDataDirChanged(const QString &)));
+	connect(ui->filterEdit, SIGNAL(textEdited(const QString&)), this, SLOT(handleFilterChanged(const QString&)));
+	connect(ui->resetFiltersButton, SIGNAL(clicked()), this, SLOT(handleResetFiltersButton()));
+
+	// Connect for settings changes.
+	connect(Core::ICore::instance(), SIGNAL(changeSettings()), this, SLOT(handleChangedSettings()));
+
+	// Set the default data dir to the primitives path.
+	QSettings *settings = Core::ICore::instance()->settings();
+	settings->beginGroup(Core::Constants::DATA_PATH_SECTION);
+	m_lastDir = settings->value(Core::Constants::PRIMITIVES_PATH).toString();
+	ui->dataDirEdit->setText(m_lastDir);
+	populateAllPrimitives(m_lastDir);
+	settings->endGroup();
+
+	NLLIGO::Register();
+	// TODO try/catch exception. Crashes if path invalid.
+	m_ligoConfig.readPrimitiveClass(NLMISC::CPath::lookup("world_editor_classes.xml").c_str(), false);
+	NLLIGO::CPrimitiveContext::instance().CurrentLigoConfig = &m_ligoConfig;
+}
+
+void MissionCompilerMainWindow::populateAllPrimitives(const QString &dataDir)
+{
+	// First we need to clear out the models entirely.
+	QStringList emptyList;
+	m_selectedPrimitivesModel->setStringList(emptyList);
+	m_allPrimitivesModel->setStringList(emptyList);
+
+	
+	// Populate the "all" primitives box.
+	QStringList list;
+	
+	// Filter for only primitive files.
+	QStringList filters;
+	filters << "*.primitive";
+
+	QDirIterator it(dataDir, filters, QDir::Files, QDirIterator::Subdirectories|QDirIterator::FollowSymlinks);
+	while(it.hasNext())
+	{
+		it.next();
+		list <<  it.fileName();
+	}
+
+	m_allPrimitivesModel->setStringList(list);
+}
+
+void MissionCompilerMainWindow::handleResetFiltersButton()
+{
+	handleDataDirChanged(m_lastDir);
+	ui->filterEdit->setText("");
+	handleFilterChanged("");
+}
+
+void MissionCompilerMainWindow::handleDataDirChanged(const QString &text)
+{
+	populateAllPrimitives(text);
+}
+
+void MissionCompilerMainWindow::handleDataDirButton()
+{
+	QString newPath = QFileDialog::getExistingDirectory(this, "", m_lastDir);
+	if(!newPath.isEmpty())
+	{
+		ui->dataDirEdit->setText(newPath);
+		m_lastDir = newPath;
+		populateAllPrimitives(newPath);
+	}
+}
+
+void MissionCompilerMainWindow::handleFilterChanged(const QString &text)
+{
+	m_regexpFilter->setPattern(text);
+	m_filteredProxyModel->setFilterRegExp(*m_regexpFilter);
+}
+
+void MissionCompilerMainWindow::handleCompile()
+{
+	compileMission();
+}
+
+void MissionCompilerMainWindow::handlePublish()
+{
+	compileMission(true);
+}
+
+void MissionCompilerMainWindow::handleMoveSelectedRight()
+{
+	QModelIndexList indexes = ui->allPrimitivesList->selectionModel()->selectedIndexes();
+	while(!indexes.isEmpty())
+	{
+		const QModelIndex index = indexes.takeFirst();
+		moveSelectedItem(index, m_allPrimitivesModel, m_selectedPrimitivesModel);
+		indexes = ui->allPrimitivesList->selectionModel()->selectedIndexes();
+	}
+}
+
+void MissionCompilerMainWindow::handleMoveAllRight()
+{
+	ui->allPrimitivesList->selectAll();
+	handleMoveSelectedRight();
+}
+
+void MissionCompilerMainWindow::handleMoveSelectedLeft()
+{
+	QModelIndexList indexes = ui->selectedPrimitivesList->selectionModel()->selectedIndexes();
+	while(!indexes.isEmpty())
+	{
+		const QModelIndex index = indexes.takeFirst();
+		moveSelectedItem(index, m_selectedPrimitivesModel, m_allPrimitivesModel);
+		indexes = ui->selectedPrimitivesList->selectionModel()->selectedIndexes();
+	}
+}
+
+void MissionCompilerMainWindow::handleMoveAllLeft()
+{
+	ui->selectedPrimitivesList->selectAll();
+	handleMoveSelectedLeft();
+}
+
+void MissionCompilerMainWindow::moveSelectedItem(const QModelIndex &index, QStringListModel *from, QStringListModel *to)
+{
+	QString item = from->data(index, Qt::DisplayRole).toString();
+
+	from->removeRows(index.row(),1);
+	QStringList list = to->stringList();
+	list << item;
+	to->setStringList(list);
+}
+
+void MissionCompilerMainWindow::handleAllDoubleClick(const QModelIndex &index)
+{
+	moveSelectedItem(index, m_allPrimitivesModel, m_selectedPrimitivesModel);
+}
+
+void MissionCompilerMainWindow::handleSelDoubleClick(const QModelIndex &index)
+{
+	moveSelectedItem(index, m_selectedPrimitivesModel, m_allPrimitivesModel);
+}
+
+void MissionCompilerMainWindow::compileMission(bool publish)
+{
+	uint nbMission = 0;
+
+	// First switch toolbox pages to show the compilation output.
+	ui->toolBox->setCurrentIndex(2);
+
+	m_compileLog.append("Begin mission compilation.\n");
+	updateCompileLog();
+
+	// Go through each file.
+	QStringList list = m_selectedPrimitivesModel->stringList();
+	QStringListIterator itr(list);
+	while(itr.hasNext())
+	{
+		QString filename = itr.next();
+		m_compileLog.append("Compiling '"+filename+"'...\n");
+		updateCompileLog();
+
+		NLLIGO::CPrimitives primDoc;
+		NLLIGO::CPrimitiveContext::instance().CurrentPrimitive = &primDoc;
+		NLLIGO::loadXmlPrimitiveFile(primDoc, NLMISC::CPath::lookup(filename.toAscii().data(), false), m_ligoConfig);
+		NLLIGO::CPrimitiveContext::instance().CurrentPrimitive = NULL;
+
+		try
+		{
+			CMissionCompiler mc;
+			mc.compileMissions(primDoc.RootNode, filename.toStdString());
+			m_compileLog.append("Found "+QString::number(mc.getMissionsCount())+" valid missions\n");
+			updateCompileLog();
+
+			mc.installCompiledMission(m_ligoConfig, filename.toStdString());
+			nbMission += mc.getMissionsCount();
+
+			// publish files to selected servers
+			if (publish)
+			{
+				m_compileLog.append("Begin publishing missions...\n");
+				QSettings *settings = Core::ICore::instance()->settings();
+				settings->beginGroup(MISSION_COMPILER_SECTION);
+
+				// Retrieve the local text path.
+				QString localPath = settings->value(SETTING_LOCAL_TEXT_PATH).toString();
+				settings->endGroup();
+				QStringList checkedServers;
+				for(int i = 0; i<ui->publishServersList->count(); i++)
+				{
+
+					// Retrieve each checked server.
+					QListWidgetItem *item = ui->publishServersList->item(i);
+					if(item->checkState() == Qt::Checked)
+						checkedServers << item->text();
+				}
+				
+				Q_FOREACH(QString checkedServer, checkedServers)
+				{
+					m_compileLog.append("Processing publication configuration for '"+checkedServer+"'\n");
+					QStringList items = settings->value(SETTING_SERVERS_TABLE_ITEMS).toStringList();
+					int column = 0;
+					int row = 0;
+					QString servName;
+					QString primPath;
+					QString textPath;
+					Q_FOREACH(QString var, items)
+					{
+						// Check to see if we're starting a new row.
+						if(column > 2)
+						{
+							column = 0;
+							row++;
+						}
+						if(column == 0)
+							servName = var;
+						else if(column == 1)
+							textPath = var;
+						else if(column == 2)
+						{
+							primPath = var;
+
+							m_compileLog.append("Publishing to "+servName+" ...\n");
+							for (uint j=0 ; j<mc.getFileToPublishCount() ; j++)
+							{
+								m_compileLog.append("   "+QString(NLMISC::CFile::getFilename(mc.getFileToPublish(j)).c_str())+"\n");
+							}
+							mc.publishFiles(primPath.toStdString(), textPath.toStdString(), localPath.toStdString());
+						}
+						
+						column++;
+					}
+				}
+				m_compileLog.append("End publishing missions...\n");
+			}
+		}
+		catch(const EParseException &e)
+		{
+
+			if (e.Primitive != NULL)
+				m_compileLog.append("In '"+QString(buildPrimPath(e.Primitive).c_str())+"'\n");
+
+			m_compileLog.append("Error while compiling '"+filename+"' :\n"+QString(e.Why.c_str())+"\n");
+			updateCompileLog();
+			break;
+		}
+	}
+
+	m_compileLog.append("Mission compilation complete.\n");
+	updateCompileLog();
+}
+
+void MissionCompilerMainWindow::handleValidation()
+{
+	// First switch toolbox pages to show the compilation output.
+	ui->toolBox->setCurrentIndex(2);
+
+	m_compileLog.append("Begin mission validation.\n");
+	updateCompileLog();
+
+	// Load existing validation
+	CValidationFile validation;
+	validation.loadMissionValidationFile("mission_validation.cfg");
+
+	// Go through each file.
+	QStringList list = m_selectedPrimitivesModel->stringList();
+	QStringListIterator itr(list);
+	while(itr.hasNext())
+	{
+		QString filename = itr.next();
+		m_compileLog.append("Parsing '"+filename+"'...\n");
+		updateCompileLog();
+
+		TMissionContainer missions;
+		NLLIGO::CPrimitives primDoc;
+		NLLIGO::CPrimitiveContext::instance().CurrentPrimitive = &primDoc;
+		NLLIGO::loadXmlPrimitiveFile(primDoc, NLMISC::CPath::lookup(filename.toAscii().data(), false), m_ligoConfig);
+		parsePrimForMissions(primDoc.RootNode, missions);
+
+		// Parse missions to check modification
+		std::map<std::string, CMission>::iterator itMission, itMissionEnd = missions.end();
+		for (itMission=missions.begin(); itMission!=itMissionEnd; ++itMission)
+		{
+			CValidationFile::TMissionStateContainer::iterator itMissionValidation = validation._MissionStates.find(itMission->first);
+			if (itMissionValidation!=validation._MissionStates.end())
+			{
+				// Mission already registered, check hash key
+				if (itMissionValidation->second.hashKey!=itMission->second.hashKey)
+				{
+					itMissionValidation->second.hashKey = itMission->second.hashKey;
+					itMissionValidation->second.state = validation.defaultState();
+				}
+			}
+			else
+			{
+				// New mission
+				validation.insertMission(itMission->first, itMission->second.hashKey);
+			}
+			m_compileLog.append("Mission: '"+QString(itMission->first.c_str())+"->"+QString(itMission->second.hashKey.c_str())+"\n");
+			updateCompileLog();
+		}
+	}
+	validation.saveMissionValidationFile("mission_validation.cfg");
+	
+	m_compileLog.append("Validation finished");
+	updateCompileLog();
+}
+
+bool MissionCompilerMainWindow::parsePrimForMissions(NLLIGO::IPrimitive const *prim, TMissionContainer &missions)
+{
+	std::string value;
+	// if the node is a mission parse it
+	if (prim->getPropertyByName("class",value) && !stricmp(value.c_str(),"mission") )
+	{
+		std::string name;
+		prim->getPropertyByName("name",name);
+		
+		m_compileLog.append("  ** Parsing mission '"+QString(name.c_str())+"'\n");
+		updateCompileLog();
+
+		// parse the mission and put it in our manager
+		CMission mission(value, "");
+		if (!mission.parsePrim(prim) )
+		{
+			m_compileLog.append("    ** Previous errors in mission '"+QString(name.c_str())+"'");
+			updateCompileLog();
+			return false;
+		}
+		missions.insert(make_pair(name, mission));
+		return true;
+	}
+	else
+	{
+		//this is not a mission node, so lookup recursively in the children
+		bool ok = true;
+		for (uint i=0;i<prim->getNumChildren();++i)	
+		{
+			const NLLIGO::IPrimitive *child;
+			if ( !prim->getChild(child,i) || !parsePrimForMissions(child, missions) )
+				ok = false;
+		}
+		return ok;
+	}
+}
+
+void MissionCompilerMainWindow::updateCompileLog()
+{
+	ui->compileOutputText->setPlainText(m_compileLog);
+	QCoreApplication::processEvents();
+}
+
+void MissionCompilerMainWindow::loadConfig() {
+	QSettings *settings = Core::ICore::instance()->settings();
+	settings->beginGroup(MISSION_COMPILER_SECTION);
+
+	// Retrieve the local text path.
+	QString localPath = settings->value(SETTING_LOCAL_TEXT_PATH).toString();
+	QListWidgetItem *item = new QListWidgetItem("Local");
+	item->setForeground(Qt::blue);
+	item->setCheckState(Qt::Unchecked);
+	ui->publishServersList->addItem(item);
+
+	QStringList items = settings->value(SETTING_SERVERS_TABLE_ITEMS).toStringList();
+	int column = 0;
+	int row = 0;
+	Q_FOREACH(QString var, items)
+	{
+		// Check to see if we're starting a new row.
+		if(column > 2)
+		{
+			column = 0;
+			row++;
+		}
+		if(column == 0)
+		{
+			item = new QListWidgetItem(var);
+			item->setCheckState(Qt::Unchecked);
+			ui->publishServersList->addItem(item);
+		}
+
+		column++;
+	}
+
+	// Reapply the checkboxes for servers we had checked previously.
+	QStringList servers = settings->value(SETTING_PUBLISH_SERVER_CHECKS).toStringList();
+	applyCheckboxes(servers);
+
+	settings->endGroup();
+}
+
+void MissionCompilerMainWindow::saveConfig() {
+	QSettings *settings = Core::ICore::instance()->settings();
+	settings->beginGroup(MISSION_COMPILER_SECTION);
+
+	QStringList servers;
+	for(int row = 0; row < ui->publishServersList->count(); row++)
+	{
+		QListWidgetItem *item = ui->publishServersList->item(row);
+		if(item->checkState() == Qt::Checked)
+			servers << item->text();
+	}
+
+	settings->setValue(SETTING_PUBLISH_SERVER_CHECKS, servers);
+
+	settings->endGroup();
+	settings->sync();
+}
+
+void MissionCompilerMainWindow::handleChangedSettings()
+{
+	QStringList servers;
+	for(int row = 0; row < ui->publishServersList->count(); row++)
+	{
+		QListWidgetItem *item = ui->publishServersList->item(row);
+		if(item->checkState() == Qt::Checked)
+			servers << item->text();
+	}
+	ui->publishServersList->clear();
+	loadConfig();
+
+	applyCheckboxes(servers);
+}
+
+void MissionCompilerMainWindow::applyCheckboxes(const QStringList &servers)
+{
+	Q_FOREACH(QString server, servers)
+	{
+		QList<QListWidgetItem*> items = ui->publishServersList->findItems(server, Qt::MatchExactly);
+		if(items.size() != 1)
+			continue;
+		items.at(0)->setCheckState(Qt::Checked);
+	}
+}
+
+MissionCompilerMainWindow::~MissionCompilerMainWindow()
+{
+	saveConfig();
+    delete ui;
+}
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.h b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.h
new file mode 100644
index 000000000..1dffea313
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.h
@@ -0,0 +1,75 @@
+#ifndef MISSION_COMPILER_MAIN_WINDOW_H
+#define MISSION_COMPILER_MAIN_WINDOW_H
+
+#include <QMainWindow>
+#include <QTimer>
+#include <QLabel>
+#include <QAction>
+#include <QtGui/QUndoStack>
+#include <QStringListModel>
+#include <QSortFilterProxyModel>
+#include <QRegExp>
+
+#include <nel/ligo/ligo_config.h>
+#include <nel/ligo/primitive.h>
+
+namespace Ui {
+    class MissionCompilerMainWindow;
+}
+
+struct CMission;
+
+class MissionCompilerMainWindow : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    explicit MissionCompilerMainWindow(QWidget *parent = 0);
+    ~MissionCompilerMainWindow();
+
+	void loadConfig();
+	void saveConfig();
+	QUndoStack *getUndoStack() { return m_undoStack; }
+
+	typedef std::map<std::string, CMission> TMissionContainer;
+
+public Q_SLOTS:
+	void handleFilterChanged(const QString &text);
+	void handleValidation();
+	void handleCompile();
+	void handlePublish();
+	void handleAllDoubleClick(const QModelIndex &index);
+	void handleSelDoubleClick(const QModelIndex &index);
+	void handleMoveSelectedRight();
+	void handleMoveSelectedLeft();
+	void handleMoveAllRight();
+	void handleMoveAllLeft();
+	void handleDataDirButton();
+	void handleDataDirChanged(const QString &text);
+	void handleResetFiltersButton();
+	void handleChangedSettings();
+
+private:
+    Ui::MissionCompilerMainWindow *ui;
+
+	void updateCompileLog();
+	void populateAllPrimitives(const QString &dataDir = QString());
+	bool parsePrimForMissions(NLLIGO::IPrimitive const *prim, TMissionContainer &missions);
+	void compileMission(bool publish=false);
+	void moveSelectedItem(const QModelIndex &index, QStringListModel *from, QStringListModel *to);
+	void applyCheckboxes(const QStringList &servers);
+	
+	
+	QMenu *_toolModeMenu;
+	QUndoStack *m_undoStack;
+	QStringListModel *m_allPrimitivesModel;
+	QStringListModel *m_selectedPrimitivesModel;
+	QSortFilterProxyModel *m_filteredProxyModel;
+	QRegExp *m_regexpFilter;
+	QString m_compileLog;
+	QString m_lastDir;
+
+	NLLIGO::CLigoConfig m_ligoConfig;
+};
+
+#endif // MISSION_COMPILER_MAIN_WINDOW_H
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.ui b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.ui
new file mode 100644
index 000000000..d68b1a76d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_main_window.ui
@@ -0,0 +1,373 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MissionCompilerMainWindow</class>
+ <widget class="QMainWindow" name="MissionCompilerMainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>794</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <layout class="QGridLayout" name="gridLayout_3">
+    <item row="0" column="0">
+     <widget class="QToolBox" name="toolBox">
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="compileOptionsPage">
+       <property name="geometry">
+        <rect>
+         <x>0</x>
+         <y>0</y>
+         <width>776</width>
+         <height>426</height>
+        </rect>
+       </property>
+       <attribute name="label">
+        <string>Mission Compiler Options</string>
+       </attribute>
+       <layout class="QGridLayout" name="gridLayout">
+        <item row="5" column="4">
+         <layout class="QVBoxLayout" name="addRemoveLayout">
+          <item>
+           <spacer name="verticalSpacer_3">
+            <property name="orientation">
+             <enum>Qt::Vertical</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>20</width>
+              <height>40</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+          <item>
+           <widget class="QPushButton" name="addSelectedButton">
+            <property name="toolTip">
+             <string>Add Selected</string>
+            </property>
+            <property name="text">
+             <string/>
+            </property>
+            <property name="icon">
+             <iconset resource="mission_compiler.qrc">
+              <normaloff>:/buttons/images/arrow-right-2.png</normaloff>:/buttons/images/arrow-right-2.png</iconset>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="addAllButton">
+            <property name="toolTip">
+             <string>Add All</string>
+            </property>
+            <property name="text">
+             <string/>
+            </property>
+            <property name="icon">
+             <iconset resource="mission_compiler.qrc">
+              <normaloff>:/buttons/images/arrow-right-double-2.png</normaloff>:/buttons/images/arrow-right-double-2.png</iconset>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <spacer name="verticalSpacer">
+            <property name="orientation">
+             <enum>Qt::Vertical</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>20</width>
+              <height>40</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+          <item>
+           <widget class="QPushButton" name="removeAllButton">
+            <property name="toolTip">
+             <string>Remove All</string>
+            </property>
+            <property name="text">
+             <string/>
+            </property>
+            <property name="icon">
+             <iconset resource="mission_compiler.qrc">
+              <normaloff>:/buttons/images/arrow-left-double-2.png</normaloff>:/buttons/images/arrow-left-double-2.png</iconset>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="removeSelectedButton">
+            <property name="toolTip">
+             <string>Remove Selected</string>
+            </property>
+            <property name="text">
+             <string/>
+            </property>
+            <property name="icon">
+             <iconset resource="mission_compiler.qrc">
+              <normaloff>:/buttons/images/arrow-left-2.png</normaloff>:/buttons/images/arrow-left-2.png</iconset>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <spacer name="verticalSpacer_2">
+            <property name="orientation">
+             <enum>Qt::Vertical</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>20</width>
+              <height>40</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
+        </item>
+        <item row="5" column="3">
+         <widget class="QListView" name="allPrimitivesList">
+          <property name="acceptDrops">
+           <bool>true</bool>
+          </property>
+          <property name="editTriggers">
+           <set>QAbstractItemView::NoEditTriggers</set>
+          </property>
+          <property name="dragEnabled">
+           <bool>true</bool>
+          </property>
+          <property name="dragDropMode">
+           <enum>QAbstractItemView::DragDrop</enum>
+          </property>
+          <property name="defaultDropAction">
+           <enum>Qt::MoveAction</enum>
+          </property>
+          <property name="alternatingRowColors">
+           <bool>true</bool>
+          </property>
+          <property name="selectionMode">
+           <enum>QAbstractItemView::ExtendedSelection</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="5" column="5">
+         <widget class="QListView" name="selectedPrimitivesList">
+          <property name="acceptDrops">
+           <bool>true</bool>
+          </property>
+          <property name="editTriggers">
+           <set>QAbstractItemView::NoEditTriggers</set>
+          </property>
+          <property name="dragEnabled">
+           <bool>true</bool>
+          </property>
+          <property name="dragDropMode">
+           <enum>QAbstractItemView::DragDrop</enum>
+          </property>
+          <property name="defaultDropAction">
+           <enum>Qt::MoveAction</enum>
+          </property>
+          <property name="alternatingRowColors">
+           <bool>true</bool>
+          </property>
+          <property name="selectionMode">
+           <enum>QAbstractItemView::ExtendedSelection</enum>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="3">
+         <widget class="QLabel" name="allPrimitivesLabel">
+          <property name="text">
+           <string>All Primitives</string>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="5">
+         <widget class="QLabel" name="selectedPrimitivesLabel">
+          <property name="text">
+           <string>Selected Primitives</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="3" colspan="3">
+         <widget class="QGroupBox" name="filterGroupBox">
+          <property name="title">
+           <string>Filter Criteria</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_5">
+           <item row="0" column="0">
+            <layout class="QHBoxLayout" name="dataDirLayout">
+             <item>
+              <widget class="QLabel" name="dataDirLabel">
+               <property name="text">
+                <string>Data Directory</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QLineEdit" name="dataDirEdit"/>
+             </item>
+             <item>
+              <widget class="QToolButton" name="dataDirButton">
+               <property name="text">
+                <string>...</string>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </item>
+           <item row="1" column="0">
+            <layout class="QHBoxLayout" name="filterLayout">
+             <item>
+              <widget class="QLabel" name="filterLabel">
+               <property name="text">
+                <string>Filter</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QLineEdit" name="filterEdit">
+               <property name="placeholderText">
+                <string>type filter here</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QPushButton" name="resetFiltersButton">
+               <property name="toolTip">
+                <string>Blanks out the filter and reloads all files from the data directory.</string>
+               </property>
+               <property name="text">
+                <string>Reset</string>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </item>
+          </layout>
+          <zorder>horizontalLayoutWidget</zorder>
+          <zorder>dataDirLabel</zorder>
+          <zorder>horizontalLayoutWidget</zorder>
+          <zorder></zorder>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="publishOptionsPage">
+       <property name="geometry">
+        <rect>
+         <x>0</x>
+         <y>0</y>
+         <width>776</width>
+         <height>426</height>
+        </rect>
+       </property>
+       <attribute name="label">
+        <string>Publish Options</string>
+       </attribute>
+       <layout class="QGridLayout" name="gridLayout_4">
+        <item row="0" column="0">
+         <widget class="QListWidget" name="publishServersList"/>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="compilationOutputPage">
+       <property name="geometry">
+        <rect>
+         <x>0</x>
+         <y>0</y>
+         <width>776</width>
+         <height>426</height>
+        </rect>
+       </property>
+       <attribute name="label">
+        <string>Compilation Output</string>
+       </attribute>
+       <layout class="QGridLayout" name="gridLayout_2">
+        <item row="0" column="0">
+         <widget class="QPlainTextEdit" name="compileOutputText">
+          <property name="readOnly">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </widget>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>794</width>
+     <height>21</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+  <widget class="QToolBar" name="toolBar">
+   <property name="windowTitle">
+    <string>toolBar</string>
+   </property>
+   <attribute name="toolBarArea">
+    <enum>TopToolBarArea</enum>
+   </attribute>
+   <attribute name="toolBarBreak">
+    <bool>false</bool>
+   </attribute>
+   <addaction name="actionValidate"/>
+   <addaction name="actionCompile"/>
+   <addaction name="actionPublish"/>
+  </widget>
+  <action name="actionCompile">
+   <property name="icon">
+    <iconset resource="mission_compiler.qrc">
+     <normaloff>:/buttons/images/run-build-2.png</normaloff>:/buttons/images/run-build-2.png</iconset>
+   </property>
+   <property name="text">
+    <string>Compile</string>
+   </property>
+   <property name="toolTip">
+    <string>Compile</string>
+   </property>
+  </action>
+  <action name="actionValidate">
+   <property name="icon">
+    <iconset resource="mission_compiler.qrc">
+     <normaloff>:/buttons/images/news-subscribe-2.png</normaloff>:/buttons/images/news-subscribe-2.png</iconset>
+   </property>
+   <property name="text">
+    <string>Validate</string>
+   </property>
+   <property name="toolTip">
+    <string>Validate</string>
+   </property>
+  </action>
+  <action name="actionPublish">
+   <property name="icon">
+    <iconset resource="mission_compiler.qrc">
+     <normaloff>:/buttons/images/document-export-4.png</normaloff>:/buttons/images/document-export-4.png</iconset>
+   </property>
+   <property name="text">
+    <string>Publish</string>
+   </property>
+   <property name="toolTip">
+    <string>Compile and Publish</string>
+   </property>
+  </action>
+ </widget>
+ <resources>
+  <include location="mission_compiler.qrc"/>
+ </resources>
+ <connections/>
+</ui>
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin.cpp b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin.cpp
new file mode 100644
index 000000000..3b9eb3ead
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin.cpp
@@ -0,0 +1,131 @@
+// Project includes
+#include "mission_compiler_plugin.h"
+#include "../core/icore.h"
+#include "../core/core_constants.h"
+#include "../core/imenu_manager.h"
+#include "../../extension_system/iplugin_spec.h"
+
+// NeL includes
+#include <nel/misc/debug.h>
+#include <nel/misc/path.h>
+
+// Qt includes
+#include <QtCore/QObject>
+#include <QtGui/QMessageBox>
+#include <QtGui/QMainWindow>
+#include <QtGui/QMenu>
+#include <QtGui/QAction>
+#include <QtGui/QMenuBar>
+
+#include "mission_compiler_settings_page.h"
+
+namespace MissionCompiler
+{
+
+MissionCompilerPlugin::~MissionCompilerPlugin()
+{
+	Q_FOREACH(QObject *obj, _autoReleaseObjects)
+	{
+		_plugMan->removeObject(obj);
+	}
+	qDeleteAll(_autoReleaseObjects);
+	_autoReleaseObjects.clear();
+}
+
+bool MissionCompilerPlugin::initialize(ExtensionSystem::IPluginManager *pluginManager, QString *errorString)
+{
+	Q_UNUSED(errorString);
+	_plugMan = pluginManager;
+
+	addAutoReleasedObject(new MissionCompilerSettingsPage(this));
+	addAutoReleasedObject(new CMissionCompilerContext(this));
+	//addAutoReleasedObject(new CCoreListener(this));
+	return true;
+}
+
+void MissionCompilerPlugin::extensionsInitialized()
+{
+	Core::ICore *core = Core::ICore::instance();
+	QSettings *settings = Core::ICore::instance()->settings();
+	Core::IMenuManager *menuManager = core->menuManager();
+	//menuManager = _plugMan->getObject<Core::IMenuManager>();
+	//QAction *exampleAction1 = new QAction("Zone1", this);
+	//QAction *exampleAction2 = new QAction("Zone2", this);
+	//QMenu *toolsMenu = menuManager->menu(Core::Constants::M_TOOLS);
+	//helpMenu->insertAction(aboutQtAction, exampleAction1);
+	//helpMenu->addSeparator();
+	//helpMenu->addAction(exampleAction2);
+	//QMenu *zoneMenu = menuManager->menuBar()->addMenu("ZoneMenu");
+	//zoneMenu->insertAction(aboutQtAction, exampleAction1);
+	//zoneMenu->addSeparator();
+	//zoneMenu->addAction(exampleAction2);
+
+	// Initialize Ligo.
+	//settings->beginGroup(Core::Constants::DATA_PATH_SECTION);
+	//QString ligoConfigFile = settings->value(Core::Constants::DATA_PATH_SECTION).toString();
+	//settings->beginGroup(Core::Constants::DATA_PATH_SECTION);
+}
+
+void MissionCompilerPlugin::setNelContext(NLMISC::INelContext *nelContext)
+{
+#ifdef NL_OS_WINDOWS
+	// Ensure that a context doesn't exist yet.
+	// This only applies to platforms without PIC, e.g. Windows.
+	nlassert(!NLMISC::INelContext::isContextInitialised());
+#endif // NL_OS_WINDOWS
+	_LibContext = new NLMISC::CLibraryContext(*nelContext);
+}
+
+QString MissionCompilerPlugin::name() const
+{
+	return "MissionCompilerPlugin";
+}
+
+QString MissionCompilerPlugin::version() const
+{
+	return "0.1";
+}
+
+QString MissionCompilerPlugin::vendor() const
+{
+	return "Ryzom Core";
+}
+
+QString MissionCompilerPlugin::description() const
+{
+	return "Mission Compiler Plugin";
+}
+
+QStringList MissionCompilerPlugin::dependencies() const
+{
+	QStringList list;
+	list.append(Core::Constants::OVQT_CORE_PLUGIN);
+	//list.append("ObjectViewer");
+	return list;
+}
+
+void MissionCompilerPlugin::addAutoReleasedObject(QObject *obj)
+{
+	_plugMan->addObject(obj);
+	_autoReleaseObjects.prepend(obj);
+}
+
+QObject* MissionCompilerPlugin::objectByName(const QString &name) const
+{
+	Q_FOREACH (QObject *qobj, _plugMan->allObjects())
+	if (qobj->objectName() == name)
+		return qobj;
+	return 0;
+}
+
+ExtensionSystem::IPluginSpec *MissionCompilerPlugin::pluginByName(const QString &name) const
+{
+	Q_FOREACH (ExtensionSystem::IPluginSpec *spec, _plugMan->plugins())
+	if (spec->name() == name)
+		return spec;
+	return 0;
+}
+
+}
+
+Q_EXPORT_PLUGIN(MissionCompiler::MissionCompilerPlugin)
\ No newline at end of file
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin.h b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin.h
new file mode 100644
index 000000000..7f64465e7
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin.h
@@ -0,0 +1,101 @@
+#ifndef MISSION_COMPILER_PLUGIN_H
+#define MISSION_COMPILER_PLUGIN_H
+
+// Project includes
+#include "../../extension_system/iplugin.h"
+#include "../core/icontext.h"
+#include "mission_compiler_main_window.h"
+
+// NeL includes
+#include <nel/misc/app_context.h>
+#include <nel/misc/singleton.h>
+
+// Qt includes
+#include <QtCore/QObject>
+#include <QtGui/QIcon>
+
+namespace NLMISC
+{
+class CLibraryContext;
+}
+
+namespace ExtensionSystem
+{
+class IPluginSpec;
+}
+
+namespace MissionCompiler
+{
+
+class MissionCompilerPlugin : public QObject, public ExtensionSystem::IPlugin
+{
+	Q_OBJECT
+	Q_INTERFACES(ExtensionSystem::IPlugin)
+public:
+
+	virtual ~MissionCompilerPlugin();
+
+	bool initialize(ExtensionSystem::IPluginManager *pluginManager, QString *errorString);
+	void extensionsInitialized();
+
+	void setNelContext(NLMISC::INelContext *nelContext);
+
+	QString name() const;
+	QString version() const;
+	QString vendor() const;
+	QString description() const;
+	QStringList dependencies() const;
+
+	void addAutoReleasedObject(QObject *obj);
+
+	QObject *objectByName(const QString &name) const;
+	ExtensionSystem::IPluginSpec *pluginByName(const QString &name) const;
+
+protected:
+	NLMISC::CLibraryContext *_LibContext;
+
+private:
+	ExtensionSystem::IPluginManager *_plugMan;
+	QList<QObject *> _autoReleaseObjects;
+};
+
+class CMissionCompilerContext: public Core::IContext
+{
+	Q_OBJECT
+public:
+	CMissionCompilerContext(QObject *parent = 0): IContext(parent)
+	{
+		m_missionCompilerMainWindow = new MissionCompilerMainWindow();
+	}
+	virtual ~CMissionCompilerContext() {}
+
+	virtual QString id() const
+	{
+		return QLatin1String("MissionCompilerContext");
+	}
+	virtual QString trName() const
+	{
+		return tr("Mission Compiler");
+	}
+	virtual QIcon icon() const
+	{
+		return QIcon();
+	}
+	virtual QWidget *widget()
+	{
+		return m_missionCompilerMainWindow;
+	}
+
+    virtual QUndoStack *undoStack()
+    {
+        return m_missionCompilerMainWindow->getUndoStack();
+    }
+    virtual void open() {}
+
+
+	MissionCompilerMainWindow *m_missionCompilerMainWindow;
+};
+
+} // namespace MissionCompiler
+
+#endif // MISSION_COMPILER_PLUGIN_H
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin_constants.h b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin_constants.h
new file mode 100644
index 000000000..bfa71ceb1
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_plugin_constants.h
@@ -0,0 +1,17 @@
+#ifndef MISSION_COMPILER_PLUGIN_CONSTANTS_H
+#define MISSION_COMPILER_PLUGIN_CONSTANTS_H
+
+namespace MissionCompiler
+{
+namespace Constants
+{
+//settings
+const char * const MISSION_COMPILER_SECTION = "MissionCompiler";
+const char * const SETTING_LOCAL_TEXT_PATH = "LocalTextPath";
+const char * const SETTING_SERVERS_TABLE_ITEMS = "ServersTableItems";
+const char * const SETTING_PUBLISH_SERVER_CHECKS = "PublishServerChecks";
+
+} // namespace Constants
+} // namespace MissionCompiler
+
+#endif // MISSION_COMPILER_PLUGIN_CONSTANTS_H
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.cpp b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.cpp
new file mode 100644
index 000000000..2f75aa4ab
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.cpp
@@ -0,0 +1,203 @@
+// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
+// Copyright (C) 2010  Winch Gate Property Limited
+// Copyright (C) 2011  Dzmitry Kamiahin <dnk-88@tut.by>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Project includes
+#include "mission_compiler_settings_page.h"
+#include "mission_compiler_plugin_constants.h"
+#include "../core/core_constants.h"
+#include "../core/icore.h"
+
+#include "server_entry_dialog.h"
+
+// NeL includes
+#include <nel/misc/path.h>
+
+// Qt includes
+#include <QtCore/QSettings>
+#include <QtGui/QWidget>
+#include <QtGui/QFileDialog>
+#include <QtGui/QTreeWidgetItem>
+
+namespace MissionCompiler
+{
+
+QString lastDir = ".";
+
+MissionCompilerSettingsPage::MissionCompilerSettingsPage(QObject *parent)
+	: IOptionsPage(parent),
+	  m_page(0)
+{
+}
+
+MissionCompilerSettingsPage::~MissionCompilerSettingsPage()
+{
+}
+
+QString MissionCompilerSettingsPage::id() const
+{
+		return QLatin1String("mission_compiler_settings");
+}
+
+QString MissionCompilerSettingsPage::trName() const
+{
+	return tr("Mission Compiler Settings");
+}
+
+QString MissionCompilerSettingsPage::category() const
+{
+	return QLatin1String("Mission Compiler");
+}
+
+QString MissionCompilerSettingsPage::trCategory() const
+{
+	return tr("Mission Compiler");
+}
+
+QIcon MissionCompilerSettingsPage::categoryIcon() const
+{
+	return QIcon();
+}
+
+QWidget *MissionCompilerSettingsPage::createPage(QWidget *parent)
+{
+	m_page = new QWidget(parent);
+	m_ui.setupUi(m_page);
+
+	readSettings();
+	connect(m_ui.addToolButton, SIGNAL(clicked()), this, SLOT(addServer()));
+	connect(m_ui.removeToolButton, SIGNAL(clicked()), this, SLOT(delServer()));
+	connect(m_ui.serversTableWidget, SIGNAL(cellDoubleClicked(int,int)), this, SLOT(editServer(int,int)));
+	return m_page;
+}
+
+void MissionCompilerSettingsPage::apply()
+{
+	writeSettings();
+}
+
+void MissionCompilerSettingsPage::finish()
+{
+	delete m_page;
+	m_page = 0;
+}
+
+void MissionCompilerSettingsPage::editServer(int row, int column)
+{
+	ServerEntryDialog serverEntryDialog;
+	serverEntryDialog.setModal(true);
+	serverEntryDialog.show();
+
+	// Copy the values from the row to the dialog.
+	QTableWidgetItem *item1 = m_ui.serversTableWidget->item(row,0);
+	QTableWidgetItem *item2 = m_ui.serversTableWidget->item(row,1);
+	QTableWidgetItem *item3 = m_ui.serversTableWidget->item(row,2);
+	serverEntryDialog.setServerName(item1->text());
+	serverEntryDialog.setTextPath(item2->text());
+	serverEntryDialog.setPrimPath(item3->text());
+
+	if(serverEntryDialog.exec())
+	{
+		item1->setText(serverEntryDialog.getServerName());
+		item2->setText(serverEntryDialog.getTextPath());
+		item3->setText(serverEntryDialog.getPrimPath());
+	}
+}
+
+void MissionCompilerSettingsPage::addServer()
+{
+	ServerEntryDialog serverEntryDialog;
+	serverEntryDialog.setModal(true);
+	serverEntryDialog.show();
+	
+
+	if(serverEntryDialog.exec())
+	{
+		int row = m_ui.serversTableWidget->rowCount();
+		m_ui.serversTableWidget->insertRow(row);
+		QTableWidgetItem *item1 = new QTableWidgetItem(serverEntryDialog.getServerName());
+		QTableWidgetItem *item2 = new QTableWidgetItem(serverEntryDialog.getTextPath());
+		QTableWidgetItem *item3 = new QTableWidgetItem(serverEntryDialog.getPrimPath());
+
+		m_ui.serversTableWidget->setItem(row, 0, item1);
+		m_ui.serversTableWidget->setItem(row, 1, item2);
+		m_ui.serversTableWidget->setItem(row, 2, item3);
+	}
+}
+
+void MissionCompilerSettingsPage::delServer()
+{
+	QList<QTableWidgetItem*> selectedItems = m_ui.serversTableWidget->selectedItems();
+	while(selectedItems.size() > 0)
+	{
+		m_ui.serversTableWidget->removeRow(selectedItems.back()->row());
+		selectedItems = m_ui.serversTableWidget->selectedItems();
+	}
+}
+
+void MissionCompilerSettingsPage::readSettings()
+{
+	QSettings *settings = Core::ICore::instance()->settings();
+	settings->beginGroup(Constants::MISSION_COMPILER_SECTION);
+
+	// Retrieve the local text path.
+	m_ui.localPathEdit->setText(settings->value(Constants::SETTING_LOCAL_TEXT_PATH).toString());
+
+	QStringList items = settings->value(Constants::SETTING_SERVERS_TABLE_ITEMS).toStringList();
+	int column = 0;
+	int row = 0;
+	m_ui.serversTableWidget->insertRow(row);
+	Q_FOREACH(QString var, items)
+	{
+		// Check to see if we're starting a new row.
+		if(column > 2)
+		{
+			column = 0;
+			row++;
+			m_ui.serversTableWidget->insertRow(row);
+		}
+		
+		QTableWidgetItem *item = new QTableWidgetItem(var);
+		m_ui.serversTableWidget->setItem(row, column, item);
+
+		column++;
+	}
+	settings->endGroup();
+}
+
+void MissionCompilerSettingsPage::writeSettings()
+{
+	QSettings *settings = Core::ICore::instance()->settings();
+	settings->beginGroup(Constants::MISSION_COMPILER_SECTION);
+	
+	// Save the local text path.
+	settings->setValue(Constants::SETTING_LOCAL_TEXT_PATH, m_ui.localPathEdit->text());
+
+	QStringList items;
+	for(int row = 0; row < m_ui.serversTableWidget->rowCount(); row++)
+	{
+		for(int column = 0; column < m_ui.serversTableWidget->columnCount(); column++)
+		{
+			items << m_ui.serversTableWidget->item(row, column)->text();
+		}
+	}
+
+	settings->setValue(Constants::SETTING_SERVERS_TABLE_ITEMS, items);
+	settings->endGroup();
+	settings->sync();
+}
+
+} /* namespace MissionCompiler */
\ No newline at end of file
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.h b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.h
new file mode 100644
index 000000000..71996e442
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.h
@@ -0,0 +1,68 @@
+// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
+// Copyright (C) 2010  Winch Gate Property Limited
+// Copyright (C) 2011  Dzmitry Kamiahin <dnk-88@tut.by>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#ifndef MISSION_COMPILER_SETTINGS_PAGE_H
+#define MISSION_COMPILER_SETTINGS_PAGE_H
+
+#include <QtCore/QObject>
+
+#include "../core/ioptions_page.h"
+
+#include "ui_mission_compiler_settings_page.h"
+
+class QWidget;
+
+namespace MissionCompiler
+{
+/**
+@class MissionCompilerSettingsPage
+*/
+class MissionCompilerSettingsPage : public Core::IOptionsPage
+{
+	Q_OBJECT
+
+public:
+	MissionCompilerSettingsPage(QObject *parent = 0);
+	~MissionCompilerSettingsPage();
+
+	QString id() const;
+	QString trName() const;
+	QString category() const;
+	QString trCategory() const;
+	QIcon categoryIcon() const;
+	QWidget *createPage(QWidget *parent);
+
+	void apply();
+	void finish();
+
+private Q_SLOTS:
+	void addServer();
+	void delServer();
+	void editServer(int row, int column);
+
+private:
+	void readSettings();
+	void writeSettings();
+
+	QWidget *m_page;
+	Ui::MissionCompilerSettingsPage m_ui;
+};
+
+} // namespace MissionCompiler
+
+#endif // MISSION_COMPILER_SETTINGS_PAGE_H
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.ui b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.ui
new file mode 100644
index 000000000..2ee2c2bce
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/mission_compiler_settings_page.ui
@@ -0,0 +1,210 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MissionCompilerSettingsPage</class>
+ <widget class="QWidget" name="MissionCompilerSettingsPage">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>496</width>
+    <height>544</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <property name="margin">
+    <number>6</number>
+   </property>
+   <property name="spacing">
+    <number>3</number>
+   </property>
+   <item row="1" column="0" colspan="2">
+    <widget class="QGroupBox" name="publicationGroupBox">
+     <property name="title">
+      <string>Publication Servers</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="0" column="2">
+       <layout class="QVBoxLayout" name="verticalLayout">
+        <item>
+         <widget class="QToolButton" name="removeToolButton">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="toolTip">
+           <string>Delete</string>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+          <property name="icon">
+           <iconset resource="mission_compiler.qrc">
+            <normaloff>:/buttons/images/ic_nel_delete_item.png</normaloff>:/buttons/images/ic_nel_delete_item.png</iconset>
+          </property>
+          <property name="iconSize">
+           <size>
+            <width>20</width>
+            <height>20</height>
+           </size>
+          </property>
+          <property name="autoRaise">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="addToolButton">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="toolTip">
+           <string>Add</string>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+          <property name="icon">
+           <iconset resource="mission_compiler.qrc">
+            <normaloff>:/buttons/images/ic_nel_add_item.png</normaloff>:/buttons/images/ic_nel_add_item.png</iconset>
+          </property>
+          <property name="iconSize">
+           <size>
+            <width>20</width>
+            <height>20</height>
+           </size>
+          </property>
+          <property name="autoRaise">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="resetToolButton">
+          <property name="toolTip">
+           <string>Reset</string>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+          <property name="icon">
+           <iconset resource="mission_compiler.qrc">
+            <normaloff>:/buttons/images/ic_nel_reset_all.png</normaloff>:/buttons/images/ic_nel_reset_all.png</iconset>
+          </property>
+          <property name="iconSize">
+           <size>
+            <width>20</width>
+            <height>20</height>
+           </size>
+          </property>
+          <property name="autoRaise">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="verticalSpacer">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+      <item row="1" column="1">
+       <spacer name="publishHorizontalSpacer">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="0" column="0" colspan="2">
+       <widget class="QTableWidget" name="serversTableWidget">
+        <property name="editTriggers">
+         <set>QAbstractItemView::NoEditTriggers</set>
+        </property>
+        <property name="alternatingRowColors">
+         <bool>true</bool>
+        </property>
+        <attribute name="horizontalHeaderDefaultSectionSize">
+         <number>100</number>
+        </attribute>
+        <attribute name="horizontalHeaderStretchLastSection">
+         <bool>true</bool>
+        </attribute>
+        <column>
+         <property name="text">
+          <string>Server Name</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Server Text Path</string>
+         </property>
+        </column>
+        <column>
+         <property name="text">
+          <string>Server Primitive Path</string>
+         </property>
+        </column>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="0" column="0" colspan="2">
+    <widget class="QGroupBox" name="generalGroupBox">
+     <property name="title">
+      <string>General Settings</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_3">
+      <item row="0" column="0">
+       <widget class="QLabel" name="localPathLabel">
+        <property name="text">
+         <string>Local Text Path</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QLineEdit" name="localPathEdit">
+        <property name="toolTip">
+         <string>Local path for compiled mission texts.</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="2">
+       <widget class="QToolButton" name="localPathButton">
+        <property name="text">
+         <string>...</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources>
+  <include location="mission_compiler.qrc"/>
+ </resources>
+ <connections/>
+</ui>
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.cpp b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.cpp
new file mode 100644
index 000000000..a9ef08f50
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.cpp
@@ -0,0 +1,89 @@
+// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
+// Copyright (C) 2010  Winch Gate Property Limited
+// Copyright (C) 2011  Dzmitry Kamiahin <dnk-88@tut.by>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Project includes
+#include "server_entry_dialog.h"
+
+#include "ui_server_entry_dialog.h"
+
+// NeL includes
+
+// Qt includes
+#include <QFileDialog>
+
+namespace MissionCompiler
+{
+
+ServerEntryDialog::ServerEntryDialog(QWidget *parent)
+	: QDialog(parent),
+	  m_ui(new Ui::ServerEntryDialog)
+{
+	m_ui->setupUi(this);
+	
+	connect(m_ui->serverTextPathButton, SIGNAL(clicked()), this, SLOT(lookupTextPath()));
+	connect(m_ui->serverPrimPathButton, SIGNAL(clicked()), this, SLOT(lookupPrimPath()));
+}
+
+ServerEntryDialog::~ServerEntryDialog()
+{
+	delete m_ui;
+}
+
+QString ServerEntryDialog::getServerName()
+{
+	return m_ui->serverNameEdit->text();
+}
+
+QString ServerEntryDialog::getTextPath()
+{
+	return m_ui->serverTextPathEdit->text();
+}
+
+QString ServerEntryDialog::getPrimPath()
+{
+	return m_ui->serverPrimPathEdit->text();
+}
+
+void ServerEntryDialog::setServerName(QString name)
+{
+	m_ui->serverNameEdit->setText(name);
+}
+
+void ServerEntryDialog::setTextPath(QString path)
+{
+	m_ui->serverTextPathEdit->setText(path);
+}
+
+void ServerEntryDialog::setPrimPath(QString path)
+{
+	m_ui->serverPrimPathEdit->setText(path);
+}
+
+void ServerEntryDialog::lookupTextPath()
+{
+	QString curPath = m_ui->serverTextPathEdit->text();
+	QString path = QFileDialog::getExistingDirectory(this, "", curPath);
+	m_ui->serverTextPathEdit->setText(path);
+}
+
+void ServerEntryDialog::lookupPrimPath()
+{
+	QString curPath = m_ui->serverPrimPathEdit->text();
+	QString path = QFileDialog::getExistingDirectory(this, "", curPath);
+	m_ui->serverPrimPathEdit->setText(path);
+}
+} /* namespace MissionCompiler */
\ No newline at end of file
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.h b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.h
new file mode 100644
index 000000000..98a086cd0
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.h
@@ -0,0 +1,59 @@
+// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
+// Copyright (C) 2010  Winch Gate Property Limited
+// Copyright (C) 2011  Dzmitry Kamiahin <dnk-88@tut.by>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#ifndef SERVER_ENTRY_DIALOG_H
+#define SERVER_ENTRY_DIALOG_H
+
+#include <QDialog>
+
+namespace Ui {
+    class ServerEntryDialog;
+}
+
+namespace MissionCompiler
+{
+/**
+@class ServerEntryDialog
+*/
+class ServerEntryDialog : public QDialog
+{
+	Q_OBJECT
+
+public:
+	explicit ServerEntryDialog(QWidget *parent = 0);
+	~ServerEntryDialog();
+
+	QString getServerName();
+	QString getTextPath();
+	QString getPrimPath();
+
+	void setServerName(QString name);
+	void setTextPath(QString path);
+	void setPrimPath(QString path);
+
+public Q_SLOTS:
+	void lookupTextPath();
+	void lookupPrimPath();
+
+private:
+	Ui::ServerEntryDialog *m_ui;
+};
+
+} // namespace MissionCompiler
+
+#endif // SERVER_ENTRY_DIALOG_H
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.ui b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.ui
new file mode 100644
index 000000000..002af82eb
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/server_entry_dialog.ui
@@ -0,0 +1,130 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ServerEntryDialog</class>
+ <widget class="QDialog" name="ServerEntryDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>488</width>
+    <height>175</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="0">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0">
+    <widget class="QGroupBox" name="serverSettingsBox">
+     <property name="title">
+      <string>Server Settings</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="0" column="0">
+       <widget class="QLabel" name="serverNameLabel">
+        <property name="text">
+         <string>Server Name</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1" colspan="2">
+       <widget class="QLineEdit" name="serverNameEdit"/>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="serverTextPathLabel">
+        <property name="text">
+         <string>Server Text Path</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QLineEdit" name="serverTextPathEdit"/>
+      </item>
+      <item row="1" column="2">
+       <widget class="QToolButton" name="serverTextPathButton">
+        <property name="text">
+         <string>...</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="serverPrimPathLabel">
+        <property name="text">
+         <string>Server Primitive Path</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLineEdit" name="serverPrimPathEdit"/>
+      </item>
+      <item row="2" column="2">
+       <widget class="QToolButton" name="serverPrimPathButton">
+        <property name="text">
+         <string>...</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0" colspan="3">
+       <spacer name="verticalSpacer">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>40</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>ServerEntryDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>ServerEntryDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/validation_file.cpp b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/validation_file.cpp
new file mode 100644
index 000000000..3e166da6b
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/validation_file.cpp
@@ -0,0 +1,133 @@
+#include "validation_file.h"
+
+#include <nel/misc/config_file.h>
+#include <nel/misc/path.h>
+
+void CValidationFile::loadMissionValidationFile(std::string filename)
+{	
+	// load the configuration file
+	NLMISC::CConfigFile cf;
+	std::string pathName = NLMISC::CPath::lookup(filename, false);
+	
+	if (pathName.empty())
+	{
+		nlwarning("Can't find index file '%s' in search path, no mission will be valid", filename.c_str());
+		return;
+	}
+	cf.load(pathName);
+	
+	// get the variable
+	NLMISC::CConfigFile::CVar* var = cf.getVarPtr("AuthorizedStates");
+	if (var)
+	{
+		for (uint i=0; i<var->size(); ++i)
+			_AuthorizedStates.push_back(var->asString(i));
+	}
+	int missionStatesFields = 3;
+	var = cf.getVarPtr("MissionStatesFields");
+	if (var)
+		missionStatesFields = var->asInt();
+	else
+		nlwarning("Mission validation file does not contain MissionStatesFields variable. Parsing may fail and corrupt data.");
+
+	var = cf.getVarPtr("MissionStates");
+	if (var)
+	{
+		for (uint i=0; i<var->size()/missionStatesFields; ++i)
+		{
+			std::string mission = var->asString(i*missionStatesFields);
+			std::string stateName = var->asString(i*missionStatesFields+1);
+			std::string hashKey = var->asString(i*missionStatesFields+2);
+			_MissionStates.insert(std::make_pair(mission, CMissionState(mission, stateName, hashKey)));
+		}
+	}
+}
+
+void CValidationFile::saveMissionValidationFile(std::string filename)
+{
+	// load the configuration file
+	std::string pathName = NLMISC::CPath::lookup(filename, false);
+	
+	if (pathName.empty())
+	{
+		nlwarning("Can't find index file '%s' in search path, no mission will be valid", filename.c_str());
+		return;
+	}
+	FILE* file = fopen(pathName.c_str(), "w");
+	nlassert(file!=NULL);
+	
+	// AuthorizedStates
+	fprintf(file, "%s",
+		"// AuthorizedStates contains the list of authorized states. EGS mission\n"
+		"// manager can accept any number of states. Default state is the first one.\n"
+		"AuthorizedStates = {\n");
+	std::deque<std::string>::iterator itAuth, itAuthEnd = _AuthorizedStates.end();
+	for (itAuth=_AuthorizedStates.begin(); itAuth!=itAuthEnd; ++itAuth)
+		fprintf(file, "\t\"%s\",\n", itAuth->c_str());
+	fprintf(file, "%s", "};\n\n");
+	
+	// MissionStatesFields
+	fprintf(file, "%s",
+		"// MissionStatesFields contains the number of fields in MissionStates, for\n"
+		"// future compatibility purpose.\n"
+		"MissionStatesFields = ");
+	fprintf(file, "%d", 3); // 3 fields: name, state, hash key
+	fprintf(file, "%s", ";\n\n");
+	
+	// MissionStates
+	fprintf(file, "%s",
+		"// MissionStates contains a list of mission with for each the state of the\n"
+		"// mission and its hash key. The tool will add new missions with the default\n"
+		"// state. It will flag missions with a modified hash key with default state to\n"
+		"// prevent untested modified missions to be published.\n"
+		"// :NOTE: You can add a field to this structure without the need to modify EGS\n"
+		"// code. Simply update MissionStatesFields.\n"
+		"MissionStates = {\n");
+	TMissionStateContainer::iterator itMission, itMissionEnd = _MissionStates.end();
+	for (itMission=_MissionStates.begin(); itMission!=itMissionEnd; ++itMission)
+		fprintf(file, "\t%-42s %-12s \"%s\",\n", ("\""+itMission->second.name+"\",").c_str(), ("\""+itMission->second.state+"\",").c_str(), itMission->second.hashKey.c_str());
+	fprintf(file, "};\n\n");
+
+	fclose(file);
+}
+
+// :NOTE: This function exists in mission_template.cpp. If you change it here modify the other file.
+std::string buildHashKey(std::string const& content)
+{
+	uint32 sum = 0;
+	size_t size = content.length()/4;
+	for (size_t i=0; i<size; ++i)
+	{
+		uint32 val = 0;
+		for (int j=0; j<4; ++j)
+			val += content[4*i+j]<<8*j;
+		sum += val;
+		if (sum&1)
+			sum = sum>>1 | 0x80000000;
+		else
+			sum = sum>>1;
+	}
+	return NLMISC::toString("0x%08X", sum);
+}
+
+bool CMission::parsePrim(NLLIGO::IPrimitive const* prim)
+{
+	// init default values
+	std::vector<std::string>* params;
+	// get the mission script
+	if (!prim->getPropertyByName("script", params) || !params)
+	{
+		nlwarning("ERROR : cant find mission script!!!!!!");
+		return false;
+	}
+	
+	// parse them
+	std::string content;
+	std::vector<std::string>::iterator itParam, itParamEnd = params->end();
+	for (itParam=params->begin(); itParam!=itParamEnd; ++itParam)
+	{
+		content += *itParam + "\n";
+	}
+	hashKey = buildHashKey(content);
+	return true;
+}
\ No newline at end of file
diff --git a/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/validation_file.h b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/validation_file.h
new file mode 100644
index 000000000..73d661a26
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_qt/src/plugins/mission_compiler/validation_file.h
@@ -0,0 +1,51 @@
+#ifndef VALIDATION_FILE_H
+#define VALIDATION_FILE_H
+
+#include <deque>
+#include <map>
+#include <string>
+
+#include <nel/ligo/primitive.h>
+
+struct CMissionState
+{
+	std::string name;
+	std::string state;
+	std::string hashKey;
+	CMissionState(std::string _name, std::string _state, std::string _hashKey)
+	: name(_name), state(_state), hashKey(_hashKey) { }
+};
+
+struct CMission
+{
+	std::string name;
+	std::string hashKey;
+	CMission(std::string _name, std::string _hashKey)
+	: name(_name), hashKey(_hashKey) { }
+	bool parsePrim(NLLIGO::IPrimitive const* prim);
+};
+
+class CValidationFile
+{
+public:
+	typedef std::map<std::string, CMissionState> TMissionStateContainer;
+	std::deque<std::string> _AuthorizedStates;
+	TMissionStateContainer _MissionStates;
+public:
+	//	CValidationFile() { }
+	void loadMissionValidationFile(std::string filename);
+	void saveMissionValidationFile(std::string filename);
+	void insertMission(std::string const& mission, std::string const& hashKey)
+	{
+		_MissionStates.insert(std::make_pair(mission, CMissionState(mission, defaultState(), hashKey)));
+	}
+	std::string defaultState()
+	{
+		if (!_AuthorizedStates.empty())
+			return _AuthorizedStates.front();
+		else
+			return "";
+	}
+};
+
+#endif // VALIDATION_FILE_H
\ No newline at end of file