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:
  Fixed PREPEND_INCLUDEPATH being executed too early.
  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

1 files changed, 91 insertions, 320 deletions

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