Merge branch 'master' of scm.dev.nokia.troll.no:qt/qt-s60-public into master-integration

* 'master' of scm.dev.nokia.troll.no:qt/qt-s60-public:
  Moved the default dependency targets to default_post.prf.
  Fixed autotest.
  get rid of QPrinterInfoPrivate::isNull member
  QPrinterInfo::supportedPaperSizes(): return early if the info is invalid
  fix QPrinterInfo::defaultPrinter() on win
  micro-optimizations, clean-ups and styling fixes
  refactoring of QPrinterInfo
  minor refactoring of QPrinterInfoPrivate
  use binary search int the string2PaperSize() helper

7 files changed, 342 insertions, 653 deletions

diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index 099619c..51f2538 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -34,6 +34,7 @@ HEADERS += \
         painting/qprinter.h \
         painting/qprinter_p.h \
         painting/qprinterinfo.h \
+        painting/qprinterinfo_p.h \
         painting/qrasterizer_p.h \
         painting/qregion.h \
         painting/qstroker_p.h \
@@ -73,6 +74,7 @@ SOURCES += \
         painting/qprintengine_pdf.cpp \
         painting/qprintengine_ps.cpp \
         painting/qprinter.cpp \
+        painting/qprinterinfo.cpp \
         painting/qrasterizer.cpp \
         painting/qregion.cpp \
         painting/qstroker.cpp \
diff --git a/src/gui/painting/qprinterinfo.qdoc b/src/gui/painting/qprinterinfo.cpp
index 9193213..72f8be3 100644
--- a/src/gui/painting/qprinterinfo.qdoc
+++ b/src/gui/painting/qprinterinfo.cpp
@@ -25,6 +25,16 @@
 **
 ****************************************************************************/
 
+#include "qprinterinfo.h"
+#include "qprinterinfo_p.h"
+
+#ifndef QT_NO_PRINTER
+
+QT_BEGIN_NAMESPACE
+
+QPrinterInfoPrivate QPrinterInfoPrivate::shared_null;
+
+
 /*!
     \class QPrinterInfo
 
@@ -59,60 +69,94 @@
 */
 
 /*!
-    \fn QPrinterInfo::QPrinterInfo()
-
     Constructs an empty QPrinterInfo object.
 
     \sa isNull()
 */
+QPrinterInfo::QPrinterInfo()
+    : d_ptr(&QPrinterInfoPrivate::shared_null)
+{
+}
 
 /*!
-    \fn QPrinterInfo::QPrinterInfo(const QPrinterInfo& src)
-
-    Constructs a copy of \a src.
+    Constructs a copy of \a other.
 */
+QPrinterInfo::QPrinterInfo(const QPrinterInfo &other)
+    : d_ptr(new QPrinterInfoPrivate(*other.d_ptr))
+{
+}
 
 /*!
-    \fn QPrinterInfo::QPrinterInfo(const QPrinter& printer)
-
     Constructs a QPrinterInfo object from \a printer.
 */
+QPrinterInfo::QPrinterInfo(const QPrinter &printer)
+    : d_ptr(&QPrinterInfoPrivate::shared_null)
+{
+    foreach (const QPrinterInfo &printerInfo, availablePrinters()) {
+        if (printerInfo.printerName() == printer.printerName()) {
+            d_ptr.reset(new QPrinterInfoPrivate(*printerInfo.d_ptr));
+            break;
+        }
+    }
+}
 
 /*!
-    \fn QPrinterInfo::~QPrinterInfo()
+    \internal
+*/
+QPrinterInfo::QPrinterInfo(const QString &name)
+    : d_ptr(new QPrinterInfoPrivate(name))
+{
+}
 
+/*!
     Destroys the QPrinterInfo object. References to the values in the
     object become invalid.
 */
+QPrinterInfo::~QPrinterInfo()
+{
+}
 
 /*!
-    \fn QPrinterInfo& QPrinterInfo::operator=(const QPrinterInfo& src)
-
-    Sets the QPrinterInfo object to be equal to \a src.
+    Sets the QPrinterInfo object to be equal to \a other.
 */
+QPrinterInfo &QPrinterInfo::operator=(const QPrinterInfo &other)
+{
+    Q_ASSERT(d_ptr);
+    d_ptr.reset(new QPrinterInfoPrivate(*other.d_ptr));
+    return *this;
+}
 
 /*!
-    \fn QString QPrinterInfo::printerName() const
-
     Returns the name of the printer.
 
     \sa QPrinter::setPrinterName()
 */
+QString QPrinterInfo::printerName() const
+{
+    const Q_D(QPrinterInfo);
+    return d->name;
+}
 
 /*!
-    \fn bool QPrinterInfo::isNull() const
-
     Returns whether this QPrinterInfo object holds a printer definition.
 
     An empty QPrinterInfo object could result for example from calling
     defaultPrinter() when there are no printers on the system.
 */
+bool QPrinterInfo::isNull() const
+{
+    const Q_D(QPrinterInfo);
+    return d == &QPrinterInfoPrivate::shared_null;
+}
 
 /*!
-    \fn bool QPrinterInfo::isDefault() const
-
     Returns whether this printer is the default printer.
 */
+bool QPrinterInfo::isDefault() const
+{
+    const Q_D(QPrinterInfo);
+    return d->isDefault;
+}
 
 /*!
     \fn QList< QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
@@ -123,3 +167,7 @@
     Not all printer drivers support this query, so the list may be empty.
     On Mac OS X 10.3, this function always returns an empty list.
 */
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprinterinfo.h b/src/gui/painting/qprinterinfo.h
index 063c6b9..c8c9534 100644
--- a/src/gui/painting/qprinterinfo.h
+++ b/src/gui/painting/qprinterinfo.h
@@ -42,9 +42,10 @@
 #ifndef QPRINTERINFO_H
 #define QPRINTERINFO_H
 
-#include <QtGui/QPrinter>
 #include <QtCore/QList>
 
+#include <QtGui/QPrinter>
+
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
@@ -56,15 +57,13 @@ class QPrinterInfoPrivate;
 class QPrinterInfoPrivateDeleter;
 class Q_GUI_EXPORT QPrinterInfo
 {
-Q_DECLARE_PRIVATE(QPrinterInfo)
-
 public:
     QPrinterInfo();
-    QPrinterInfo(const QPrinterInfo& src);
-    QPrinterInfo(const QPrinter& printer);
+    QPrinterInfo(const QPrinterInfo &other);
+    QPrinterInfo(const QPrinter &printer);
     ~QPrinterInfo();
 
-    QPrinterInfo& operator=(const QPrinterInfo& src);
+    QPrinterInfo &operator=(const QPrinterInfo &other);
 
     QString printerName() const;
     bool isNull() const;
@@ -75,8 +74,10 @@ public:
     static QPrinterInfo defaultPrinter();
 
 private:
-    QPrinterInfo(const QString& name);
+    QPrinterInfo(const QString &name);
 
+private:
+    Q_DECLARE_PRIVATE(QPrinterInfo)
     QScopedPointer<QPrinterInfoPrivate, QPrinterInfoPrivateDeleter> d_ptr;
 };
 
diff --git a/src/gui/painting/qprinterinfo_mac.cpp b/src/gui/painting/qprinterinfo_mac.cpp
index 9b199f4..033682a 100644
--- a/src/gui/painting/qprinterinfo_mac.cpp
+++ b/src/gui/painting/qprinterinfo_mac.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include "qprinterinfo.h"
+#include "qprinterinfo_p.h"
 
 #include "private/qt_mac_p.h"
 
@@ -47,189 +48,71 @@ QT_BEGIN_NAMESPACE
 
 #ifndef QT_NO_PRINTER
 
-class QPrinterInfoPrivate
-{
-Q_DECLARE_PUBLIC(QPrinterInfo)
-public:
-    ~QPrinterInfoPrivate();
-    QPrinterInfoPrivate();
-    QPrinterInfoPrivate(const QString& name);
-
-private:
-    QPrinterInfo*                 q_ptr;
-
-    QString                     m_name;
-    bool                        m_default;
-    bool                        m_isNull;
-};
-
-static QPrinterInfoPrivate nullQPrinterInfoPrivate;
-
-class QPrinterInfoPrivateDeleter
-{
-public:
-    static inline void cleanup(QPrinterInfoPrivate *d)
-    {
-        if (d != &nullQPrinterInfoPrivate)
-            delete d;
-    }
-};
-
-extern QPrinter::PaperSize qSizeFTopaperSize(const QSizeF& size);
-
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
+extern QPrinter::PaperSize qSizeFTopaperSize(const QSizeF &size);
 
 QList<QPrinterInfo> QPrinterInfo::availablePrinters()
 {
     QList<QPrinterInfo> printers;
 
-    OSStatus status = noErr;
-    QCFType<CFArrayRef> printerList;
-    status = PMServerCreatePrinterList(kPMServerLocal, &printerList);
-    if (status == noErr) {
-        CFIndex count = CFArrayGetCount(printerList);
-        for (CFIndex i=0; i<count; ++i) {
-            PMPrinter printer = static_cast<PMPrinter>(const_cast<void *>(CFArrayGetValueAtIndex(printerList, i)));
-            QString name = QCFString::toQString(PMPrinterGetName(printer));
-            printers.append(QPrinterInfo(name));
-            if (PMPrinterIsDefault(printer)) {
-                printers[i].d_ptr->m_default = true;
-            }
+    QCFType<CFArrayRef> array;
+    if (PMServerCreatePrinterList(kPMServerLocal, &array) == noErr) {
+        CFIndex count = CFArrayGetCount(array);
+        for (int i = 0; i < count; ++i) {
+            PMPrinter printer = static_cast<PMPrinter>(const_cast<void *>(CFArrayGetValueAtIndex(array, i)));
+            QString printerName = QCFString::toQString(PMPrinterGetName(printer));
+
+            QPrinterInfo printerInfo(printerName);
+            if (PMPrinterIsDefault(printer))
+                printerInfo.d_ptr->isDefault = true;
+            printers.append(printerInfo);
         }
     }
 
     return printers;
 }
 
-QPrinterInfo QPrinterInfo::defaultPrinter(){
-    QList<QPrinterInfo> printers = availablePrinters();
-    for (int c = 0; c < printers.size(); ++c) {
-        if (printers[c].isDefault()) {
-            return printers[c];
-        }
-    }
-    return QPrinterInfo();
-}
-
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
-
-QPrinterInfo::QPrinterInfo(const QPrinter& prn)
-    : d_ptr(&nullQPrinterInfoPrivate)
+QPrinterInfo QPrinterInfo::defaultPrinter()
 {
-    QList<QPrinterInfo> list = availablePrinters();
-    for (int c = 0; c < list.size(); ++c) {
-        if (prn.printerName() == list[c].printerName()) {
-            *this = list[c];
-            return;
-        }
+    QList<QPrinterInfo> printers = availablePrinters();
+    foreach (const QPrinterInfo &printerInfo, printers) {
+        if (printerInfo.isDefault())
+            return printerInfo;
     }
-}
-
-QPrinterInfo::~QPrinterInfo()
-{
-}
-
-QPrinterInfo::QPrinterInfo()
-    : d_ptr(&nullQPrinterInfoPrivate)
-{
-}
-
-QPrinterInfo::QPrinterInfo(const QString& name)
-    : d_ptr(new QPrinterInfoPrivate(name))
-{
-    d_ptr->q_ptr = this;
-}
-
-QPrinterInfo::QPrinterInfo(const QPrinterInfo& src)
-    : d_ptr(&nullQPrinterInfoPrivate)
-{
-    *this = src;
-}
-
-QPrinterInfo& QPrinterInfo::operator=(const QPrinterInfo& src)
-{
-    Q_ASSERT(d_ptr);
-    d_ptr.reset(new QPrinterInfoPrivate(*src.d_ptr));
-    d_ptr->q_ptr = this;
-    return *this;
-}
-
-QString QPrinterInfo::printerName() const
-{
-    const Q_D(QPrinterInfo);
-    return d->m_name;
-}
 
-bool QPrinterInfo::isNull() const
-{
-    const Q_D(QPrinterInfo);
-    return d->m_isNull;
-}
-
-bool QPrinterInfo::isDefault() const
-{
-    const Q_D(QPrinterInfo);
-    return d->m_default;
+    return printers.value(0);
 }
 
 QList<QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
 {
     const Q_D(QPrinterInfo);
 
-    PMPrinter cfPrn = PMPrinterCreateFromPrinterID(QCFString::toCFStringRef(d->m_name));
+    QList<QPrinter::PaperSize> paperSizes;
+    if (isNull())
+        return paperSizes;
 
-    if (!cfPrn) return QList<QPrinter::PaperSize>();
+    PMPrinter cfPrn = PMPrinterCreateFromPrinterID(QCFString::toCFStringRef(d->name));
+    if (!cfPrn)
+        return paperSizes;
 
     CFArrayRef array;
-    OSStatus status = PMPrinterGetPaperList(cfPrn, &array);
-
-    if (status != 0) {
+    if (PMPrinterGetPaperList(cfPrn, &array) != noErr) {
         PMRelease(cfPrn);
-        return QList<QPrinter::PaperSize>();
+        return paperSizes;
     }
 
-    QList<QPrinter::PaperSize> paperList;
     int count = CFArrayGetCount(array);
-    for (int c = 0; c < count; c++) {
-        PMPaper paper = static_cast<PMPaper>(
-                const_cast<void*>(
-                CFArrayGetValueAtIndex(array, c)));
+    for (int i = 0; i < count; ++i) {
+        PMPaper paper = static_cast<PMPaper>(const_cast<void *>(CFArrayGetValueAtIndex(array, i)));
         double width, height;
-        status = PMPaperGetWidth(paper, &width);
-        status |= PMPaperGetHeight(paper, &height);
-        if (status != 0) continue;
-
-        QSizeF size(width * 0.3527, height * 0.3527);
-        paperList.append(qSizeFTopaperSize(size));
+        if (PMPaperGetWidth(paper, &width) == noErr && PMPaperGetHeight(paper, &height) == noErr) {
+            QSizeF size(width * 0.3527, height * 0.3527);
+            paperSizes.append(qSizeFTopaperSize(size));
+        }
     }
 
     PMRelease(cfPrn);
 
-    return paperList;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
-
-QPrinterInfoPrivate::QPrinterInfoPrivate() :
-    q_ptr(NULL),
-    m_default(false),
-    m_isNull(true)
-{
-}
-
-QPrinterInfoPrivate::QPrinterInfoPrivate(const QString& name) :
-    q_ptr(NULL),
-    m_name(name),
-    m_default(false),
-    m_isNull(false)
-{
-}
-
-QPrinterInfoPrivate::~QPrinterInfoPrivate()
-{
+    return paperSizes;
 }
 
 #endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprinterinfo_p.h b/src/gui/painting/qprinterinfo_p.h
new file mode 100644
index 0000000..7781d59
--- /dev/null
+++ b/src/gui/painting/qprinterinfo_p.h
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** 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 QtGui module 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$
+**
+****************************************************************************/
+
+#ifndef QPRINTERINFO_P_H
+#define QPRINTERINFO_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qglobal.h"
+
+#ifndef QT_NO_PRINTER
+
+#include "QtCore/qlist.h"
+
+QT_BEGIN_NAMESPACE
+
+class QPrinterInfoPrivate
+{
+public:
+    QPrinterInfoPrivate(const QString& name = QString()) :
+        name(name), isDefault(false)
+#if (defined(Q_OS_UNIX) && !defined(Q_OS_MAC) && !defined(Q_OS_SYMBIAN)) || defined(Q_WS_QPA)
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+        , cupsPrinterIndex(0), hasPaperSizes(false)
+#endif
+#endif
+    {}
+    ~QPrinterInfoPrivate()
+    {}
+
+    static QPrinterInfoPrivate shared_null;
+
+    QString name;
+    bool isDefault;
+
+#if (defined(Q_OS_UNIX) && !defined(Q_OS_MAC) && !defined(Q_OS_SYMBIAN)) || defined(Q_WS_QPA)
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+    int cupsPrinterIndex;
+    mutable bool hasPaperSizes;
+    mutable QList<QPrinter::PaperSize> paperSizes;
+#endif
+#endif
+};
+
+
+class QPrinterInfoPrivateDeleter
+{
+public:
+    static inline void cleanup(QPrinterInfoPrivate *d)
+    {
+        if (d != &QPrinterInfoPrivate::shared_null)
+            delete d;
+    }
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_PRINTER
+
+#endif // QPRINTERINFO_P_H
diff --git a/src/gui/painting/qprinterinfo_unix.cpp b/src/gui/painting/qprinterinfo_unix.cpp
index 2129aa5..af2e52a 100644
--- a/src/gui/painting/qprinterinfo_unix.cpp
+++ b/src/gui/painting/qprinterinfo_unix.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include "qprinterinfo.h"
+#include "qprinterinfo_p.h"
 
 #include <qfile.h>
 #include <qfileinfo.h>
@@ -60,42 +61,66 @@ QT_BEGIN_NAMESPACE
 
 #ifndef QT_NO_PRINTER
 
-class QPrinterInfoPrivate
-{
-Q_DECLARE_PUBLIC(QPrinterInfo)
-public:
-    QPrinterInfoPrivate();
-    QPrinterInfoPrivate(const QString& name);
-    ~QPrinterInfoPrivate();
-
-    static QPrinter::PaperSize string2PaperSize(const QString& str);
-    static QString pageSize2String(QPrinter::PaperSize size);
-
-private:
-    QString                     m_name;
-    bool                        m_isNull;
-    bool                        m_default;
-    mutable bool                m_mustGetPaperSizes;
-    mutable QList<QPrinter::PaperSize> m_paperSizes;
-    int                         m_cupsPrinterIndex;
-
-    QPrinterInfo*               q_ptr;
+#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+// preserver names in ascending order for the binary search
+static const struct NamedPaperSize {
+    const char *const name;
+    QPrinter::PaperSize size;
+} named_sizes_map[QPrinter::NPageSize] = {
+    { "A0", QPrinter::A0 },
+    { "A1", QPrinter::A1 },
+    { "A2", QPrinter::A2 },
+    { "A3", QPrinter::A3 },
+    { "A4", QPrinter::A4 },
+    { "A5", QPrinter::A5 },
+    { "A6", QPrinter::A6 },
+    { "A7", QPrinter::A7 },
+    { "A8", QPrinter::A8 },
+    { "A9", QPrinter::A9 },
+    { "B0", QPrinter::B0 },
+    { "B1", QPrinter::B1 },
+    { "B10", QPrinter::B10 },
+    { "B2", QPrinter::B2 },
+    { "B4", QPrinter::B4 },
+    { "B5", QPrinter::B5 },
+    { "B6", QPrinter::B6 },
+    { "B7", QPrinter::B7 },
+    { "B8", QPrinter::B8 },
+    { "B9", QPrinter::B9 },
+    { "C5E", QPrinter::C5E },
+    { "Comm10E", QPrinter::Comm10E },
+    { "Custom", QPrinter::Custom },
+    { "DLE", QPrinter::DLE },
+    { "Executive", QPrinter::Executive },
+    { "Folio", QPrinter::Folio },
+    { "Ledger", QPrinter::Ledger },
+    { "Legal", QPrinter::Legal },
+    { "Letter", QPrinter::Letter },
+    { "Tabloid", QPrinter::Tabloid }
 };
 
-static QPrinterInfoPrivate nullQPrinterInfoPrivate;
+inline bool operator<(const char *name, const NamedPaperSize &data)
+{ return qstrcmp(name, data.name) < 0; }
+inline bool operator<(const NamedPaperSize &data, const char *name)
+{ return qstrcmp(data.name, name) < 0; }
 
-class QPrinterInfoPrivateDeleter
+static inline QPrinter::PaperSize string2PaperSize(const char *name)
 {
-public:
-    static inline void cleanup(QPrinterInfoPrivate *d)
-    {
-        if (d != &nullQPrinterInfoPrivate)
-            delete d;
-    }
-};
+    const NamedPaperSize *r = qBinaryFind(named_sizes_map, named_sizes_map + QPrinter::NPageSize, name);
+    if (r - named_sizes_map != QPrinter::NPageSize)
+        return r->size;
+    return QPrinter::Custom;
+}
 
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
+static inline const char *paperSize2String(QPrinter::PaperSize size)
+{
+    for (int i = 0; i < QPrinter::NPageSize; ++i) {
+        if (size == named_sizes_map[i].size)
+            return named_sizes_map[i].name;
+    }
+    return 0;
+}
+#endif
 
 void qt_perhapsAddPrinter(QList<QPrinterDescription> *printers, const QString &name,
                                QString host, QString comment,
@@ -784,12 +809,12 @@ int qt_getLprPrinters(QList<QPrinterDescription>& printers)
 #endif
     }
 
+    QRegExp ps(QLatin1String("[^a-z]ps(?:[^a-z]|$)"));
+    QRegExp lp(QLatin1String("[^a-z]lp(?:[^a-z]|$)"));
+
     int quality = 0;
     int best = 0;
     for (int i = 0; i < printers.size(); ++i) {
-        QRegExp ps(QLatin1String("[^a-z]ps(?:[^a-z]|$)"));
-        QRegExp lp(QLatin1String("[^a-z]lp(?:[^a-z]|$)"));
-
         QString name = printers.at(i).name;
         QString comment = printers.at(i).comment;
         if (quality < 5 && name == dollarPrinter) {
@@ -824,331 +849,77 @@ int qt_getLprPrinters(QList<QPrinterDescription>& printers)
 
 QList<QPrinterInfo> QPrinterInfo::availablePrinters()
 {
-    QList<QPrinterInfo> list;
+    QList<QPrinterInfo> printers;
 
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
-    QCUPSSupport cups;
     if (QCUPSSupport::isAvailable()) {
-        //const ppd_file_t* cupsPPD = cups.currentPPD();
+        QCUPSSupport cups;
         int cupsPrinterCount = cups.availablePrintersCount();
         const cups_dest_t* cupsPrinters = cups.availablePrinters();
-
         for (int i = 0; i < cupsPrinterCount; ++i) {
             QString printerName(QString::fromLocal8Bit(cupsPrinters[i].name));
             if (cupsPrinters[i].instance)
                 printerName += QLatin1Char('/') + QString::fromLocal8Bit(cupsPrinters[i].instance);
-            list.append(QPrinterInfo(printerName));
+
+            QPrinterInfo printerInfo(printerName);
             if (cupsPrinters[i].is_default)
-                list[i].d_ptr->m_default = true;
-            list[i].d_ptr->m_cupsPrinterIndex = i;
+                printerInfo.d_ptr->isDefault = true;
+            printerInfo.d_ptr->cupsPrinterIndex = i;
+            printers.append(printerInfo);
         }
-    } else {
+    } else
 #endif
+           {
         QList<QPrinterDescription> lprPrinters;
         int defprn = qt_getLprPrinters(lprPrinters);
         // populating printer combo
-        QList<QPrinterDescription>::const_iterator i = lprPrinters.constBegin();
-        for(; i != lprPrinters.constEnd(); ++i) {
-            list.append(QPrinterInfo((*i).name));
-        }
-        if (defprn >= 0 && defprn < lprPrinters.size()) {
-            list[defprn].d_ptr->m_default = true;
-        }
-#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
+        foreach (const QPrinterDescription &description, lprPrinters)
+            printers.append(QPrinterInfo(description.name));
+        if (defprn >= 0 && defprn < printers.size())
+            printers[defprn].d_ptr->isDefault = true;
     }
-#endif
 
-    return list;
+    return printers;
 }
 
 QPrinterInfo QPrinterInfo::defaultPrinter()
 {
-    QList<QPrinterInfo> prnList = availablePrinters();
-    for (int i = 0; i < prnList.size(); ++i) {
-        if (prnList[i].isDefault())
-            return prnList[i];
+    QList<QPrinterInfo> printers = availablePrinters();
+    foreach (const QPrinterInfo &printerInfo, printers) {
+        if (printerInfo.isDefault())
+            return printerInfo;
     }
-    return (prnList.size() > 0) ? prnList[0] : QPrinterInfo();
-}
-
-QPrinterInfo::QPrinterInfo()
-    : d_ptr(&nullQPrinterInfoPrivate)
-{
-}
 
-QPrinterInfo::QPrinterInfo(const QPrinterInfo& src)
-    : d_ptr(&nullQPrinterInfoPrivate)
-{
-    *this = src;
+    return printers.value(0);
 }
 
-QPrinterInfo::QPrinterInfo(const QPrinter& printer)
-    : d_ptr(new QPrinterInfoPrivate(printer.printerName()))
+QList<QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
 {
-
-    Q_D(QPrinterInfo);
-    d->q_ptr = this;
-
 #if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
-    QCUPSSupport cups;
-    if (QCUPSSupport::isAvailable()) {
-        int cupsPrinterCount = cups.availablePrintersCount();
-        const cups_dest_t* cupsPrinters = cups.availablePrinters();
-
-        for (int i = 0; i < cupsPrinterCount; ++i) {
-            QString printerName(QString::fromLocal8Bit(cupsPrinters[i].name));
-            if (cupsPrinters[i].instance)
-                printerName += QLatin1Char('/') + QString::fromLocal8Bit(cupsPrinters[i].instance);
-            if (printerName == printer.printerName()) {
-                if (cupsPrinters[i].is_default)
-                    d->m_default = true;
-                d->m_cupsPrinterIndex = i;
-                return;
-            }
-        }
-    } else {
-#endif
-        QList<QPrinterDescription> lprPrinters;
-        int defprn = qt_getLprPrinters(lprPrinters);
-        // populating printer combo
-        QList<QPrinterDescription>::const_iterator i = lprPrinters.constBegin();
-        int c;
-        for(c = 0; i != lprPrinters.constEnd(); ++i, ++c) {
-            if (i->name == printer.printerName()) {
-                if (defprn == c)
-                    d->m_default = true;
-                return;
-            }
-        }
-#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
-    }
-#endif
-
-    // Printer not found.
-    d_ptr.reset(&nullQPrinterInfoPrivate);
-}
-
-QPrinterInfo::QPrinterInfo(const QString& name)
-    : d_ptr(new QPrinterInfoPrivate(name))
-{
-    d_ptr->q_ptr = this;
-}
-
-QPrinterInfo::~QPrinterInfo()
-{
-}
-
-QPrinterInfo& QPrinterInfo::operator=(const QPrinterInfo& src)
-{
-    Q_ASSERT(d_ptr);
-    d_ptr.reset(new QPrinterInfoPrivate(*src.d_ptr));
-    d_ptr->q_ptr = this;
-    return *this;
-}
-
-QString QPrinterInfo::printerName() const
-{
     const Q_D(QPrinterInfo);
-    return d->m_name;
-}
-
-bool QPrinterInfo::isNull() const
-{
-    const Q_D(QPrinterInfo);
-    return d->m_isNull;
-}
 
-bool QPrinterInfo::isDefault() const
-{
-    const Q_D(QPrinterInfo);
-    return d->m_default;
-}
+    if (isNull())
+        return d->paperSizes;
 
-QList< QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
-{
-    const Q_D(QPrinterInfo);
-    if (d->m_mustGetPaperSizes) {
-        d->m_mustGetPaperSizes = false;
+    if (!d->hasPaperSizes) {
+        d->hasPaperSizes = true;
 
-#if !defined(QT_NO_CUPS) && !defined(QT_NO_LIBRARY)
-        QCUPSSupport cups;
         if (QCUPSSupport::isAvailable()) {
             // Find paper sizes from CUPS.
-            cups.setCurrentPrinter(d->m_cupsPrinterIndex);
+            QCUPSSupport cups;
+            cups.setCurrentPrinter(d->cupsPrinterIndex);
             const ppd_option_t* sizes = cups.pageSizes();
             if (sizes) {
-                for (int j = 0; j < sizes->num_choices; ++j) {
-                    d->m_paperSizes.append(
-                        QPrinterInfoPrivate::string2PaperSize(
-                            QLatin1String(sizes->choices[j].choice)));
-                }
+                for (int j = 0; j < sizes->num_choices; ++j)
+                    d->paperSizes.append(string2PaperSize(sizes->choices[j].choice));
             }
         }
-#endif
-
     }
-    return d->m_paperSizes;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
-
-QPrinterInfoPrivate::QPrinterInfoPrivate()
-{
-    m_isNull = true;
-    m_default = false;
-    m_mustGetPaperSizes = true;
-    m_cupsPrinterIndex = 0;
-    q_ptr = 0;
-}
-
-QPrinterInfoPrivate::QPrinterInfoPrivate(const QString& name)
-{
-    m_name = name;
-    m_isNull = false;
-    m_default = false;
-    m_mustGetPaperSizes = true;
-    m_cupsPrinterIndex = 0;
-    q_ptr = 0;
-}
 
-QPrinterInfoPrivate::~QPrinterInfoPrivate()
-{
-}
-
-QPrinter::PaperSize QPrinterInfoPrivate::string2PaperSize(const QString& str)
-{
-    if (str == QLatin1String("A4")) {
-        return QPrinter::A4;
-    } else if (str == QLatin1String("B5")) {
-        return QPrinter::B5;
-    } else if (str == QLatin1String("Letter")) {
-        return QPrinter::Letter;
-    } else if (str == QLatin1String("Legal")) {
-        return QPrinter::Legal;
-    } else if (str == QLatin1String("Executive")) {
-        return QPrinter::Executive;
-    } else if (str == QLatin1String("A0")) {
-        return QPrinter::A0;
-    } else if (str == QLatin1String("A1")) {
-        return QPrinter::A1;
-    } else if (str == QLatin1String("A2")) {
-        return QPrinter::A2;
-    } else if (str == QLatin1String("A3")) {
-        return QPrinter::A3;
-    } else if (str == QLatin1String("A5")) {
-        return QPrinter::A5;
-    } else if (str == QLatin1String("A6")) {
-        return QPrinter::A6;
-    } else if (str == QLatin1String("A7")) {
-        return QPrinter::A7;
-    } else if (str == QLatin1String("A8")) {
-        return QPrinter::A8;
-    } else if (str == QLatin1String("A9")) {
-        return QPrinter::A9;
-    } else if (str == QLatin1String("B0")) {
-        return QPrinter::B0;
-    } else if (str == QLatin1String("B1")) {
-        return QPrinter::B1;
-    } else if (str == QLatin1String("B10")) {
-        return QPrinter::B10;
-    } else if (str == QLatin1String("B2")) {
-        return QPrinter::B2;
-    } else if (str == QLatin1String("B3")) {
-        return QPrinter::B3;
-    } else if (str == QLatin1String("B4")) {
-        return QPrinter::B4;
-    } else if (str == QLatin1String("B6")) {
-        return QPrinter::B6;
-    } else if (str == QLatin1String("B7")) {
-        return QPrinter::B7;
-    } else if (str == QLatin1String("B8")) {
-        return QPrinter::B8;
-    } else if (str == QLatin1String("B9")) {
-        return QPrinter::B9;
-    } else if (str == QLatin1String("C5E")) {
-        return QPrinter::C5E;
-    } else if (str == QLatin1String("Comm10E")) {
-        return QPrinter::Comm10E;
-    } else if (str == QLatin1String("DLE")) {
-        return QPrinter::DLE;
-    } else if (str == QLatin1String("Folio")) {
-        return QPrinter::Folio;
-    } else if (str == QLatin1String("Ledger")) {
-        return QPrinter::Ledger;
-    } else if (str == QLatin1String("Tabloid")) {
-        return QPrinter::Tabloid;
-    } else {
-        return QPrinter::Custom;
-    }
-}
-
-QString QPrinterInfoPrivate::pageSize2String(QPrinter::PaperSize size)
-{
-    switch (size) {
-    case QPrinter::A4:
-        return QLatin1String("A4");
-    case QPrinter::B5:
-        return QLatin1String("B5");
-    case QPrinter::Letter:
-        return QLatin1String("Letter");
-    case QPrinter::Legal:
-        return QLatin1String("Legal");
-    case QPrinter::Executive:
-        return QLatin1String("Executive");
-    case QPrinter::A0:
-        return QLatin1String("A0");
-    case QPrinter::A1:
-        return QLatin1String("A1");
-    case QPrinter::A2:
-        return QLatin1String("A2");
-    case QPrinter::A3:
-        return QLatin1String("A3");
-    case QPrinter::A5:
-        return QLatin1String("A5");
-    case QPrinter::A6:
-        return QLatin1String("A6");
-    case QPrinter::A7:
-        return QLatin1String("A7");
-    case QPrinter::A8:
-        return QLatin1String("A8");
-    case QPrinter::A9:
-        return QLatin1String("A9");
-    case QPrinter::B0:
-        return QLatin1String("B0");
-    case QPrinter::B1:
-        return QLatin1String("B1");
-    case QPrinter::B10:
-        return QLatin1String("B10");
-    case QPrinter::B2:
-        return QLatin1String("B2");
-    case QPrinter::B3:
-        return QLatin1String("B3");
-    case QPrinter::B4:
-        return QLatin1String("B4");
-    case QPrinter::B6:
-        return QLatin1String("B6");
-    case QPrinter::B7:
-        return QLatin1String("B7");
-    case QPrinter::B8:
-        return QLatin1String("B8");
-    case QPrinter::B9:
-        return QLatin1String("B9");
-    case QPrinter::C5E:
-        return QLatin1String("C5E");
-    case QPrinter::Comm10E:
-        return QLatin1String("Comm10E");
-    case QPrinter::DLE:
-        return QLatin1String("DLE");
-    case QPrinter::Folio:
-        return QLatin1String("Folio");
-    case QPrinter::Ledger:
-        return QLatin1String("Ledger");
-    case QPrinter::Tabloid:
-        return QLatin1String("Tabloid");
-    default:
-        return QLatin1String("Custom");
-    }
+    return d->paperSizes;
+#else
+    return QList<QPrinter::PaperSize>();
+#endif
 }
 
 #endif // QT_NO_PRINTER
diff --git a/src/gui/painting/qprinterinfo_win.cpp b/src/gui/painting/qprinterinfo_win.cpp
index caada1f..2d25063 100644
--- a/src/gui/painting/qprinterinfo_win.cpp
+++ b/src/gui/painting/qprinterinfo_win.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include "qprinterinfo.h"
+#include "qprinterinfo_p.h"
 
 #include <qstringlist.h>
 
@@ -51,59 +52,25 @@ QT_BEGIN_NAMESPACE
 
 extern QPrinter::PaperSize mapDevmodePaperSize(int s);
 
-class QPrinterInfoPrivate
-{
-Q_DECLARE_PUBLIC(QPrinterInfo)
-public:
-    ~QPrinterInfoPrivate();
-    QPrinterInfoPrivate();
-    QPrinterInfoPrivate(const QString& name);
-
-private:
-    QString                     m_name;
-    bool                        m_default;
-    bool                        m_isNull;
-
-    QPrinterInfo*               q_ptr;
-};
-
-static QPrinterInfoPrivate nullQPrinterInfoPrivate;
-
-class QPrinterInfoPrivateDeleter
-{
-public:
-    static inline void cleanup(QPrinterInfoPrivate *d)
-    {
-        if (d != &nullQPrinterInfoPrivate)
-            delete d;
-    }
-};
-
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
-
 QList<QPrinterInfo> QPrinterInfo::availablePrinters()
 {
     QList<QPrinterInfo> printers;
-    LPBYTE buffer;
+
     DWORD needed = 0;
     DWORD returned = 0;
-
-    if ( !EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 4, 0, 0, &needed, &returned))
-    {
-        buffer = new BYTE[needed];
-        if (!EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS , NULL,
-                           4, buffer, needed, &needed, &returned))
-        {
-            delete [] buffer;
-            return printers;
-        }
-        PPRINTER_INFO_4 infoList = reinterpret_cast<PPRINTER_INFO_4>(buffer);
-        QPrinterInfo defPrn = defaultPrinter();
-        for (uint i = 0; i < returned; ++i) {
-            printers.append(QPrinterInfo(QString::fromWCharArray(infoList[i].pPrinterName)));
-            if (printers.at(i).printerName() == defPrn.printerName())
-                printers[i].d_ptr->m_default = true;
+    if (!EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 4, 0, 0, &needed, &returned)) {
+        LPBYTE buffer = new BYTE[needed];
+        if (EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 4, buffer, needed, &needed, &returned)) {
+            PPRINTER_INFO_4 infoList = reinterpret_cast<PPRINTER_INFO_4>(buffer);
+            QPrinterInfo defPrn = defaultPrinter();
+            for (uint i = 0; i < returned; ++i) {
+                QString printerName(QString::fromWCharArray(infoList[i].pPrinterName));
+
+                QPrinterInfo printerInfo(printerName);
+                if (printerInfo.printerName() == defPrn.printerName())
+                    printerInfo.d_ptr->isDefault = true;
+                printers.append(printerInfo);
+            }
         }
         delete [] buffer;
     }
@@ -117,127 +84,37 @@ QPrinterInfo QPrinterInfo::defaultPrinter()
     wchar_t buffer[256];
     GetProfileString(L"windows", L"device", (wchar_t*)noPrinters.utf16(), buffer, 256);
     QString output = QString::fromWCharArray(buffer);
-
-    // Filter out the name of the printer, which should be everything
-    // before a comma.
-    bool noConfiguredPrinters = (output == noPrinters);
-    QStringList info = output.split(QLatin1Char(','));
-    QString printerName = noConfiguredPrinters ? QString() : info.at(0);
-
-    QPrinterInfo prn(printerName);
-    prn.d_ptr->m_default = true;
-    if (noConfiguredPrinters)
-        prn.d_ptr->m_isNull = true;
-    return prn;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
-
-QPrinterInfo::QPrinterInfo()
-    : d_ptr(&nullQPrinterInfoPrivate)
-{
-}
-
-QPrinterInfo::QPrinterInfo(const QString& name)
-    : d_ptr(new QPrinterInfoPrivate(name))
-{
-    d_ptr->q_ptr = this;
-}
-
-QPrinterInfo::QPrinterInfo(const QPrinterInfo& src)
-    : d_ptr(&nullQPrinterInfoPrivate)
-{
-    *this = src;
-}
-
-QPrinterInfo::QPrinterInfo(const QPrinter& prn)
-    : d_ptr(&nullQPrinterInfoPrivate)
-{
-    QList<QPrinterInfo> list = availablePrinters();
-    for (int c = 0; c < list.size(); ++c) {
-        if (prn.printerName() == list[c].printerName()) {
-            *this = list[c];
-            return;
-        }
+    if (output != noPrinters) {
+        // Filter out the name of the printer, which should be everything before a comma.
+        QString printerName = output.split(QLatin1Char(',')).value(0);
+        QPrinterInfo printerInfo(printerName);
+        printerInfo.d_ptr->isDefault = true;
+        return printerInfo;
     }
 
-    *this = QPrinterInfo();
-}
-
-QPrinterInfo::~QPrinterInfo()
-{
-}
-
-QPrinterInfo& QPrinterInfo::operator=(const QPrinterInfo& src)
-{
-    Q_ASSERT(d_ptr);
-    d_ptr.reset(new QPrinterInfoPrivate(*src.d_ptr));
-    d_ptr->q_ptr = this;
-    return *this;
-}
-
-QString QPrinterInfo::printerName() const
-{
-    const Q_D(QPrinterInfo);
-    return d->m_name;
-}
-
-bool QPrinterInfo::isNull() const
-{
-    const Q_D(QPrinterInfo);
-    return d->m_isNull;
-}
-
-bool QPrinterInfo::isDefault() const
-{
-    const Q_D(QPrinterInfo);
-    return d->m_default;
+    return QPrinterInfo();
 }
 
 QList<QPrinter::PaperSize> QPrinterInfo::supportedPaperSizes() const
 {
     const Q_D(QPrinterInfo);
-    QList<QPrinter::PaperSize> paperList;
 
-    DWORD size = DeviceCapabilities(reinterpret_cast<const wchar_t*>(d->m_name.utf16()),
-                                    NULL, DC_PAPERS, NULL, NULL);
-    if ((int)size == -1)
-        return paperList;
-
-    wchar_t *papers = new wchar_t[size];
-    size = DeviceCapabilities(reinterpret_cast<const wchar_t*>(d->m_name.utf16()),
-                              NULL, DC_PAPERS, papers, NULL);
+    QList<QPrinter::PaperSize> paperSizes;
+    if (isNull())
+        return paperSizes;
 
-    for (int c = 0; c < (int)size; ++c) {
-        paperList.append(mapDevmodePaperSize(papers[c]));
+    DWORD size = DeviceCapabilities(reinterpret_cast<const wchar_t*>(d->name.utf16()),
+                                    NULL, DC_PAPERS, NULL, NULL);
+    if ((int)size != -1) {
+        wchar_t *papers = new wchar_t[size];
+        size = DeviceCapabilities(reinterpret_cast<const wchar_t*>(d->name.utf16()),
+                                  NULL, DC_PAPERS, papers, NULL);
+        for (int c = 0; c < (int)size; ++c)
+            paperSizes.append(mapDevmodePaperSize(papers[c]));
+        delete [] papers;
     }
 
-    delete [] papers;
-
-    return paperList;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
-
-QPrinterInfoPrivate::QPrinterInfoPrivate() :
-    m_default(false),
-    m_isNull(true),
-    q_ptr(NULL)
-{
-}
-
-QPrinterInfoPrivate::QPrinterInfoPrivate(const QString& name) :
-    m_name(name),
-    m_default(false),
-    m_isNull(false),
-    q_ptr(NULL)
-{
-}
-
-QPrinterInfoPrivate::~QPrinterInfoPrivate()
-{
+    return paperSizes;
 }
 
 #endif // QT_NO_PRINTER