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

**

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

#include "qdesigner_utils_p.h"

#include "dynamicpropertysheet.h"

#include "qdesigner_propertyeditor_p.h"

#include "qdesigner_integration_p.h"

#include "spacer_widget_p.h"

#include "qdesigner_propertysheet_p.h"

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtDesigner/QDesignerFormWindowInterface>

#include <QtDesigner/QDesignerFormWindowCursorInterface>

#include <QtDesigner/QDesignerDynamicPropertySheetExtension>

#include <QtDesigner/QDesignerPropertySheetExtension>

#include <QtDesigner/QDesignerPropertyEditorInterface>

#include <QtDesigner/QDesignerObjectInspectorInterface>

#include <QtDesigner/QDesignerIntegrationInterface>

#include <QtDesigner/QDesignerWidgetDataBaseInterface>

#include <QtDesigner/QExtensionManager>

#include <QtCore/QSize>

#include <QtCore/QTextStream>

#include <QtGui/QWidget>

#include <QtGui/QApplication>

#include <QtGui/QAction>

#include <QtGui/QDialog>

#include <QtGui/QPushButton>

#include <QtGui/QLayout>

#include <qdebug.h>

QT_BEGIN_NAMESPACE

namespace  {

enum { debugPropertyCommands = 0 };

// Debug resolve mask of font

QString fontMask(unsigned m)

{

    QString rc;

    if (m & QFont::FamilyResolved)

        rc += QLatin1String("Family");

    if (m & QFont::SizeResolved)

        rc += QLatin1String("Size ");

    if (m & QFont::WeightResolved)

        rc += QLatin1String("Bold ");

    if (m & QFont::StyleResolved)

        rc += QLatin1String("Style ");

    if (m & QFont::UnderlineResolved)

        rc += QLatin1String("Underline ");

    if (m & QFont::StrikeOutResolved)

        rc += QLatin1String("StrikeOut ");

    if (m & QFont::KerningResolved)

        rc += QLatin1String("Kerning ");

    if (m & QFont::StyleStrategyResolved)

        rc += QLatin1String("StyleStrategy");

    return rc;

}

// Debug font

QString fontString(const QFont &f)

{

    QString rc; {

        const QChar comma = QLatin1Char(',');

        QTextStream str(&rc);

        str << QLatin1String("QFont(\"") <<  f.family() << comma <<

            f.pointSize();

        if (f.bold())

            str << comma <<  QLatin1String("bold");

        if (f.italic())

            str << comma <<  QLatin1String("italic");

        if (f.underline())

            str << comma <<  QLatin1String("underline");

        if (f.strikeOut())

            str << comma <<  QLatin1String("strikeOut");

        if (f.kerning())

            str << comma << QLatin1String("kerning");

        str <<  comma << f.styleStrategy() << QLatin1String(" resolve: ")

            << fontMask(f.resolve()) << QLatin1Char(')');

    }

    return rc;

}

QSize checkSize(const QSize &size)

{

    return size.boundedTo(QSize(0xFFFFFF, 0xFFFFFF));

}

QSize diffSize(QDesignerFormWindowInterface *fw)

{

    const QWidget *container = fw->core()->integration()->containerWindow(fw);

    if (!container)

        return QSize();

    const QSize diff = container->size() - fw->size(); // decoration offset of container window

    return diff;

}

void checkSizes(QDesignerFormWindowInterface *fw, const QSize &size, QSize *formSize, QSize *containerSize)

{

    const QWidget *container = fw->core()->integration()->containerWindow(fw);

    if (!container)

        return;

    const  QSize diff = diffSize(fw); // decoration offset of container window

    QSize newFormSize = checkSize(size).expandedTo(fw->mainContainer()->minimumSizeHint()); // don't try to resize to smaller size than minimumSizeHint

    QSize newContainerSize = newFormSize + diff;

    newContainerSize = newContainerSize.expandedTo(container->minimumSizeHint());

    newContainerSize = newContainerSize.expandedTo(container->minimumSize());

    newFormSize = newContainerSize - diff;

    newContainerSize = checkSize(newContainerSize);

    if (formSize)

        *formSize = newFormSize;

    if (containerSize)

        *containerSize = newContainerSize;

}

/* SubProperties: When applying a changed property to a multiselection, it sometimes makes

 * sense to apply only parts (subproperties) of the property.

 * For example, if someone changes the x-value of a geometry in the property editor

 * and applies it to a multi-selection, y should not be applied as this would cause all

 * the widgets to overlap.

 * The following routines can be used to find out the changed subproperties of a property,

 * which are represented as a mask, and to apply them while leaving the others intact. */

enum RectSubPropertyMask {  SubPropertyX=1, SubPropertyY = 2, SubPropertyWidth = 4, SubPropertyHeight = 8 };

enum SizePolicySubPropertyMask { SubPropertyHSizePolicy = 1, SubPropertyHStretch = 2, SubPropertyVSizePolicy = 4, SubPropertyVStretch = 8 };

enum AlignmentSubPropertyMask { SubPropertyHorizontalAlignment = 1, SubPropertyVerticalAlignment = 2 };

enum StringSubPropertyMask { SubPropertyStringValue = 1, SubPropertyStringComment = 2, SubPropertyStringTranslatable = 4, SubPropertyStringDisambiguation = 8 };

enum KeySequenceSubPropertyMask { SubPropertyKeySequenceValue = 1, SubPropertyKeySequenceComment = 2, SubPropertyKeySequenceTranslatable = 4, SubPropertyKeySequenceDisambiguation = 8 };

enum CommonSubPropertyMask { SubPropertyAll = 0xFFFFFFFF };

// Set the mask flag in mask if the properties do not match.

#define COMPARE_SUBPROPERTY(object1, object2, getter, mask, maskFlag) if (object1.getter() != object2.getter()) mask |= maskFlag;

// find changed subproperties of a rectangle

unsigned compareSubProperties(const QRect & r1, const QRect & r2)

{

    unsigned rc = 0;

    COMPARE_SUBPROPERTY(r1, r2, x, rc, SubPropertyX)

    COMPARE_SUBPROPERTY(r1, r2, y, rc, SubPropertyY)

    COMPARE_SUBPROPERTY(r1, r2, width, rc, SubPropertyWidth)

    COMPARE_SUBPROPERTY(r1, r2, height, rc, SubPropertyHeight)

    return rc;

}

// find changed subproperties of a QSize

unsigned compareSubProperties(const QSize & r1, const QSize & r2)

{

    unsigned rc = 0;

    COMPARE_SUBPROPERTY(r1, r2, width,  rc, SubPropertyWidth)

    COMPARE_SUBPROPERTY(r1, r2, height, rc, SubPropertyHeight)

    return rc;

}

// find changed subproperties of a QSizePolicy

unsigned compareSubProperties(const QSizePolicy & sp1, const QSizePolicy & sp2)

{

    unsigned rc = 0;

    COMPARE_SUBPROPERTY(sp1, sp2, horizontalPolicy,  rc, SubPropertyHSizePolicy)

    COMPARE_SUBPROPERTY(sp1, sp2, horizontalStretch, rc, SubPropertyHStretch)

    COMPARE_SUBPROPERTY(sp1, sp2, verticalPolicy,    rc, SubPropertyVSizePolicy)

    COMPARE_SUBPROPERTY(sp1, sp2, verticalStretch,   rc, SubPropertyVStretch)

    return rc;

}

// find changed subproperties of qdesigner_internal::PropertySheetStringValue

unsigned compareSubProperties(const qdesigner_internal::PropertySheetStringValue & str1, const qdesigner_internal::PropertySheetStringValue & str2)

{

    unsigned rc = 0;

    COMPARE_SUBPROPERTY(str1, str2, value,          rc, SubPropertyStringValue)

    COMPARE_SUBPROPERTY(str1, str2, comment,        rc, SubPropertyStringComment)

    COMPARE_SUBPROPERTY(str1, str2, translatable,   rc, SubPropertyStringTranslatable)

    COMPARE_SUBPROPERTY(str1, str2, disambiguation, rc, SubPropertyStringDisambiguation)

    return rc;

}

// find changed subproperties of qdesigner_internal::PropertySheetKeySequenceValue

unsigned compareSubProperties(const qdesigner_internal::PropertySheetKeySequenceValue & str1, const qdesigner_internal::PropertySheetKeySequenceValue & str2)

{

    unsigned rc = 0;

    COMPARE_SUBPROPERTY(str1, str2, value,          rc, SubPropertyKeySequenceValue)

    COMPARE_SUBPROPERTY(str1, str2, comment,        rc, SubPropertyKeySequenceComment)

    COMPARE_SUBPROPERTY(str1, str2, translatable,   rc, SubPropertyKeySequenceTranslatable)

    COMPARE_SUBPROPERTY(str1, str2, disambiguation, rc, SubPropertyKeySequenceDisambiguation)

    return rc;

}

// Compare font-subproperties taking the [undocumented]

// resolve flag into account

template <class Property>

void compareFontSubProperty(const QFont & f1,

                            const QFont & f2,

                            Property (QFont::*getter) () const,

                            unsigned maskBit,

                            unsigned &mask)

{

    const bool f1Changed = f1.resolve() & maskBit;

    const bool f2Changed = f2.resolve() & maskBit;

    // Role has been set/reset in editor

    if (f1Changed != f2Changed) {

        mask |= maskBit;

    } else {

        // Was modified in both palettes: Compare values.

        if (f1Changed && f2Changed && (f1.*getter)() != (f2.*getter)())

            mask |= maskBit;

    }

}

// find changed subproperties of a QFont

unsigned compareSubProperties(const QFont & f1, const QFont & f2)

{

    unsigned rc = 0;

    compareFontSubProperty(f1, f2, &QFont::family,        QFont::FamilyResolved, rc);

    compareFontSubProperty(f1, f2, &QFont::pointSize,     QFont::SizeResolved, rc);

    compareFontSubProperty(f1, f2, &QFont::bold,          QFont::WeightResolved, rc);

    compareFontSubProperty(f1, f2, &QFont::italic,        QFont::StyleResolved, rc);

    compareFontSubProperty(f1, f2, &QFont::underline,     QFont::UnderlineResolved, rc);

    compareFontSubProperty(f1, f2, &QFont::strikeOut,     QFont::StrikeOutResolved, rc);

    compareFontSubProperty(f1, f2, &QFont::kerning,       QFont::KerningResolved, rc);

    compareFontSubProperty(f1, f2, &QFont::styleStrategy, QFont::StyleStrategyResolved, rc);

    if (debugPropertyCommands)

        qDebug() << "compareSubProperties " <<  fontString(f1) << fontString(f2) << "\n\treturns " << fontMask(rc);

    return rc;

}

// Compare colors of a role

bool roleColorChanged(const QPalette & p1, const QPalette & p2, QPalette::ColorRole role)

{

    for (int group = QPalette::Active; group < QPalette::NColorGroups;  group++) {

        const QPalette::ColorGroup pgroup = static_cast<QPalette::ColorGroup>(group);

        if (p1.color(pgroup, role) != p2.color(pgroup, role))

            return true;

    }

    return false;

}

// find changed subproperties of a QPalette taking the [undocumented] resolve flags into account

unsigned compareSubProperties(const QPalette & p1, const QPalette & p2)

{

    unsigned rc = 0;

    unsigned maskBit = 1u;

    // generate a mask for each role

    const unsigned p1Changed = p1.resolve();

    const unsigned p2Changed = p2.resolve();

    for (int role = QPalette::WindowText;  role < QPalette::NColorRoles; role++, maskBit <<= 1u) {

        const bool p1RoleChanged = p1Changed & maskBit;

        const bool p2RoleChanged = p2Changed & maskBit;

        // Role has been set/reset in editor

        if (p1RoleChanged != p2RoleChanged) {

            rc |= maskBit;

        } else {

            // Was modified in both palettes: Compare values.

            if (p1RoleChanged && p2RoleChanged && roleColorChanged(p1, p2, static_cast<QPalette::ColorRole>(role)))

                rc |= maskBit;

        }

    }

    return rc;

}

// find changed subproperties of a QAlignment which is a flag combination of vertical and horizontal

unsigned compareSubProperties(Qt::Alignment a1, Qt::Alignment a2)

{

    unsigned rc = 0;

    if ((a1 & Qt::AlignHorizontal_Mask) != (a2 & Qt::AlignHorizontal_Mask))

        rc |= SubPropertyHorizontalAlignment;

    if ((a1 & Qt::AlignVertical_Mask) != (a2 & Qt::AlignVertical_Mask))

        rc |= SubPropertyVerticalAlignment;

    return rc;

}

Qt::Alignment variantToAlignment(const QVariant & q)

{

    return Qt::Alignment(qdesigner_internal::Utils::valueOf(q));

}

// find changed subproperties of a variant

unsigned compareSubProperties(const QVariant & q1, const QVariant & q2, qdesigner_internal::SpecialProperty specialProperty)

{

    // Do not clobber new value in the comparison function in

    // case someone sets a QString on a PropertySheetStringValue.

    if (q1.type() != q2.type())

        return SubPropertyAll;

    switch (q1.type()) {

    case QVariant::Rect:

        return compareSubProperties(q1.toRect(), q2.toRect());

    case QVariant::Size:

        return compareSubProperties(q1.toSize(), q2.toSize());

    case QVariant::SizePolicy:

        return compareSubProperties(qvariant_cast<QSizePolicy>(q1), qvariant_cast<QSizePolicy>(q2));

    case QVariant::Font:

        return compareSubProperties(qvariant_cast<QFont>(q1), qvariant_cast<QFont>(q2));

    case QVariant::Palette:

        return compareSubProperties(qvariant_cast<QPalette>(q1), qvariant_cast<QPalette>(q2));

    default:

        if (q1.userType() == qMetaTypeId<qdesigner_internal::PropertySheetIconValue>())

            return qvariant_cast<qdesigner_internal::PropertySheetIconValue>(q1).compare(qvariant_cast<qdesigner_internal::PropertySheetIconValue>(q2));

        else if (q1.userType() == qMetaTypeId<qdesigner_internal::PropertySheetStringValue>())

            return compareSubProperties(qvariant_cast<qdesigner_internal::PropertySheetStringValue>(q1), qvariant_cast<qdesigner_internal::PropertySheetStringValue>(q2));

        else if (q1.userType() == qMetaTypeId<qdesigner_internal::PropertySheetKeySequenceValue>())

            return compareSubProperties(qvariant_cast<qdesigner_internal::PropertySheetKeySequenceValue>(q1), qvariant_cast<qdesigner_internal::PropertySheetKeySequenceValue>(q2));

        // Enumerations, flags

        switch (specialProperty) {

        case qdesigner_internal::SP_Alignment:

            return compareSubProperties(variantToAlignment(q1), variantToAlignment(q2));

        default:

        break;

        }

        break;

    }

    return SubPropertyAll;

}

// Apply  the sub property if mask flag is set in mask

#define SET_SUBPROPERTY(rc, newValue, getter, setter, mask, maskFlag) if (mask & maskFlag) rc.setter(newValue.getter());

// apply changed subproperties to a rectangle

QRect applyRectSubProperty(const QRect &oldValue, const QRect &newValue, unsigned mask)

{

    QRect rc = oldValue;

    SET_SUBPROPERTY(rc, newValue, x,      moveLeft,  mask, SubPropertyX)

    SET_SUBPROPERTY(rc, newValue, y,      moveTop,   mask, SubPropertyY)

    SET_SUBPROPERTY(rc, newValue, width,  setWidth,  mask, SubPropertyWidth)

    SET_SUBPROPERTY(rc, newValue, height, setHeight, mask, SubPropertyHeight)

    return rc;

}

// apply changed subproperties to a rectangle QSize

QSize applySizeSubProperty(const QSize &oldValue, const QSize &newValue, unsigned mask)

{

    QSize rc = oldValue;

    SET_SUBPROPERTY(rc, newValue, width,  setWidth,  mask, SubPropertyWidth)

    SET_SUBPROPERTY(rc, newValue, height, setHeight, mask, SubPropertyHeight)

    return rc;

}

// apply changed subproperties to a SizePolicy

QSizePolicy applySizePolicySubProperty(const QSizePolicy &oldValue, const QSizePolicy &newValue, unsigned mask)

{

    QSizePolicy rc = oldValue;

    SET_SUBPROPERTY(rc, newValue, horizontalPolicy,  setHorizontalPolicy,  mask, SubPropertyHSizePolicy)

    SET_SUBPROPERTY(rc, newValue, horizontalStretch, setHorizontalStretch, mask, SubPropertyHStretch)

    SET_SUBPROPERTY(rc, newValue, verticalPolicy,    setVerticalPolicy,    mask, SubPropertyVSizePolicy)

    SET_SUBPROPERTY(rc, newValue, verticalStretch,   setVerticalStretch,   mask, SubPropertyVStretch)

    return rc;

}

// apply changed subproperties to a qdesigner_internal::PropertySheetStringValue

qdesigner_internal::PropertySheetStringValue applyStringSubProperty(const qdesigner_internal::PropertySheetStringValue &oldValue,

            const qdesigner_internal::PropertySheetStringValue &newValue, unsigned mask)

{

    qdesigner_internal::PropertySheetStringValue rc = oldValue;

    SET_SUBPROPERTY(rc, newValue, value, setValue, mask, SubPropertyStringValue)

    SET_SUBPROPERTY(rc, newValue, comment, setComment, mask, SubPropertyStringComment)

    SET_SUBPROPERTY(rc, newValue, translatable, setTranslatable, mask, SubPropertyStringTranslatable)

    SET_SUBPROPERTY(rc, newValue, disambiguation, setDisambiguation, mask, SubPropertyStringDisambiguation)

    return rc;

}

// apply changed subproperties to a qdesigner_internal::PropertySheetKeySequenceValue

qdesigner_internal::PropertySheetKeySequenceValue applyKeySequenceSubProperty(const qdesigner_internal::PropertySheetKeySequenceValue &oldValue,

            const qdesigner_internal::PropertySheetKeySequenceValue &newValue, unsigned mask)

{

    qdesigner_internal::PropertySheetKeySequenceValue rc = oldValue;

    SET_SUBPROPERTY(rc, newValue, value, setValue, mask, SubPropertyKeySequenceValue)

    SET_SUBPROPERTY(rc, newValue, comment, setComment, mask, SubPropertyKeySequenceComment)

    SET_SUBPROPERTY(rc, newValue, translatable, setTranslatable, mask, SubPropertyKeySequenceTranslatable)

    SET_SUBPROPERTY(rc, newValue, disambiguation, setDisambiguation, mask, SubPropertyKeySequenceDisambiguation)

    return rc;

}

// Apply the font-subproperties keeping the [undocumented]

// resolve flag in sync (note that PropertySetterType might be something like const T&).

template <class PropertyReturnType, class PropertySetterType>

inline void setFontSubProperty(unsigned mask,

                               const QFont &newValue,

                               unsigned maskBit,

                               PropertyReturnType (QFont::*getter) () const,

                               void (QFont::*setter) (PropertySetterType),

                               QFont &value)

{

    if (mask & maskBit) {

        (value.*setter)((newValue.*getter)());

        // Set the resolve bit from NewValue in return value

        uint r = value.resolve();

        const bool origFlag = newValue.resolve() & maskBit;

        if (origFlag)

            r |= maskBit;

        else

            r &= ~maskBit;

        value.resolve(r);

        if (debugPropertyCommands)

            qDebug() << "setFontSubProperty " <<  fontMask(maskBit) << " resolve=" << origFlag;

    }

}

// apply changed subproperties to a QFont

QFont applyFontSubProperty(const QFont &oldValue, const QFont &newValue, unsigned mask)

{

    QFont  rc = oldValue;

    setFontSubProperty(mask, newValue, QFont::FamilyResolved,        &QFont::family,        &QFont::setFamily, rc);

    setFontSubProperty(mask, newValue, QFont::SizeResolved,          &QFont::pointSize,     &QFont::setPointSize, rc);

    setFontSubProperty(mask, newValue, QFont::WeightResolved,        &QFont::bold,          &QFont::setBold, rc);

    setFontSubProperty(mask, newValue, QFont::StyleResolved,         &QFont::italic,        &QFont::setItalic, rc);

    setFontSubProperty(mask, newValue, QFont::UnderlineResolved,     &QFont::underline,     &QFont::setUnderline, rc);

    setFontSubProperty(mask, newValue, QFont::StrikeOutResolved,     &QFont::strikeOut,     &QFont::setStrikeOut, rc);

    setFontSubProperty(mask, newValue, QFont::KerningResolved,       &QFont::kerning,       &QFont::setKerning, rc);

    setFontSubProperty(mask, newValue, QFont::StyleStrategyResolved, &QFont::styleStrategy, &QFont::setStyleStrategy, rc);

    if (debugPropertyCommands)

        qDebug() << "applyFontSubProperty old " <<  fontMask(oldValue.resolve()) << " new " << fontMask(newValue.resolve()) << " return: " << fontMask(rc.resolve());

    return rc;

}

// apply changed subproperties to a QPalette

QPalette applyPaletteSubProperty(const QPalette &oldValue, const QPalette &newValue, unsigned mask)

{

    QPalette rc = oldValue;

    // apply a mask for each role

    unsigned maskBit = 1u;

    for (int role = QPalette::WindowText;  role < QPalette::NColorRoles; role++, maskBit <<= 1u) {

        if (mask & maskBit) {

            for (int group = QPalette::Active; group < QPalette::NColorGroups;  group++) {

                const QPalette::ColorGroup pgroup = static_cast<QPalette::ColorGroup>(group);

                const QPalette::ColorRole prole =  static_cast<QPalette::ColorRole>(role);

                rc.setColor(pgroup, prole, newValue.color(pgroup, prole));

            }

            // Set the resolve bit from NewValue in return value

            uint r = rc.resolve();

            const bool origFlag = newValue.resolve() & maskBit;

            if (origFlag)

                r |= maskBit;

            else

                r &= ~maskBit;

            rc.resolve(r);

        }

    }

    return rc;

}

// apply changed subproperties to  a QAlignment which is a flag combination of vertical and horizontal

Qt::Alignment applyAlignmentSubProperty(Qt::Alignment oldValue, Qt::Alignment newValue, unsigned mask)

{

    // easy: both changed.

    if (mask == (SubPropertyHorizontalAlignment|SubPropertyVerticalAlignment))

        return newValue;

    // Change subprop

    const Qt::Alignment changeMask   = (mask & SubPropertyHorizontalAlignment) ? Qt::AlignHorizontal_Mask : Qt::AlignVertical_Mask;

    const Qt::Alignment takeOverMask = (mask & SubPropertyHorizontalAlignment) ? Qt::AlignVertical_Mask   : Qt::AlignHorizontal_Mask;

    return (oldValue & takeOverMask) | (newValue & changeMask);

}

}

namespace qdesigner_internal {

// apply changed subproperties to a variant

PropertyHelper::Value applySubProperty(const QVariant &oldValue, const QVariant &newValue, qdesigner_internal::SpecialProperty specialProperty, unsigned mask, bool changed)

{

    if (mask == SubPropertyAll)

        return PropertyHelper::Value(newValue, changed);

    switch (oldValue.type()) {

    case QVariant::Rect:

        return PropertyHelper::Value(applyRectSubProperty(oldValue.toRect(), newValue.toRect(), mask), changed);

    case QVariant::Size:

        return PropertyHelper::Value(applySizeSubProperty(oldValue.toSize(), newValue.toSize(), mask), changed);

    case QVariant::SizePolicy:

        return PropertyHelper::Value(qVariantFromValue(applySizePolicySubProperty(qvariant_cast<QSizePolicy>(oldValue), qvariant_cast<QSizePolicy>(newValue), mask)), changed);

    case QVariant::Font: {

        // Changed flag in case of font and palette depends on resolve mask only, not on the passed "changed" value.

        // The first case: the user changed bold subproperty and then pressed reset button for this subproperty (not for

        // the whole font property). We instantiate SetPropertyCommand passing changed=true. But in this case no

        // subproperty is changed and the whole property should be marked an unchanged.

        // The second case: there are 2 pushbuttons, for 1st the user set bold and italic subproperties,

        // for the 2nd he set bold only. He does multiselection so that the current widget is the 2nd one.

        // He press reset next to bold subproperty. In result the 2nd widget should have the whole

        // font property marked as unchanged and the 1st widget should have the font property

        // marked as changed and only italic subproperty should be marked as changed (the bold should be reset).

        // The third case: there are 2 pushbuttons, for 1st the user set bold and italic subproperties,

        // for the 2nd he set bold only. He does multiselection so that the current widget is the 2nd one.

        // He press reset button for the whole font property. In result whole font properties for both

        // widgets should be marked as unchanged.

        QFont font = applyFontSubProperty(qvariant_cast<QFont>(oldValue), qvariant_cast<QFont>(newValue), mask);

        return PropertyHelper::Value(qVariantFromValue(font), font.resolve());

        }