Merge commit 'qt/master'

Conflicts:
	doc/src/examples.qdoc
	doc/src/plugins-howto.qdoc
	doc/src/topics.qdoc
	examples/phonon/musicplayer/mainwindow.cpp
	src/3rdparty/freetype/src/base/ftobjs.c
	src/corelib/global/qglobal.h
	src/corelib/tools/qalgorithms.h
	src/corelib/tools/qshareddata.cpp
	src/corelib/tools/qsharedpointer.cpp
	src/corelib/tools/tools.pri
	src/corelib/xml/qxmlstream.h
	src/gui/painting/painting.pri
	src/gui/widgets/qdatetimeedit.cpp
	tests/auto/qdesktopservices/qdesktopservices.pro
	tests/auto/qgraphicsitem/tst_qgraphicsitem.cpp
	tests/auto/qtextcodec/test/test.pro

1 files changed, 521 insertions, 0 deletions

diff --git a/src/gui/kernel/qsizepolicy.qdoc b/src/gui/kernel/qsizepolicy.qdoc
new file mode 100644
index 0000000..200deb5
--- /dev/null
+++ b/src/gui/kernel/qsizepolicy.qdoc
@@ -0,0 +1,521 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation 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 http://qt.nokia.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QSizePolicy
+    \brief The QSizePolicy class is a layout attribute describing horizontal
+    and vertical resizing policy.
+
+    \ingroup geomanagement
+
+    The size policy of a widget is an expression of its willingness to
+    be resized in various ways, and affects how the widget is treated
+    by the \l{Layout Management}{layout engine}. Each widget returns a
+    QSizePolicy that describes the horizontal and vertical resizing
+    policy it prefers when being laid out. You can change this for
+    a specific widget by changing its QWidget::sizePolicy property.
+
+    QSizePolicy contains two independent QSizePolicy::Policy values
+    and two stretch factors; one describes the widgets's horizontal
+    size policy, and the other describes its vertical size policy. It
+    also contains a flag to indicate whether the height and width of
+    its preferred size are related.
+
+    The horizontal and vertical policies can be set in the
+    constructor, and altered using the setHorizontalPolicy() and
+    setVerticalPolicy() functions. The stretch factors can be set
+    using the setHorizontalStretch() and setVerticalStretch()
+    functions. The flag indicating whether the widget's
+    \l{QWidget::sizeHint()}{sizeHint()} is width-dependent (such as a
+    menu bar or a word-wrapping label) can be set using the
+    setHeightForWidth() function.
+
+    The current size policies and stretch factors be retrieved using
+    the horizontalPolicy(), verticalPolicy(), horizontalStretch() and
+    verticalStretch() functions. Alternatively, use the transpose()
+    function to swap the horizontal and vertical policies and
+    stretches. The hasHeightForWidth() function returns the current
+    status of the flag indicating the size hint dependencies.
+
+    Use the expandingDirections() function to determine whether the
+    associated widget can make use of more space than its
+    \l{QWidget::sizeHint()}{sizeHint()} function indicates, as well as
+    find out in which directions it can expand.
+
+    Finally, the QSizePolicy class provides operators comparing this
+    size policy to a given policy, as well as a QVariant operator
+    storing this QSizePolicy as a QVariant object.
+
+    \sa QSize, QWidget::sizeHint(), QWidget::sizePolicy,
+    QLayoutItem::sizeHint()
+*/
+
+/*!
+    \enum QSizePolicy::PolicyFlag
+
+    These flags are combined together to form the various \l{Policy}
+    values:
+
+    \value GrowFlag  The widget can grow beyond its size hint if necessary.
+    \value ExpandFlag  The widget should get as much space as possible.
+    \value ShrinkFlag  The widget can shrink below its size hint if necessary.
+    \value IgnoreFlag  The widget's size hint is ignored. The widget will get
+        as much space as possible.
+
+    \sa Policy
+*/
+
+/*!
+    \enum QSizePolicy::Policy
+
+    This enum describes the various per-dimension sizing types used
+    when constructing a QSizePolicy.
+
+    \value Fixed  The QWidget::sizeHint() is the only acceptable
+        alternative, so the widget can never grow or shrink (e.g. the
+        vertical direction of a push button).
+
+    \value Minimum  The sizeHint() is minimal, and sufficient. The
+        widget can be expanded, but there is no advantage to it being
+        larger (e.g. the horizontal direction of a push button).
+        It cannot be smaller than the size provided by sizeHint().
+
+    \value Maximum  The sizeHint() is a maximum. The widget can be
+        shrunk any amount without detriment if other widgets need the
+        space (e.g. a separator line).
+        It cannot be larger than the size provided by sizeHint().
+
+    \value Preferred  The sizeHint() is best, but the widget can be
+        shrunk and still be useful. The widget can be expanded, but there
+        is no advantage to it being larger than sizeHint() (the default
+        QWidget policy).
+
+    \value Expanding  The sizeHint() is a sensible size, but the
+        widget can be shrunk and still be useful. The widget can make use
+        of extra space, so it should get as much space as possible (e.g.
+        the horizontal direction of a horizontal slider).
+
+    \value MinimumExpanding  The sizeHint() is minimal, and sufficient.
+        The widget can make use of extra space, so it should get as much
+        space as possible (e.g. the horizontal direction of a horizontal
+        slider).
+
+    \value Ignored  The sizeHint() is ignored. The widget will get as
+        much space as possible.
+
+    \sa PolicyFlag, setHorizontalPolicy(), setVerticalPolicy()
+*/
+
+/*!
+    \fn QSizePolicy::QSizePolicy()
+
+    Constructs a QSizePolicy object with \l Fixed as its horizontal
+    and vertical policies.
+
+    The policies can be altered using the setHorizontalPolicy() and
+    setVerticalPolicy() functions. Use the setHeightForWidth()
+    function if the preferred height of the widget is dependent on the
+    width of the widget (for example, a QLabel with line wrapping).
+
+    \sa setHorizontalStretch(), setVerticalStretch()
+*/
+
+/*!
+    \fn QSizePolicy::QSizePolicy(Policy horizontal, Policy vertical)
+
+    Constructs a QSizePolicy object with the given \a horizontal and
+    \a vertical policies, and DefaultType as the control type.
+
+    Use setHeightForWidth() if the preferred height of the widget is
+    dependent on the width of the widget (for example, a QLabel with
+    line wrapping).
+
+    \sa setHorizontalStretch(), setVerticalStretch()
+*/
+
+/*!
+    \fn QSizePolicy::QSizePolicy(Policy horizontal, Policy vertical, ControlType type)
+    \since 4.3
+
+    Constructs a QSizePolicy object with the given \a horizontal and
+    \a vertical policies, and the specified control \a type.
+
+    Use setHeightForWidth() if the preferred height of the widget is
+    dependent on the width of the widget (for example, a QLabel with
+    line wrapping).
+
+    \sa setHorizontalStretch(), setVerticalStretch(), controlType()
+*/
+
+/*!
+    \fn QSizePolicy::Policy QSizePolicy::horizontalPolicy() const
+
+    Returns the horizontal component of the size policy.
+
+    \sa setHorizontalPolicy(), verticalPolicy(), horizontalStretch()
+*/
+
+/*!
+    \fn QSizePolicy::Policy QSizePolicy::verticalPolicy() const
+
+    Returns the vertical component of the size policy.
+
+    \sa setVerticalPolicy(), horizontalPolicy(), verticalStretch()
+*/
+
+/*!
+    \fn void QSizePolicy::setHorizontalPolicy(Policy policy)
+
+    Sets the horizontal component to the given \a policy.
+
+    \sa horizontalPolicy(), setVerticalPolicy(), setHorizontalStretch()
+*/
+
+/*!
+    \fn void QSizePolicy::setVerticalPolicy(Policy policy)
+
+    Sets the vertical component to the given \a policy.
+
+    \sa verticalPolicy(), setHorizontalPolicy(), setVerticalStretch()
+*/
+
+/*!
+    \fn Qt::Orientations QSizePolicy::expandingDirections() const
+
+    Returns whether a widget can make use of more space than the
+    QWidget::sizeHint() function indicates.
+
+    A value of Qt::Horizontal or Qt::Vertical means that the widget
+    can grow horizontally or vertically (i.e., the horizontal or
+    vertical policy is \l Expanding or \l MinimumExpanding), whereas
+    Qt::Horizontal | Qt::Vertical means that it can grow in both
+    dimensions.
+
+    \sa horizontalPolicy(), verticalPolicy()
+*/
+
+/*!
+    \fn ControlType QSizePolicy::controlType() const
+    \since 4.3
+
+    Returns the control type associated with the widget for which
+    this size policy applies.
+*/
+
+/*!
+    \fn void QSizePolicy::setControlType(ControlType type)
+    \since 4.3
+
+    Sets the control type associated with the widget for which this
+    size policy applies to \a type.
+
+    The control type specifies the type of the widget for which this
+    size policy applies. It is used by some styles, notably
+    QMacStyle, to insert proper spacing between widgets. For example,
+    the Mac OS X Aqua guidelines specify that push buttons should be
+    separated by 12 pixels, whereas vertically stacked radio buttons
+    only require 6 pixels.
+
+    \sa QStyle::layoutSpacing()
+*/
+
+/*!
+    \fn void QSizePolicy::setHeightForWidth(bool dependent)
+
+    Sets the flag determining whether the widget's preferred height
+    depends on its width, to \a dependent.
+
+    \sa hasHeightForWidth()
+*/
+
+/*!
+    \fn bool QSizePolicy::hasHeightForWidth() const
+
+    Returns true if the widget's preferred height depends on its
+    width; otherwise returns false.
+
+    \sa setHeightForWidth()
+*/
+
+/*!
+    \fn bool QSizePolicy::operator==(const QSizePolicy &other) const
+
+    Returns true if this policy is equal to \a other; otherwise
+    returns false.
+
+    \sa operator!=()
+*/
+
+/*!
+    \fn bool QSizePolicy::operator!=(const QSizePolicy &other) const
+
+    Returns true if this policy is different from \a other; otherwise
+    returns false.
+
+    \sa operator==()
+*/
+
+/*!
+    \fn int QSizePolicy::horizontalStretch() const
+
+    Returns the horizontal stretch factor of the size policy.
+
+    \sa setHorizontalStretch(), verticalStretch(), horizontalPolicy()
+*/
+
+/*!
+    \fn int QSizePolicy::verticalStretch() const
+
+    Returns the vertical stretch factor of the size policy.
+
+    \sa setVerticalStretch(), horizontalStretch(), verticalPolicy()
+*/
+
+/*!
+    \fn void QSizePolicy::setHorizontalStretch(uchar stretchFactor)
+
+    Sets the horizontal stretch factor of the size policy to the given \a
+    stretchFactor.
+
+    \sa horizontalStretch(), setVerticalStretch(), setHorizontalPolicy()
+*/
+
+/*!
+    \fn void QSizePolicy::setVerticalStretch(uchar stretchFactor)
+
+    Sets the vertical stretch factor of the size policy to the given
+    \a stretchFactor.
+
+    \sa verticalStretch(), setHorizontalStretch(), setVerticalPolicy()
+*/
+
+/*!
+    \fn void QSizePolicy::transpose()
+
+    Swaps the horizontal and vertical policies and stretches.
+*/
+
+/*!
+    \enum QSizePolicy::ControlType
+    \since 4.3
+
+    This enum specifies the different types of widgets in terms of
+    layout interaction:
+
+    \value DefaultType  The default type, when none is specified.
+    \value ButtonBox  A QDialogButtonBox instance.
+    \value CheckBox  A QCheckBox instance.
+    \value ComboBox  A QComboBox instance.
+    \value Frame  A QFrame instance.
+    \value GroupBox  A QGroupBox instance.
+    \value Label  A QLabel instance.
+    \value Line  A QFrame instance with QFrame::HLine or QFrame::VLine.
+    \value LineEdit  A QLineEdit instance.
+    \value PushButton  A QPushButton instance.
+    \value RadioButton  A QRadioButton instance.
+    \value Slider  A QAbstractSlider instance.
+    \value SpinBox  A QAbstractSpinBox instance.
+    \value TabWidget  A QTabWidget instance.
+    \value ToolButton  A QToolButton instance.
+
+    \sa setControlType(), controlType()
+*/
+
+#ifdef QT3_SUPPORT
+/*!
+    \typedef QSizePolicy::SizeType
+    \compat
+
+    Use the QSizePolicy::Policy enum instead.
+*/
+
+/*!
+    \enum QSizePolicy::ExpandData
+    \compat
+
+    Use the Qt::Orientations enum instead.
+
+    \value NoDirection  Use 0 instead.
+    \value Horizontally  Use Qt::Horizontal instead.
+    \value Vertically  Use Qt::Vertical instead.
+    \value BothDirections  Use Qt::Horizontal | Qt::Vertical instead.
+*/
+
+/*!
+    \fn bool QSizePolicy::mayShrinkHorizontally() const
+
+    Use the horizontalPolicy() function combined with the
+    QSizePolicy::PolicyFlag enum instead.
+
+    \oldcode
+        bool policy = mayShrinkHorizontally();
+    \newcode
+        bool policy = horizontalPolicy() & QSizePolicy::ShrinkFlag;
+    \endcode
+*/
+
+/*!
+    \fn bool QSizePolicy::mayShrinkVertically() const
+
+    Use the verticalPolicy() function combined with the
+    QSizePolicy::PolicyFlag enum instead.
+
+    \oldcode
+        bool policy = mayShrinkVertically();
+    \newcode
+        bool policy = verticalPolicy() & QSizePolicy::ShrinkFlag;
+    \endcode
+*/
+
+/*!
+    \fn bool QSizePolicy::mayGrowHorizontally() const
+
+    Use the horizontalPolicy() function combined with the
+    QSizePolicy::PolicyFlag enum instead.
+
+    \oldcode
+        bool policy = mayGrowHorizontally();
+    \newcode
+        bool policy = horizontalPolicy() & QSizePolicy::GrowFlag;
+    \endcode
+*/
+
+/*!
+    \fn bool QSizePolicy::mayGrowVertically() const
+
+    Use the verticalPolicy() function combined with the
+    QSizePolicy::PolicyFlag enum instead.
+
+    \oldcode
+        bool policy = mayGrowVertically();
+    \newcode
+        bool policy = verticalPolicy() & QSizePolicy::GrowFlag;
+    \endcode
+*/
+
+/*!
+    \fn Qt::QSizePolicy::Orientations QSizePolicy::expanding() const
+
+    Use expandingDirections() instead.
+*/
+
+/*!
+    \fn QSizePolicy::QSizePolicy(Policy horizontal, Policy vertical, bool dependent)
+
+    Use the QSizePolicy() constructor and the setHeightForWidth()
+    function instead.
+
+    \oldcode
+        QSizePolicy *policy = new QSizePolicy(horizontal, vertical, dependent);
+    \newcode
+        QSizePolicy *policy = new QSizePolicy(horizontal, vertical);
+        policy->setHeightForWidth(dependent);
+    \endcode
+*/
+
+/*!
+    \fn QSizePolicy::QSizePolicy(Policy horizontal, Policy vertical, uchar horizontalStretch,
+                                 uchar verticalStretch, bool dependent)
+
+    Use the QSizePolicy() constructor and call the
+    setHorizontalStretch(), setVerticalStretch(), and
+    setHeightForWidth() functions instead.
+
+    \oldcode
+        QSizePolicy *policy = new QSizePolicy(horizontal, vertical,
+                                                                 horizontalStretch, verticalStretch,
+                                                                 dependent);
+    \newcode
+        QSizePolicy *policy = new QSizePolicy(horizontal, vertical);
+        policy->setHorizontalStretch(horizontalStretch);
+        policy->setVerticalStretch(verticalStretch);
+        policy->setHeightForWidth(dependent);
+    \endcode
+*/
+
+/*!
+    \fn QSizePolicy::Policy QSizePolicy::horData() const
+
+    Use horizontalPolicy() instead.
+*/
+
+/*!
+    \fn QSizePolicy::Policy QSizePolicy::verData() const
+
+    Use verticalPolicy() instead.
+*/
+
+/*!
+    \fn void QSizePolicy::setHorData(Policy policy)
+
+    Use setHorizontalPolicy() instead.
+*/
+
+/*!
+    \fn void QSizePolicy::setVerData(Policy policy)
+
+    Use setVerticalPolicy() instead.
+*/
+
+/*!
+    \fn uint QSizePolicy::horStretch() const
+
+    Use horizontalStretch() instead.
+*/
+
+/*!
+    \fn uint QSizePolicy::verStretch() const
+
+    Use verticalStretch() instead.
+*/
+
+/*!
+    \fn void QSizePolicy::setHorStretch(uchar stretch)
+
+    Use setHorizontalStretch() instead.
+*/
+
+/*!
+    \fn void QSizePolicy::setVerStretch(uchar stretch)
+
+    Use setVerticalStretch() instead.
+*/
+#endif