Merge lp:~jonas-drange/ubuntu-settings-components/asyncness into lp:~phablet-team/ubuntu-settings-components/printer-components

[Jonas G. Drange]

* rename CupsPkHelper to IppClient
* drop CupsFacade and move everything to PrinterCupsBackend
* add delete functionality
* move PrinterDriverLoader into it's own file
* add PrintersLoader
* break PrintJob API (force clients to use Printers.createJob(printerName)
* fix some read/write bugs that caused unnecessary cups communication
* Add JobFilter
* Moves JobModel to Printers so there is only one.
* Printer::jobs() is now a proxy (filter), lazily coupled with a source model.

[Andrew Hayzen (ahayzen)]

As the diff is so long and LP is truncating, but I still wanted to put my comments inline. I've generated a diff with my first round comments here http://pastebin.ubuntu.com/24002329/

Also removing a 'generic' printer still freezes the example app for me, this is what i see in the cups logs http://pastebin.ubuntu.com/24002348/

review: Needs Fixing

[Jonas G. Drange (jonas-drange)]

> Is there any reason you can't show the printerPageLoaded to start the loading? and then show the ActivityIndicator as an overlay while printer.isLoaded is false?

Yes, it's to stay the warnings. It also will load the printer page a lot quicker. But it's also just an example :)

> QUESTION: Hah! is this to start the lazy load? wonder if there is a better way todo this?

Would love a suggestion. :)

> NOTE: can you check the following and remove if it does?
>>> Cups will notify us (I think.)

It will, removed.

> QUESTION: how costly is this? maybe there could be two private methods:
>> getDest(printerName, instance) and getPpdFile(printerName, instance)

Good idea! Done.

> what is this used or?
>> if (m_printerName.isEmpty()) {
>> throw std::invalid_argument("Trying to refresh unnamed printer.");

It's used to catch bugs. If it throws, then we got in a situation where a printer that's expected to work, has no name, which is an exception and can't be handled properly by that piece of code.

> QUESTION: could the above not be the following to make it a 1 liner?

Done

> FIXME: can the values be set in the member initializer list?
> const QStringList m_knownQualityOptions = QStringList({

Done

>FIXME: can the -1 be set in the member initializer list?
> int m_cupsSubscriptionId = -1;

Done

> NOTE: maybe instead move this inside an else case for the above if
> to make it more clear this is the !accept route and then the comment can
> be removed

Done

> QUESTION: should we call it dest? maybe printerName is better?

Done

> QUESTION: is owner used anymore? is this now user?
> OwnerRole,

It was the owning printer, but now the printer does not own a JobModel anymore (just a proxy), so I've removed it.

> QUESTION: I think the 1 should be 'from'? So it should read like the following
>> !beginMoveRows(QModelIndex(), from, from, QModelIndex(), to)
> As in the examples on http://doc.qt.io/qt-5/qabstractitemmodel.html#beginMoveRows
> they have beginMoveRows(parent, 2, 2, parent, 0); to move one row?

Yup, done

> QUESTION: i think we said that this should be the default case?
> so if anything other than the above cases is hit, lazy load starts

You're right, done.

[Andrew Hayzen (ahayzen)]

I've found supportedPrintQualities doesn't work looks like it is missing setting the ret value in printerGetOptions. This diff fixes it http://pastebin.ubuntu.com/24013170/

review: Needs Fixing

[lp:~jonas-drange/ubuntu-settings-components/asyncness]

253. By Jonas G. Drange on 2017-02-17

addresses andrews comments

[Andrew Hayzen (ahayzen)]

Thanks for those extra fixes to quality and duplex, I think this looks good now and there are follow-up branches fixing further issues. So lets land this :-)

review: Approve

=== modified file 'examples/Printers.qml'
--- examples/Printers.qml	2017-01-27 14:07:29 +0000
+++ examples/Printers.qml	2017-02-17 13:07:34 +0000
@@ -35,14 +35,41 @@
             visible: false
             property var printer
             header: PageHeader {
+                id: printerPageHeader
                 title: printer.name
                 flickable: printerFlickable
             }
 
+            Component {
+                id: printerPageNotYetLoaded
+
+                Item {
+                    anchors.fill: parent
+                    ActivityIndicator {
+                        anchors.centerIn: parent
+                        running: true
+                    }
+                }
+            }
+
+            Component.onCompleted: {
+                printer.description;
+            }
+
             Flickable {
                 id: printerFlickable
                 anchors.fill: parent
 
+                Loader {
+                    id: printerPageBitsLoader
+                    anchors.fill: parent
+                    sourceComponent: printer.isLoaded ? printerPageLoaded : printerPageNotYetLoaded
+                }
+            }
+
+            Component {
+                id: printerPageLoaded
+
                 Column {
                     spacing: units.gu(2)
                     anchors {
@@ -52,6 +79,42 @@
                         right: parent.right
                     }
 
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Enabled"
+
+                        control: Switch {
+                            checked: printer.printerEnabled
+                            onCheckedChanged: printer.printerEnabled = checked
+                        }
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Accepting jobs"
+
+                        control: Switch {
+                            checked: printer.acceptJobs
+                            onCheckedChanged: printer.acceptJobs = checked
+                        }
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Jobs"
+                        progression: true
+                        onClicked: pageStack.push(jobPage, { printer: printer })
+                    }
+
                     Label {
                         anchors {
                             left: parent.left
@@ -143,6 +206,73 @@
         }
     }
 
+    Component {
+        id: jobPage
+        Page {
+            property var printer
+            header: PageHeader {
+                id: jobPageHeader
+                title: "%1 (%2 jobs)".arg(printer.name).arg(jobList.count)
+                flickable: jobList
+            }
+
+            ListView {
+                id: jobList
+                anchors.fill: parent
+                model: printer.jobs
+                delegate: ListItem {
+                    height: jobLayout.height + (divider.visible ? divider.height : 0)
+                    ListItemLayout {
+                        id: jobLayout
+                        title.text: displayName
+
+                        Icon {
+                            id: icon
+                            width: height
+                            height: units.gu(2.5)
+                            name: "stock_document"
+                            SlotsLayout.position: SlotsLayout.First
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    Component {
+        id: allJobsPage
+        Page {
+            header: PageHeader {
+                id: allJobsHeader
+                title: "Printer jobs"
+                flickable: jobsList
+            }
+
+            ListView {
+                id: jobsList
+                anchors.fill: parent
+                model: Printers.printJobs
+                delegate: ListItem {
+                    height: jobsLayout.height + (divider.visible ? divider.height : 0)
+                    ListItemLayout {
+                        id: jobsLayout
+                        title.text: displayName
+
+                        Icon {
+                            id: icon
+                            width: height
+                            height: units.gu(2.5)
+                            name: "stock_document"
+                            SlotsLayout.position: SlotsLayout.First
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
     PageStack {
         id: pageStack
 
@@ -159,6 +289,11 @@
                             iconName: "add"
                             text: "Add printer"
                             onTriggered: pageStack.push(addPrinterPageComponent)
+                        },
+                        Action {
+                            iconName: "document-print"
+                            text: "Printer jobs"
+                            onTriggered: pageStack.push(allJobsPage)
                         }
                     ]
                 }
@@ -171,11 +306,28 @@
                 model: Printers.allPrintersWithPdf
                 delegate: ListItem {
                     height: modelLayout.height + (divider.visible ? divider.height : 0)
+                    trailingActions: ListItemActions {
+                        actions: [
+                            Action {
+                                iconName: "delete"
+                                onTriggered: {
+                                    if (!Printers.removePrinter(model.name)) {
+                                        console.error('failed to remove printer', Printers.lastMessage);
+                                    }
+                                }
+                            },
+                            Action {
+                                iconName: model.default ? "starred" : "non-starred"
+                                enabled: !model.default
+                                onTriggered: Printers.defaultPrinterName = model.name
+                            }
+
+                        ]
+                    }
                     ListItemLayout {
                         id: modelLayout
                         title.text: displayName
                         title.font.bold: model.default
-                        subtitle.text: description
 
                         Icon {
                             id: icon

=== modified file 'plugins/Ubuntu/Settings/Printers/CMakeLists.txt'
--- plugins/Ubuntu/Settings/Printers/CMakeLists.txt	2017-02-03 12:04:46 +0000
+++ plugins/Ubuntu/Settings/Printers/CMakeLists.txt	2017-02-17 13:07:34 +0000
@@ -20,16 +20,21 @@
     backend/backend.cpp
     backend/backend_cups.cpp
     backend/backend_pdf.cpp
-    cups/cupsfacade.cpp
-    cups/cupspkhelper.cpp
-    enums.h
-    i18n.cpp
+
+    cups/ippclient.cpp
+    cups/printerdriverloader.cpp
+    cups/printerloader.cpp
+
     models/drivermodel.cpp
     models/jobmodel.cpp
     models/printermodel.cpp
+
     printer/printer.cpp
     printer/printerjob.cpp
     printers/printers.cpp
+
+    enums.h
+    i18n.cpp
     plugin.cpp
     structs.h
     utils.h

=== modified file 'plugins/Ubuntu/Settings/Printers/backend/backend.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend.cpp	2017-02-06 13:58:14 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend.cpp	2017-02-17 13:07:34 +0000
@@ -16,14 +16,10 @@
 
 #include "backend/backend.h"
 
-PrinterBackend::PrinterBackend(QObject *parent)
-    : QObject(parent)
-{
-}
-
 PrinterBackend::PrinterBackend(const QString &printerName, QObject *parent)
     : QObject(parent)
     , m_printerName(printerName)
+    , m_type(PrinterEnum::PrinterType::ProxyType)
 {
 }
 
@@ -70,6 +66,12 @@
     return QString();
 }
 
+QString PrinterBackend::printerSetDefault(const QString &name)
+{
+    Q_UNUSED(name);
+    return QString();
+}
+
 QString PrinterBackend::printerSetEnabled(const QString &name,
                                           const bool enabled)
 {
@@ -193,8 +195,7 @@
 }
 
 QMap<QString, QVariant> PrinterBackend::printerGetOptions(
-    const QString &name, const QStringList &options
-)
+    const QString &name, const QStringList &options) const
 {
     Q_UNUSED(name);
     Q_UNUSED(options);
@@ -210,34 +211,6 @@
     return Q_NULLPTR;
 }
 
-QList<ColorModel> PrinterBackend::printerGetSupportedColorModels(
-    const QString &name) const
-{
-    Q_UNUSED(name);
-    return QList<ColorModel>();
-}
-
-ColorModel PrinterBackend::printerGetDefaultColorModel(
-    const QString &name) const
-{
-    Q_UNUSED(name);
-    return ColorModel();
-}
-
-QList<PrintQuality> PrinterBackend::printerGetSupportedQualities(
-    const QString &name) const
-{
-    Q_UNUSED(name);
-    return QList<PrintQuality>();
-}
-
-PrintQuality PrinterBackend::printerGetDefaultQuality(
-        const QString &name) const
-{
-    Q_UNUSED(name);
-    return PrintQuality();
-}
-
 void PrinterBackend::cancelJob(const QString &name, const int jobId)
 {
     Q_UNUSED(jobId);
@@ -254,16 +227,22 @@
     return -1;
 }
 
-QList<QSharedPointer<PrinterJob>> PrinterBackend::printerGetJobs(const QString &name)
+QList<QSharedPointer<PrinterJob>> PrinterBackend::printerGetJobs()
 {
-    Q_UNUSED(name);
-
     return QList<QSharedPointer<PrinterJob>>{};
 }
 
+QMap<QString, QVariant> PrinterBackend::printerGetJobAttributes(
+        const QString &name, const int jobId)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(jobId);
+    return QMap<QString, QVariant>();
+}
+
 QString PrinterBackend::printerName() const
 {
-    return QString();
+    return m_printerName;
 }
 
 QString PrinterBackend::description() const
@@ -326,9 +305,9 @@
     return QList<PrinterEnum::DuplexMode>();
 }
 
-QList<Printer*> PrinterBackend::availablePrinters()
+QList<QSharedPointer<Printer>> PrinterBackend::availablePrinters()
 {
-    return QList<Printer*>();
+    return QList<QSharedPointer<Printer>>();
 }
 
 QStringList PrinterBackend::availablePrinterNames()
@@ -336,10 +315,10 @@
     return QStringList();
 }
 
-Printer* PrinterBackend::getPrinter(const QString &printerName)
+QSharedPointer<Printer> PrinterBackend::getPrinter(const QString &printerName)
 {
     Q_UNUSED(printerName);
-    return Q_NULLPTR;
+    return QSharedPointer<Printer>(Q_NULLPTR);
 }
 
 QString PrinterBackend::defaultPrinterName()
@@ -347,13 +326,23 @@
     return QString();
 }
 
-void PrinterBackend::requestAvailablePrinterDrivers()
-{
-}
-
-PrinterBackend::BackendType PrinterBackend::backendType() const
-{
-    return BackendType::DefaultType;
+void PrinterBackend::requestPrinterDrivers()
+{
+}
+
+void PrinterBackend::requestPrinter(const QString &printerName)
+{
+    Q_UNUSED(printerName);
+}
+
+PrinterEnum::PrinterType PrinterBackend::type() const
+{
+    return m_type;
+}
+
+void PrinterBackend::setPrinterNameInternal(const QString &printerName)
+{
+    m_printerName = printerName;
 }
 
 void PrinterBackend::refresh()

=== modified file 'plugins/Ubuntu/Settings/Printers/backend/backend.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend.h	2017-02-03 16:34:49 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend.h	2017-02-17 13:07:34 +0000
@@ -40,14 +40,6 @@
                             QObject *parent = Q_NULLPTR);
     virtual ~PrinterBackend();
 
-    enum class BackendType
-    {
-        DefaultType = 0,
-        CupsType,
-        PdfType,
-    };
-    Q_ENUM(BackendType)
-
     virtual bool holdsDefinition() const;
 
     // Add a printer using an already existing ppd.
@@ -64,11 +56,12 @@
                                       const QString &info,
                                       const QString &location);
     virtual QString printerDelete(const QString &name);
+    virtual QString printerSetDefault(const QString &name);
     virtual QString printerSetEnabled(const QString &name,
                                       const bool enabled);
     virtual QString printerSetAcceptJobs(
         const QString &name,
-        const bool enabled,
+        const bool accept,
         const QString &reason = QString::null);
     virtual QString printerSetInfo(const QString &name,
                                    const QString &info);
@@ -97,28 +90,21 @@
                                      const QString &option,
                                      const QStringList &values);
 
-    // TODO: const for both these getters (if possible)!
     virtual QVariant printerGetOption(const QString &name,
                                       const QString &option) const;
     virtual QMap<QString, QVariant> printerGetOptions(
-        const QString &name, const QStringList &options
-    );
+        const QString &name, const QStringList &options) const;
     // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
     virtual cups_dest_t* makeDest(const QString &name,
                                   const PrinterJob *options);
 
-    virtual QList<ColorModel> printerGetSupportedColorModels(
-        const QString &name) const;
-    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
-    virtual QList<PrintQuality> printerGetSupportedQualities(
-        const QString &name) const;
-    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
-
     virtual void cancelJob(const QString &name, const int jobId);
     virtual int printFileToDest(const QString &filepath,
                                 const QString &title,
                                 const cups_dest_t *dest);
-    virtual QList<QSharedPointer<PrinterJob>> printerGetJobs(const QString &name);
+    virtual QList<QSharedPointer<PrinterJob>> printerGetJobs();
+    virtual QMap<QString, QVariant> printerGetJobAttributes(
+        const QString &name, const int jobId);
 
     virtual QString printerName() const;
     virtual QString description() const;
@@ -136,14 +122,17 @@
     virtual PrinterEnum::DuplexMode defaultDuplexMode() const;
     virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const;
 
-    virtual QList<Printer*> availablePrinters();
+    virtual QList<QSharedPointer<Printer>> availablePrinters();
     virtual QStringList availablePrinterNames();
-    virtual Printer* getPrinter(const QString &printerName);
+    virtual QSharedPointer<Printer> getPrinter(const QString &printerName);
     virtual QString defaultPrinterName();
 
-    virtual void requestAvailablePrinterDrivers();
-
-    virtual BackendType backendType() const;
+    virtual void requestPrinterDrivers();
+    virtual void requestPrinter(const QString &printerName);
+
+    virtual PrinterEnum::PrinterType type() const;
+
+    virtual void setPrinterNameInternal(const QString &printerName);
 
 public Q_SLOTS:
     virtual void refresh();
@@ -152,6 +141,8 @@
     void printerDriversLoaded(const QList<PrinterDriver> &drivers);
     void printerDriversFailedToLoad(const QString &errorMessage);
 
+    void printerLoaded(QSharedPointer<Printer> printers);
+
     void jobCompleted(
         const QString &text,
         const QString &printerUri,
@@ -215,9 +206,18 @@
         const QString &printerStateReason,
         bool acceptingJobs
     );
+    void printerStateChanged(
+        const QString &text,
+        const QString &printerUri,
+        const QString &printerName,
+        uint printerState,
+        const QString &printerStateReason,
+        bool acceptingJobs
+    );
 
 protected:
-    const QString m_printerName;
+    QString m_printerName;
+    PrinterEnum::PrinterType m_type;
 };
 
 #endif // USC_PRINTERS_BACKEND_H

=== modified file 'plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp	2017-02-07 13:42:07 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp	2017-02-17 13:07:34 +0000
@@ -15,39 +15,37 @@
  */
 
 #include "backend/backend_cups.h"
-#include "backend/backend_pdf.h"
-#include "i18n.h"
+#include "cups/printerdriverloader.h"
+#include "cups/printerloader.h"
 #include "utils.h"
 
-#include <QDBusConnection>
+#include <cups/http.h>
+#include <cups/ipp.h>
+#include <cups/ppd.h>
+
 #include <QLocale>
+#include <QThread>
 #include <QTimeZone>
 
-PrinterCupsBackend::PrinterCupsBackend(QObject *parent)
-    : PrinterCupsBackend(new CupsFacade(), QPrinterInfo(),
-                         new OrgCupsCupsdNotifierInterface("",
-                                                           CUPSD_NOTIFIER_DBUS_PATH,
-                                                           QDBusConnection::systemBus()),
-                         parent)
-{
-    // Use proper RAII of things we create:
-    m_cups->setParent(this);
-    m_notifier->setParent(this);
-}
-
-PrinterCupsBackend::PrinterCupsBackend(CupsFacade *cups, QPrinterInfo info,
+#define __CUPS_ADD_OPTION(dest, name, value) dest->num_options = \
+    cupsAddOption(name, value, dest->num_options, &dest->options);
+
+#define __CUPS_ATTR_EXISTS(map, attr, type) map.contains(attr) \
+    && map.value(attr).canConvert<type>()
+
+PrinterCupsBackend::PrinterCupsBackend(IppClient *client, QPrinterInfo info,
                                        OrgCupsCupsdNotifierInterface *notifier,
                                        QObject *parent)
     : PrinterBackend(info.printerName(), parent)
-    , m_cups(cups)
+    , m_knownQualityOptions({
+        "Quality", "PrintQuality", "HPPrintQuality", "StpQuality",
+        "OutputMode",})
+    , m_client(client)
     , m_info(info)
     , m_notifier(notifier)
+    , m_cupsSubscriptionId(-1)
 {
-    connect(m_cups, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)),
-            this, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)));
-    connect(m_cups, SIGNAL(printerDriversFailedToLoad(const QString&)),
-            this, SIGNAL(printerDriversFailedToLoad(const QString&)));
-
+    m_type = PrinterEnum::PrinterType::CupsType;
     connect(m_notifier, SIGNAL(JobCompleted(const QString&, const QString&,
                                             const QString&, uint,
                                             const QString&, bool, uint, uint,
@@ -90,11 +88,29 @@
             this, SIGNAL(printerModified(const QString&, const QString&,
                                          const QString&, uint,
                                          const QString&, bool)));
+    connect(m_notifier, SIGNAL(PrinterStateChanged(const QString&,
+                                                   const QString&,
+                                                   const QString&, uint,
+                                                   const QString&, bool)),
+            this, SIGNAL(printerStateChanged(const QString&, const QString&,
+                                             const QString&, uint,
+                                             const QString&, bool)));
+
 }
 
 PrinterCupsBackend::~PrinterCupsBackend()
 {
+    Q_FOREACH(auto dest, m_dests) {
+        if (dest)
+            cupsFreeDests(1, dest);
+    }
+    Q_FOREACH(auto ppd, m_ppds) {
+        if (ppd)
+            ppdClose(ppd);
+    }
+
     cancelSubscription();
+    Q_EMIT cancelWorkers();
 }
 
 QString PrinterCupsBackend::printerAdd(const QString &name,
@@ -103,7 +119,10 @@
                                        const QString &info,
                                        const QString &location)
 {
-    return m_cups->printerAdd(name, uri, ppdFile, info, location);
+    if (!m_client->printerAdd(name, uri, ppdFile, info, location)) {
+        return m_client->getLastError();
+    }
+    return QString();
 }
 
 QString PrinterCupsBackend::printerAddWithPpd(const QString &name,
@@ -112,7 +131,10 @@
                                               const QString &info,
                                               const QString &location)
 {
-    return m_cups->printerAddWithPpd(name, uri, ppdFileName, info, location);
+    if (!m_client->printerAddWithPpdFile(name, uri, ppdFileName, info, location)) {
+        return m_client->getLastError();
+    }
+    return QString();
 }
 
 bool PrinterCupsBackend::holdsDefinition() const
@@ -122,163 +144,414 @@
 
 QString PrinterCupsBackend::printerDelete(const QString &name)
 {
-    // TODO: implement
-    Q_UNUSED(name);
+    if (!m_client->printerDelete(name)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetDefault(const QString &name)
+{
+    if (!m_client->printerSetDefault(name)) {
+        return m_client->getLastError();
+    }
     return QString();
 }
 
 QString PrinterCupsBackend::printerSetEnabled(const QString &name,
                                               const bool enabled)
 {
-    // TODO: implement
-    Q_UNUSED(name);
-    Q_UNUSED(enabled);
+    if (!m_client->printerSetEnabled(name, enabled)) {
+        return m_client->getLastError();
+    }
     return QString();
 }
 
 QString PrinterCupsBackend::printerSetAcceptJobs(
         const QString &name,
-        const bool enabled,
+        const bool accept,
         const QString &reason)
 {
-    // TODO: implement
-    Q_UNUSED(name);
-    Q_UNUSED(enabled);
-    Q_UNUSED(reason);
+    if (!m_client->printerSetAcceptJobs(name, accept, reason)) {
+        return m_client->getLastError();
+    }
     return QString();
 }
 
 QString PrinterCupsBackend::printerSetInfo(const QString &name,
                                            const QString &info)
 {
-    return m_cups->printerSetInfo(name, info);
+    if (!m_client->printerClassSetInfo(name, info)) {
+        return m_client->getLastError();
+    }
+    return QString();
 }
 
 QString PrinterCupsBackend::printerSetLocation(const QString &name,
                                                const QString &location)
 {
-    return m_cups->printerSetLocation(name, location);
+    Q_UNUSED(name);
+    Q_UNUSED(location);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerSetShared(const QString &name,
                                              const bool shared)
 {
-    return m_cups->printerSetShared(name, shared);
+    Q_UNUSED(name);
+    Q_UNUSED(shared);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerSetJobSheets(const QString &name,
                                                 const QString &start,
                                                 const QString &end)
 {
-    return m_cups->printerSetJobSheets(name, start, end);
+    Q_UNUSED(name);
+    Q_UNUSED(start);
+    Q_UNUSED(end);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerSetErrorPolicy(const QString &name,
                                                   const PrinterEnum::ErrorPolicy &policy)
 {
-    return m_cups->printerSetErrorPolicy(name, policy);
+    Q_UNUSED(name);
+    Q_UNUSED(policy);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerSetOpPolicy(const QString &name,
                                                const PrinterEnum::OperationPolicy &policy)
 {
-    return m_cups->printerSetOpPolicy(name, policy);
+    Q_UNUSED(name);
+    Q_UNUSED(policy);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerSetUsersAllowed(const QString &name,
                                                    const QStringList &users)
 {
-    return m_cups->printerSetUsersAllowed(name, users);
+    Q_UNUSED(name);
+    Q_UNUSED(users);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerSetUsersDenied(const QString &name,
                                                   const QStringList &users)
 {
-    return m_cups->printerSetUsersDenied(name, users);
+    Q_UNUSED(name);
+    Q_UNUSED(users);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerAddOptionDefault(const QString &name,
                                                     const QString &option,
                                                     const QStringList &values)
 {
-    return m_cups->printerAddOptionDefault(name, option, values);
+    Q_UNUSED(name);
+    Q_UNUSED(option);
+    Q_UNUSED(values);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerDeleteOptionDefault(const QString &name,
                                                        const QString &value)
 {
-    return m_cups->printerDeleteOptionDefault(name, value);
+    Q_UNUSED(name);
+    Q_UNUSED(value);
+    return QString();
 }
 
 QString PrinterCupsBackend::printerAddOption(const QString &name,
                                              const QString &option,
                                              const QStringList &values)
 {
-    return m_cups->printerAddOption(name, option, values);
+    if (!m_client->printerClassSetOption(name, option, values)) {
+        return m_client->getLastError();
+    }
+
+    return QString();
 }
 
-    // TODO: const for both these getters (if possible)!
 QVariant PrinterCupsBackend::printerGetOption(const QString &name,
                                               const QString &option) const
 {
-    return m_cups->printerGetOption(name, option);
+    auto res = printerGetOptions(name, QStringList({option}));
+    return res[option];
 }
+
 QMap<QString, QVariant> PrinterCupsBackend::printerGetOptions(
-        const QString &name, const QStringList &options)
+        const QString &name, const QStringList &options) const
 {
-    return m_cups->printerGetOptions(name, options);
+    QMap<QString, QVariant> ret;
+
+    cups_dest_t *dest = getDest(name);
+    ppd_file_t* ppd = getPpd(name);
+
+    if (!dest || !ppd) {
+        return ret;
+    }
+
+    Q_FOREACH(const QString &option, options) {
+        if (option == QStringLiteral("DefaultColorModel")) {
+            ColorModel model;
+            ppd_option_t *ppdColorModel = ppdFindOption(ppd, "ColorModel");
+            if (ppdColorModel) {
+                ppd_choice_t* def = ppdFindChoice(ppdColorModel,
+                                                  ppdColorModel->defchoice);
+                if (def) {
+                    model = Utils::parsePpdColorModel(def->choice,
+                                                      def->text,
+                                                      "ColorModel");
+                }
+            }
+            ret[option] = QVariant::fromValue(model);
+        } else if (option == QStringLiteral("DefaultPrintQuality")) {
+            PrintQuality quality;
+            Q_FOREACH(const QString opt, m_knownQualityOptions) {
+                ppd_option_t *ppdQuality = ppdFindOption(ppd, opt.toUtf8());
+                if (ppdQuality) {
+                    ppd_choice_t* def = ppdFindChoice(ppdQuality,
+                                                      ppdQuality->defchoice);
+                    if (def) {
+                        quality = Utils::parsePpdPrintQuality(def->choice,
+                                                              def->text, opt);
+                    }
+                }
+            }
+            ret[option] = QVariant::fromValue(quality);
+        } else if (option == QStringLiteral("SupportedPrintQualities")) {
+            QList<PrintQuality> qualities;
+            Q_FOREACH(const QString &opt, m_knownQualityOptions) {
+                ppd_option_t *qualityOpt = ppdFindOption(ppd, opt.toUtf8());
+                if (qualityOpt) {
+                    for (int i = 0; i < qualityOpt->num_choices; ++i) {
+                        qualities.append(
+                            Utils::parsePpdPrintQuality(
+                                qualityOpt->choices[i].choice,
+                                qualityOpt->choices[i].text,
+                                opt
+                            )
+                        );
+                    }
+                }
+            }
+            ret[option] = QVariant::fromValue(qualities);
+        } else if (option == QStringLiteral("SupportedColorModels")) {
+            QList<ColorModel> models;
+            ppd_option_t *colorModels = ppdFindOption(ppd, "ColorModel");
+            if (colorModels) {
+                for (int i = 0; i < colorModels->num_choices; ++i) {
+                    models.append(
+                        Utils::parsePpdColorModel(
+                            colorModels->choices[i].choice,
+                            colorModels->choices[i].text,
+                            QStringLiteral("ColorModel")
+                        )
+                    );
+                }
+            }
+            ret[option] = QVariant::fromValue(models);
+        } else if (option == QStringLiteral("AcceptJobs")) {
+            // "true" if the destination is accepting new jobs, "false" if not.
+            QString res = cupsGetOption("printer-is-accepting-jobs",
+                                        dest->num_options, dest->options);
+            ret[option] = res.contains("true");
+        } else {
+            ppd_option_t *val = ppdFindOption(ppd, option.toUtf8());
+
+            if (val) {
+                qWarning() << "asking for" << option << "returns" << val->text;
+            } else {
+                qWarning() << "option" << option << "yielded no option";
+            }
+        }
+    }
+    return ret;
 }
 
 // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
 cups_dest_t* PrinterCupsBackend::makeDest(const QString &name,
                                           const PrinterJob *options)
 {
-    return m_cups->makeDest(name, options);
-}
-
-QList<ColorModel> PrinterCupsBackend::printerGetSupportedColorModels(
-        const QString &name) const
-{
-    return m_cups->printerGetSupportedColorModels(name);
-}
-
-ColorModel PrinterCupsBackend::printerGetDefaultColorModel(
-    const QString &name) const
-{
-    return printerGetOption(name, "DefaultColorModel").value<ColorModel>();
-}
-
-QList<PrintQuality> PrinterCupsBackend::printerGetSupportedQualities(
-        const QString &name) const
-{
-    return m_cups->printerGetSupportedQualities(name);
-}
-
-PrintQuality PrinterCupsBackend::printerGetDefaultQuality(
-        const QString &name) const
-{
-    return printerGetOption(name, "DefaultPrintQuality").value<PrintQuality>();
+    // Get the cups dest
+    cups_dest_t *dest = getDest(name);
+
+    if (options->collate()) {
+        __CUPS_ADD_OPTION(dest, "Collate", "True");
+    } else {
+        __CUPS_ADD_OPTION(dest, "Collate", "False");
+    }
+
+    if (options->copies() > 1) {
+        __CUPS_ADD_OPTION(dest, "copies", QString::number(options->copies()).toLocal8Bit());
+    }
+
+    __CUPS_ADD_OPTION(dest, "ColorModel", options->getColorModel().name.toLocal8Bit());
+    __CUPS_ADD_OPTION(dest, "Duplex", Utils::duplexModeToPpdChoice(options->getDuplexMode()).toLocal8Bit());
+
+    if (options->landscape()) {
+        __CUPS_ADD_OPTION(dest, "landscape", "");
+    }
+
+    if (options->printRangeMode() == PrinterEnum::PrintRange::PageRange
+            && !options->printRange().isEmpty()) {
+        __CUPS_ADD_OPTION(dest, "page-ranges", options->printRange().toLocal8Bit());
+    }
+
+    PrintQuality quality = options->getPrintQuality();
+    __CUPS_ADD_OPTION(dest, quality.originalOption.toLocal8Bit(),
+                      quality.name.toLocal8Bit());
+
+    if (options->reverse()) {
+        __CUPS_ADD_OPTION(dest, "OutputOrder", "Reverse");
+    } else {
+        __CUPS_ADD_OPTION(dest, "OutputOrder", "Normal");
+    }
+
+    // Always scale to fit the page for now
+    __CUPS_ADD_OPTION(dest, "fit-to-page", "True");
+
+    return dest;
 }
 
 void PrinterCupsBackend::cancelJob(const QString &name, const int jobId)
 {
-    m_cups->cancelJob(name, jobId);
+    int ret = cupsCancelJob(name.toLocal8Bit(), jobId);
+
+    if (!ret) {
+        qWarning() << "Failed to cancel job:" << jobId << "for" << name;
+    }
 }
 
 int PrinterCupsBackend::printFileToDest(const QString &filepath,
                                         const QString &title,
                                         const cups_dest_t *dest)
 {
-    return m_cups->printFileToDest(filepath, title, dest);
-}
-
-QList<QSharedPointer<PrinterJob>> PrinterCupsBackend::printerGetJobs(const QString &name)
-{
-    auto jobs = m_cups->printerGetJobs(name);
+    qDebug() << "Printing:" << filepath << title << dest->name << dest->num_options;
+    return cupsPrintFile(dest->name,
+                         filepath.toLocal8Bit(),
+                         title.toLocal8Bit(),
+                         dest->num_options,
+                         dest->options);
+}
+
+
+QList<cups_job_t *> PrinterCupsBackend::getCupsJobs(const QString &name)
+{
+    QList<cups_job_t *> list;
+    cups_job_t *jobs;
+
+    // Get a list of the jobs that are 'mine' and only active ones
+    // https://www.cups.org/doc/api-cups.html#cupsGetJobs
+    int count;
+    if (name.isEmpty()) {
+        count = cupsGetJobs(&jobs, NULL, 1, CUPS_WHICHJOBS_ACTIVE);
+    } else {
+        count = cupsGetJobs(&jobs, name.toLocal8Bit(), 1, CUPS_WHICHJOBS_ACTIVE);
+    }
+
+    for (int i=0; i < count; i++) {
+        list.append(&jobs[i]);
+    }
+
+    return list;
+}
+
+QMap<QString, QVariant> PrinterCupsBackend::printerGetJobAttributes(
+    const QString &name, const int jobId)
+{
+    Q_UNUSED(name);
+    QMap<QString, QVariant> rawMap = m_client->printerGetJobAttributes(jobId);
+    QMap<QString, QVariant> map;
+
+    // Filter attributes to know values
+    // Do this here so we can use things such as m_knownQualityOptions
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "Collate", bool)) {
+        map.insert("Collate", rawMap.value("Collate"));
+    } else {
+        map.insert("Collate", QVariant(true));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "copies", int)) {
+        map.insert("copies", rawMap.value("copies"));
+    } else {
+        map.insert("copies", QVariant(1));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "ColorModel", QString)) {
+        map.insert("ColorModel", rawMap.value("ColorModel"));
+    } else {
+        map.insert("ColorModel", QVariant(""));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "Duplex", QString)) {
+        map.insert("Duplex", rawMap.value("Duplex"));
+    } else {
+        map.insert("Duplex", QVariant(""));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "landscape", bool)) {
+        map.insert("landscape", rawMap.value("landscape"));
+    } else {
+        map.insert("landscape", QVariant(false));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "page-ranges", QList<QVariant>)) {
+        QList<QVariant> range = rawMap.value("page-ranges").toList();
+        QStringList rangeStrings;
+
+        Q_FOREACH(QVariant var, range) {
+            rangeStrings << var.toString();
+        }
+
+        map.insert("page-ranges", QVariant(rangeStrings));
+    } else {
+        map.insert("page-ranges", QVariant(QStringList()));
+    }
+
+    Q_FOREACH(QString qualityOption, m_knownQualityOptions) {
+        if (rawMap.contains(qualityOption)
+                && rawMap.value(qualityOption).canConvert<QString>()) {
+            map.insert("quality", rawMap.value(qualityOption).toString());
+        }
+    }
+
+    if (!map.contains("quality")) {
+        map.insert("quality", QVariant(""));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "OutputOrder", QString)) {
+        map.insert("OutputOrder", rawMap.value("OutputOrder"));
+    } else {
+        map.insert("OutputOrder", "Normal");
+    }
+
+    // Generate a list of messages
+    // TODO: for now just using job-printer-state-message, are there others?
+    QStringList messages;
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "job-printer-state-message", QString)) {
+        messages << rawMap.value("job-printer-state-message").toString();
+    }
+
+    map.insert("messages", QVariant(messages));
+
+    return map;
+}
+
+
+QList<QSharedPointer<PrinterJob>> PrinterCupsBackend::printerGetJobs()
+{
+    auto jobs = getCupsJobs();
     QList<QSharedPointer<PrinterJob>> list;
 
     Q_FOREACH(auto job, jobs) {
-        QSharedPointer<PrinterJob> newJob = QSharedPointer<PrinterJob>(new PrinterJob(name, this, job->id));
+        auto newJob = QSharedPointer<PrinterJob>(
+            new PrinterJob(QString::fromUtf8(job->dest), this, job->id)
+        );
 
         // Extract the times
         QDateTime completedTime;
@@ -302,63 +575,7 @@
         newJob->setTitle(QString::fromLocal8Bit(job->title));
         newJob->setUser(QString::fromLocal8Bit(job->user));
 
-        // Load the extra attributes for the job
-        // NOTE: we don't need to type check them as they have been filtered for us
-        QMap<QString, QVariant> attributes = m_cups->printerGetJobAttributes(name, job->id);
-
-        newJob->setCollate(attributes.value("Collate").toBool());
-        newJob->setCopies(attributes.value("copies").toInt());
-
-        // No colorModel will result in PrinterJob using defaultColorModel
-        if (!newJob->printer()) {
-            QString colorModel = attributes.value("ColorModel").toString();
-
-            for (int i=0; i < newJob->printer()->supportedColorModels().length(); i++) {
-                if (newJob->printer()->supportedColorModels().at(i).originalOption == colorModel) {
-                    newJob->setColorModel(i);
-                }
-            }
-        }
-
-        // No duplexMode will result in PrinterJob using defaultDuplexMode
-        if (!newJob->printer()) {
-            QString duplex = attributes.value("Duplex").toString();
-            PrinterEnum::DuplexMode duplexMode = Utils::ppdChoiceToDuplexMode(duplex);
-
-            for (int i=0; i < newJob->printer()->supportedDuplexModes().length(); i++) {
-                if (newJob->printer()->supportedDuplexModes().at(i) == duplexMode) {
-                    newJob->setDuplexMode(i);
-                }
-            }
-        }
-
-        newJob->setLandscape(attributes.value("landscape").toBool());
-        newJob->setMessages(attributes.value("messages").toStringList());
-
-        QStringList pageRanges = attributes.value("page-ranges").toStringList();
-
-        if (pageRanges.isEmpty()) {
-            newJob->setPrintRangeMode(PrinterEnum::PrintRange::AllPages);
-            newJob->setPrintRange(QStringLiteral(""));
-        } else {
-            newJob->setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
-            // Use groupSeparator as createSeparatedList adds "and" into the string
-            newJob->setPrintRange(pageRanges.join(QLocale::system().groupSeparator()));
-        }
-
-        // No quality will result in PrinterJob using defaultPrintQuality
-        if (!newJob->printer()) {
-            QString quality = attributes.value("quality").toString();
-
-            for (int i=0; i < newJob->printer()->supportedPrintQualities().length(); i++) {
-                if (newJob->printer()->supportedPrintQualities().at(i).name == quality) {
-                    newJob->setQuality(i);
-                }
-            }
-        }
-
-        newJob->setReverse(attributes.value("OutputOrder").toString() == "Reverse");
-
+        cupsFreeJobs(1, job);
         list.append(newJob);
     }
 
@@ -367,7 +584,7 @@
 
 QString PrinterCupsBackend::printerName() const
 {
-    return m_info.printerName();
+    return m_printerName;
 }
 
 QString PrinterCupsBackend::description() const
@@ -377,14 +594,12 @@
 
 QString PrinterCupsBackend::location() const
 {
-    // TODO: implement
-    return QString();
+    return m_info.location();
 }
 
 QString PrinterCupsBackend::makeAndModel() const
 {
-    // TODO: implement
-    return QString();
+    return m_info.makeAndModel();
 }
 
 PrinterEnum::State PrinterCupsBackend::state() const
@@ -414,26 +629,22 @@
 
 bool PrinterCupsBackend::supportsCustomPageSizes() const
 {
-    // TODO: implement
-    return false;
+    return m_info.supportsCustomPageSizes();
 }
 
 QPageSize PrinterCupsBackend::minimumPhysicalPageSize() const
 {
-    // TODO: implement
-    return QPageSize();
+    return m_info.minimumPhysicalPageSize();
 }
 
 QPageSize PrinterCupsBackend::maximumPhysicalPageSize() const
 {
-    // TODO: implement
-    return QPageSize();
+    return m_info.maximumPhysicalPageSize();
 }
 
 QList<int> PrinterCupsBackend::supportedResolutions() const
 {
-    // TODO: implement
-    return QList<int>{};
+    return m_info.supportedResolutions();
 }
 
 PrinterEnum::DuplexMode PrinterCupsBackend::defaultDuplexMode() const
@@ -449,28 +660,16 @@
             list.append(Utils::qDuplexModeToDuplexMode(mode));
         }
     }
+
+    if (list.isEmpty())
+        list.append(PrinterEnum::DuplexMode::DuplexNone);
+
     return list;
 }
 
-QList<Printer*> PrinterCupsBackend::availablePrinters()
+QList<QSharedPointer<Printer>> PrinterCupsBackend::availablePrinters()
 {
-    QList<Printer*> list;
-
-    // Use availablePrinterNames as this gives us a name for even null printers
-    Q_FOREACH(QString name, QPrinterInfo::availablePrinterNames()) {
-        QPrinterInfo info = QPrinterInfo::printerInfo(name);
-
-        if (!info.isNull()) {
-            list.append(new Printer(new PrinterCupsBackend(m_cups, info, m_notifier)));
-        } else {
-            qWarning() << "Printer is null so skipping (" << name << ")";
-        }
-    }
-
-    // Cups allows a faux PDF printer.
-    list.append(new Printer(new PrinterPdfBackend(__("Create PDF"))));
-
-    return list;
+    return QList<QSharedPointer<Printer>>();
 }
 
 QStringList PrinterCupsBackend::availablePrinterNames()
@@ -478,11 +677,10 @@
     return QPrinterInfo::availablePrinterNames();
 }
 
-Printer* PrinterCupsBackend::getPrinter(const QString &printerName)
+QSharedPointer<Printer> PrinterCupsBackend::getPrinter(const QString &printerName)
 {
-    // TODO: implement
-    Q_UNUSED(printerName);
-    return Q_NULLPTR;
+    QPrinterInfo info = QPrinterInfo::printerInfo(printerName);
+    return QSharedPointer<Printer>(new Printer(new PrinterCupsBackend(m_client, info, m_notifier)));
 }
 
 QString PrinterCupsBackend::defaultPrinterName()
@@ -490,14 +688,40 @@
     return QPrinterInfo::defaultPrinterName();
 }
 
-void PrinterCupsBackend::requestAvailablePrinterDrivers()
-{
-    return m_cups->requestPrinterDrivers();
-}
-
-PrinterBackend::BackendType PrinterCupsBackend::backendType() const
-{
-    return PrinterBackend::BackendType::CupsType;
+void PrinterCupsBackend::requestPrinter(const QString &printerName)
+{
+    auto thread = new QThread;
+    auto loader = new PrinterLoader(printerName, m_client, m_notifier);
+    loader->moveToThread(thread);
+    connect(thread, SIGNAL(started()), loader, SLOT(load()));
+    connect(loader, SIGNAL(finished()), thread, SLOT(quit()));
+    connect(loader, SIGNAL(finished()), loader, SLOT(deleteLater()));
+    connect(loader, SIGNAL(loaded(QSharedPointer<Printer>)),
+            this, SIGNAL(printerLoaded(QSharedPointer<Printer>)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+    thread->start();
+}
+
+void PrinterCupsBackend::requestPrinterDrivers()
+{
+    auto thread = new QThread;
+    auto loader = new PrinterDriverLoader();
+    loader->moveToThread(thread);
+    connect(loader, SIGNAL(error(const QString&)),
+            this, SIGNAL(printerDriversFailedToLoad(const QString&)));
+    connect(this, SIGNAL(requestPrinterDriverCancel()), loader, SLOT(cancel()));
+    connect(thread, SIGNAL(started()), loader, SLOT(process()));
+    connect(loader, SIGNAL(finished()), thread, SLOT(quit()));
+    connect(loader, SIGNAL(finished()), loader, SLOT(deleteLater()));
+    connect(loader, SIGNAL(loaded(const QList<PrinterDriver>&)),
+            this, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+    thread->start();
+}
+
+void PrinterCupsBackend::cancelPrinterDriverRequest()
+{
+    Q_EMIT requestPrinterDriverCancel();
 }
 
 void PrinterCupsBackend::refresh()
@@ -511,11 +735,52 @@
 
 void PrinterCupsBackend::createSubscription()
 {
-    m_cupsSubscriptionId = m_cups->createSubscription();
+    m_cupsSubscriptionId = m_client->createSubscription();;
 }
 
 void PrinterCupsBackend::cancelSubscription()
 {
     if (m_cupsSubscriptionId > 0)
-        m_cups->cancelSubscription(m_cupsSubscriptionId);
+        m_client->cancelSubscription(m_cupsSubscriptionId);
+}
+
+QString PrinterCupsBackend::getPrinterInstance(const QString &name) const
+{
+    const auto parts = name.splitRef(QLatin1Char('/'));
+    QString instance;
+    if (parts.size() > 1)
+        instance = parts.at(1).toString();
+
+    return instance;
+}
+
+QString PrinterCupsBackend::getPrinterName(const QString &name) const
+{
+    return name.splitRef(QLatin1Char('/')).first().toString();
+}
+
+cups_dest_t* PrinterCupsBackend::getDest(const QString &name) const
+{
+    QString printerName = getPrinterName(name);
+    QString instance = getPrinterInstance(name);
+
+    if (m_dests.contains(name)) {
+        return m_dests[name];
+    } else {
+        m_dests[name] = m_client->getDest(printerName, instance);
+        return m_dests[name];
+    }
+}
+
+ppd_file_t* PrinterCupsBackend::getPpd(const QString &name) const
+{
+    QString printerName = getPrinterName(name);
+    QString instance = getPrinterInstance(name);
+
+    if (m_ppds.contains(name)) {
+        return m_ppds[name];
+    } else {
+        m_ppds[name] = m_client->getPpdFile(printerName, instance);
+        return m_ppds[name];
+    }
 }

=== modified file 'plugins/Ubuntu/Settings/Printers/backend/backend_cups.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend_cups.h	2017-02-03 12:04:46 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_cups.h	2017-02-17 13:07:34 +0000
@@ -18,18 +18,18 @@
 #define USC_PRINTERS_CUPS_BACKEND_H
 
 #include "backend/backend.h"
-#include "cups/cupsfacade.h"
+#include "cups/ippclient.h"
 #include "cupsdnotifier.h" // Note: this file was generated.
 
+#include <cups/cups.h>
+
 #include <QPrinterInfo>
 
-#define CUPSD_NOTIFIER_DBUS_PATH "/org/cups/cupsd/Notifier"
-
 class PRINTERS_DECL_EXPORT PrinterCupsBackend : public PrinterBackend
 {
+    Q_OBJECT
 public:
-    explicit PrinterCupsBackend(QObject *parent = Q_NULLPTR);
-    explicit PrinterCupsBackend(CupsFacade *cups, QPrinterInfo info,
+    explicit PrinterCupsBackend(IppClient *client, QPrinterInfo info,
                                 OrgCupsCupsdNotifierInterface* notifier,
                                 QObject *parent = Q_NULLPTR);
     virtual ~PrinterCupsBackend() override;
@@ -47,11 +47,12 @@
                                       const QString &info,
                                       const QString &location) override;
     virtual QString printerDelete(const QString &name) override;
+    virtual QString printerSetDefault(const QString &name) override;
     virtual QString printerSetEnabled(const QString &name,
                                       const bool enabled) override;
     virtual QString printerSetAcceptJobs(
         const QString &name,
-        const bool enabled,
+        const bool accept,
         const QString &reason = QString::null) override;
     virtual QString printerSetInfo(const QString &name,
                                    const QString &info) override;
@@ -80,28 +81,20 @@
                                      const QString &option,
                                      const QStringList &values) override;
 
-    // TODO: const for both these getters (if possible)!
     virtual QVariant printerGetOption(const QString &name,
                                       const QString &option) const override;
     virtual QMap<QString, QVariant> printerGetOptions(
         const QString &name, const QStringList &options
-    ) override;
+    ) const override;
     // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
     virtual cups_dest_t* makeDest(const QString &name,
                                   const PrinterJob *options) override;
 
-    virtual QList<ColorModel> printerGetSupportedColorModels(
-        const QString &name) const override;
-    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
-    virtual QList<PrintQuality> printerGetSupportedQualities(
-        const QString &name) const override;
-    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
-
     virtual void cancelJob(const QString &name, const int jobId) override;
     virtual int printFileToDest(const QString &filepath,
                                 const QString &title,
                                 const cups_dest_t *dest) override;
-    virtual QList<QSharedPointer<PrinterJob>> printerGetJobs(const QString &name) override;
+    virtual QList<QSharedPointer<PrinterJob>> printerGetJobs() override;
 
     virtual QString printerName() const override;
     virtual QString description() const override;
@@ -119,24 +112,41 @@
     virtual PrinterEnum::DuplexMode defaultDuplexMode() const override;
     virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override;
 
-    virtual QList<Printer*> availablePrinters() override;
+    virtual QList<QSharedPointer<Printer>> availablePrinters() override;
     virtual QStringList availablePrinterNames() override;
-    virtual Printer* getPrinter(const QString &printerName) override;
+    virtual QSharedPointer<Printer> getPrinter(const QString &printerName) override;
     virtual QString defaultPrinterName() override;
-    virtual void requestAvailablePrinterDrivers() override;
-
-    virtual PrinterBackend::BackendType backendType() const override;
+    virtual void requestPrinterDrivers() override;
+    virtual void requestPrinter(const QString &printerName) override;
+    virtual QMap<QString, QVariant> printerGetJobAttributes(
+        const QString &name, const int jobId) override;
 
 public Q_SLOTS:
     virtual void refresh() override;
     void createSubscription();
 
+Q_SIGNALS:
+    void cancelWorkers();
+    void printerDriversLoaded(const QList<PrinterDriver> &drivers);
+    void printerDriversFailedToLoad(const QString &errorMessage);
+    void requestPrinterDriverCancel();
+
 private:
     void cancelSubscription();
-    CupsFacade *m_cups;
+    void cancelPrinterDriverRequest();
+    QList<cups_job_t *> getCupsJobs(const QString &name = QStringLiteral());
+
+    QString getPrinterName(const QString &name) const;
+    QString getPrinterInstance(const QString &name) const;
+    cups_dest_t* getDest(const QString &name) const;
+    ppd_file_t* getPpd(const QString &name) const;
+    const QStringList m_knownQualityOptions;
+    IppClient *m_client;
     QPrinterInfo m_info;
     OrgCupsCupsdNotifierInterface *m_notifier;
-    int m_cupsSubscriptionId = -1;
+    int m_cupsSubscriptionId;
+    mutable QMap<QString, cups_dest_t*> m_dests; // Printer name, dest.
+    mutable QMap<QString, ppd_file_t*> m_ppds; // Printer name, ppd.
 };
 
 #endif // USC_PRINTERS_CUPS_BACKEND_H

=== modified file 'plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp	2017-02-06 13:58:14 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp	2017-02-17 13:07:34 +0000
@@ -21,38 +21,50 @@
                                      QObject *parent)
     : PrinterBackend(printerName, parent)
 {
+    m_type = PrinterEnum::PrinterType::PdfType;
 }
 
-QList<ColorModel> PrinterPdfBackend::printerGetSupportedColorModels(
-    const QString &name) const
+QVariant PrinterPdfBackend::printerGetOption(const QString &name,
+                                             const QString &option) const
 {
-    return QList<ColorModel>{printerGetDefaultColorModel(name)};
+    auto res = printerGetOptions(name, QStringList({option}));
+    return res[option];
 }
 
-ColorModel PrinterPdfBackend::printerGetDefaultColorModel(
-    const QString &name) const
+QMap<QString, QVariant> PrinterPdfBackend::printerGetOptions(
+    const QString &name, const QStringList &options) const
 {
     Q_UNUSED(name);
+
+    QMap<QString, QVariant> ret;
+
     ColorModel rgb;
     rgb.colorType = PrinterEnum::ColorModelType::ColorType;
     rgb.name = "RGB";
     rgb.text = __("Color");
-    return rgb;
-}
-
-QList<PrintQuality> PrinterPdfBackend::printerGetSupportedQualities(
-    const QString &name) const
-{
-    return QList<PrintQuality>({printerGetDefaultQuality(name)});
-}
-
-PrintQuality PrinterPdfBackend::printerGetDefaultQuality(
-        const QString &name) const
-{
-    Q_UNUSED(name);
+
     PrintQuality quality;
     quality.name = __("Normal");
-    return quality;
+
+    Q_FOREACH(const QString &option, options) {
+        if (option == QLatin1String("DefaultColorModel")) {
+            ret[option] = QVariant::fromValue(rgb);
+        } else if (option == QLatin1String("DefaultPrintQuality")) {
+            ret[option] = QVariant::fromValue(quality);
+        } else if (option == QLatin1String("SupportedPrintQualities")) {
+            auto qualities = QList<PrintQuality>({quality});
+            ret[option] = QVariant::fromValue(qualities);
+        } else if (option == QLatin1String("SupportedColorModels")) {
+            auto models = QList<ColorModel>{rgb};
+            ret[option] = QVariant::fromValue(models);
+        } else if (option == QLatin1String("AcceptJobs")) {
+            ret[option] = true;
+        } else {
+            throw std::invalid_argument("Invalid value for PDF printer: " + option.toStdString());
+        }
+    }
+
+    return ret;
 }
 
 QString PrinterPdfBackend::printerName() const
@@ -60,21 +72,6 @@
     return m_printerName;
 }
 
-QString PrinterPdfBackend::description() const
-{
-    return QStringLiteral("");
-}
-
-QString PrinterPdfBackend::location() const
-{
-    return QStringLiteral("");
-}
-
-QString PrinterPdfBackend::makeAndModel() const
-{
-    return QStringLiteral("");
-}
-
 PrinterEnum::State PrinterPdfBackend::state() const
 {
     return PrinterEnum::State::IdleState;
@@ -95,7 +92,6 @@
     return false;
 }
 
-
 QPageSize PrinterPdfBackend::minimumPhysicalPageSize() const
 {
     return QPageSize(QPageSize::A4);
@@ -121,7 +117,3 @@
     return QList<PrinterEnum::DuplexMode>{PrinterEnum::DuplexMode::DuplexNone};
 }
 
-PrinterBackend::BackendType PrinterPdfBackend::backendType() const
-{
-    return PrinterBackend::BackendType::PdfType;
-}

=== modified file 'plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h	2017-01-22 14:21:11 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h	2017-02-17 13:07:34 +0000
@@ -24,17 +24,13 @@
 public:
     explicit PrinterPdfBackend(const QString &printerName,
                                QObject *parent = Q_NULLPTR);
-    virtual QList<ColorModel> printerGetSupportedColorModels(
-        const QString &name) const override;
-    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
-    virtual QList<PrintQuality> printerGetSupportedQualities(
-        const QString &name) const override;
-    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const override;
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options
+    ) const override;
 
     virtual QString printerName() const override;
-    virtual QString description() const override;
-    virtual QString location() const override;
-    virtual QString makeAndModel() const override;
 
     virtual PrinterEnum::State state() const override;
     virtual QList<QPageSize> supportedPageSizes() const override;
@@ -46,8 +42,6 @@
     virtual QList<int> supportedResolutions() const override;
     virtual PrinterEnum::DuplexMode defaultDuplexMode() const override;
     virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override;
-
-    virtual PrinterBackend::BackendType backendType() const override;
 };
 
 #endif // USC_PRINTERS_PDF_BACKEND_H

=== removed file 'plugins/Ubuntu/Settings/Printers/cups/cupsfacade.cpp'
--- plugins/Ubuntu/Settings/Printers/cups/cupsfacade.cpp	2017-02-07 13:42:07 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/cupsfacade.cpp	1970-01-01 00:00:00 +0000
@@ -1,640 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "utils.h"
-
-#include "cups/cupsfacade.h"
-
-#include <cups/http.h>
-#include <cups/ipp.h>
-#include <cups/ppd.h>
-
-#include <QDebug>
-#include <QThread>
-
-#define __CUPS_ADD_OPTION(dest, name, value) dest->num_options = \
-    cupsAddOption(name, value, dest->num_options, &dest->options);
-
-#define __CUPS_ATTR_EXISTS(map, attr, type) map.contains(attr) \
-    && map.value(attr).canConvert<type>()
-
-CupsFacade::CupsFacade(QObject *parent) : QObject(parent)
-{
-}
-
-CupsFacade::~CupsFacade()
-{
-    cancelPrinterDriverRequest();
-}
-
-QString CupsFacade::printerAdd(const QString &name,
-                               const QString &uri,
-                               const QString &ppdFile,
-                               const QString &info,
-                               const QString &location)
-{
-    if (!helper.printerAdd(name, uri, ppdFile, info, location)) {
-        return helper.getLastError();
-    }
-    return QString();
-}
-
-QString CupsFacade::printerAddWithPpd(const QString &name,
-                                      const QString &uri,
-                                      const QString &ppdFileName,
-                                      const QString &info,
-                                      const QString &location)
-{
-    if (!helper.printerAddWithPpdFile(name, uri, ppdFileName, info, location)) {
-        return helper.getLastError();
-    }
-    return QString();
-}
-
-QString CupsFacade::printerDelete(const QString &name)
-{
-    Q_UNUSED(name);
-    return QString();
-}
-
-QString CupsFacade::printerSetEnabled(const QString &name, const bool enabled)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(enabled);
-    return QString();
-}
-
-QString CupsFacade::printerSetAcceptJobs(
-        const QString &name,
-        const bool enabled,
-        const QString &reason)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(enabled);
-    Q_UNUSED(reason);
-    return QString();
-}
-
-QString CupsFacade::printerSetInfo(const QString &name, const QString &info)
-{
-    if (!helper.printerClassSetInfo(name, info)) {
-        return helper.getLastError();
-    }
-    return QString();
-}
-
-QString CupsFacade::printerSetLocation(const QString &name,
-                                       const QString &location)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(location);
-    return QString();
-}
-
-QString CupsFacade::printerSetShared(const QString &name, const bool shared)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(shared);
-    return QString();
-}
-
-QString CupsFacade::printerSetJobSheets(const QString &name,
-                                        const QString &start,
-                                        const QString &end)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(start);
-    Q_UNUSED(end);
-    return QString();
-}
-
-QString CupsFacade::printerSetErrorPolicy(const QString &name,
-                                          const PrinterEnum::ErrorPolicy &policy)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(policy);
-    return QString();
-}
-
-QString CupsFacade::printerSetOpPolicy(const QString &name,
-                                       const PrinterEnum::OperationPolicy &policy)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(policy);
-    return QString();
-}
-
-QString CupsFacade::printerSetUsersAllowed(const QString &name,
-                                           const QStringList &users)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(users);
-    return QString();
-}
-
-QString CupsFacade::printerSetUsersDenied(const QString &name,
-                                          const QStringList &users)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(users);
-    return QString();
-}
-
-QString CupsFacade::printerAddOptionDefault(const QString &name,
-                                            const QString &option,
-                                            const QStringList &values)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(option);
-    Q_UNUSED(values);
-    return QString();
-}
-
-QString CupsFacade::printerDeleteOptionDefault(const QString &name,
-                                               const QString &value)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(value);
-    return QString();
-}
-
-QString CupsFacade::printerAddOption(const QString &name,
-                                     const QString &option,
-                                     const QStringList &values)
-{
-    if (!helper.printerClassSetOption(name, option, values)) {
-        return helper.getLastError();
-    }
-
-    Q_EMIT printerModified(name, true);
-    return QString();
-}
-
-QVariant CupsFacade::printerGetOption(const QString &name,
-                                      const QString &option)
-{
-    QStringList opts({option});
-    auto res = printerGetOptions(name, opts);
-    return res[option];
-}
-
-QMap<QString, QVariant> CupsFacade::printerGetOptions(
-    const QString &name, const QStringList &options)
-{
-    QMap<QString, QVariant> ret;
-
-    QString printerName = getPrinterName(name);
-    QString instance = getPrinterInstance(name);
-
-    ppd_file_t* ppd;
-
-    // We don't need a dest, really.
-    cups_dest_t *dest = helper.getDest(printerName, instance);
-    if (!dest) {
-        qCritical() << "Could not get dest for" << printerName;
-        return ret;
-    }
-
-    ppd = helper.getPpdFile(printerName, instance);
-    if (!ppd) {
-        qCritical() << "Could not get PPD for" << printerName;
-        cupsFreeDests(1, dest);
-        return ret;
-    }
-
-    Q_FOREACH(const QString &option, options) {
-        if (option == "DefaultColorModel") {
-            ColorModel model;
-            ppd_option_t *ppdColorModel = ppdFindOption(ppd, "ColorModel");
-            if (ppdColorModel) {
-                ppd_choice_t* def = ppdFindChoice(ppdColorModel,
-                                                  ppdColorModel->defchoice);
-                if (def) {
-                    model = Utils::parsePpdColorModel(def->choice,
-                                                      def->text,
-                                                      "ColorModel");
-                }
-            }
-            ret[option] = QVariant::fromValue(model);
-        } else if (option == "DefaultPrintQuality") {
-            PrintQuality quality;
-            Q_FOREACH(const QString opt, m_knownQualityOptions) {
-                ppd_option_t *ppdQuality = ppdFindOption(ppd, opt.toUtf8());
-                if (ppdQuality) {
-                    ppd_choice_t* def = ppdFindChoice(ppdQuality,
-                                                      ppdQuality->defchoice);
-                    if (def) {
-                        quality = Utils::parsePpdPrintQuality(def->choice,
-                                                              def->text, opt);
-                    }
-                }
-            }
-            ret[option] = QVariant::fromValue(quality);
-        } else {
-            ppd_option_t *val = ppdFindOption(ppd, option.toUtf8());
-
-            if (val) {
-                qWarning() << "asking for" << option << "returns" << val->text;
-            } else {
-                qWarning() << "option" << option << "yielded no option";
-            }
-        }
-    }
-
-    ppdClose(ppd);
-    cupsFreeDests(1, dest);
-    return ret;
-}
-
-QList<ColorModel> CupsFacade::printerGetSupportedColorModels(
-    const QString &name) const
-{
-    QList<ColorModel> ret;
-    ppd_file_t* ppd;
-
-    ppd = helper.getPpdFile(getPrinterName(name), getPrinterInstance(name));
-    if (!ppd) {
-        qCritical() << "Could not get PPD for" << name;
-        return ret;
-    }
-
-    ppd_option_t *colorModels = ppdFindOption(ppd, "ColorModel");
-    if (colorModels) {
-        for (int i = 0; i < colorModels->num_choices; ++i) {
-            ret.append(Utils::parsePpdColorModel(colorModels->choices[i].choice,
-                                                 colorModels->choices[i].text,
-                                                 "ColorModel"));
-        }
-    }
-
-    ppdClose(ppd);
-    return ret;
-}
-
-QList<PrintQuality> CupsFacade::printerGetSupportedQualities(
-    const QString &name) const
-{
-    QList<PrintQuality> ret;
-    ppd_file_t* ppd;
-
-    ppd = helper.getPpdFile(getPrinterName(name), getPrinterInstance(name));
-    if (!ppd) {
-        qCritical() << "Could not get PPD for" << name;
-        return ret;
-    }
-
-    Q_FOREACH(const QString &opt, m_knownQualityOptions) {
-        ppd_option_t *qualityOpt = ppdFindOption(ppd, opt.toUtf8());
-        if (qualityOpt) {
-            for (int i = 0; i < qualityOpt->num_choices; ++i)
-                ret.append(Utils::parsePpdPrintQuality(qualityOpt->choices[i].choice,
-                                                       qualityOpt->choices[i].text,
-                                                       opt));
-        }
-    }
-
-    ppdClose(ppd);
-    return ret;
-}
-
-QString CupsFacade::getPrinterName(const QString &name) const
-{
-    const auto parts = name.splitRef(QLatin1Char('/'));
-    return parts.at(0).toString();
-}
-
-QString CupsFacade::getPrinterInstance(const QString &name) const
-{
-    const auto parts = name.splitRef(QLatin1Char('/'));
-    QString instance;
-    if (parts.size() > 1)
-        instance = parts.at(1).toString();
-
-    return instance;
-}
-
-cups_dest_t* CupsFacade::makeDest(const QString &name,
-                                  const PrinterJob *options)
-{
-    // Get the cups dest
-    cups_dest_t *dest = helper.getDest(getPrinterName(name), getPrinterInstance(name));
-
-    if (options->collate()) {
-        __CUPS_ADD_OPTION(dest, "Collate", "True");
-    } else {
-        __CUPS_ADD_OPTION(dest, "Collate", "False");
-    }
-
-    if (options->copies() > 1) {
-        __CUPS_ADD_OPTION(dest, "copies", QString::number(options->copies()).toLocal8Bit());
-    }
-
-    __CUPS_ADD_OPTION(dest, "ColorModel", options->getColorModel().name.toLocal8Bit());
-    __CUPS_ADD_OPTION(dest, "Duplex", Utils::duplexModeToPpdChoice(options->getDuplexMode()).toLocal8Bit());
-
-    if (options->landscape()) {
-        __CUPS_ADD_OPTION(dest, "landscape", "");
-    }
-
-    if (options->printRangeMode() == PrinterEnum::PrintRange::PageRange
-            && !options->printRange().isEmpty()) {
-        __CUPS_ADD_OPTION(dest, "page-ranges", options->printRange().toLocal8Bit());
-    }
-
-    PrintQuality quality = options->getPrintQuality();
-    __CUPS_ADD_OPTION(dest, quality.originalOption.toLocal8Bit(),
-                      quality.name.toLocal8Bit());
-
-    if (options->reverse()) {
-        __CUPS_ADD_OPTION(dest, "OutputOrder", "Reverse");
-    } else {
-        __CUPS_ADD_OPTION(dest, "OutputOrder", "Normal");
-    }
-
-    // Always scale to fit the page for now
-    __CUPS_ADD_OPTION(dest, "fit-to-page", "True");
-
-    return dest;
-}
-
-void CupsFacade::cancelJob(const QString &name, const int jobId)
-{
-    int ret = cupsCancelJob(name.toLocal8Bit(), jobId);
-
-    if (!ret) {
-        qWarning() << "Failed to cancel job:" << jobId << "for" << name;
-    }
-}
-
-QList<cups_job_t *> CupsFacade::printerGetJobs(const QString &name)
-{
-    QList<cups_job_t *> list;
-    cups_job_t *jobs;
-
-    // Get a list of the jobs that are 'mine' and only active ones
-    // https://www.cups.org/doc/api-cups.html#cupsGetJobs
-    int count = cupsGetJobs(&jobs, name.toLocal8Bit(), 1, CUPS_WHICHJOBS_ACTIVE);
-
-    for (int i=0; i < count; i++) {
-        list.append(&jobs[i]);
-    }
-
-    // FIXME: needs to run cupsFreeJobs();
-
-    return list;
-}
-
-QMap<QString, QVariant> CupsFacade::printerGetJobAttributes(const QString &name, const int jobId)
-{
-    Q_UNUSED(name);
-    QMap<QString, QVariant> rawMap = helper.printerGetJobAttributes(jobId);
-    QMap<QString, QVariant> map;
-
-    // Filter attributes to know values
-    // Do this here so we can use things such as m_knownQualityOptions
-
-    if (__CUPS_ATTR_EXISTS(rawMap, "Collate", bool)) {
-        map.insert("Collate", rawMap.value("Collate"));
-    } else {
-        map.insert("Collate", QVariant(true));
-    }
-
-    if (__CUPS_ATTR_EXISTS(rawMap, "copies", int)) {
-        map.insert("copies", rawMap.value("copies"));
-    } else {
-        map.insert("copies", QVariant(1));
-    }
-
-    if (__CUPS_ATTR_EXISTS(rawMap, "ColorModel", QString)) {
-        map.insert("ColorModel", rawMap.value("ColorModel"));
-    } else {
-        map.insert("ColorModel", QVariant(""));
-    }
-
-    if (__CUPS_ATTR_EXISTS(rawMap, "Duplex", QString)) {
-        map.insert("Duplex", rawMap.value("Duplex"));
-    } else {
-        map.insert("Duplex", QVariant(""));
-    }
-
-    if (__CUPS_ATTR_EXISTS(rawMap, "landscape", bool)) {
-        map.insert("landscape", rawMap.value("landscape"));
-    } else {
-        map.insert("landscape", QVariant(false));
-    }
-
-    if (__CUPS_ATTR_EXISTS(rawMap, "page-ranges", QList<QVariant>)) {
-        QList<QVariant> range = rawMap.value("page-ranges").toList();
-        QStringList rangeStrings;
-
-        Q_FOREACH(QVariant var, range) {
-            rangeStrings << var.toString();
-        }
-
-        map.insert("page-ranges", QVariant(rangeStrings));
-    } else {
-        map.insert("page-ranges", QVariant(QStringList()));
-    }
-
-    Q_FOREACH(QString qualityOption, m_knownQualityOptions) {
-        if (rawMap.contains(qualityOption)
-                && rawMap.value(qualityOption).canConvert<QString>()) {
-            map.insert("quality", rawMap.value(qualityOption).toString());
-        }
-    }
-
-    if (!map.contains("quality")) {
-        map.insert("quality", QVariant(""));
-    }
-
-    if (__CUPS_ATTR_EXISTS(rawMap, "OutputOrder", QString)) {
-        map.insert("OutputOrder", rawMap.value("OutputOrder"));
-    } else {
-        map.insert("OutputOrder", "Normal");
-    }
-
-    // Generate a list of messages
-    // TODO: for now just using job-printer-state-message, are there others?
-    QStringList messages;
-
-    if (__CUPS_ATTR_EXISTS(rawMap, "job-printer-state-message", QString)) {
-        messages << rawMap.value("job-printer-state-message").toString();
-    }
-
-    map.insert("messages", QVariant(messages));
-
-    return map;
-}
-
-int CupsFacade::printFileToDest(const QString &filepath, const QString &title,
-                                const cups_dest_t *dest)
-{
-    qDebug() << "Printing:" << filepath << title << dest->name << dest->num_options;
-    return cupsPrintFile(dest->name,
-                         filepath.toLocal8Bit(),
-                         title.toLocal8Bit(),
-                         dest->num_options,
-                         dest->options);
-}
-
-void CupsFacade::requestPrinterDrivers(
-    const QString &deviceId, const QString &language, const QString &makeModel,
-    const QString &product, const QStringList &includeSchemes,
-    const QStringList &excludeSchemes
-)
-{
-    auto thread = new QThread;
-    auto loader = new PrinterDriverLoader(deviceId, language, makeModel,
-                                          product, includeSchemes,
-                                          excludeSchemes);
-    loader->moveToThread(thread);
-    connect(loader, SIGNAL(error(const QString&)),
-            this, SIGNAL(printerDriversFailedToLoad(const QString&)));
-    connect(this, SIGNAL(requestPrinterDriverCancel()), loader, SLOT(cancel()));
-    connect(thread, SIGNAL(started()), loader, SLOT(process()));
-    connect(loader, SIGNAL(finished()), thread, SLOT(quit()));
-    connect(loader, SIGNAL(finished()), loader, SLOT(deleteLater()));
-    connect(loader, SIGNAL(loaded(const QList<PrinterDriver>&)),
-            this, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)));
-    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
-    thread->start();
- }
-
-void CupsFacade::cancelPrinterDriverRequest()
-{
-    Q_EMIT requestPrinterDriverCancel();
-}
-
-int CupsFacade::createSubscription()
-{
-    return helper.createSubscription();
-}
-
-void CupsFacade::cancelSubscription(const int &subscriptionId)
-{
-    helper.cancelSubscription(subscriptionId);
-}
-
-PrinterDriverLoader::PrinterDriverLoader(
-        const QString &deviceId, const QString &language,
-        const QString &makeModel, const QString &product,
-        const QStringList &includeSchemes, const QStringList &excludeSchemes)
-    : m_deviceId(deviceId)
-    , m_language(language)
-    , m_makeModel(makeModel)
-    , m_product(product)
-    , m_includeSchemes(includeSchemes)
-    , m_excludeSchemes(excludeSchemes)
-{
-}
-
-PrinterDriverLoader::~PrinterDriverLoader()
-{
-}
-
-void PrinterDriverLoader::process()
-{
-    m_running = true;
-
-    ipp_t* response = helper.createPrinterDriversRequest(
-        m_deviceId, m_language, m_makeModel, m_product, m_includeSchemes,
-        m_excludeSchemes
-    );
-
-    // Note: if the response somehow fails, we return.
-    if (!response || ippGetStatusCode(response) > IPP_OK_CONFLICT) {
-        QString err(cupsLastErrorString());
-        qWarning() << __PRETTY_FUNCTION__ << "Cups HTTP error:" << err;
-
-        if (response)
-            ippDelete(response);
-
-        Q_EMIT error(err);
-        Q_EMIT finished();
-        return;
-    }
-
-    ipp_attribute_t *attr;
-    QByteArray ppdDeviceId;
-    QByteArray ppdLanguage;
-    QByteArray ppdMakeModel;
-    QByteArray ppdName;
-
-    // cups_option_t option;
-    QList<PrinterDriver> drivers;
-
-    for (attr = ippFirstAttribute(response); attr != NULL && m_running; attr = ippNextAttribute(response)) {
-
-        while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_PRINTER)
-            attr = ippNextAttribute(response);
-
-        if (attr == NULL)
-            break;
-
-        // Pull the needed attributes from this PPD...
-        ppdDeviceId = "NONE";
-        ppdLanguage.clear();
-        ppdMakeModel.clear();
-        ppdName.clear();
-
-        while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_PRINTER) {
-            if (!strcmp(ippGetName(attr), "ppd-device-id") &&
-                 ippGetValueTag(attr) == IPP_TAG_TEXT) {
-                ppdDeviceId = ippGetString(attr, 0, NULL);
-            } else if (!strcmp(ippGetName(attr), "ppd-natural-language") &&
-                       ippGetValueTag(attr) == IPP_TAG_LANGUAGE) {
-                ppdLanguage = ippGetString(attr, 0, NULL);
-
-            } else if (!strcmp(ippGetName(attr), "ppd-make-and-model") &&
-                       ippGetValueTag(attr) == IPP_TAG_TEXT) {
-                ppdMakeModel = ippGetString(attr, 0, NULL);
-            } else if (!strcmp(ippGetName(attr), "ppd-name") &&
-                       ippGetValueTag(attr) == IPP_TAG_NAME) {
-
-                ppdName = ippGetString(attr, 0, NULL);
-            }
-
-            attr = ippNextAttribute(response);
-        }
-
-        // See if we have everything needed...
-        if (ppdLanguage.isEmpty() || ppdMakeModel.isEmpty() ||
-            ppdName.isEmpty()) {
-            if (attr == NULL)
-                break;
-            else
-                continue;
-        }
-
-        PrinterDriver m;
-        m.name = ppdName;
-        m.deviceId = ppdDeviceId;
-        m.makeModel = ppdMakeModel;
-        m.language = ppdLanguage;
-
-        drivers.append(m);
-    }
-
-    ippDelete(response);
-
-    Q_EMIT loaded(drivers);
-    Q_EMIT finished();
-}
-
-void PrinterDriverLoader::cancel()
-{
-    m_running = false;
-}

=== removed file 'plugins/Ubuntu/Settings/Printers/cups/cupsfacade.h'
--- plugins/Ubuntu/Settings/Printers/cups/cupsfacade.h	2017-02-07 13:42:07 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/cupsfacade.h	1970-01-01 00:00:00 +0000
@@ -1,166 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_CUPSFACADE_H
-#define USC_PRINTERS_CUPSFACADE_H
-
-#include "enums.h"
-#include "structs.h"
-
-#include "cups/cupspkhelper.h"
-#include "printer/printerjob.h"
-
-#include <cups/cups.h>
-
-#include <QList>
-#include <QMap>
-#include <QObject>
-#include <QString>
-#include <QStringList>
-#include <QVariant>
-
-class PrinterJob;
-class CupsFacade : public QObject
-{
-    Q_OBJECT
-public:
-    explicit CupsFacade(QObject *parent = Q_NULLPTR);
-    ~CupsFacade();
-    QString printerAdd(const QString &name,
-                       const QString &uri,
-                       const QString &ppdFile,
-                       const QString &info,
-                       const QString &location);
-    QString printerAddWithPpd(const QString &name,
-                              const QString &uri,
-                              const QString &ppdFileName,
-                              const QString &info,
-                              const QString &location);
-    QString printerDelete(const QString &name);
-    QString printerSetEnabled(const QString &name, const bool enabled);
-    QString printerSetAcceptJobs(
-        const QString &name,
-        const bool enabled,
-        const QString &reason = QString::null);
-    QString printerSetInfo(const QString &name, const QString &info);
-    QString printerSetLocation(const QString &name, const QString &location);
-    QString printerSetShared(const QString &name, const bool shared);
-    QString printerSetJobSheets(const QString &name, const QString &start,
-                                const QString &end);
-    QString printerSetErrorPolicy(const QString &name,
-                                  const PrinterEnum::ErrorPolicy &policy);
-
-    QString printerSetOpPolicy(const QString &name,
-                               const PrinterEnum::OperationPolicy &policy);
-    QString printerSetUsersAllowed(const QString &name,
-                                   const QStringList &users);
-    QString printerSetUsersDenied(const QString &name,
-                                  const QStringList &users);
-    QString printerAddOptionDefault(const QString &name,
-                                    const QString &option,
-                                    const QStringList &values);
-    QString printerDeleteOptionDefault(const QString &name,
-                                       const QString &value);
-    QString printerAddOption(const QString &name,
-                             const QString &option,
-                             const QStringList &values);
-
-    // TODO: const for both these getters (if possible)!
-    QVariant printerGetOption(const QString &name, const QString &option);
-    QMap<QString, QVariant> printerGetOptions(const QString &name,
-                                              const QStringList &options);
-    // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
-    cups_dest_t* makeDest(const QString &name, const PrinterJob *options);
-
-    QList<ColorModel> printerGetSupportedColorModels(const QString &name) const;
-    QList<PrintQuality> printerGetSupportedQualities(const QString &name) const;
-
-    void cancelJob(const QString &name, const int jobId);
-    QList<cups_job_t *> printerGetJobs(const QString &name);
-    QMap<QString, QVariant> printerGetJobAttributes(const QString &name, const int jobId);
-    int printFileToDest(const QString &filepath, const QString &title,
-                        const cups_dest_t *dest);
-    int createSubscription();
-    void cancelSubscription(const int &subscriptionId);
-
-public Q_SLOTS:
-    void requestPrinterDrivers(
-        const QString &deviceId = "",
-        const QString &language = "",
-        const QString &makeModel = "",
-        const QString &product = "",
-        const QStringList &includeSchemes = QStringList(),
-        const QStringList &excludeSchemes = QStringList()
-    );
-    void cancelPrinterDriverRequest();
-
-Q_SIGNALS:
-    void printerAdded(const QString &name);
-    void printerModified(const QString &name, const bool ppdChanged);
-    void printerDeleted(const QString &name);
-    void printerStateChanged(const QString &name);
-
-    void requestPrinterDriverCancel();
-    void printerDriversLoaded(const QList<PrinterDriver> &drivers);
-    void printerDriversFailedToLoad(const QString &errorMessage);
-
-private:
-    QString getPrinterName(const QString &name) const;
-    QString getPrinterInstance(const QString &name) const;
-    QStringList parsePpdColorModel(const QString &colorModel);
-    const QStringList m_knownQualityOptions = QStringList({
-        "Quality", "PrintQuality", "HPPrintQuality", "StpQuality",
-        "OutputMode",
-    });
-    CupsPkHelper helper;
-};
-
-class PrinterDriverLoader : public QObject
-{
-    Q_OBJECT
-public:
-    PrinterDriverLoader(
-        const QString &deviceId = "",
-        const QString &language = "",
-        const QString &makeModel = "",
-        const QString &product = "",
-        const QStringList &includeSchemes = QStringList(),
-        const QStringList &excludeSchemes = QStringList());
-    ~PrinterDriverLoader();
-
-public Q_SLOTS:
-    void process();
-    void cancel();
-
-Q_SIGNALS:
-    void finished();
-    void loaded(const QList<PrinterDriver> &drivers);
-    void error(const QString &error);
-
-private:
-    QString m_deviceId = QString::null;
-    QString m_language = QString::null;
-    QString m_makeModel = QString::null;
-    QString m_product = QString::null;
-    QStringList m_includeSchemes;
-    QStringList m_excludeSchemes;
-
-    bool m_running = false;
-    CupsPkHelper helper;
-};
-
-
-#endif // USC_PRINTERS_CUPSFACADE_H

=== renamed file 'plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.cpp' => 'plugins/Ubuntu/Settings/Printers/cups/ippclient.cpp'
--- plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.cpp	2017-02-07 13:42:07 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/ippclient.cpp	2017-02-17 13:07:34 +0000
@@ -17,7 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "cups/cupspkhelper.h"
+#include "cups/ippclient.h"
 
 #include <errno.h>
 #include <string.h>
@@ -28,7 +28,7 @@
 #include <QTimeZone>
 #include <QUrl>
 
-CupsPkHelper::CupsPkHelper()
+IppClient::IppClient()
     : m_connection(httpConnectEncrypt(cupsServer(),
                                       ippPort(),
                                       cupsEncryption()))
@@ -40,17 +40,23 @@
     }
 }
 
-CupsPkHelper::~CupsPkHelper()
+IppClient::~IppClient()
 {
     if (m_connection)
         httpClose(m_connection);
 }
 
-bool CupsPkHelper::printerAdd(const QString &printerName,
-                              const QString &printerUri,
-                              const QString &ppdFile,
-                              const QString &info,
-                              const QString &location)
+bool IppClient::printerDelete(const QString &printerName)
+{
+    return sendNewSimpleRequest(CUPS_DELETE_PRINTER, printerName.toUtf8(),
+                                CupsResource::CupsResourceAdmin);
+}
+
+bool IppClient::printerAdd(const QString &printerName,
+                           const QString &printerUri,
+                           const QString &ppdFile,
+                           const QString &info,
+                           const QString &location)
 {
     ipp_t *request;
 
@@ -100,18 +106,18 @@
                      "printer-info", NULL, info.toUtf8());
     }
     if (!location.isEmpty()) {
-            ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT,
-                         "printer-location", NULL, location.toUtf8());
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT,
+                     "printer-location", NULL, location.toUtf8());
     }
 
-    return sendRequest(request, CphResourceAdmin);
+    return sendRequest(request, CupsResourceAdmin);
 }
 
-bool CupsPkHelper::printerAddWithPpdFile(const QString &printerName,
-                                         const QString &printerUri,
-                                         const QString &ppdFileName,
-                                         const QString &info,
-                                         const QString &location)
+bool IppClient::printerAddWithPpdFile(const QString &printerName,
+                                      const QString &printerUri,
+                                      const QString &ppdFileName,
+                                      const QString &info,
+                                      const QString &location)
 {
     ipp_t *request;
 
@@ -160,18 +166,71 @@
                      "printer-info", NULL, info.toUtf8());
     }
     if (!location.isEmpty()) {
-            ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT,
-                         "printer-location", NULL, location.toUtf8());
-    }
-
-    return postRequest(request, ppdFileName.toUtf8(), CphResourceAdmin);
-}
-
-bool CupsPkHelper::printerClassSetInfo(const QString &name,
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT,
+                     "printer-location", NULL, location.toUtf8());
+    }
+
+    return postRequest(request, ppdFileName.toUtf8(), CupsResourceAdmin);
+}
+
+bool IppClient::printerSetDefault(const QString &printerName)
+{
+    return sendNewSimpleRequest(CUPS_SET_DEFAULT, printerName.toUtf8(),
+                                CupsResource::CupsResourceAdmin);
+}
+
+bool IppClient::printerSetEnabled(const QString &printerName,
+                                  const bool enabled)
+{
+    ipp_op_t op;
+    op = enabled ? IPP_RESUME_PRINTER : IPP_PAUSE_PRINTER;
+    return sendNewSimpleRequest(op, printerName, CupsResourceAdmin);
+}
+
+/* reason must be empty if accept is true */
+bool IppClient::printerSetAcceptJobs(const QString &printerName,
+                                     const bool accept,
+                                     const QString &reason)
+{
+    ipp_t *request;
+
+    if (accept && !reason.isEmpty()) {
+        setInternalStatus("Accepting jobs does not take a reason.");
+        return false;
+    }
+
+    if (!isPrinterNameValid(printerName)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(printerName));
+        return false;
+    }
+
+    if (!isStringValid(reason)) {
+        setInternalStatus(QString("%1 is not a valid reason.").arg(reason));
+        return false;
+    }
+
+    if (accept) {
+        return sendNewSimpleRequest(CUPS_ACCEPT_JOBS, printerName.toUtf8(),
+                                    CupsResourceAdmin);
+    } else {
+        request = ippNewRequest(CUPS_REJECT_JOBS);
+        addPrinterUri(request, printerName);
+        addRequestingUsername(request, NULL);
+
+        if (!reason.isEmpty())
+            ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_TEXT,
+                         "printer-state-message", NULL, reason.toUtf8());
+
+        return sendRequest(request, CupsResourceAdmin);
+    }
+}
+
+
+bool IppClient::printerClassSetInfo(const QString &name,
                                        const QString &info)
 {
     if (!isPrinterNameValid(name)) {
-        setInternalStatus(QString("%1 is not a valid printer name.").arg(info));
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(name));
         return false;
     }
 
@@ -184,9 +243,9 @@
                                       "printer-info", info);
 }
 
-bool CupsPkHelper::printerClassSetOption(const QString &name,
-                                         const QString &option,
-                                         const QStringList &values)
+bool IppClient::printerClassSetOption(const QString &name,
+                                      const QString &option,
+                                      const QStringList &values)
 {
     bool isClass;
     int length = 0;
@@ -266,18 +325,18 @@
     }
 
     if (!newPpdFile.isEmpty()) {
-        retval = postRequest(request, newPpdFile, CphResourceAdmin);
+        retval = postRequest(request, newPpdFile, CupsResourceAdmin);
 
         unlink(newPpdFile.toUtf8());
         // TODO: fix leak here.
     } else {
-        retval = sendRequest(request, CphResourceAdmin);
+        retval = sendRequest(request, CupsResourceAdmin);
     }
 
     return retval;
 }
 
-QMap<QString, QVariant> CupsPkHelper::printerGetJobAttributes(const int jobId)
+QMap<QString, QVariant> IppClient::printerGetJobAttributes(const int jobId)
 {
     ipp_t *request;
     QMap<QString, QVariant> map;
@@ -292,7 +351,7 @@
 
     // Send request and construct reply
     ipp_t *reply;
-    const QString resourceChar = getResource(CphResourceRoot);
+    const QString resourceChar = getResource(CupsResourceRoot);
     reply = cupsDoRequest(m_connection, request,
                           resourceChar.toUtf8());
 
@@ -322,9 +381,8 @@
  * This needs to be done because of applications which use content of PPD files
  * instead of IPP attributes.
  * CUPS doesn't do this automatically (but hopefully will starting with 1.6) */
-QString CupsPkHelper::preparePpdForOptions(const QString &ppdfile,
-                                           cups_option_t *options,
-                                           int numOptions)
+QString IppClient::preparePpdForOptions(const QString &ppdfile,
+                                        cups_option_t *options, int numOptions)
 {
     auto ppdfile_c = ppdfile.toUtf8();
     ppd_file_t *ppd;
@@ -459,11 +517,10 @@
 }
 
 
-bool CupsPkHelper::sendNewPrinterClassRequest(const QString &printerName,
-                                              ipp_tag_t group,
-                                              ipp_tag_t type,
-                                              const QString &name,
-                                              const QString &value)
+bool IppClient::sendNewPrinterClassRequest(const QString &printerName,
+                                           ipp_tag_t group, ipp_tag_t type,
+                                           const QString &name,
+                                           const QString &value)
 {
     ipp_t *request;
 
@@ -473,7 +530,7 @@
     ippAddString(request, group, type, name.toUtf8(), NULL,
                  value.toUtf8());
 
-    if (sendRequest(request, CphResource::CphResourceAdmin))
+    if (sendRequest(request, CupsResource::CupsResourceAdmin))
         return true;
 
     // it failed, maybe it was a class?
@@ -485,16 +542,14 @@
     return false;
 }
 
-void CupsPkHelper::addPrinterUri(ipp_t *request,
-                                 const QString &name)
+void IppClient::addPrinterUri(ipp_t *request, const QString &name)
 {
     QUrl uri(QString("ipp://localhost/printers/%1").arg(name));
     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
                  "printer-uri", NULL, uri.toEncoded().data());
 }
 
-void CupsPkHelper::addRequestingUsername(ipp_t *request,
-                                         const QString &username)
+void IppClient::addRequestingUsername(ipp_t *request, const QString &username)
 {
     if (!username.isEmpty())
         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
@@ -505,30 +560,27 @@
                      "requesting-user-name", NULL, cupsUser());
 }
 
-QString CupsPkHelper::getLastError() const
+QString IppClient::getLastError() const
 {
     return m_internalStatus;
 }
 
-const QString CupsPkHelper::getResource(
-        const CupsPkHelper::CphResource &resource)
+const QString IppClient::getResource(const IppClient::CupsResource &resource)
 {
     switch (resource) {
-    case CphResourceRoot:
+    case CupsResourceRoot:
         return "/";
-    case CphResourceAdmin:
+    case CupsResourceAdmin:
         return "/admin/";
-    case CphResourceJobs:
+    case CupsResourceJobs:
         return "/jobs/";
     default:
-        /* that's a fall back -- we don't use
-         * g_assert_not_reached() to avoid crashing. */
         qCritical("Asking for a resource with no match.");
         return "/";
     }
 }
 
-bool CupsPkHelper::isPrinterNameValid(const QString &name)
+bool IppClient::isPrinterNameValid(const QString &name)
 {
     int i;
     int len;
@@ -553,26 +605,25 @@
     for (i = 0; i < len; i++) {
         const QChar c = name.at(i);
         if (!c.isPrint())
-                return false;
+            return false;
         if (c.isSpace())
-                return false;
+            return false;
         if (c == '/' || c == '#')
-                return false;
+            return false;
     }
     return true;
 }
 
-bool CupsPkHelper::isStringValid(const QString &string, const bool checkNull,
-                                 const int maxLength)
+bool IppClient::isStringValid(const QString &string, const bool checkNull,
+                              const int maxLength)
 {
     if (isStringPrintable(string, checkNull, maxLength))
         return true;
     return false;
 }
 
-bool CupsPkHelper::isStringPrintable(const QString &string,
-                                     const bool checkNull,
-                                     const int maxLength)
+bool IppClient::isStringPrintable(const QString &string, const bool checkNull,
+                                  const int maxLength)
 {
     int i;
     int len;
@@ -589,12 +640,12 @@
     for (i = 0; i < len; i++) {
         const QChar c = string.at(i);
         if (!c.isPrint())
-                return false;
+            return false;
     }
     return true;
 }
 
-void CupsPkHelper::setInternalStatus(const QString &status)
+void IppClient::setInternalStatus(const QString &status)
 {
     if (!m_internalStatus.isNull()) {
         m_internalStatus = QString::null;
@@ -610,8 +661,8 @@
     }
 }
 
-bool CupsPkHelper::postRequest(ipp_t *request, const QString &file,
-                               const CphResource &resource)
+bool IppClient::postRequest(ipp_t *request, const QString &file,
+                            const CupsResource &resource)
 {
     ipp_t *reply;
     QString resourceChar;
@@ -629,7 +680,7 @@
 }
 
 
-bool CupsPkHelper::sendRequest(ipp_t *request, const CphResource &resource)
+bool IppClient::sendRequest(ipp_t *request, const CupsResource &resource)
 {
     ipp_t *reply;
     const QString resourceChar = getResource(resource);
@@ -638,7 +689,22 @@
     return handleReply(reply);
 }
 
-bool CupsPkHelper::handleReply(ipp_t *reply)
+bool IppClient::sendNewSimpleRequest(ipp_op_t op, const QString &printerName,
+                                     const IppClient::CupsResource &resource)
+{
+    ipp_t *request;
+
+    if (!isPrinterNameValid(printerName))
+        return false;
+
+    request = ippNewRequest(op);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+
+    return sendRequest(request, resource);
+}
+
+bool IppClient::handleReply(ipp_t *reply)
 {
     bool retval;
     retval = isReplyOk(reply, false);
@@ -648,7 +714,7 @@
     return retval;
 }
 
-bool CupsPkHelper::isReplyOk(ipp_t *reply, bool deleteIfReplyNotOk)
+bool IppClient::isReplyOk(ipp_t *reply, bool deleteIfReplyNotOk)
 {
     /* reset the internal status: we'll use the cups status */
     m_lastStatus = IPP_STATUS_CUPS_INVALID;
@@ -658,7 +724,7 @@
         return true;
     } else {
         setErrorFromReply(reply);
-        qWarning() << __PRETTY_FUNCTION__ << "Cups HTTP error:" << cupsLastErrorString();
+        qWarning() << Q_FUNC_INFO << "Cups HTTP error:" << cupsLastErrorString();
 
         if (deleteIfReplyNotOk && reply)
             ippDelete(reply);
@@ -667,7 +733,7 @@
     }
 }
 
-void CupsPkHelper::setErrorFromReply(ipp_t *reply)
+void IppClient::setErrorFromReply(ipp_t *reply)
 {
     if (reply)
         m_lastStatus = ippGetStatusCode(reply);
@@ -675,7 +741,7 @@
         m_lastStatus = cupsLastError();
 }
 
-bool CupsPkHelper::printerIsClass(const QString &name)
+bool IppClient::printerIsClass(const QString &name)
 {
     const char * const attrs[1] = { "member-names" };
     ipp_t *request;
@@ -695,7 +761,7 @@
     ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
                   "requested-attributes", 1, NULL, attrs);
 
-    resource = getResource(CphResource::CphResourceRoot);
+    resource = getResource(CupsResource::CupsResourceRoot);
     reply = cupsDoRequest(m_connection, request, resource.toUtf8());
 
     if (!isReplyOk(reply, true))
@@ -712,15 +778,15 @@
     return retval;
 }
 
-void CupsPkHelper::addClassUri(ipp_t *request, const QString &name)
+void IppClient::addClassUri(ipp_t *request, const QString &name)
 {
     QUrl uri(QString("ipp://localhost/printers/%1").arg(name));
     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
                  "printer-uri", NULL, uri.toEncoded().data());
 }
 
-ppd_file_t* CupsPkHelper::getPpdFile(const QString &name,
-                                     const QString &instance) const
+ppd_file_t* IppClient::getPpdFile(const QString &name,
+                                  const QString &instance) const
 {
     Q_UNUSED(instance);
 
@@ -739,16 +805,20 @@
     return file;
 }
 
-cups_dest_t* CupsPkHelper::getDest(const QString &name,
-                                   const QString &instance) const
+cups_dest_t* IppClient::getDest(const QString &name,
+                                const QString &instance) const
 {
     cups_dest_t *dest = 0;
-    dest = cupsGetNamedDest(m_connection, name.toUtf8(),
-                            instance.toUtf8());
+
+    if (instance.isEmpty()) {
+        dest = cupsGetNamedDest(m_connection, name.toUtf8(), NULL);
+    } else {
+        dest = cupsGetNamedDest(m_connection, name.toUtf8(), instance.toUtf8());
+    }
     return dest;
 }
 
-ipp_t* CupsPkHelper::createPrinterDriversRequest(
+ipp_t* IppClient::createPrinterDriversRequest(
     const QString &deviceId, const QString &language, const QString &makeModel,
     const QString &product, const QStringList &includeSchemes,
     const QStringList &excludeSchemes
@@ -775,12 +845,12 @@
                  NULL, product.toUtf8());
 
     // Do the request and get return the response.
-    const QString resourceChar = getResource(CphResourceRoot);
+    const QString resourceChar = getResource(CupsResourceRoot);
     return cupsDoRequest(m_connection, request,
                          resourceChar.toUtf8());
 }
 
-int CupsPkHelper::createSubscription()
+int IppClient::createSubscription()
 {
     ipp_t *req;
     ipp_t *resp;
@@ -798,7 +868,7 @@
                   "notify-lease-duration", 0);
 
     resp = cupsDoRequest(m_connection, req,
-                         getResource(CphResourceRoot).toUtf8());
+                         getResource(CupsResourceRoot).toUtf8());
     if (!isReplyOk(resp, true)) {
         return subscriptionId;
     }
@@ -817,7 +887,7 @@
     return subscriptionId;
 }
 
-void CupsPkHelper::cancelSubscription(const int &subscriptionId)
+void IppClient::cancelSubscription(const int &subscriptionId)
 {
     ipp_t *req;
     ipp_t *resp;
@@ -833,7 +903,7 @@
                   "notify-subscription-id", subscriptionId);
 
     resp = cupsDoRequest(m_connection, req,
-                         getResource(CphResourceRoot).toUtf8());
+                         getResource(CupsResourceRoot).toUtf8());
     if (!isReplyOk(resp, true)) {
         return;
     }
@@ -841,7 +911,7 @@
     ippDelete(resp);
 }
 
-QVariant CupsPkHelper::getAttributeValue(ipp_attribute_t *attr, int index) const
+QVariant IppClient::getAttributeValue(ipp_attribute_t *attr, int index) const
 {
     QVariant var;
 

=== renamed file 'plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.h' => 'plugins/Ubuntu/Settings/Printers/cups/ippclient.h'
--- plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.h	2017-02-07 13:42:07 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/ippclient.h	2017-02-17 13:07:34 +0000
@@ -14,8 +14,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef USC_PRINTERS_CUPSPKHELPER_H
-#define USC_PRINTERS_CUPSPKHELPER_H
+#ifndef USC_PRINTERS_CUPS_IPPCLIENT_H
+#define USC_PRINTERS_CUPS_IPPCLIENT_H
 
 #include "structs.h"
 
@@ -33,29 +33,28 @@
  */
 #define CPH_STR_MAXLEN 512
 
-/* This code is only a shim for systems not running the daemon provided by
-cups-pk-helper. Once provided on all platforms, this code should be replaced
-by proper dbus bindings, and subsequently be set on fire.
-
-TODO: rename to CupsPkHelperShim to emphasize its transient nature.
-FIXME: make most of the "is..." methods const.
-*/
-class CupsPkHelper
+class IppClient
 {
 public:
-    explicit CupsPkHelper();
-    ~CupsPkHelper();
+    explicit IppClient();
+    ~IppClient();
 
+    bool printerDelete(const QString &printerName);
     bool printerAdd(const QString &printerName,
                     const QString &printerUri,
                     const QString &ppdFile,
                     const QString &info,
                     const QString &location);
+
     bool printerAddWithPpdFile(const QString &printerName,
                                const QString &printerUri,
                                const QString &ppdFileName,
                                const QString &info,
                                const QString &location);
+    bool printerSetDefault(const QString &printerName);
+    bool printerSetEnabled(const QString &printerName, const bool enabled);
+    bool printerSetAcceptJobs(const QString &printerName, const bool accept,
+                              const QString &reason);
     bool printerClassSetInfo(const QString &name, const QString &info);
     bool printerClassSetOption(const QString &name, const QString &option,
                                const QStringList &values);
@@ -66,24 +65,21 @@
 
     QString getLastError() const;
 
-    // This response needs to be free by the caller.
+    // Note: This response needs to be free by the caller.
     ipp_t* createPrinterDriversRequest(
-        const QString &deviceId = "",
-        const QString &language = "",
-        const QString &makeModel = "",
-        const QString &product = "",
-        const QStringList &includeSchemes = QStringList(),
-        const QStringList &excludeSchemes = QStringList()
+        const QString &deviceId, const QString &language,
+        const QString &makeModel, const QString &product,
+        const QStringList &includeSchemes, const QStringList &excludeSchemes
     );
     int createSubscription();
     void cancelSubscription(const int &subscriptionId);
 
 private:
-    enum CphResource
+    enum CupsResource
     {
-        CphResourceRoot = 0,
-        CphResourceAdmin,
-        CphResourceJobs,
+        CupsResourceRoot = 0,
+        CupsResourceAdmin,
+        CupsResourceJobs,
     };
 
     bool sendNewPrinterClassRequest(const QString &printerName,
@@ -93,7 +89,7 @@
                                     const QString &value);
     static void addPrinterUri(ipp_t *request, const QString &name);
     static void addRequestingUsername(ipp_t *request, const QString &username);
-    static const QString getResource(const CphResource &resource);
+    static const QString getResource(const CupsResource &resource);
     static bool isPrinterNameValid(const QString &name);
     static void addClassUri(ipp_t *request, const QString &name);
     static bool isStringValid(const QString &string,
@@ -107,8 +103,10 @@
     bool printerIsClass(const QString &name);
     void setInternalStatus(const QString &status);
     bool postRequest(ipp_t *request, const QString &file,
-                     const CphResource &resource);
-    bool sendRequest(ipp_t *request, const CphResource &resource);
+                     const CupsResource &resource);
+    bool sendRequest(ipp_t *request, const CupsResource &resource);
+    bool sendNewSimpleRequest(ipp_op_t op, const QString &printerName,
+                              const CupsResource &resource);
     bool handleReply(ipp_t *reply);
     bool isReplyOk(ipp_t *reply, bool deleteIfReplyNotOk);
     void setErrorFromReply(ipp_t *reply);
@@ -120,4 +118,4 @@
 };
 
 
-#endif // USC_PRINTERS_CUPSPKHELPER_H
+#endif // USC_PRINTERS_CUPS_IPPCLIENT_H

=== added file 'plugins/Ubuntu/Settings/Printers/cups/printerdriverloader.cpp'
--- plugins/Ubuntu/Settings/Printers/cups/printerdriverloader.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/printerdriverloader.cpp	2017-02-17 13:07:34 +0000
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "printerdriverloader.h"
+
+PrinterDriverLoader::PrinterDriverLoader(
+        const QString &deviceId, const QString &language,
+        const QString &makeModel, const QString &product,
+        const QStringList &includeSchemes, const QStringList &excludeSchemes)
+    : m_deviceId(deviceId)
+    , m_language(language)
+    , m_makeModel(makeModel)
+    , m_product(product)
+    , m_includeSchemes(includeSchemes)
+    , m_excludeSchemes(excludeSchemes)
+{
+}
+
+PrinterDriverLoader::~PrinterDriverLoader()
+{
+}
+
+void PrinterDriverLoader::process()
+{
+    m_running = true;
+
+    ipp_t* response = client.createPrinterDriversRequest(
+        m_deviceId, m_language, m_makeModel, m_product, m_includeSchemes,
+        m_excludeSchemes
+    );
+
+    // Note: if the response somehow fails, we return.
+    if (!response || ippGetStatusCode(response) > IPP_OK_CONFLICT) {
+        QString err(cupsLastErrorString());
+        qWarning() << Q_FUNC_INFO << "Cups HTTP error:" << err;
+
+        if (response)
+            ippDelete(response);
+
+        Q_EMIT error(err);
+        Q_EMIT finished();
+        return;
+    }
+
+    ipp_attribute_t *attr;
+    QByteArray ppdDeviceId;
+    QByteArray ppdLanguage;
+    QByteArray ppdMakeModel;
+    QByteArray ppdName;
+
+    // cups_option_t option;
+    QList<PrinterDriver> drivers;
+
+    for (attr = ippFirstAttribute(response); attr != NULL && m_running; attr = ippNextAttribute(response)) {
+
+        while (attr != NULL && ippGetGroupTag(attr) != IPP_TAG_PRINTER)
+            attr = ippNextAttribute(response);
+
+        if (attr == NULL)
+            break;
+
+        // Pull the needed attributes from this PPD...
+        ppdDeviceId = "NONE";
+        ppdLanguage.clear();
+        ppdMakeModel.clear();
+        ppdName.clear();
+
+        while (attr != NULL && ippGetGroupTag(attr) == IPP_TAG_PRINTER) {
+            if (!strcmp(ippGetName(attr), "ppd-device-id") &&
+                 ippGetValueTag(attr) == IPP_TAG_TEXT) {
+                ppdDeviceId = ippGetString(attr, 0, NULL);
+            } else if (!strcmp(ippGetName(attr), "ppd-natural-language") &&
+                       ippGetValueTag(attr) == IPP_TAG_LANGUAGE) {
+                ppdLanguage = ippGetString(attr, 0, NULL);
+
+            } else if (!strcmp(ippGetName(attr), "ppd-make-and-model") &&
+                       ippGetValueTag(attr) == IPP_TAG_TEXT) {
+                ppdMakeModel = ippGetString(attr, 0, NULL);
+            } else if (!strcmp(ippGetName(attr), "ppd-name") &&
+                       ippGetValueTag(attr) == IPP_TAG_NAME) {
+
+                ppdName = ippGetString(attr, 0, NULL);
+            }
+
+            attr = ippNextAttribute(response);
+        }
+
+        // See if we have everything needed...
+        if (ppdLanguage.isEmpty() || ppdMakeModel.isEmpty() ||
+            ppdName.isEmpty()) {
+            if (attr == NULL)
+                break;
+            else
+                continue;
+        }
+
+        PrinterDriver m;
+        m.name = ppdName;
+        m.deviceId = ppdDeviceId;
+        m.makeModel = ppdMakeModel;
+        m.language = ppdLanguage;
+
+        drivers.append(m);
+    }
+
+    ippDelete(response);
+
+    Q_EMIT loaded(drivers);
+    Q_EMIT finished();
+}
+
+void PrinterDriverLoader::cancel()
+{
+    m_running = false;
+}

=== added file 'plugins/Ubuntu/Settings/Printers/cups/printerdriverloader.h'
--- plugins/Ubuntu/Settings/Printers/cups/printerdriverloader.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/printerdriverloader.h	2017-02-17 13:07:34 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_PRINTERS_CUPS_DRIVERLOADER_H
+#define USC_PRINTERS_CUPS_DRIVERLOADER_H
+
+#include "ippclient.h"
+#include "structs.h"
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+
+class PrinterDriverLoader : public QObject
+{
+    Q_OBJECT
+public:
+    PrinterDriverLoader(
+        const QString &deviceId = "",
+        const QString &language = "",
+        const QString &makeModel = "",
+        const QString &product = "",
+        const QStringList &includeSchemes = QStringList(),
+        const QStringList &excludeSchemes = QStringList());
+    ~PrinterDriverLoader();
+
+public Q_SLOTS:
+    void process();
+    void cancel();
+
+Q_SIGNALS:
+    void finished();
+    void loaded(const QList<PrinterDriver> &drivers);
+    void error(const QString &error);
+
+private:
+    QString m_deviceId = QString::null;
+    QString m_language = QString::null;
+    QString m_makeModel = QString::null;
+    QString m_product = QString::null;
+    QStringList m_includeSchemes;
+    QStringList m_excludeSchemes;
+
+    bool m_running = false;
+    IppClient client;
+};
+
+#endif // USC_PRINTERS_CUPS_DRIVERLOADER_H

=== added file 'plugins/Ubuntu/Settings/Printers/cups/printerloader.cpp'
--- plugins/Ubuntu/Settings/Printers/cups/printerloader.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/printerloader.cpp	2017-02-17 13:07:34 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "backend/backend_pdf.h"
+#include "backend/backend_cups.h"
+#include "printerloader.h"
+
+#include <QPrinterInfo>
+
+class PrinterCupsBackend;
+PrinterLoader::PrinterLoader(const QString &printerName,
+                             IppClient *client,
+                             OrgCupsCupsdNotifierInterface* notifier,
+                             QObject *parent)
+    : QObject(parent)
+    , m_printerName(printerName)
+    , m_client(client)
+    , m_notifier(notifier)
+{
+}
+
+PrinterLoader::~PrinterLoader()
+{
+}
+
+void PrinterLoader::load()
+{
+    QPrinterInfo info = QPrinterInfo::printerInfo(m_printerName);
+    auto backend = new PrinterCupsBackend(m_client, info, m_notifier);
+
+    // Dest or PPD was null, but we know it's name so we will use it.
+    if (info.printerName().isEmpty()) {
+        backend->setPrinterNameInternal(m_printerName);
+    }
+
+    auto p = QSharedPointer<Printer>(new Printer(backend));
+
+    Q_EMIT loaded(p);
+    Q_EMIT finished();
+}

=== added file 'plugins/Ubuntu/Settings/Printers/cups/printerloader.h'
--- plugins/Ubuntu/Settings/Printers/cups/printerloader.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/printerloader.h	2017-02-17 13:07:34 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_PRINTERS_CUPS_PRINTERLOADER_H
+#define USC_PRINTERS_CUPS_PRINTERLOADER_H
+
+#include "cups/ippclient.h"
+#include "cupsdnotifier.h" // Note: this file was generated.
+#include "printer/printer.h"
+
+#include <QList>
+#include <QObject>
+#include <QSharedPointer>
+
+class PrinterLoader : public QObject
+{
+    Q_OBJECT
+    const QString m_printerName;
+    IppClient *m_client;
+    OrgCupsCupsdNotifierInterface *m_notifier;
+public:
+    explicit PrinterLoader(const QString &printerName,
+                           IppClient *client,
+                           OrgCupsCupsdNotifierInterface* notifier,
+                           QObject *parent = Q_NULLPTR);
+    ~PrinterLoader();
+
+public Q_SLOTS:
+    void load();
+
+Q_SIGNALS:
+    void finished();
+    void loaded(QSharedPointer<Printer> printer);
+};
+
+#endif // USC_PRINTERS_CUPS_PRINTERLOADER_H

=== modified file 'plugins/Ubuntu/Settings/Printers/enums.h'
--- plugins/Ubuntu/Settings/Printers/enums.h	2017-02-02 16:00:55 +0000
+++ plugins/Ubuntu/Settings/Printers/enums.h	2017-02-17 13:07:34 +0000
@@ -128,6 +128,14 @@
         ErrorState,
     };
     Q_ENUM(State)
+
+    enum class PrinterType
+    {
+        ProxyType = 0, // Represents a printer not yet loaded.
+        CupsType,
+        PdfType,
+    };
+    Q_ENUM(PrinterType)
 };
 
 #endif // USC_PRINTERS_ENUMS_H

=== modified file 'plugins/Ubuntu/Settings/Printers/models/drivermodel.cpp'
--- plugins/Ubuntu/Settings/Printers/models/drivermodel.cpp	2017-01-27 14:05:06 +0000
+++ plugins/Ubuntu/Settings/Printers/models/drivermodel.cpp	2017-02-17 13:07:34 +0000
@@ -15,17 +15,11 @@
  */
 
 #include "backend/backend_cups.h"
-#include "cups/cupsfacade.h"
 #include "models/drivermodel.h"
 
 #include <QDebug>
 #include <QtConcurrent>
 
-DriverModel::DriverModel(QObject *parent)
-    : DriverModel(new PrinterCupsBackend, parent)
-{
-}
-
 DriverModel::DriverModel(PrinterBackend *backend, QObject *parent)
     : QAbstractListModel(parent)
     , m_backend(backend)
@@ -156,7 +150,7 @@
 
 void DriverModel::load()
 {
-    m_backend->requestAvailablePrinterDrivers();
+    m_backend->requestPrinterDrivers();
 }
 
 void DriverModel::cancel()

=== modified file 'plugins/Ubuntu/Settings/Printers/models/drivermodel.h'
--- plugins/Ubuntu/Settings/Printers/models/drivermodel.h	2017-01-27 13:52:47 +0000
+++ plugins/Ubuntu/Settings/Printers/models/drivermodel.h	2017-02-17 13:07:34 +0000
@@ -32,7 +32,6 @@
     Q_OBJECT
     Q_PROPERTY(int count READ count NOTIFY countChanged)
 public:
-    explicit DriverModel(QObject *parent = Q_NULLPTR);
     explicit DriverModel(PrinterBackend *backend, QObject *parent = Q_NULLPTR);
     ~DriverModel();
 

=== modified file 'plugins/Ubuntu/Settings/Printers/models/jobmodel.cpp'
--- plugins/Ubuntu/Settings/Printers/models/jobmodel.cpp	2017-02-07 13:42:07 +0000
+++ plugins/Ubuntu/Settings/Printers/models/jobmodel.cpp	2017-02-17 13:07:34 +0000
@@ -17,22 +17,19 @@
 #include "utils.h"
 
 #include "backend/backend_cups.h"
-#include "cups/cupsfacade.h"
 
 #include "models/jobmodel.h"
 
 #include <QDebug>
 
-JobModel::JobModel(QObject *parent)
-    : JobModel(QStringLiteral(""), new PrinterCupsBackend, parent)
+JobModel::JobModel(QObject *parent) : QAbstractListModel(parent)
 {
 }
 
-JobModel::JobModel(const QString &printerName, PrinterBackend *backend,
+JobModel::JobModel(PrinterBackend *backend,
                    QObject *parent)
     : QAbstractListModel(parent)
     , m_backend(backend)
-    , m_printer_name(printerName)
 {
     update();
 
@@ -67,6 +64,10 @@
     Q_UNUSED(job_name);
     Q_UNUSED(job_impressions_completed);
 
+    auto job = getJobById(job_id);
+    if (job)
+        job->setImpressionsCompleted(job_impressions_completed);
+
     update();
 }
 
@@ -74,12 +75,7 @@
 {
     // Store the old count and get the new printers
     int oldCount = m_jobs.size();
-    QList<QSharedPointer<PrinterJob>> newJobs = m_backend->printerGetJobs(m_printer_name);
-
-    /* If any printers returned from the backend are irrelevant, we delete
-    them. This a list of indices that corresponds to printers scheduled for
-    deletion in newPrinters. */
-    QList<uint> forDeletion;
+    QList<QSharedPointer<PrinterJob>> newJobs = m_backend->printerGetJobs();
 
     // Go through the old model
     for (int i=0; i < m_jobs.count(); i++) {
@@ -105,7 +101,6 @@
         if (!exists) {
             beginRemoveRows(QModelIndex(), i, i);
             QSharedPointer<PrinterJob> p = m_jobs.takeAt(i);
-            p->deleteLater();
             endRemoveRows();
 
             i--;  // as we have removed an item decrement
@@ -121,7 +116,6 @@
         for (j=0; j < m_jobs.count(); j++) {
             if (m_jobs.at(j)->jobId() == newJobs.at(i)->jobId()) {
                 exists = true;
-                forDeletion << i;
                 break;
             }
         }
@@ -135,9 +129,6 @@
                 m_jobs.move(j, i);
                 endMoveRows();
             }
-
-            // We can safely delete the newPrinter as it already exists.
-            forDeletion << i;
         } else {
             // New printer does not exist insert into model
             beginInsertRows(QModelIndex(), i, i);
@@ -146,10 +137,6 @@
         }
     }
 
-    Q_FOREACH(const int &index, forDeletion) {
-        newJobs.at(index)->deleteLater();
-    }
-
     if (oldCount != m_jobs.size()) {
         Q_EMIT countChanged();
     }
@@ -208,14 +195,17 @@
         case IdRole:
             ret = job->jobId();
             break;
+        case ImpressionsCompletedRole:
+            ret = job->impressionsCompleted();
+            break;
         case LandscapeRole:
             ret = job->landscape();
             break;
         case MessagesRole:
             ret = job->messages();
             break;
-        case OwnerRole:
-            ret = m_printer_name;
+        case PrinterNameRole:
+            ret = job->printerName();
             break;
         case PrintRangeRole:
             ret = job->printRange();
@@ -293,9 +283,10 @@
         names[CopiesRole] = "copies";
         names[CreationTimeRole] = "creationTime";
         names[DuplexRole] = "duplexMode";
+        names[ImpressionsCompletedRole] = "impressionsCompleted";
         names[LandscapeRole] = "landscape";
         names[MessagesRole] = "messages";
-        names[OwnerRole] = "owner";
+        names[PrinterNameRole] = "printerName";
         names[PrintRangeRole] = "printRange";
         names[PrintRangeModeRole] = "printRangeMode";
         names[ProcessingTimeRole] = "processingTime";
@@ -324,3 +315,77 @@
 
     return result;
 }
+
+QSharedPointer<PrinterJob> JobModel::getJobById(const int &id)
+{
+    Q_FOREACH(auto job, m_jobs) {
+        if (job->jobId() == id) {
+            return job;
+        }
+    }
+    return QSharedPointer<PrinterJob>(Q_NULLPTR);
+}
+
+
+JobFilter::JobFilter(QObject *parent) : QSortFilterProxyModel(parent)
+{
+    connect(this, SIGNAL(sourceModelChanged()), SLOT(onSourceModelChanged()));
+}
+
+JobFilter::~JobFilter()
+{
+}
+
+QVariantMap JobFilter::get(const int row) const
+{
+    QHashIterator<int, QByteArray> iterator(roleNames());
+    QVariantMap result;
+    QModelIndex modelIndex = index(row, 0);
+
+    while (iterator.hasNext()) {
+        iterator.next();
+        result[iterator.value()] = modelIndex.data(iterator.key());
+    }
+
+    return result;
+}
+
+void JobFilter::onSourceModelChanged()
+{
+    connect((JobModel*) sourceModel(),
+            SIGNAL(countChanged()),
+            this,
+            SIGNAL(countChanged()));
+}
+
+void JobFilter::onSourceModelCountChanged()
+{
+    Q_EMIT countChanged();
+}
+
+int JobFilter::count() const
+{
+    return rowCount();
+}
+
+void JobFilter::filterOnPrinterName(const QString &name)
+{
+    m_printerName = name;
+    m_printerNameFilterEnabled = true;
+    invalidate();
+}
+
+bool JobFilter::filterAcceptsRow(int sourceRow,
+                                 const QModelIndex &sourceParent) const
+{
+    bool accepts = true;
+    QModelIndex childIndex = sourceModel()->index(sourceRow, 0, sourceParent);
+
+    if (accepts && m_printerNameFilterEnabled) {
+        QString printerName = childIndex.model()->data(
+            childIndex, JobModel::PrinterNameRole).toString();
+        accepts = m_printerName == printerName;
+    }
+
+    return accepts;
+}

=== modified file 'plugins/Ubuntu/Settings/Printers/models/jobmodel.h'
--- plugins/Ubuntu/Settings/Printers/models/jobmodel.h	2017-02-07 13:42:07 +0000
+++ plugins/Ubuntu/Settings/Printers/models/jobmodel.h	2017-02-17 13:07:34 +0000
@@ -18,13 +18,14 @@
 #define USC_JOB_MODEL_H
 
 #include "printers_global.h"
-
-#include "printer/printer.h"
+#include "backend/backend.h"
+#include "printer/printerjob.h"
 
 #include <QAbstractListModel>
 #include <QByteArray>
 #include <QModelIndex>
 #include <QObject>
+#include <QSharedPointer>
 #include <QSortFilterProxyModel>
 #include <QTimer>
 #include <QVariant>
@@ -36,7 +37,7 @@
     Q_PROPERTY(int count READ count NOTIFY countChanged)
 public:
     explicit JobModel(QObject *parent = Q_NULLPTR);
-    explicit JobModel(const QString &printerName, PrinterBackend *backend,
+    explicit JobModel(PrinterBackend *backend,
                       QObject *parent = Q_NULLPTR);
     ~JobModel();
 
@@ -50,9 +51,10 @@
         CopiesRole,
         CreationTimeRole,
         DuplexRole,
+        ImpressionsCompletedRole,
         LandscapeRole,
-        OwnerRole,
         MessagesRole,
+        PrinterNameRole,
         PrintRangeRole,
         PrintRangeModeRole,
         ProcessingTimeRole,
@@ -73,9 +75,9 @@
     int count() const;
 
     Q_INVOKABLE QVariantMap get(const int row) const;
+    QSharedPointer<PrinterJob> getJobById(const int &id);
 private:
     PrinterBackend *m_backend;
-    QString m_printer_name;
 
     QList<QSharedPointer<PrinterJob>> m_jobs;
 private Q_SLOTS:
@@ -92,4 +94,32 @@
     void countChanged();
 };
 
+class PRINTERS_DECL_EXPORT JobFilter : public QSortFilterProxyModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+public:
+    explicit JobFilter(QObject *parent = Q_NULLPTR);
+    ~JobFilter();
+
+    Q_INVOKABLE QVariantMap get(const int row) const;
+
+    void filterOnPrinterName(const QString &name);
+    int count() const;
+protected:
+    virtual bool filterAcceptsRow(
+        int sourceRow, const QModelIndex &sourceParent) const override;
+
+Q_SIGNALS:
+    void countChanged();
+
+private Q_SLOTS:
+    void onSourceModelChanged();
+    void onSourceModelCountChanged();
+
+private:
+    QString m_printerName = QString::null;
+    bool m_printerNameFilterEnabled = false;
+};
+
 #endif // USC_JOB_MODEL_H

=== modified file 'plugins/Ubuntu/Settings/Printers/models/printermodel.cpp'
--- plugins/Ubuntu/Settings/Printers/models/printermodel.cpp	2017-02-03 16:34:49 +0000
+++ plugins/Ubuntu/Settings/Printers/models/printermodel.cpp	2017-02-17 13:07:34 +0000
@@ -14,146 +14,168 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "utils.h"
-
 #include "backend/backend_cups.h"
-#include "cups/cupsfacade.h"
+#include "backend/backend_pdf.h"
+#include "i18n.h"
 #include "models/jobmodel.h"
 #include "models/printermodel.h"
+#include "utils.h"
 
 #include <QDebug>
-#include <QQmlEngine>
-
-PrinterModel::PrinterModel(QObject *parent)
-    : PrinterModel(new PrinterCupsBackend, parent)
-{
-}
 
 PrinterModel::PrinterModel(PrinterBackend *backend, QObject *parent)
     : QAbstractListModel(parent)
     , m_backend(backend)
 {
-    update();
 
     QObject::connect(m_backend, &PrinterBackend::printerAdded,
-                     this, &PrinterModel::printerSignalCatchall);
+                     this, &PrinterModel::printerAdded);
     QObject::connect(m_backend, &PrinterBackend::printerModified,
-                     this, &PrinterModel::printerSignalCatchall);
+                     this, &PrinterModel::printerModified);
+    QObject::connect(m_backend, &PrinterBackend::printerStateChanged,
+                     this, &PrinterModel::printerModified);
     QObject::connect(m_backend, &PrinterBackend::printerDeleted,
-                     this, &PrinterModel::printerSignalCatchall);
+                     this, &PrinterModel::printerDeleted);
+
+    connect(m_backend, SIGNAL(printerLoaded(QSharedPointer<Printer>)),
+            this, SLOT(printerLoaded(QSharedPointer<Printer>)));
+
+    // Create printer proxies for every printerName.
+    Q_FOREACH(auto printerName, m_backend->availablePrinterNames()) {
+        auto p = QSharedPointer<Printer>(new Printer(new PrinterBackend(printerName)));
+        addPrinter(p, CountChangeSignal::Defer);
+    }
+
+    // Add a PDF printer.
+    auto pdfPrinter = QSharedPointer<Printer>(
+        new Printer(new PrinterPdfBackend(__("Create PDF")))
+    );
+    addPrinter(pdfPrinter, CountChangeSignal::Defer);
+
+    Q_EMIT countChanged();
 }
 
 PrinterModel::~PrinterModel()
 {
 }
 
-void PrinterModel::printerSignalCatchall(
-    const QString &text, const QString &printerUri,
-    const QString &printerName, uint printerState,
-    const QString &printerStateReason, bool acceptingJobs)
-{
-    Q_UNUSED(text);
-    Q_UNUSED(printerUri);
-    Q_UNUSED(printerName);
-    Q_UNUSED(printerState);
-    Q_UNUSED(printerStateReason);
-    Q_UNUSED(acceptingJobs);
-    update();
-}
-
-void PrinterModel::update()
-{
-    // Store the old count and get the new printers
-    int oldCount = m_printers.size();
-    QList<Printer*> newPrinters = m_backend->availablePrinters();
-
-    /* If any printers returned from the backend are irrelevant, we delete
-    them. This a list of indices that corresponds to printers scheduled for
-    deletion in newPrinters. */
-    QList<uint> forDeletion;
-
-    // Go through the old model
+void PrinterModel::printerLoaded(QSharedPointer<Printer> printer)
+{
+    // Find and possibly replace an old printer.
     for (int i=0; i < m_printers.count(); i++) {
-        // Determine if the old printer exists in the new model
-        bool exists = false;
-
-        Q_FOREACH(Printer *p, newPrinters) {
-            if (p->name() == m_printers.at(i)->name()) {
-                exists = true;
-
-                // Ensure the other properties of the Printer are up to date
-                if (!m_printers.at(i)->deepCompare(p)) {
-                    m_printers.at(i)->updateFrom(p);
-
-                    Q_EMIT dataChanged(index(i), index(i));
-                }
-
-                break;
-            }
-        }
-
-        // If it doesn't exist then remove it from the old model
-        if (!exists) {
-            beginRemoveRows(QModelIndex(), i, i);
-            Printer *p = m_printers.takeAt(i);
-            JobModel *jobModel = m_job_models.take(p->name());
-
-            p->deleteLater();
-            jobModel->deleteLater();
-
-            endRemoveRows();
-
-            i--;  // as we have removed an item decrement
-        }
-    }
-
-    // Go through the new model
-    for (int i=0; i < newPrinters.count(); i++) {
-        // Determine if the new printer exists in the old model
-        bool exists = false;
-        int j;
-
-        for (j=0; j < m_printers.count(); j++) {
-            if (m_printers.at(j)->name() == newPrinters.at(i)->name()) {
-                exists = true;
-                forDeletion << i;
-                break;
-            }
-        }
-
-        if (exists) {
-            if (j == i) {  // New printer exists and in correct position
-                continue;
-            } else {
-                // New printer does exist but needs to be moved in old model
-                beginMoveRows(QModelIndex(), j, 1, QModelIndex(), i);
-                m_printers.move(j, i);
-                endMoveRows();
-            }
-
-            // We can safely delete the newPrinter as it already exists.
-            forDeletion << i;
-        } else {
-            // New printer does not exist insert into model
-            beginInsertRows(QModelIndex(), i, i);
-
-            m_printers.insert(i, newPrinters.at(i));
-
-            JobModel *model = new JobModel(newPrinters.at(i)->name(), m_backend, this);
-            QQmlEngine::setObjectOwnership(model, QQmlEngine::CppOwnership);
-            m_job_models.insert(newPrinters.at(i)->name(), model);
-
-            endInsertRows();
-        }
-    }
-
-    Q_FOREACH(const int &index, forDeletion) {
-        newPrinters.at(index)->deleteLater();
-    }
-
-    if (oldCount != m_printers.size()) {
-        Q_EMIT countChanged();
-    }
+        auto oldPrinter = m_printers.at(i);
+        if (printer->name() == oldPrinter->name()) {
+            if (!oldPrinter->deepCompare(printer)) {
+                updatePrinter(oldPrinter, printer);
+            }
+
+            // We're done.
+            return;
+        }
+    }
+
+    addPrinter(printer, CountChangeSignal::Emit);
+}
+
+void PrinterModel::printerModified(
+    const QString &text, const QString &printerUri,
+    const QString &printerName, uint printerState,
+    const QString &printerStateReason, bool acceptingJobs)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printerUri);
+    Q_UNUSED(printerState);
+    Q_UNUSED(printerStateReason);
+    Q_UNUSED(acceptingJobs);
+
+    m_backend->requestPrinter(printerName);
+}
+
+void PrinterModel::printerAdded(
+    const QString &text, const QString &printerUri,
+    const QString &printerName, uint printerState,
+    const QString &printerStateReason, bool acceptingJobs)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printerUri);
+    Q_UNUSED(printerState);
+    Q_UNUSED(printerStateReason);
+    Q_UNUSED(acceptingJobs);
+
+    m_backend->requestPrinter(printerName);
+}
+
+void PrinterModel::printerDeleted(
+    const QString &text, const QString &printerUri,
+    const QString &printerName, uint printerState,
+    const QString &printerStateReason, bool acceptingJobs)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printerUri);
+    Q_UNUSED(printerState);
+    Q_UNUSED(printerStateReason);
+    Q_UNUSED(acceptingJobs);
+
+    auto printer = getPrinterByName(printerName);
+    if (printer) {
+        removePrinter(printer, CountChangeSignal::Emit);
+    }
+}
+
+QSharedPointer<Printer> PrinterModel::getPrinterByName(const QString &printerName)
+{
+    Q_FOREACH(auto p, m_printers) {
+        if (p->name() == printerName)
+            return p;
+    }
+    return QSharedPointer<Printer>(Q_NULLPTR);
+}
+
+void PrinterModel::movePrinter(const int &from, const int &to)
+{
+    int size = m_printers.size();
+    if (from < 0 || to < 0 || from >= size || to >= size) {
+        qWarning() << Q_FUNC_INFO << "Illegal move operation from"
+                   << from << "to" << to << ". Size was" << size;
+        return;
+    }
+    if (!beginMoveRows(QModelIndex(), from, from, QModelIndex(), to)) {
+        qWarning() << Q_FUNC_INFO << "failed to move rows.";
+        return;
+    }
+    m_printers.move(from, to);
+    endMoveRows();
+}
+
+void PrinterModel::removePrinter(QSharedPointer<Printer> printer, const CountChangeSignal &notify)
+{
+    int idx = m_printers.indexOf(printer);
+    beginRemoveRows(QModelIndex(), idx, idx);
+    m_printers.removeAt(idx);
+    endRemoveRows();
+
+    if (notify == CountChangeSignal::Emit)
+        Q_EMIT countChanged();
+}
+
+void PrinterModel::updatePrinter(QSharedPointer<Printer> old,
+                                  QSharedPointer<Printer> newPrinter)
+{
+    int i = m_printers.indexOf(old);
+    QModelIndex idx = index(i);
+    old->updateFrom(newPrinter);
+    Q_EMIT dataChanged(idx, idx);
+}
+
+void PrinterModel::addPrinter(QSharedPointer<Printer> printer, const CountChangeSignal &notify)
+{
+    int i = m_printers.size();
+    beginInsertRows(QModelIndex(), i, i);
+    m_printers.append(printer);
+    endInsertRows();
+
+    if (notify == CountChangeSignal::Emit)
+        Q_EMIT countChanged();
 }
 
 int PrinterModel::rowCount(const QModelIndex &parent) const
@@ -175,6 +197,23 @@
 
         auto printer = m_printers[index.row()];
 
+
+        /* If printer is a proxy (not loaded), determine if the requested role
+        is something async and that we need to request the data. */
+        if (printer->type() == PrinterEnum::PrinterType::ProxyType) {
+            switch (role) {
+            case Qt::DisplayRole:
+            case NameRole:
+            case DefaultPrinterRole:
+            case PrinterRole:
+            case IsPdfRole:
+            case IsLoadedRole:
+                break; // All of these can be inferred from the name (lazily).
+            default:
+                m_backend->requestPrinter(printer->name());
+            }
+        }
+
         switch (role) {
         case NameRole:
         case Qt::DisplayRole:
@@ -195,7 +234,7 @@
         //     ret = printer->copies();
         //     break;
         case DefaultPrinterRole:
-            ret = printer->isDefault();
+            ret = printer->name() == m_backend->defaultPrinterName();
             break;
         case DuplexRole:
             ret = printer->supportedDuplexModes().indexOf(printer->defaultDuplexMode());
@@ -209,9 +248,6 @@
         // case PrintRangeModeRole:
         //     ret = printer->printRangeMode();
         //     break;
-        // case PdfModeRole:
-        //     ret = printer->pdfMode();
-        //     break;
         case PrintQualityRole:
             ret = printer->supportedPrintQualities().indexOf(printer->defaultPrintQuality());
             break;
@@ -254,12 +290,24 @@
             ret = QVariant::fromValue(printer);
             break;
         case IsPdfRole:
-            ret = printer->isPdf();
-            break;
-        case JobRole: {
-            ret = QVariant::fromValue(m_job_models.value(printer->name()));
-            break;
-        }
+            ret = printer->type() == PrinterEnum::PrinterType::PdfType;
+            break;
+        case IsLoadedRole:
+            ret = printer->type() != PrinterEnum::PrinterType::ProxyType;
+            break;
+        case IsRawRole:
+            ret = !printer->holdsDefinition();
+            break;
+        case JobRole:
+            ret = QVariant::fromValue(printer->jobs());
+            break;
+        case EnabledRole:
+            ret = printer->enabled();
+            break;
+        case AcceptJobsRole:
+            ret = printer->acceptJobs();
+            break;
+
         // case LastStateMessageRole:
         //     ret = printer->lastStateMessage();
         //     break;
@@ -312,6 +360,12 @@
                 }
             }
             break;
+        case EnabledRole:
+            printer->setEnabled(value.toBool());
+            break;
+        case AcceptJobsRole:
+            printer->setAcceptJobs(value.toBool());
+            break;
         }
     }
 
@@ -331,6 +385,8 @@
         names[DuplexRole] = "duplexMode";
         names[SupportedDuplexModesRole] = "supportedDuplexModes";
         names[NameRole] = "name";
+        names[EnabledRole] = "printerEnabled";
+        names[AcceptJobsRole] = "acceptJobs";
         names[PrintRangeRole] = "printRange";
         names[PrintRangeModeRole] = "printRangeMode";
         names[PdfModeRole] = "pdfMode";
@@ -345,6 +401,8 @@
         names[StateRole] = "state";
         names[PrinterRole] = "printer";
         names[IsPdfRole] = "isPdf";
+        names[IsLoadedRole] = "isLoaded";
+        names[IsRawRole] = "isRaw";
         names[JobRole] = "jobs";
         names[LastStateMessageRole] = "lastStateMessage";
     }
@@ -366,12 +424,6 @@
     return result;
 }
 
-Printer* PrinterModel::getPrinterFromName(const QString &name)
-{
-    Q_UNUSED(name);
-    return Q_NULLPTR;
-}
-
 PrinterFilter::PrinterFilter(QObject *parent) : QSortFilterProxyModel(parent)
 {
     connect(this, SIGNAL(sourceModelChanged()), SLOT(onSourceModelChanged()));
@@ -484,4 +536,3 @@
         return leftData < rightData;
     }
 }
-

=== modified file 'plugins/Ubuntu/Settings/Printers/models/printermodel.h'
--- plugins/Ubuntu/Settings/Printers/models/printermodel.h	2017-02-03 12:04:46 +0000
+++ plugins/Ubuntu/Settings/Printers/models/printermodel.h	2017-02-17 13:07:34 +0000
@@ -35,7 +35,6 @@
     Q_OBJECT
     Q_PROPERTY(int count READ count NOTIFY countChanged)
 public:
-    explicit PrinterModel(QObject *parent = Q_NULLPTR);
     explicit PrinterModel(PrinterBackend *backend, QObject *parent = Q_NULLPTR);
     ~PrinterModel();
 
@@ -49,6 +48,8 @@
         DuplexRole,
         SupportedDuplexModesRole,
         NameRole,
+        EnabledRole,
+        AcceptJobsRole,
         PrintRangeRole,
         PrintRangeModeRole,
         PdfModeRole,
@@ -63,9 +64,19 @@
         StateRole,
         PrinterRole,
         LastStateMessageRole,
+
+        /* Indicates that this printer is a pseudo printer used to create
+        PDF files. */
         IsPdfRole,
+
+        /* Indicates whether or not this printer has been fully loaded. If not
+        fully loaded, basically only its name will be accessible.  */
+        IsLoadedRole,
+
+        /* Indicates that this printers has no associated PPD. */
+        IsRawRole,
         JobRole,
-        LastRole = LastStateMessageRole,
+        LastRole = JobRole,
     };
 
     virtual int rowCount(const QModelIndex &parent = QModelIndex()) const override;
@@ -75,20 +86,35 @@
 
     int count() const;
 
-    Printer* getPrinterFromName(const QString &name);
-
     Q_INVOKABLE QVariantMap get(const int row) const;
+    QSharedPointer<Printer> getPrinterByName(const QString &printerName);
 private:
+    enum class CountChangeSignal
+    {
+        Defer,
+        Emit,
+    };
+
+    void addPrinter(QSharedPointer<Printer> printer,
+        const CountChangeSignal &notify = CountChangeSignal::Defer);
+    void removePrinter(QSharedPointer<Printer> printer,
+        const CountChangeSignal &notify = CountChangeSignal::Defer);
+    void movePrinter(const int &from, const int &to);
+    void updatePrinter(QSharedPointer<Printer> old,
+                       QSharedPointer<Printer> newPrinter);
     PrinterBackend *m_backend;
 
-    /* FIXME: there's currently no need to share the Printer obj with QML, so
-    this should be normal pointers that are deletedLater. */
-    QList<Printer*> m_printers;
-    QMap<QString, JobModel *> m_job_models;
+    QList<QSharedPointer<Printer>> m_printers;
 
 private Q_SLOTS:
-    void update();
-    void printerSignalCatchall(const QString &text, const QString &printerUri,
+    void printerLoaded(QSharedPointer<Printer> printer);
+    void printerModified(const QString &text, const QString &printerUri,
+        const QString &printerName, uint printerState,
+        const QString &printerStateReason, bool acceptingJobs);
+    void printerAdded(const QString &text, const QString &printerUri,
+        const QString &printerName, uint printerState,
+        const QString &printerStateReason, bool acceptingJobs);
+    void printerDeleted(const QString &text, const QString &printerUri,
         const QString &printerName, uint printerState,
         const QString &printerStateReason, bool acceptingJobs);
 

=== modified file 'plugins/Ubuntu/Settings/Printers/plugin.cpp'
--- plugins/Ubuntu/Settings/Printers/plugin.cpp	2017-01-26 16:19:10 +0000
+++ plugins/Ubuntu/Settings/Printers/plugin.cpp	2017-02-17 13:07:34 +0000
@@ -48,8 +48,11 @@
     qmlRegisterUncreatableType<Printer>(
         uri, 0, 1, "Printer", "use Printers to get a list of Printers."
     );
-    qmlRegisterType<PrinterJob>(uri, 0, 1, "PrinterJob");
+
+    qmlRegisterUncreatableType<PrinterJob>(uri, 0, 1, "PrinterJob",
+                                           "use Printers to create jobs.");
 
     qmlRegisterUncreatableType<PrinterEnum>(uri, 0, 1, "PrinterEnum", "Is an enum");
     qRegisterMetaType<QList<PrinterDriver>>("QList<PrinterDriver>");
+    qRegisterMetaType<QList<QSharedPointer<Printer>>>("QList<QSharedPointer<Printer>>");
 }

=== modified file 'plugins/Ubuntu/Settings/Printers/printer/printer.cpp'
--- plugins/Ubuntu/Settings/Printers/printer/printer.cpp	2017-02-06 13:58:14 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printer.cpp	2017-02-17 13:07:34 +0000
@@ -19,12 +19,7 @@
 #include "printer.h"
 
 #include <QDebug>
-
-Printer::Printer(QObject *parent)
-    : QObject(parent)
-{
-    // TODO: remove this constructor.
-}
+#include <QQmlEngine>
 
 Printer::Printer(PrinterBackend *backend, QObject *parent)
     : QObject(parent)
@@ -32,6 +27,9 @@
 {
     loadColorModel();
     loadPrintQualities();
+    loadAcceptJobs();
+
+    m_jobs.filterOnPrinterName(name());
 }
 
 Printer::~Printer()
@@ -39,10 +37,30 @@
     m_backend->deleteLater();
 }
 
+void Printer::setJobModel(JobModel* jobModel)
+{
+    if (!m_jobs.sourceModel()) {
+        m_jobs.setSourceModel(jobModel);
+        m_jobs.sort(JobModel::Roles::IdRole);
+    }
+}
+
+void Printer::loadAcceptJobs()
+{
+    auto opt = QStringLiteral("AcceptJobs");
+    m_acceptJobs = m_backend->printerGetOption(name(), opt).toBool();
+}
+
 void Printer::loadColorModel()
 {
-    m_supportedColorModels = m_backend->printerGetSupportedColorModels(name());
-    m_defaultColorModel = m_backend->printerGetDefaultColorModel(name());
+    auto defModel = QStringLiteral("DefaultColorModel");
+    auto models = QStringLiteral("SupportedColorModels");
+    auto result = m_backend->printerGetOptions(
+        name(), QStringList({defModel, models})
+    );
+
+    m_defaultColorModel = result.value(defModel).value<ColorModel>();
+    m_supportedColorModels = result.value(models).value<QList<ColorModel>>();
 
     if (m_supportedColorModels.size() == 0) {
         m_supportedColorModels.append(m_defaultColorModel);
@@ -51,8 +69,14 @@
 
 void Printer::loadPrintQualities()
 {
-    m_supportedPrintQualities = m_backend->printerGetSupportedQualities(name());
-    m_defaultPrintQuality = m_backend->printerGetDefaultQuality(name());
+    auto defQuality = QStringLiteral("DefaultPrintQuality");
+    auto qualities = QStringLiteral("SupportedPrintQualities");
+    auto result = m_backend->printerGetOptions(
+        name(), QStringList({defQuality, qualities})
+    );
+
+    m_supportedPrintQualities = result.value(qualities).value<QList<PrintQuality>>();
+    m_defaultPrintQuality = result.value(defQuality).value<PrintQuality>();
 
     if (m_supportedPrintQualities.size() == 0) {
         m_supportedPrintQualities.append(m_defaultPrintQuality);
@@ -98,11 +122,6 @@
     return m_backend->defaultDuplexMode();
 }
 
-PrinterJob *Printer::job()
-{
-    return new PrinterJob(this);
-}
-
 int Printer::printFile(const QString &filepath, const PrinterJob *options)
 {
     auto dest = m_backend->makeDest(name(), options);  // options could be QMap<QString, QString> ?
@@ -145,8 +164,7 @@
 
 bool Printer::enabled() const
 {
-    // TODO: implement
-    return true;
+    return state() != PrinterEnum::State::ErrorState;
 }
 
 QStringList Printer::users() const
@@ -166,14 +184,19 @@
     return QString();
 }
 
-bool Printer::isDefault()
-{
-    return name() == m_backend->defaultPrinterName();
-}
-
-bool Printer::isPdf()
-{
-    return m_backend->backendType() == PrinterBackend::BackendType::PdfType;
+bool Printer::acceptJobs() const
+{
+    return m_acceptJobs;
+}
+
+bool Printer::holdsDefinition() const
+{
+    return m_backend->holdsDefinition();
+}
+
+PrinterEnum::PrinterType Printer::type() const
+{
+    return m_backend->type();
 }
 
 void Printer::setDefaultColorModel(const ColorModel &colorModel)
@@ -200,7 +223,9 @@
 
 void Printer::setDescription(const QString &description)
 {
-    QString answer = m_backend->printerSetInfo(name(), description);
+    if (this->description() != description) {
+        m_backend->printerSetInfo(name(), description);
+    }
 }
 
 void Printer::setDefaultDuplexMode(const PrinterEnum::DuplexMode &duplexMode)
@@ -210,7 +235,7 @@
     }
 
     if (!m_backend->supportedDuplexModes().contains(duplexMode)) {
-        qWarning() << Q_FUNC_INFO << "duplex mode not supported";
+        qWarning() << Q_FUNC_INFO << "duplex mode not supported" << duplexMode;
         return;
     }
 
@@ -220,8 +245,22 @@
 
 void Printer::setEnabled(const bool enabled)
 {
-    // TODO: implement
-    Q_UNUSED(enabled);
+    if (this->enabled() != enabled) {
+        QString reply = m_backend->printerSetEnabled(name(), enabled);
+        if (!reply.isEmpty()) {
+            qWarning() << Q_FUNC_INFO << "failed to set enabled:" << reply;
+        }
+    }
+}
+
+void Printer::setAcceptJobs(const bool accepting)
+{
+    if (this->acceptJobs() != accepting) {
+        QString reply = m_backend->printerSetAcceptJobs(name(), accepting);
+        if (!reply.isEmpty()) {
+            qWarning() << Q_FUNC_INFO << "failed to set accepting:" << reply;
+        }
+    }
 }
 
 void Printer::setErrorPolicy(const PrinterEnum::ErrorPolicy &errorPolicy)
@@ -230,12 +269,6 @@
     Q_UNUSED(errorPolicy);
 }
 
-void Printer::setName(const QString &name)
-{
-    // TODO: implement
-    Q_UNUSED(name);
-}
-
 void Printer::setDefaultPrintQuality(const PrintQuality &quality)
 {
     if (defaultPrintQuality() == quality) {
@@ -271,7 +304,6 @@
     QString reply = m_backend->printerAddOption(name(), "PageSize", vals);
 
     m_backend->refresh();
-    Q_EMIT defaultPageSizeChanged();
 }
 
 void Printer::addUser(const QString &username)
@@ -286,13 +318,14 @@
     Q_UNUSED(username);
 }
 
-void Printer::requestInkLevels(const QString &name)
+QAbstractItemModel* Printer::jobs()
 {
-    // TODO: implement
-    Q_UNUSED(name);
+    auto ret = &m_jobs;
+    QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
+    return ret;
 }
 
-bool Printer::deepCompare(Printer *other) const
+bool Printer::deepCompare(QSharedPointer<Printer> other) const
 {
     bool changed = false;
 
@@ -301,33 +334,25 @@
     changed |= description() != other->description();
     changed |= defaultDuplexMode() != other->defaultDuplexMode();
     changed |= defaultPageSize() != other->defaultPageSize();
+    changed |= type() != other->type();
+    changed |= acceptJobs() != other->acceptJobs();
+    changed |= enabled() != other->enabled();
     changed |= state() != other->state();
 
     // TODO: accessControl
-    // TODO: enabled
     // TODO: errorPolicy
 
     // Return true if they are the same, so no change
     return changed == false;
 }
 
-void Printer::updateFrom(Printer* newPrinter)
+void Printer::updateFrom(QSharedPointer<Printer> other)
 {
-    Q_UNUSED(newPrinter);
-
-    m_backend->refresh();
+    PrinterBackend *tmp = m_backend;
+    m_backend = other->m_backend;
+    other->m_backend = tmp;
 
     loadColorModel();
     loadPrintQualities();
-
-    Q_EMIT descriptionChanged();
-    Q_EMIT defaultColorModelChanged();
-    Q_EMIT defaultDuplexModeChanged();
-    Q_EMIT defaultPageSizeChanged();
-    Q_EMIT defaultPrintQualityChanged();
-    Q_EMIT stateChanged();
-
-    // TODO: accessControl
-    // TODO: enabled
-    // TODO: errorPolicy
+    loadAcceptJobs();
 }

=== modified file 'plugins/Ubuntu/Settings/Printers/printer/printer.h'
--- plugins/Ubuntu/Settings/Printers/printer/printer.h	2017-02-03 14:43:41 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printer.h	2017-02-17 13:07:34 +0000
@@ -21,6 +21,7 @@
 
 #include "backend/backend.h"
 #include "enums.h"
+#include "models/jobmodel.h"
 #include "printer/printerjob.h"
 #include "structs.h"
 
@@ -28,6 +29,7 @@
 #include <QPageSize>
 #include <QList>
 #include <QScopedPointer>
+#include <QSortFilterProxyModel>
 #include <QString>
 #include <QStringList>
 
@@ -37,7 +39,6 @@
 {
     Q_OBJECT
 public:
-    explicit Printer(QObject *parent = nullptr);
     explicit Printer(PrinterBackend *backend, QObject *parent = nullptr);
     ~Printer();
 
@@ -58,66 +59,48 @@
     QStringList users() const;
     PrinterEnum::State state() const;
     QString lastStateMessage() const;
-    bool isDefault();
-    bool isPdf();
+    bool acceptJobs() const;
+    bool holdsDefinition() const;
+    QAbstractItemModel* jobs();
+
+    PrinterEnum::PrinterType type() const;
 
     void setAccessControl(const PrinterEnum::AccessControl &accessControl);
     void setDefaultColorModel(const ColorModel &colorModel);
     void setDescription(const QString &description);
     void setDefaultDuplexMode(const PrinterEnum::DuplexMode &duplexMode);
     void setEnabled(const bool enabled);
+    void setAcceptJobs(const bool accepting);
     void setErrorPolicy(const PrinterEnum::ErrorPolicy &errorPolicy);
-    void setName(const QString &name);
     void setDefaultPrintQuality(const PrintQuality &quality);
     void setDefaultPageSize(const QPageSize &pageSize);
-
-    bool deepCompare(Printer *other) const;
+    void setJobModel(JobModel* jobModel);
+
+    bool deepCompare(QSharedPointer<Printer> other) const;
+    void updateFrom(QSharedPointer<Printer> other);
+
+
 public Q_SLOTS:
     // Add user that is either denied or allowed printer. See AccessControl.
     void addUser(const QString &username);
 
-    // Helper for managing a job on the printer
-    PrinterJob *job();
     int printFile(const QString &filepath, const PrinterJob *options);
 
     // Removes user. See addUser.
     void removeUser(const QString &username);
 
-    // Requests ink levels for printer.
-    void requestInkLevels(const QString &name);
-
-    void updateFrom(Printer *newPrinter);
-Q_SIGNALS:
-    void nameChanged();
-    void enabledChanged();
-    void descriptionChanged();
-    void defaultPageSizeChanged();
-    void defaultDuplexModeChanged();
-    void defaultColorModelChanged();
-    void defaultPrintQualityChanged();
-    void qualityChanged();
-    void accessControlChanged();
-    void errorPolicyChanged();
-    void usersChanged();
-    void stateChanged();
-    void settingsChanged();
-    void lastStateMessageChanged();
-
-    void inkLevelsRequestComplete(const InkLevels &inkLevels);
-    void inkLevelsRequestFailed(const QString &reply);
-
-    // Signals that some printer setting was changed.
-    void printerChanged();
-
 private:
+    void loadAcceptJobs();
     void loadColorModel();
     void loadPrintQualities();
 
+    JobFilter m_jobs;
     PrinterBackend *m_backend;
     ColorModel m_defaultColorModel;
     QList<ColorModel> m_supportedColorModels;
     PrintQuality m_defaultPrintQuality;
     QList<PrintQuality> m_supportedPrintQualities;
+    bool m_acceptJobs;
 };
 
 // FIXME: not necessary outside tests

=== modified file 'plugins/Ubuntu/Settings/Printers/printer/printerjob.cpp'
--- plugins/Ubuntu/Settings/Printers/printer/printerjob.cpp	2017-02-07 13:42:07 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerjob.cpp	2017-02-17 13:07:34 +0000
@@ -20,18 +20,16 @@
 #include "backend/backend_cups.h"
 #include "models/printermodel.h"
 #include "printer/printerjob.h"
-
-PrinterJob::PrinterJob(QObject *parent)
-    : PrinterJob(Q_NULLPTR, parent)
-{
-}
-
-PrinterJob::PrinterJob(Printer *printer, QObject *parent)
-    : PrinterJob(printer, new PrinterCupsBackend, parent)
-{
-}
-
-PrinterJob::PrinterJob(Printer *printer, PrinterBackend *backend,
+#include "utils.h"
+
+PrinterJob::PrinterJob(QString printerName,
+                       PrinterBackend *backend,
+                       QObject *parent)
+    : PrinterJob(printerName, backend, -1, parent)
+{
+}
+
+PrinterJob::PrinterJob(QString printerName, PrinterBackend *backend, int jobId,
                        QObject *parent)
     : QObject(parent)
     , m_collate(true)
@@ -40,12 +38,13 @@
     , m_copies(1)
     , m_creation_time(QDateTime())
     , m_backend(backend)
+    , m_printerName(printerName)
     , m_duplex_mode(0)
+    , m_impressions_completed(0)
     , m_is_two_sided(false)
-    , m_job_id(-1)
+    , m_job_id(jobId)
     , m_messages(QStringList())
-    , m_printer(printer)
-    , m_printer_name(QStringLiteral(""))
+    , m_printer(QSharedPointer<Printer>(Q_NULLPTR))
     , m_print_range(QStringLiteral(""))
     , m_print_range_mode(PrinterEnum::PrintRange::AllPages)
     , m_processing_time(QDateTime())
@@ -56,27 +55,10 @@
     , m_title(QStringLiteral(""))
     , m_user("")
 {
-    if (m_printer) {
-        m_printer_name = printer->name();
-    }
-
-    loadDefaults();
-}
-
-PrinterJob::PrinterJob(const QString &name, PrinterBackend *backend, int jobId, QObject *parent)
-    : QObject(parent)
-    , m_backend(backend)
-    , m_job_id(jobId)
-{
-    setPrinterName(name);
-
-    // TODO: load other options from job
-}
-
+}
 
 PrinterJob::~PrinterJob()
 {
-
 }
 
 bool PrinterJob::collate() const
@@ -114,6 +96,11 @@
     return m_duplex_mode;
 }
 
+int PrinterJob::impressionsCompleted() const
+{
+    return m_impressions_completed;
+}
+
 ColorModel PrinterJob::getColorModel() const
 {
     if (m_printer && colorModel() > -1 && colorModel() < m_printer->supportedColorModels().count()) {
@@ -158,12 +145,67 @@
 
 void PrinterJob::loadDefaults()
 {
-    if (m_printer) {
-        // Load defaults from printer
-        setColorModel(m_printer->supportedColorModels().indexOf(m_printer->defaultColorModel()));
-        setDuplexMode(m_printer->supportedDuplexModes().indexOf(m_printer->defaultDuplexMode()));
-        setQuality(m_printer->supportedPrintQualities().indexOf(m_printer->defaultPrintQuality()));
-    }
+    if (!m_printer) {
+        qWarning() << Q_FUNC_INFO << "Job can't load defaults from null printer.";
+        return;
+    }
+
+    qWarning() << Q_FUNC_INFO << jobId();
+
+    if (jobId() > 0) {
+        // Load the extra attributes for the job
+        // NOTE: we don't need to type check them as they have been filtered for us
+
+        QMap<QString, QVariant> attributes = m_backend->printerGetJobAttributes(
+            m_printer->name(), jobId());
+
+        setCollate(attributes.value("Collate").toBool());
+        setCopies(attributes.value("copies").toInt());
+
+        // No colorModel will result in PrinterJob using defaultColorModel
+        QString colorModel = attributes.value("ColorModel").toString();
+        for (int i=0; i < m_printer->supportedColorModels().length(); i++) {
+            if (m_printer->supportedColorModels().at(i).originalOption == colorModel) {
+                setColorModel(i);
+            }
+        }
+
+        // No duplexMode will result in PrinterJob using defaultDuplexMode
+        QString duplex = attributes.value("Duplex").toString();
+        PrinterEnum::DuplexMode duplexMode = Utils::ppdChoiceToDuplexMode(duplex);
+        for (int i=0; i < m_printer->supportedDuplexModes().length(); i++) {
+            if (m_printer->supportedDuplexModes().at(i) == duplexMode) {
+                setDuplexMode(i);
+            }
+        }
+
+        setLandscape(attributes.value("landscape").toBool());
+        setMessages(attributes.value("messages").toStringList());
+
+        QStringList pageRanges = attributes.value("page-ranges").toStringList();
+        if (pageRanges.isEmpty()) {
+            setPrintRangeMode(PrinterEnum::PrintRange::AllPages);
+            setPrintRange(QStringLiteral(""));
+        } else {
+            setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
+            // Use groupSeparator as createSeparatedList adds "and" into the string
+            setPrintRange(pageRanges.join(QLocale::system().groupSeparator()));
+        }
+
+        // No quality will result in PrinterJob using defaultPrintQuality
+        QString quality = attributes.value("quality").toString();
+        for (int i=0; i < m_printer->supportedPrintQualities().length(); i++) {
+            if (m_printer->supportedPrintQualities().at(i).name == quality) {
+                setQuality(i);
+            }
+        }
+
+        setReverse(attributes.value("OutputOrder").toString() == "Reverse");
+    }
+
+    setColorModel(m_printer->supportedColorModels().indexOf(m_printer->defaultColorModel()));
+    setDuplexMode(m_printer->supportedDuplexModes().indexOf(m_printer->defaultDuplexMode()));
+    setQuality(m_printer->supportedPrintQualities().indexOf(m_printer->defaultPrintQuality()));
 }
 
 QStringList PrinterJob::messages() const
@@ -171,14 +213,14 @@
     return m_messages;
 }
 
-Printer *PrinterJob::printer() const
+QSharedPointer<Printer> PrinterJob::printer() const
 {
     return m_printer;
 }
 
 QString PrinterJob::printerName() const
 {
-    return m_printer_name;
+    return m_printerName; // Maybe check if it's a class.
 }
 
 void PrinterJob::printFile(const QUrl &url)
@@ -302,6 +344,14 @@
     }
 }
 
+void PrinterJob::setImpressionsCompleted(const int &impressionsCompleted)
+{
+    if (m_impressions_completed != impressionsCompleted) {
+        m_impressions_completed = impressionsCompleted;
+        Q_EMIT impressionsCompletedChanged();
+    }
+}
+
 void PrinterJob::setLandscape(const bool landscape)
 {
     if (m_landscape != landscape) {
@@ -320,33 +370,19 @@
     }
 }
 
-//void PrinterJob::setPrinter(Printer *printer)
-//{
-//    qDebug() << "Attempting to set printer!" << printer;
-
-//    if (m_printer != printer) {
-//        m_printer = printer;
-
-//        Q_EMIT printerChanged();
-//    }
-//}
-
-void PrinterJob::setPrinterName(const QString &printerName)
+void PrinterJob::setPrinter(QSharedPointer<Printer> printer)
 {
-    // Please note the return inside the foreach.
-    if (m_printer_name != printerName) {
-        Q_FOREACH(Printer *printer, m_backend->availablePrinters()) {
-            if (printer->name() == printerName) {
-                m_printer_name = printerName;
-                m_printer = printer;
-                loadDefaults();
-                Q_EMIT printerNameChanged();
-                return;
-            }
-        }
-
-        qWarning() << "Unknown printer:" << printerName;
-    }
+   if (m_printer != printer) {
+       m_printer = printer;
+
+       if (printer->name() != m_printerName) {
+            m_printerName = printer->name();
+            Q_EMIT printerNameChanged();
+       }
+
+       Q_EMIT printerChanged();
+   }
+   loadDefaults();
 }
 
 void PrinterJob::setPrintRange(const QString &printRange)
@@ -457,19 +493,19 @@
     return changed == false;
 }
 
-void PrinterJob::updateFrom(QSharedPointer<PrinterJob> newPrinterJob)
+void PrinterJob::updateFrom(QSharedPointer<PrinterJob> other)
 {
-    setCollate(newPrinterJob->collate());
-    setColorModel(newPrinterJob->colorModel());
-    setCopies(newPrinterJob->copies());
-    setDuplexMode(newPrinterJob->duplexMode());
-    setLandscape(newPrinterJob->landscape());
-    setPrintRange(newPrinterJob->printRange());
-    setPrintRangeMode(newPrinterJob->printRangeMode());
-    setQuality(newPrinterJob->quality());
-    setReverse(newPrinterJob->reverse());
-    setState(newPrinterJob->state());
-    setTitle(newPrinterJob->title());
+    setCollate(other->collate());
+    setColorModel(other->colorModel());
+    setCopies(other->copies());
+    setDuplexMode(other->duplexMode());
+    setLandscape(other->landscape());
+    setPrintRange(other->printRange());
+    setPrintRangeMode(other->printRangeMode());
+    setQuality(other->quality());
+    setReverse(other->reverse());
+    setState(other->state());
+    setTitle(other->title());
 }
 
 QString PrinterJob::user() const

=== modified file 'plugins/Ubuntu/Settings/Printers/printer/printerjob.h'
--- plugins/Ubuntu/Settings/Printers/printer/printerjob.h	2017-02-07 14:29:48 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerjob.h	2017-02-17 13:07:34 +0000
@@ -25,6 +25,7 @@
 #include "backend/backend.h"
 #include "printer/printer.h"
 
+#include <QSharedPointer>
 #include <QtCore/QDateTime>
 #include <QtCore/QObject>
 
@@ -42,11 +43,12 @@
     Q_PROPERTY(int copies READ copies WRITE setCopies NOTIFY copiesChanged)
     Q_PROPERTY(QDateTime creationTime READ creationTime NOTIFY creationTimeChanged)
     Q_PROPERTY(int duplexMode READ duplexMode WRITE setDuplexMode NOTIFY duplexModeChanged)
+    Q_PROPERTY(int impressionsCompleted READ impressionsCompleted NOTIFY impressionsCompletedChanged)
     Q_PROPERTY(bool isTwoSided READ isTwoSided NOTIFY isTwoSidedChanged)
     Q_PROPERTY(bool landscape READ landscape WRITE setLandscape NOTIFY landscapeChanged)
     Q_PROPERTY(QStringList messages READ messages NOTIFY messagesChanged)
-//    Q_PROPERTY(Printer *printer READ printer WRITE setPrinter NOTIFY printerChanged)
-    Q_PROPERTY(QString printerName READ printerName WRITE setPrinterName NOTIFY printerNameChanged)
+    Q_PROPERTY(QSharedPointer<Printer> printer READ printer WRITE setPrinter NOTIFY printerChanged)
+    Q_PROPERTY(QString printerName READ printerName NOTIFY printerNameChanged)
     Q_PROPERTY(QString printRange READ printRange WRITE setPrintRange NOTIFY printRangeChanged)
     Q_PROPERTY(PrinterEnum::PrintRange printRangeMode READ printRangeMode WRITE setPrintRangeMode NOTIFY printRangeModeChanged)
     Q_PROPERTY(QDateTime processingTime READ processingTime NOTIFY processingTimeChanged)
@@ -59,11 +61,11 @@
 
     friend class PrinterCupsBackend;
 public:
-    explicit PrinterJob(QObject *parent=Q_NULLPTR);
-    explicit PrinterJob(Printer *printer, QObject *parent=Q_NULLPTR);
-    explicit PrinterJob(Printer *printer, PrinterBackend *backend,
-                        QObject *parent=Q_NULLPTR);
-    explicit PrinterJob(const QString &name, PrinterBackend *backend, int jobId, QObject *parent=Q_NULLPTR);
+    explicit PrinterJob(QString dest,
+                        PrinterBackend *backend,
+                        QObject *parent=Q_NULLPTR);
+    explicit PrinterJob(QString dest, PrinterBackend *backend, int jobId,
+                        QObject *parent=Q_NULLPTR);
     ~PrinterJob();
 
     bool collate() const;
@@ -73,11 +75,12 @@
     int copies() const;
     QDateTime creationTime() const;
     int duplexMode() const;
+    int impressionsCompleted() const;
     bool isTwoSided() const;
-    int jobId() const;  // TODO: implement
+    int jobId() const;
     bool landscape() const;
     QStringList messages() const;
-    Printer* printer() const;
+    QSharedPointer<Printer> printer() const;
     QString printerName() const;
     QString printRange() const;
     PrinterEnum::PrintRange printRangeMode() const;
@@ -99,16 +102,16 @@
     void setColorModel(const int colorModel);
     void setCopies(const int copies);
     void setDuplexMode(const int duplexMode);
+    void setImpressionsCompleted(const int &impressionsCompleted);
     void setLandscape(const bool landscape);
-//    void setPrinter(Printer *printer);
-    void setPrinterName(const QString &printerName);
+    void setPrinter(QSharedPointer<Printer> printer);
     void setPrintRange(const QString &printRange);
     void setPrintRangeMode(const PrinterEnum::PrintRange printRangeMode);