/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Designer 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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "abstractformwindow.h"

#include <widgetfactory_p.h>

#include <QtGui/QTabBar>

#include <QtGui/QSizeGrip>

#include <QtGui/QAbstractButton>

#include <QtGui/QToolBox>

#include <QtGui/QMenuBar>

#include <QtGui/QMainWindow>

#include <QtGui/QDockWidget>

#include <QtGui/QToolBar>

#include <QtCore/qdebug.h>

QT_BEGIN_NAMESPACE

/*!

    \class QDesignerFormWindowInterface

    \brief The QDesignerFormWindowInterface class allows you to query

    and manipulate form windows appearing in Qt Designer's workspace.

    \inmodule QtDesigner

    QDesignerFormWindowInterface provides information about

    the associated form window as well as allowing its properties to be

    altered. The interface is not intended to be instantiated

    directly, but to provide access to \QD's current form windows

    controlled by \QD's \l {QDesignerFormWindowManagerInterface}{form

    window manager}.

    If you are looking for the form window containing a specific

    widget, you can use the static

    QDesignerFormWindowInterface::findFormWindow() function:

    \snippet doc/src/snippets/code/tools_designer_src_lib_sdk_abstractformwindow.cpp 0

    But in addition, you can access any of the current form windows

    through \QD's form window manager: Use the

    QDesignerFormEditorInterface::formWindowManager() function to

    retrieve an interface to the manager. Once you have this

    interface, you have access to all of \QD's current form windows

    through the QDesignerFormWindowManagerInterface::formWindow()

    function. For example:

    \snippet doc/src/snippets/code/tools_designer_src_lib_sdk_abstractformwindow.cpp 1

    The pointer to \QD's current QDesignerFormEditorInterface object

    (\c formEditor in the example above) is provided by the

    QDesignerCustomWidgetInterface::initialize() function's

    parameter. When implementing a custom widget plugin, you must

    subclass the QDesignerCustomWidgetInterface class to expose your

    plugin to \QD.

    Once you have the form window, you can query its properties. For

    example, a plain custom widget plugin is managed by \QD only at

    its top level, i.e. none of its child widgets can be resized in

    \QD's workspace. But QDesignerFormWindowInterface provides you

    with functions that enables you to control whether a widget should

    be managed by \QD, or not:

    \snippet doc/src/snippets/code/tools_designer_src_lib_sdk_abstractformwindow.cpp 2

    The complete list of functions concerning widget management is:

    isManaged(), manageWidget() and unmanageWidget(). There is also

    several associated signals: widgetManaged(), widgetRemoved(),

    aboutToUnmanageWidget() and widgetUnmanaged().

    In addition to controlling the management of widgets, you can

    control the current selection in the form window using the

    selectWidget(), clearSelection() and emitSelectionChanged()

    functions, and the selectionChanged() signal.

    You can also retrieve information about where the form is stored

    using absoluteDir(), its include files using includeHints(), and

    its layout and pixmap functions using layoutDefault(),

    layoutFunction() and pixmapFunction(). You can find out whether

    the form window has been modified (but not saved) or not, using

    the isDirty() function. You can retrieve its author(), its

    contents(), its fileName(), associated comment() and

    exportMacro(), its mainContainer(), its features(), its grid() and

    its resourceFiles().

    The interface provides you with functions and slots allowing you

    to alter most of this information as well. The exception is the

    directory storing the form window. Finally, there is several

    signals associated with changes to the information mentioned above

    and to the form window in general.

    \sa QDesignerFormWindowCursorInterface,

    QDesignerFormEditorInterface, QDesignerFormWindowManagerInterface

*/

/*!

    \enum QDesignerFormWindowInterface::FeatureFlag

    This enum describes the features that are available and can be

    controlled by the form window interface. These values are used

    when querying the form window to determine which features it

    supports:

    \value EditFeature      Form editing

    \value GridFeature      Grid display and snap-to-grid facilities for editing

    \value TabOrderFeature  Tab order management

    \value DefaultFeature   Support for default features (form editing and grid)

    \sa hasFeature(), features()

*/

/*!

    Constructs a form window interface with the given \a parent and

    the specified window \a flags.

*/

QDesignerFormWindowInterface::QDesignerFormWindowInterface(QWidget *parent, Qt::WindowFlags flags)

    : QWidget(parent, flags)

{

}

/*!

    Destroys the form window interface.

*/

QDesignerFormWindowInterface::~QDesignerFormWindowInterface()

{

}

/*!

    Returns a pointer to \QD's current QDesignerFormEditorInterface

    object.

*/

QDesignerFormEditorInterface *QDesignerFormWindowInterface::core() const

{

    return 0;

}

/*!

    \fn QDesignerFormWindowInterface *QDesignerFormWindowInterface::findFormWindow(QWidget *widget)

    Returns the form window interface for the given \a widget.

*/

static inline bool stopFindAtTopLevel(const QObject *w, bool stopAtMenu)

{

    // Do we need to go beyond top levels when looking for the form window?

    // 1) A dialog has a window attribute at the moment it is created

    //    before it is properly embedded into a form window. The property

    //    sheet queries the layout attributes precisely at this moment.

    // 2) In the case of floating docks and toolbars, we also need to go beyond the top level window.

    // 3) In the case of menu editing, we don't want to block events from the

    //    Designer menu, so, we say stop.

    // Note that there must be no false positives for dialogs parented on

    // the form (for example, the "change object name" dialog), else, its

    // events will be blocked.

    if (stopAtMenu && w->inherits("QDesignerMenu"))

        return true;

    return !qdesigner_internal::WidgetFactory::isFormEditorObject(w);

}

QDesignerFormWindowInterface *QDesignerFormWindowInterface::findFormWindow(QWidget *w)

{

    while (w != 0) {

        if (QDesignerFormWindowInterface *fw = qobject_cast<QDesignerFormWindowInterface*>(w)) {

            return fw;

        } else {

            if (w->isWindow() && stopFindAtTopLevel(w, true))

                break;

        }

        w = w->parentWidget();

    }

    return 0;

}

/*!

    \fn QDesignerFormWindowInterface *QDesignerFormWindowInterface::findFormWindow(QObject *object)

    Returns the form window interface for the given \a object.

    \since 4.4

*/

QDesignerFormWindowInterface *QDesignerFormWindowInterface::findFormWindow(QObject *object)

{

    while (object != 0) {

        if (QDesignerFormWindowInterface *fw = qobject_cast<QDesignerFormWindowInterface*>(object)) {

            return fw;

        } else {

            QWidget *w = qobject_cast<QWidget *>(object);

            // QDesignerMenu is a window, so stopFindAtTopLevel(w) returns 0.

            // However, we want to find the form window for QActions of a menu.

            // If this check is inside stopFindAtTopLevel(w), it will break designer

            // menu editing (e.g. when clicking on items inside an opened menu)

            if (w && w->isWindow() && stopFindAtTopLevel(w, false))

                break;

        }

        object = object->parent();

    }

    return 0;

}

/*!

    \fn virtual QString QDesignerFormWindowInterface::fileName() const

    Returns the file name of the UI file that describes the form

    currently being shown.

    \sa setFileName()

*/

/*!

    \fn virtual QDir QDesignerFormWindowInterface::absoluteDir() const

    Returns the absolute location of the directory containing the form

    shown in the form window.

*/

/*!

    \fn virtual QString QDesignerFormWindowInterface::contents() const

    Returns details of the contents of the form currently being

    displayed in the window.

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setContents(QIODevice *device)

    Sets the form's contents using data obtained from the given \a device.

    Data can be read from QFile objects or any other subclass of QIODevice.

*/

/*!

    \fn virtual Feature QDesignerFormWindowInterface::features() const

    Returns a combination of the features provided by the form window

    associated with the interface. The value returned can be tested

    against the \l Feature enum values to determine which features are

    supported by the window.

    \sa setFeatures(), hasFeature()

*/

/*!

    \fn virtual bool QDesignerFormWindowInterface::hasFeature(Feature feature) const

    Returns true if the form window offers the specified \a feature;

    otherwise returns false.

    \sa features()

*/

/*!

    \fn virtual QString QDesignerFormWindowInterface::author() const

    Returns details of the author or creator of the form currently

    being displayed in the window.

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setAuthor(const QString &author)

    Sets the details for the author or creator of the form to the \a

    author specified.

*/

/*!

    \fn virtual QString QDesignerFormWindowInterface::comment() const

    Returns comments about the form currently being displayed in the window.

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setComment(const QString &comment)

    Sets the information about the form to the \a comment

    specified. This information should be a human-readable comment

    about the form.

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::layoutDefault(int *margin, int *spacing)

    Fills in the default margin and spacing for the form's default

    layout in the \a margin and \a spacing variables specified.

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setLayoutDefault(int margin, int spacing)

    Sets the default \a margin and \a spacing for the form's layout.

    \sa layoutDefault()

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::layoutFunction(QString *margin, QString *spacing)

    Fills in the current margin and spacing for the form's layout in

    the \a margin and \a spacing variables specified.

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setLayoutFunction(const QString &margin, const QString &spacing)

    Sets the \a margin and \a spacing for the form's layout.

    The default layout properties will be replaced by the

    corresponding layout functions when \c uic generates code for the

    form, that is, if the functions are specified. This is useful when

    different environments requires different layouts for the same

    form.

    \sa layoutFunction()

*/

/*!

    \fn virtual QString QDesignerFormWindowInterface::pixmapFunction() const

    Returns the name of the function used to load pixmaps into the

    form window.

    \sa setPixmapFunction()

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setPixmapFunction(const QString &pixmapFunction)

    Sets the function used to load pixmaps into the form window

    to the given \a pixmapFunction.

    \sa pixmapFunction()

*/

/*!

    \fn virtual QString QDesignerFormWindowInterface::exportMacro() const

    Returns the export macro associated with the form currently being

    displayed in the window.  The export macro is used when the form

    is compiled to create a widget plugin.

    \sa {Creating Custom Widgets for Qt Designer}

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setExportMacro(const QString &exportMacro)

    Sets the form window's export macro to \a exportMacro. The export

    macro is used when building a widget plugin to export the form's

    interface to other components.

*/

/*!

    \fn virtual QStringList QDesignerFormWindowInterface::includeHints() const

    Returns a list of the header files that will be included in the

    form window's associated UI file.

    Header files may be local, i.e. relative to the project's

    directory, \c "mywidget.h", or global, i.e. part of Qt or the

    compilers standard libraries: \c <QtGui/QWidget>.

    \sa setIncludeHints()

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setIncludeHints(const QStringList &includeHints)

    Sets the header files that will be included in the form window's

    associated UI file to the specified \a includeHints.

    Header files may be local, i.e. relative to the project's

    directory, \c "mywidget.h", or global, i.e. part of Qt or the

    compilers standard libraries: \c <QtGui/QWidget>.

    \sa includeHints()

*/

/*!

    \fn virtual QDesignerFormWindowCursorInterface *QDesignerFormWindowInterface::cursor() const

    Returns the cursor interface used by the form window.

*/

/*!

    \fn virtual int QDesignerFormWindowInterface::toolCount() const

    Returns the number of tools available.

    \internal

*/

/*!

    \fn virtual int QDesignerFormWindowInterface::currentTool() const

    Returns the index of the current tool in use.

    \sa setCurrentTool()

    \internal

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setCurrentTool(int index)

    Sets the current tool to be the one with the given \a index.

    \sa currentTool()

    \internal

*/

/*!

    \fn virtual QDesignerFormWindowToolInterface *QDesignerFormWindowInterface::tool(int index) const

    Returns an interface to the tool with the given \a index.

    \internal

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::registerTool(QDesignerFormWindowToolInterface *tool)

    Registers the given \a tool with the form window.

    \internal

*/

/*!

    \fn virtual QPoint QDesignerFormWindowInterface::grid() const = 0

    Returns the grid spacing used by the form window.

    \sa setGrid()

*/

/*!

    \fn virtual QWidget *QDesignerFormWindowInterface::mainContainer() const

    Returns the main container widget for the form window.

    \sa setMainContainer()

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::setMainContainer(QWidget *mainContainer)

    Sets the main container widget on the form to the specified \a

    mainContainer.

    \sa mainContainer(), mainContainerChanged()

*/

/*!

    \fn virtual bool QDesignerFormWindowInterface::isManaged(QWidget *widget) const

    Returns true if the specified \a widget is managed by the form

    window; otherwise returns false.

    \sa manageWidget()

*/

/*!

    \fn virtual bool QDesignerFormWindowInterface::isDirty() const

    Returns true if the form window is "dirty" (modified but not

    saved); otherwise returns false.

    \sa setDirty()

*/

/*!

    \fn virtual QUndoStack *QDesignerFormWindowInterface::commandHistory() const

    Returns an object that can be used to obtain the commands used so

    far in the construction of the form.

    \internal

*/

/*!

    \fn virtual void QDesignerFormWindowInterface::beginCommand(const QString &description)