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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** 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 "abstractsettings_p.h"

#include "previewmanager_p.h"

#include "qdesigner_formbuilder_p.h"

#include "shared_settings_p.h"

#include "shared_settings_p.h"

#include "zoomwidget_p.h"

#include "formwindowbase_p.h"

#include "widgetfactory_p.h"

#include <deviceskin.h>

#include <QtDesigner/QDesignerFormWindowInterface>

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtDesigner/QDesignerFormWindowManagerInterface>

#include <QtGui/QWidget>

#include <QtGui/qevent.h>

#include <QtGui/QDesktopWidget>

#include <QtGui/QMainWindow>

#include <QtGui/QDockWidget>

#include <QtGui/QApplication>

#include <QtGui/QPixmap>

#include <QtGui/QVBoxLayout>

#include <QtGui/QDialog>

#include <QtGui/QMenu>

#include <QtGui/QAction>

#include <QtGui/QActionGroup>

#include <QtGui/QCursor>

#include <QtGui/QMatrix>

#include <QtCore/QMap>

#include <QtCore/QDebug>

#include <QtCore/QSharedData>

QT_BEGIN_NAMESPACE

static inline int compare(const qdesigner_internal::PreviewConfiguration &pc1, const qdesigner_internal::PreviewConfiguration &pc2)

{

    int rc = pc1.style().compare(pc2.style());

    if (rc)

        return rc;

    rc = pc1.applicationStyleSheet().compare(pc2.applicationStyleSheet());

    if (rc)

        return rc;

    return pc1.deviceSkin().compare(pc2.deviceSkin());

}

namespace {

    // ------ PreviewData (data associated with a preview window)

    struct PreviewData {

        PreviewData(const QPointer<QWidget> &widget, const  QDesignerFormWindowInterface *formWindow, const qdesigner_internal::PreviewConfiguration &pc);

        QPointer<QWidget> m_widget;

        const QDesignerFormWindowInterface *m_formWindow;

        qdesigner_internal::PreviewConfiguration m_configuration;

    };

    PreviewData::PreviewData(const QPointer<QWidget>& widget,

                             const QDesignerFormWindowInterface *formWindow,

                             const qdesigner_internal::PreviewConfiguration &pc) :

        m_widget(widget),

        m_formWindow(formWindow),

        m_configuration(pc)

    {

    }

}

namespace qdesigner_internal {

/* In designer, we have the situation that laid-out maincontainers have

 * a geometry set (which might differ from their sizeHint()). The QGraphicsItem

 * should return that in its size hint, else such cases won't work */

class DesignerZoomProxyWidget : public ZoomProxyWidget  {

    Q_DISABLE_COPY(DesignerZoomProxyWidget)

public:

    DesignerZoomProxyWidget(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);

protected:

    virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;

};

DesignerZoomProxyWidget::DesignerZoomProxyWidget(QGraphicsItem *parent, Qt::WindowFlags wFlags) :

    ZoomProxyWidget(parent, wFlags)

{

}

QSizeF DesignerZoomProxyWidget::sizeHint(Qt::SizeHint which, const QSizeF & constraint) const

{

    if (const QWidget *w = widget())

            return QSizeF(w->size());

    return ZoomProxyWidget::sizeHint(which, constraint);

}

// DesignerZoomWidget which returns DesignerZoomProxyWidget in its factory function

class DesignerZoomWidget : public ZoomWidget {

    Q_DISABLE_COPY(DesignerZoomWidget)

public:

    DesignerZoomWidget(QWidget *parent = 0);

private:

    virtual QGraphicsProxyWidget *createProxyWidget(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0) const;

};

DesignerZoomWidget::DesignerZoomWidget(QWidget *parent) :

    ZoomWidget(parent)

{

}

QGraphicsProxyWidget *DesignerZoomWidget::createProxyWidget(QGraphicsItem *parent, Qt::WindowFlags wFlags) const

{

    return new DesignerZoomProxyWidget(parent, wFlags);

}

// PreviewDeviceSkin: Forwards the key events to the window and

// provides context menu with rotation options. Derived class

// can apply additional transformations to the skin.

class PreviewDeviceSkin : public  DeviceSkin

{

    Q_OBJECT

public:

    enum Direction { DirectionUp, DirectionLeft,  DirectionRight };

    explicit PreviewDeviceSkin(const DeviceSkinParameters &parameters, QWidget *parent);

    virtual void setPreview(QWidget *w);

    QSize screenSize() const { return  m_screenSize; }

private slots:

    void slotSkinKeyPressEvent(int code, const QString& text, bool autorep);

    void slotSkinKeyReleaseEvent(int code, const QString& text, bool autorep);

    void slotPopupMenu();

protected:

    virtual void populateContextMenu(QMenu *) {}

private slots:

    void slotDirection(QAction *);

protected:

    // Fit the widget in case the orientation changes (transposing screensize)

    virtual void fitWidget(const QSize &size);    

    //  Calculate the complete transformation for the skin

    // (base class implementation provides rotation).

    virtual QMatrix skinTransform() const;

private:

    const QSize m_screenSize;

    Direction m_direction;

    QAction *m_directionUpAction;

    QAction *m_directionLeftAction;

    QAction *m_directionRightAction;

    QAction *m_closeAction;

};

PreviewDeviceSkin::PreviewDeviceSkin(const DeviceSkinParameters &parameters, QWidget *parent) :

    DeviceSkin(parameters, parent),    

    m_screenSize(parameters.screenSize()),

    m_direction(DirectionUp),

    m_directionUpAction(0),

    m_directionLeftAction(0),

    m_directionRightAction(0),

    m_closeAction(0)

{

    connect(this, SIGNAL(skinKeyPressEvent(int,QString,bool)),

            this, SLOT(slotSkinKeyPressEvent(int,QString,bool)));

    connect(this, SIGNAL(skinKeyReleaseEvent(int,QString,bool)),

            this, SLOT(slotSkinKeyReleaseEvent(int,QString,bool)));

    connect(this, SIGNAL(popupMenu()), this, SLOT(slotPopupMenu()));

}

void PreviewDeviceSkin::setPreview(QWidget *formWidget)

{

    formWidget->setFixedSize(m_screenSize);

    formWidget->setParent(this, Qt::SubWindow);

    formWidget->setAutoFillBackground(true);

    setView(formWidget);

}

void PreviewDeviceSkin::slotSkinKeyPressEvent(int code, const QString& text, bool autorep)

{

    if (QWidget *focusWidget =  QApplication::focusWidget()) {

        QKeyEvent e(QEvent::KeyPress,code,0,text,autorep);

        QApplication::sendEvent(focusWidget, &e);

    }

}

void PreviewDeviceSkin::slotSkinKeyReleaseEvent(int code, const QString& text, bool autorep)

{

    if (QWidget *focusWidget =  QApplication::focusWidget()) {

        QKeyEvent e(QEvent::KeyRelease,code,0,text,autorep);

        QApplication::sendEvent(focusWidget, &e);

    }

}

// Create a checkable action with integer data and

// set it checked if it matches the currentState.

static inline QAction

        *createCheckableActionIntData(const QString &label,

                                      int actionValue, int currentState,

                                      QActionGroup *ag, QObject *parent)

{

    QAction *a = new QAction(label, parent);

    a->setData(actionValue);

    a->setCheckable(true);

    if (actionValue == currentState)

        a->setChecked(true);

    ag->addAction(a);

    return a;

}

void PreviewDeviceSkin::slotPopupMenu()

{

    QMenu menu(this);

    // Create actions

    if (!m_directionUpAction) {

        QActionGroup *directionGroup = new QActionGroup(this);

        connect(directionGroup, SIGNAL(triggered(QAction*)), this, SLOT(slotDirection(QAction*)));

        directionGroup->setExclusive(true);

        m_directionUpAction = createCheckableActionIntData(tr("&Portrait"), DirectionUp, m_direction, directionGroup, this);

	//: Rotate form preview counter-clockwise

        m_directionLeftAction = createCheckableActionIntData(tr("Landscape (&CCW)"), DirectionLeft, m_direction, directionGroup, this);

        //: Rotate form preview clockwise

        m_directionRightAction = createCheckableActionIntData(tr("&Landscape (CW)"), DirectionRight, m_direction, directionGroup, this);

        m_closeAction = new QAction(tr("&Close"), this);

        connect(m_closeAction, SIGNAL(triggered()), parentWidget(), SLOT(close()));

    }

    menu.addAction(m_directionUpAction);

    menu.addAction(m_directionLeftAction);

    menu.addAction(m_directionRightAction);

    menu.addSeparator();

    populateContextMenu(&menu);

    menu.addAction(m_closeAction);

    menu.exec(QCursor::pos());

}

void PreviewDeviceSkin::slotDirection(QAction *a)

{

    const Direction newDirection = static_cast<Direction>(a->data().toInt());

    if (m_direction == newDirection)

        return;

    const Qt::Orientation newOrientation = newDirection == DirectionUp ? Qt::Vertical : Qt::Horizontal;

    const Qt::Orientation oldOrientation = m_direction  == DirectionUp ? Qt::Vertical : Qt::Horizontal;

    m_direction = newDirection;

    QApplication::setOverrideCursor(Qt::WaitCursor);

    if (oldOrientation != newOrientation) {

        QSize size = screenSize();

        if (newOrientation == Qt::Horizontal)

            size.transpose();

        fitWidget(size);

    }

    setTransform(skinTransform());

    QApplication::restoreOverrideCursor();

}

void PreviewDeviceSkin::fitWidget(const QSize &size)

{

    view()->setFixedSize(size);

}

QMatrix PreviewDeviceSkin::skinTransform() const

{

    QMatrix newTransform;    

    switch (m_direction)  {

        case DirectionUp:

            break;

        case DirectionLeft:

            newTransform.rotate(270.0);

            break;

        case DirectionRight:

            newTransform.rotate(90.0);

            break;

    }

    return newTransform;

}

// ------------ PreviewConfigurationPrivate

class PreviewConfigurationData : public QSharedData {

public:

    PreviewConfigurationData() {}

    explicit PreviewConfigurationData(const QString &style, const QString &applicationStyleSheet, const QString &deviceSkin);

    QString m_style;

    // Style sheet to prepend (to simulate the effect od QApplication::setSyleSheet()).

    QString m_applicationStyleSheet;

    QString m_deviceSkin;

};

PreviewConfigurationData::PreviewConfigurationData(const QString &style, const QString &applicationStyleSheet, const QString &deviceSkin) :

    m_style(style),

    m_applicationStyleSheet(applicationStyleSheet),

    m_deviceSkin(deviceSkin)

{

}

/* ZoomablePreviewDeviceSkin: A Zoomable Widget Preview skin. Embeds preview

 *  into a ZoomWidget and this in turn into the DeviceSkin view and keeps

 * Device skin zoom + ZoomWidget zoom in sync. */

class ZoomablePreviewDeviceSkin : public PreviewDeviceSkin

{

    Q_OBJECT

public:

    explicit ZoomablePreviewDeviceSkin(const DeviceSkinParameters &parameters, QWidget *parent);

    virtual void setPreview(QWidget *w);

    int zoomPercent() const; // Device Skins have a double 'zoom' property

public slots:

    void setZoomPercent(int);

signals:

    void zoomPercentChanged(int);

protected:

    virtual void populateContextMenu(QMenu *m);    

    virtual QMatrix skinTransform() const;

    virtual void fitWidget(const QSize &size);

private:

    ZoomMenu *m_zoomMenu;

    QAction *m_zoomSubMenuAction;

    ZoomWidget *m_zoomWidget;

};

ZoomablePreviewDeviceSkin::ZoomablePreviewDeviceSkin(const DeviceSkinParameters &parameters, QWidget *parent) :

    PreviewDeviceSkin(parameters, parent),

    m_zoomMenu(new ZoomMenu(this)),

    m_zoomSubMenuAction(0),

    m_zoomWidget(new DesignerZoomWidget)

{

    connect(m_zoomMenu, SIGNAL(zoomChanged(int)), this, SLOT(setZoomPercent(int)));

    connect(m_zoomMenu, SIGNAL(zoomChanged(int)), this, SIGNAL(zoomPercentChanged(int)));

    m_zoomWidget->setZoomContextMenuEnabled(false);

    m_zoomWidget->setWidgetZoomContextMenuEnabled(false);

    m_zoomWidget->resize(screenSize());

    m_zoomWidget->setParent(this, Qt::SubWindow);

    m_zoomWidget->setAutoFillBackground(true);

    setView(m_zoomWidget);

}

static inline qreal zoomFactor(int percent)

{

    return qreal(percent) / 100.0;

}

static inline QSize scaleSize(int zoomPercent, const QSize &size)

{

    return zoomPercent == 100 ? size : (QSizeF(size) * zoomFactor(zoomPercent)).toSize();

}

void ZoomablePreviewDeviceSkin::setPreview(QWidget *formWidget)

{    

    m_zoomWidget->setWidget(formWidget);

    m_zoomWidget->resize(scaleSize(zoomPercent(), screenSize()));

}

int ZoomablePreviewDeviceSkin::zoomPercent() const

{

    return m_zoomWidget->zoom();

}

void ZoomablePreviewDeviceSkin::setZoomPercent(int zp)

{

    if (zp == zoomPercent())

        return;

    // If not triggered by the menu itself: Update it

    if (m_zoomMenu->zoom() != zp)

        m_zoomMenu->setZoom(zp);

    QApplication::setOverrideCursor(Qt::WaitCursor);    

    m_zoomWidget->setZoom(zp);

    setTransform(skinTransform());

    QApplication::restoreOverrideCursor();

}

void ZoomablePreviewDeviceSkin::populateContextMenu(QMenu *menu)

{

    if (!m_zoomSubMenuAction) {

        m_zoomSubMenuAction = new QAction(tr("&Zoom"), this);

        QMenu *zoomSubMenu = new QMenu;

        m_zoomSubMenuAction->setMenu(zoomSubMenu);

        m_zoomMenu->addActions(zoomSubMenu);

    }

    menu->addAction(m_zoomSubMenuAction);

    menu->addSeparator();

}

QMatrix ZoomablePreviewDeviceSkin::skinTransform() const

{

    // Complete transformation consisting of base class rotation and zoom.

    QMatrix rc = PreviewDeviceSkin::skinTransform();

    const int zp = zoomPercent();

    if (zp != 100) {

        const qreal factor = zoomFactor(zp);

        rc.scale(factor, factor);

    }

    return rc;

}

void ZoomablePreviewDeviceSkin::fitWidget(const QSize &size)

{

    m_zoomWidget->resize(scaleSize(zoomPercent(), size));

}

// ------------- PreviewConfiguration

static const char *styleKey = "Style";

static const char *appStyleSheetKey = "AppStyleSheet";

static const char *skinKey = "Skin";

PreviewConfiguration::PreviewConfiguration() :

    m_d(new PreviewConfigurationData)

{

}

PreviewConfiguration::PreviewConfiguration(const QString &sty, const QString &applicationSheet, const QString &skin) :

    m_d(new PreviewConfigurationData(sty, applicationSheet, skin))

{

}

PreviewConfiguration::PreviewConfiguration(const PreviewConfiguration &o) :

    m_d(o.m_d)

{

}

PreviewConfiguration &PreviewConfiguration::operator=(const PreviewConfiguration &o)

{

    m_d.operator=(o.m_d);

    return *this;

}

PreviewConfiguration::~PreviewConfiguration()

{

}

void PreviewConfiguration::clear()

{

    PreviewConfigurationData &d = *m_d;

    d.m_style.clear();

    d.m_applicationStyleSheet.clear();

    d.m_deviceSkin.clear();

}

QString PreviewConfiguration::style() const

{

    return m_d->m_style;

}

void PreviewConfiguration::setStyle(const QString &s)

{

    m_d->m_style = s;

}

// Style sheet to prepend (to simulate the effect od QApplication::setSyleSheet()).

QString PreviewConfiguration::applicationStyleSheet() const

{

    return m_d->m_applicationStyleSheet;

}

void PreviewConfiguration::setApplicationStyleSheet(const QString &as)

{

    m_d->m_applicationStyleSheet = as;

}

QString PreviewConfiguration::deviceSkin() const

{

    return m_d->m_deviceSkin;

}

void PreviewConfiguration::setDeviceSkin(const QString &s)

{

     m_d->m_deviceSkin = s;

}

void PreviewConfiguration::toSettings(const QString &prefix, QDesignerSettingsInterface *settings) const

{

    const PreviewConfigurationData &d = *m_d;

    settings->beginGroup(prefix);

    settings->setValue(QLatin1String(styleKey),  d.m_style);

    settings->setValue(QLatin1String(appStyleSheetKey), d.m_applicationStyleSheet);

    settings->setValue(QLatin1String(skinKey), d.m_deviceSkin);

    settings->endGroup();

}

void PreviewConfiguration::fromSettings(const QString &prefix, const QDesignerSettingsInterface *settings)

{

    clear();