Merge lp:~jonas-drange/ubuntu-ui-extras/printerloader-thread-affinity into lp:ubuntu-ui-extras

[Jonas G. Drange]

corrects thread affinity for printerloaded printers, as well as any qobject children it might have

corrects thread affinity for printerloaded printers, as well as any qobject children it might have

Unmerged revisions

=== modified file 'modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml'
--- modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml	2017-02-21 11:31:44 +0000
+++ modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml	2017-03-20 13:32:24 +0000
@@ -46,20 +46,36 @@
                 }
                 delegate: ListItem {
                     height: modelLayout.height + (divider.visible ? divider.height : 0)
+                    trailingActions: ListItemActions {
+                        actions: [
+                            Action {
+                                iconName: model.held ? "media-playback-start" : "media-playback-pause"
+                                text: model.held ? "Release" : "Hold"
+
+                                onTriggered: {
+                                    if (model.held) {
+                                        Printers.releaseJob(printer.name, model.id);
+                                    } else {
+                                        Printers.holdJob(printer.name, model.id);
+                                    }
+                                }
+                            },
+                            Action {
+                                iconName: "cancel"
+                                text: "Cancel"
+
+                                onTriggered: Printers.cancelJob(printer.name, model.id);
+                            }
+                        ]
+                    }
+
                     ListItemLayout {
                         id: modelLayout
                         title.text: displayName
-                        subtitle.text: "Job: " + model.id + " State: " + model.state
-                                       + " Color: " + model.colorModel + " CreationTime: "
-                                       + model.creationTime + " PageRange: "
-                                       + model.printRange + " Messages: " + model.messages;
+                        subtitle.text: model.title + " (" + model.id + ")\nPrinting " + model.impressionsCompleted + " pages"
                         subtitle.wrapMode: Text.WrapAtWordBoundaryOrAnywhere
                         subtitle.maximumLineCount: 3
                     }
-                    onClicked: {
-                        console.debug("Cancel:", printer.name, model.id);
-                        Printers.cancelJob(printer.name, model.id);
-                    }
                 }
                 model: printer.jobs
 

=== modified file 'modules/Ubuntu/Components/Extras/Example/Printers.qml'
--- modules/Ubuntu/Components/Extras/Example/Printers.qml	2017-02-21 11:31:44 +0000
+++ modules/Ubuntu/Components/Extras/Example/Printers.qml	2017-03-20 13:32:24 +0000
@@ -51,17 +51,17 @@
                 }
             }
 
-            Component.onCompleted: {
-                printer.description;
-            }
-
             Flickable {
                 id: printerFlickable
                 anchors.fill: parent
-
+                contentHeight: contentItem.childrenRect.height
                 Loader {
                     id: printerPageBitsLoader
-                    anchors.fill: parent
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+
                     sourceComponent: printer.isLoaded ? printerPageLoaded : printerPageNotYetLoaded
                 }
             }
@@ -70,7 +70,7 @@
                 id: printerPageLoaded
 
                 Column {
-                    spacing: units.gu(2)
+                    height: childrenRect.height + anchors.topMargin
                     anchors {
                         top: parent.top
                         topMargin: units.gu(2)
@@ -91,6 +91,31 @@
                         }
                     }
 
+                    ListItems.SingleValue {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Status"
+
+                        value: {
+                            var state;
+                            if (printer.state == PrinterEnum.IdleState) {
+                                state = i18n.tr("Idle");
+                            } else if (printer.state == PrinterEnum.AbortedState) {
+                                state = i18n.tr("Aborted");
+                            } else if (printer.state == PrinterEnum.ActiveState) {
+                                state = i18n.tr("Active");
+                            } else if (printer.state == PrinterEnum.ErrorState) {
+                                state = i18n.tr("Stopped");
+                            }
+                            return "%1 — %2"
+                                .arg(state)
+                                .arg(printer.lastMessage ?
+                                     printer.lastMessage : i18n.tr("No messages"));
+                        }
+                    }
+
                     ListItems.Standard {
                         anchors {
                             left: parent.left
@@ -109,25 +134,30 @@
                             left: parent.left
                             right: parent.right
                         }
+                        text: "Shared"
+
+                        control: Switch {
+                            checked: printer.shared
+                            onCheckedChanged: printer.shared = checked
+                        }
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
                         text: "Jobs"
                         progression: true
                         onClicked: pageStack.push(jobPage, { printer: printer })
                     }
 
-                    Label {
+                    ListItems.Standard {
                         anchors {
                             left: parent.left
                             right: parent.right
-                            margins: units.gu(2)
                         }
                         text: "Description"
-                    }
-
-                    ListItems.SingleControl {
-                        anchors {
-                            left: parent.left
-                            right: parent.right
-                        }
 
                         control: TextField {
                            anchors {
@@ -141,6 +171,27 @@
                         }
                     }
 
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Copies"
+
+                        control: TextField {
+                            id: copiesField
+                            inputMethodHints: Qt.ImhDigitsOnly
+                            text: printer.copies
+                            validator: IntValidator {
+                                bottom: 1
+                                top: 999
+                            }
+                            width: units.gu(10)
+                            onTextChanged: printer.copies = text
+                        }
+
+                    }
+
 
                     ListItems.ValueSelector {
                         anchors {
@@ -200,6 +251,26 @@
                                 selectedIndex = printer.printQuality
                         }
                     }
+
+                    ListItems.SingleControl {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        control: Button {
+                            text: "Print test page"
+                            onClicked: Printers.printTestPage(printer.name)
+                        }
+                    }
+
+                    ListItems.SingleValue {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Device URI"
+                        value: printer.deviceUri
+                    }
                 }
             }
         }
@@ -338,9 +409,18 @@
 
                         ProgressionSlot {}
                     }
-                    onClicked: pageStack.push(printerPage, { printer: model })
+                    onClicked: {
+                        Printers.loadPrinter(model.name);
+                        pageStack.push(printerPage, { printer: model });
+                    }
                 }
             }
+
+            Label {
+                anchors.centerIn: parent
+                visible: printerList.count === 0
+                text: "No printers found"
+            }
         }
     }
 
@@ -423,9 +503,7 @@
                 }
             }
 
-            Component.onCompleted: {
-                Printers.prepareToAddPrinter();
-            }
+            Component.onCompleted: Printers.prepareToAddPrinter()
 
             Timer {
                 id: okTimer
@@ -436,14 +514,12 @@
             Flickable {
                 id: addPrinterFlickable
                 anchors.fill: parent
+                contentHeight: contentItem.childrenRect.height
 
                 Column {
                     id: addPrinterCol
                     property bool enabled: true
-                    anchors {
-                        left: parent.left
-                        right: parent.right
-                    }
+                    anchors { left: parent.left; right: parent.right }
 
                     Item {
                         id: errorMessageContainer
@@ -476,10 +552,7 @@
 
                     ListItems.ValueSelector {
                         id: driverSelector
-                        anchors {
-                            left: parent.left
-                            right: parent.right
-                        }
+                        anchors { left: parent.left; right: parent.right }
                         text: "Choose driver"
                         values: [
                             "Select printer from database",
@@ -489,10 +562,7 @@
                     }
 
                     ListItems.Standard {
-                        anchors {
-                            left: parent.left
-                            right: parent.right
-                        }
+                        anchors { left: parent.left; right: parent.right }
                         text: "Filter drivers"
                         control: TextField {
                             id: driverFilter
@@ -559,10 +629,7 @@
                     }
 
                     ListItems.Standard {
-                        anchors {
-                            left: parent.left
-                            right: parent.right
-                        }
+                        anchors { left: parent.left; right: parent.right }
                         text: "Printer name"
                         control: TextField {
                             id: printerName
@@ -572,10 +639,7 @@
                     }
 
                     ListItems.Standard {
-                        anchors {
-                            left: parent.left
-                            right: parent.right
-                        }
+                        anchors { left: parent.left; right: parent.right }
                         text: "Description (optional)"
                         control: TextField {
                             id: printerDescription
@@ -585,10 +649,7 @@
                     }
 
                     ListItems.Standard {
-                        anchors {
-                            left: parent.left
-                            right: parent.right
-                        }
+                        anchors { left: parent.left; right: parent.right }
                         text: "Location (optional)"
                         control: TextField {
                             id: printerLocation
@@ -597,6 +658,93 @@
                         enabled: parent.enabled
                     }
                 }
+
+                Label {
+                    id: remotePrintersLabel
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                        margins: units.gu(2)
+                        top: addPrinterCol.bottom
+                    }
+                    text: "Other printers"
+
+                    ActivityIndicator {
+                        id: remotePrintersSearchIndicator
+                        anchors {
+                            right: parent.right
+                            verticalCenter: parent.verticalCenter
+                        }
+                        property var target
+                        Component.onCompleted: target = Printers.remotePrinters
+                        running: target.searching
+                    }
+                }
+
+                ListView {
+                    id: remotePrintersList
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                        top: remotePrintersLabel.bottom
+                        topMargin: units.gu(2)
+                    }
+                    height: contentItem.childrenRect.height
+                    model: Printers.remotePrinters
+                    delegate: ListItem {
+                        height: modelLayout.height + (divider.visible ? divider.height : 0)
+                        ListItemLayout {
+                            id: modelLayout
+                            title.text: displayName
+                            subtitle.text: {
+                                if (type == PrinterEnum.LPDType) return "LPD";
+                                if (type == PrinterEnum.IppSType) return "IppS";
+                                if (type == PrinterEnum.Ipp14Type) return "Ipp14";
+                                if (type == PrinterEnum.HttpType) return "Http";
+                                if (type == PrinterEnum.BehType) return "Beh";
+                                if (type == PrinterEnum.SocketType) return "Socket";
+                                if (type == PrinterEnum.HttpsType) return "Https";
+                                if (type == PrinterEnum.IppType) return "Ipp";
+                                if (type == PrinterEnum.HPType) return "HP";
+                                if (type == PrinterEnum.USBType) return "USB";
+                                if (type == PrinterEnum.HPFaxType) return "HPFax";
+                                if (type == PrinterEnum.DNSSDType) return "DNSSD";
+                                else return "Unknown protocol";
+                            }
+
+                            Icon {
+                                id: icon
+                                width: height
+                                height: units.gu(2.5)
+                                name: "network-printer-symbolic"
+                                SlotsLayout.position: SlotsLayout.First
+                            }
+
+                            Button {
+                                text: "Select printer"
+                                onClicked: {
+                                    var suggestedPrinterName = (" " + displayName).slice(1);
+                                    suggestedPrinterName = suggestedPrinterName.replace(/\ /g, "\-");
+                                    printerUri.text = uri;
+                                    printerName.text = suggestedPrinterName;
+                                    printerDescription.text = info;
+                                    printerLocation.text = location;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                Label {
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                        top: remotePrintersLabel.bottom
+                        topMargin: units.gu(2)
+                    }
+                    text: "No other printers found"
+                    visible: !remotePrintersSearchIndicator.running && remotePrintersList.count == 0
+                }
             }
         }
     }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt'
--- modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt	2017-02-21 16:55:36 +0000
+++ modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt	2017-03-20 13:32:24 +0000
@@ -29,17 +29,20 @@
     backend/backend_cups.cpp
     backend/backend_pdf.cpp
 
+    cups/devicesearcher.cpp
     cups/ippclient.cpp
+    cups/jobloader.cpp
     cups/printerdriverloader.cpp
     cups/printerloader.cpp
 
+    models/devicemodel.cpp
     models/drivermodel.cpp
     models/jobmodel.cpp
     models/printermodel.cpp
 
     printer/printer.cpp
     printer/printerjob.cpp
-    printer/printersignalhandler.cpp
+    printer/signalratelimiter.cpp
     printers/printers.cpp
 
     enums.h

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp	2017-03-20 13:32:24 +0000
@@ -91,6 +91,22 @@
     return QString();
 }
 
+QString PrinterBackend::printerSetCopies(const QString &name,
+                                         const int &copies)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(copies);
+    return QString();
+}
+
+QString PrinterBackend::printerSetShared(const QString &name,
+                                         const bool shared)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(shared);
+    return QString();
+}
+
 QString PrinterBackend::printerSetInfo(const QString &name,
                                        const QString &info)
 {
@@ -139,6 +155,18 @@
     Q_UNUSED(name);
 }
 
+void PrinterBackend::holdJob(const QString &name, const int jobId)
+{
+    Q_UNUSED(jobId);
+    Q_UNUSED(name);
+}
+
+void PrinterBackend::releaseJob(const QString &name, const int jobId)
+{
+    Q_UNUSED(jobId);
+    Q_UNUSED(name);
+}
+
 int PrinterBackend::printFileToDest(const QString &filepath,
                             const QString &title,
                             const cups_dest_t *dest)
@@ -154,6 +182,14 @@
     return QList<QSharedPointer<PrinterJob>>{};
 }
 
+QSharedPointer<PrinterJob> PrinterBackend::printerGetJob(
+        const QString &printerName, const int jobId)
+{
+    Q_UNUSED(printerName);
+    Q_UNUSED(jobId);
+    return QSharedPointer<PrinterJob>(Q_NULLPTR);
+}
+
 QMap<QString, QVariant> PrinterBackend::printerGetJobAttributes(
         const QString &name, const int jobId)
 {
@@ -182,6 +218,11 @@
     return QString();
 }
 
+bool PrinterBackend::isRemote() const
+{
+    return false;
+}
+
 PrinterEnum::State PrinterBackend::state() const
 {
     return PrinterEnum::State::IdleState;
@@ -248,6 +289,13 @@
     return QString();
 }
 
+void PrinterBackend::requestJobExtendedAttributes(
+        QSharedPointer<Printer> printer, QSharedPointer<PrinterJob> job)
+{
+    Q_UNUSED(printer);
+    Q_UNUSED(job);
+}
+
 void PrinterBackend::requestPrinterDrivers()
 {
 }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend.h'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend.h	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend.h	2017-03-20 13:32:24 +0000
@@ -63,6 +63,9 @@
         const QString &name,
         const bool accept,
         const QString &reason = QString::null);
+    virtual QString printerSetCopies(const QString &name, const int &copies);
+    virtual QString printerSetShared(const QString &name,
+                                     const bool shared);
     virtual QString printerSetInfo(const QString &name,
                                    const QString &info);
     virtual QString printerAddOption(const QString &name,
@@ -77,10 +80,14 @@
                                   const PrinterJob *options);
 
     virtual void cancelJob(const QString &name, const int jobId);
+    virtual void holdJob(const QString &name, const int jobId);
+    virtual void releaseJob(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();
+    virtual QSharedPointer<PrinterJob> printerGetJob(const QString &printerName,
+                                                     const int jobId);
     virtual QMap<QString, QVariant> printerGetJobAttributes(
         const QString &name, const int jobId);
 
@@ -88,6 +95,7 @@
     virtual QString description() const;
     virtual QString location() const;
     virtual QString makeAndModel() const;
+    virtual bool isRemote() const;
 
     virtual PrinterEnum::State state() const;
     virtual QList<QPageSize> supportedPageSizes() const;
@@ -105,6 +113,8 @@
     virtual QSharedPointer<Printer> getPrinter(const QString &printerName);
     virtual QString defaultPrinterName();
 
+    virtual void requestJobExtendedAttributes(QSharedPointer<Printer> printer,
+                                              QSharedPointer<PrinterJob> job);
     virtual void requestPrinterDrivers();
     virtual void requestPrinter(const QString &printerName);
 
@@ -119,7 +129,10 @@
     void printerDriversLoaded(const QList<PrinterDriver> &drivers);
     void printerDriversFailedToLoad(const QString &errorMessage);
 
+    void jobLoaded(QString, int, QMap<QString, QVariant>);
     void printerLoaded(QSharedPointer<Printer> printers);
+    void deviceFound(const Device &device);
+    void deviceSearchFinished();
 
     void jobCompleted(
         const QString &text,

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp	2017-02-24 12:53:34 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp	2017-03-20 13:32:24 +0000
@@ -15,6 +15,8 @@
  */
 
 #include "backend/backend_cups.h"
+#include "cups/devicesearcher.h"
+#include "cups/jobloader.h"
 #include "cups/printerdriverloader.h"
 #include "cups/printerloader.h"
 #include "utils.h"
@@ -40,6 +42,10 @@
     , m_knownQualityOptions({
         "Quality", "PrintQuality", "HPPrintQuality", "StpQuality",
         "OutputMode",})
+    , m_extendedAttributeNames({
+        QStringLiteral("StateMessage"), QStringLiteral("DeviceUri"),
+        QStringLiteral("IsShared"), QStringLiteral("Copies"),
+    })
     , m_client(client)
     , m_info(info)
     , m_notifier(notifier)
@@ -178,6 +184,24 @@
     return QString();
 }
 
+QString PrinterCupsBackend::printerSetCopies(const QString &name,
+                                             const int &copies)
+{
+    if (!m_client->printerSetCopies(name, copies)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetShared(const QString &name,
+                                             const bool shared)
+{
+    if (!m_client->printerSetShared(name, shared)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
 QString PrinterCupsBackend::printerSetInfo(const QString &name,
                                            const QString &info)
 {
@@ -213,12 +237,27 @@
     cups_dest_t *dest = getDest(name);
     ppd_file_t* ppd = getPpd(name);
 
-    if (!dest || !ppd) {
-        return ret;
+    // Used to store extended attributes, which we should request maximum once.
+    QMap<QString, QVariant> extendedAttributesResults;
+
+    /* Goes through known extended attributes. If one is being asked for,
+    ask for all of them right away. */
+    Q_FOREACH(const QString &extendedOption, m_extendedAttributeNames) {
+        if (options.contains(extendedOption)) {
+            extendedAttributesResults = m_client->printerGetAttributes(
+                name, QStringList({
+                    QStringLiteral("device-uri"),
+                    QStringLiteral("printer-uri-supported"),
+                    QStringLiteral("printer-state-message"),
+                    QStringLiteral("copies-default"),
+                })
+            );
+            break;
+        }
     }
 
     Q_FOREACH(const QString &option, options) {
-        if (option == QStringLiteral("DefaultColorModel")) {
+        if (option == QStringLiteral("DefaultColorModel") && ppd) {
             ColorModel model;
             ppd_option_t *ppdColorModel = ppdFindOption(ppd, "ColorModel");
             if (ppdColorModel) {
@@ -231,7 +270,7 @@
                 }
             }
             ret[option] = QVariant::fromValue(model);
-        } else if (option == QStringLiteral("DefaultPrintQuality")) {
+        } else if (option == QStringLiteral("DefaultPrintQuality") && ppd) {
             PrintQuality quality;
             Q_FOREACH(const QString opt, m_knownQualityOptions) {
                 ppd_option_t *ppdQuality = ppdFindOption(ppd, opt.toUtf8());
@@ -245,7 +284,7 @@
                 }
             }
             ret[option] = QVariant::fromValue(quality);
-        } else if (option == QStringLiteral("SupportedPrintQualities")) {
+        } else if (option == QStringLiteral("SupportedPrintQualities") && ppd) {
             QList<PrintQuality> qualities;
             Q_FOREACH(const QString &opt, m_knownQualityOptions) {
                 ppd_option_t *qualityOpt = ppdFindOption(ppd, opt.toUtf8());
@@ -262,7 +301,7 @@
                 }
             }
             ret[option] = QVariant::fromValue(qualities);
-        } else if (option == QStringLiteral("SupportedColorModels")) {
+        } else if (option == QStringLiteral("SupportedColorModels") && ppd) {
             QList<ColorModel> models;
             ppd_option_t *colorModels = ppdFindOption(ppd, "ColorModel");
             if (colorModels) {
@@ -277,19 +316,29 @@
                 }
             }
             ret[option] = QVariant::fromValue(models);
-        } else if (option == QStringLiteral("AcceptJobs")) {
+        } else if (option == QStringLiteral("AcceptJobs") && dest) {
             // "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";
-            }
+        } else if (option == QStringLiteral("StateReasons") && dest) {
+            ret[option] = cupsGetOption("printer-state-reasons",
+                                        dest->num_options, dest->options);
+        } else if (option == QStringLiteral("StateMessage")) {
+            ret[option] = extendedAttributesResults["printer-state-message"];
+        } else if (option == QStringLiteral("DeviceUri")) {
+            auto res = extendedAttributesResults;
+            if (!res["printer-uri-supported"].toString().isEmpty()) {
+                ret[option] = res["printer-uri-supported"];
+            }
+            if (!res["device-uri"].toString().isEmpty()) {
+                ret[option] = res["device-uri"];
+            }
+        } else if (option == QStringLiteral("Copies")) {
+            ret[option] = extendedAttributesResults[QStringLiteral("copies-default")];
+        } else if (option == QStringLiteral("Shared") && dest) {
+            ret[option] = cupsGetOption("printer-is-shared",
+                                        dest->num_options, dest->options);
         }
     }
     return ret;
@@ -306,10 +355,7 @@
         __CUPS_ADD_OPTION(dest, "Collate", "False");
     }
 
-    if (options->copies() > 1) {
-        __CUPS_ADD_OPTION(dest, "copies", QString::number(options->copies()).toLocal8Bit());
-    }
-
+    __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());
 
@@ -347,6 +393,20 @@
     }
 }
 
+void PrinterCupsBackend::holdJob(const QString &name, const int jobId)
+{
+    if (!m_client->printerHoldJob(name, jobId)) {
+        qWarning() << "Failed to hold job:" << jobId << "for" << name;
+    }
+}
+
+void PrinterCupsBackend::releaseJob(const QString &name, const int jobId)
+{
+    if (!m_client->printerReleaseJob(name, jobId)) {
+        qWarning() << "Failed to release job:" << jobId << "for" << name;
+    }
+}
+
 int PrinterCupsBackend::printFileToDest(const QString &filepath,
                                         const QString &title,
                                         const cups_dest_t *dest)
@@ -385,7 +445,7 @@
     const QString &name, const int jobId)
 {
     Q_UNUSED(name);
-    QMap<QString, QVariant> rawMap = m_client->printerGetJobAttributes(jobId);
+    QMap<QString, QVariant> rawMap = m_client->printerGetJobAttributes(name, jobId);
     QMap<QString, QVariant> map;
 
     // Filter attributes to know values
@@ -409,12 +469,34 @@
         map.insert("ColorModel", QVariant(""));
     }
 
+    if (__CUPS_ATTR_EXISTS(rawMap, "date-time-at-completed", QDateTime)) {
+        map.insert("CompletedTime", rawMap.value("date-time-at-completed"));
+    } else {
+        map.insert("CompletedTime", QVariant(QDateTime()));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "date-time-at-creation", QDateTime)) {
+        map.insert("CreationTime", rawMap.value("date-time-at-creation"));
+    } else {
+        map.insert("CreationTime", QVariant(QDateTime()));
+    }
+
     if (__CUPS_ATTR_EXISTS(rawMap, "Duplex", QString)) {
         map.insert("Duplex", rawMap.value("Duplex"));
     } else {
         map.insert("Duplex", QVariant(""));
     }
 
+    // Try job-media-sheets-completed first as it should include duplex
+    // if it doesn't exist fallback to job-impressions-completed
+    if (__CUPS_ATTR_EXISTS(rawMap, "job-media-sheets-completed", int)) {
+        map.insert("impressionsCompleted", rawMap.value("job-media-sheets-completed"));
+    } else if (__CUPS_ATTR_EXISTS(rawMap, "job-impressions-completed", int)) {
+        map.insert("impressionsCompleted", rawMap.value("job-impressions-completed"));
+    } else {
+        map.insert("impressionsCompleted", QVariant(0));
+    }
+
     if (__CUPS_ATTR_EXISTS(rawMap, "landscape", bool)) {
         map.insert("landscape", rawMap.value("landscape"));
     } else {
@@ -434,6 +516,12 @@
         map.insert("page-ranges", QVariant(QStringList()));
     }
 
+    if (__CUPS_ATTR_EXISTS(rawMap, "date-time-at-processing", QDateTime)) {
+        map.insert("ProcessingTime", rawMap.value("date-time-at-processing"));
+    } else {
+        map.insert("ProcessingTime", QVariant(QDateTime()));
+    }
+
     Q_FOREACH(QString qualityOption, m_knownQualityOptions) {
         if (rawMap.contains(qualityOption)
                 && rawMap.value(qualityOption).canConvert<QString>()) {
@@ -451,6 +539,24 @@
         map.insert("OutputOrder", "Normal");
     }
 
+    if (__CUPS_ATTR_EXISTS(rawMap, "job-k-octets", int)) {
+        map.insert("Size", rawMap.value("job-k-octets"));
+    } else {
+        map.insert("Size", QVariant(0));
+    }
+
+    // If there is a state then get it, as there could have been a signal
+    // flood. Which then means a forceJobRefresh is able to update the state
+    if (__CUPS_ATTR_EXISTS(rawMap, "job-state", int)) {
+        map.insert("State", rawMap.value("job-state").toInt());
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "job-originating-user-name", QString)) {
+        map.insert("User", rawMap.value("job-originating-user-name"));
+    } else {
+        map.insert("User", QVariant(""));
+    }
+
     // Generate a list of messages
     // TODO: for now just using job-printer-state-message, are there others?
     QStringList messages;
@@ -471,31 +577,13 @@
     QList<QSharedPointer<PrinterJob>> list;
 
     Q_FOREACH(auto job, jobs) {
+        // Note: extended attributes are not loaded here
+        // they are loaded in JobLoader
         auto newJob = QSharedPointer<PrinterJob>(
             new PrinterJob(QString::fromUtf8(job->dest), this, job->id)
         );
-
-        // Extract the times
-        QDateTime completedTime;
-        completedTime.setTimeZone(QTimeZone::systemTimeZone());
-        completedTime.setTime_t(job->completed_time);
-
-        QDateTime creationTime;
-        creationTime.setTimeZone(QTimeZone::systemTimeZone());
-        creationTime.setTime_t(job->creation_time);
-
-        QDateTime processingTime;
-        processingTime.setTimeZone(QTimeZone::systemTimeZone());
-        processingTime.setTime_t(job->processing_time);
-
-        // Load the information from the cups struct
-        newJob->setCompletedTime(completedTime);
-        newJob->setCreationTime(creationTime);
-        newJob->setProcessingTime(processingTime);
-        newJob->setSize(job->size);
         newJob->setState(static_cast<PrinterEnum::JobState>(job->state));
         newJob->setTitle(QString::fromLocal8Bit(job->title));
-        newJob->setUser(QString::fromLocal8Bit(job->user));
 
         list.append(newJob);
     }
@@ -505,6 +593,35 @@
     return list;
 }
 
+QSharedPointer<PrinterJob> PrinterCupsBackend::printerGetJob(
+        const QString &printerName, const int jobId)
+{
+    auto jobs = getCupsJobs(printerName);
+    cups_job_t *cupsJob = Q_NULLPTR;
+    QSharedPointer<PrinterJob> job(Q_NULLPTR);
+
+    for (int i=0; i < jobs.size(); i++) {
+        if (jobs.at(i)->id == jobId) {
+            cupsJob = jobs.at(i);
+            break;
+        }
+    }
+
+    if (cupsJob) {
+        job = QSharedPointer<PrinterJob>(
+            new PrinterJob(QString::fromUtf8(cupsJob->dest), this, cupsJob->id)
+        );
+
+        job->setState(static_cast<PrinterEnum::JobState>(cupsJob->state));
+        job->setTitle(QString::fromLocal8Bit(cupsJob->title));
+    }
+
+    if (!jobs.size())
+        cupsFreeJobs(jobs.size(), jobs.first());
+
+    return job;
+}
+
 QString PrinterCupsBackend::printerName() const
 {
     return m_printerName;
@@ -525,6 +642,11 @@
     return m_info.makeAndModel();
 }
 
+bool PrinterCupsBackend::isRemote() const
+{
+    return m_info.isRemote();
+}
+
 PrinterEnum::State PrinterCupsBackend::state() const
 {
     switch (m_info.state()) {
@@ -611,9 +733,35 @@
     return QPrinterInfo::defaultPrinterName();
 }
 
+void PrinterCupsBackend::requestJobExtendedAttributes(
+        QSharedPointer<Printer> printer, QSharedPointer<PrinterJob> job)
+{
+    QPair<QString, int> pair(printer->name(), job->jobId());
+
+    if (m_activeJobRequests.contains(pair)) {
+        return;
+    }
+
+    auto thread = new QThread;
+    auto loader = new JobLoader(this, printer->name(), job->jobId());
+    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(QString, int, QMap<QString, QVariant>)),
+            this, SIGNAL(jobLoaded(QString, int, QMap<QString, QVariant>)));
+    connect(loader, SIGNAL(loaded(QString, int, QMap<QString, QVariant>)),
+            this, SLOT(onJobLoaded(QString, int, QMap<QString, QVariant>)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
+    m_activeJobRequests << pair;
+
+    thread->start();
+}
+
 void PrinterCupsBackend::requestPrinter(const QString &printerName)
 {
-    if (m_activeRequests.contains(printerName)) {
+    if (m_activePrinterRequests.contains(printerName)) {
         return;
     }
 
@@ -628,9 +776,10 @@
     connect(loader, SIGNAL(loaded(QSharedPointer<Printer>)),
             this, SLOT(onPrinterLoaded(QSharedPointer<Printer>)));
     connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
+    m_activePrinterRequests << printerName;
+
     thread->start();
-
-    m_activeRequests << printerName;
 }
 
 void PrinterCupsBackend::requestPrinterDrivers()
@@ -647,6 +796,7 @@
     connect(loader, SIGNAL(loaded(const QList<PrinterDriver>&)),
             this, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)));
     connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
     thread->start();
 }
 
@@ -655,6 +805,22 @@
     Q_EMIT requestPrinterDriverCancel();
 }
 
+void PrinterCupsBackend::searchForDevices()
+{
+
+    auto thread = new QThread;
+    auto searcher = new DeviceSearcher();
+    searcher->moveToThread(thread);
+    connect(thread, SIGNAL(started()), searcher, SLOT(load()));
+    connect(searcher, SIGNAL(finished()), thread, SLOT(quit()));
+    connect(searcher, SIGNAL(finished()), searcher, SLOT(deleteLater()));
+    connect(searcher, SIGNAL(finished()), this, SIGNAL(deviceSearchFinished()));
+    connect(searcher, SIGNAL(loaded(const Device&)),
+            this, SIGNAL(deviceFound(const Device&)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+    thread->start();
+}
+
 void PrinterCupsBackend::refresh()
 {
     if (m_printerName.isEmpty()) {
@@ -716,7 +882,22 @@
     }
 }
 
+bool PrinterCupsBackend::isExtendedAttribute(const QString &attributeName) const
+{
+    return m_extendedAttributeNames.contains(attributeName);
+}
+
+void PrinterCupsBackend::onJobLoaded(QString printerName, int jobId,
+                                     QMap<QString, QVariant> attributes)
+{
+    Q_UNUSED(attributes);
+
+    QPair<QString, int> pair(printerName, jobId);
+    m_activeJobRequests.remove(pair);
+}
+
 void PrinterCupsBackend::onPrinterLoaded(QSharedPointer<Printer> printer)
 {
-    m_activeRequests.remove(printer->name());
+    m_activePrinterRequests.remove(printer->name());
 }
+

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h	2017-02-24 12:53:34 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h	2017-03-20 13:32:24 +0000
@@ -55,6 +55,10 @@
         const QString &name,
         const bool accept,
         const QString &reason = QString::null) override;
+    virtual QString printerSetCopies(
+        const QString &name, const int &copies) override;
+    virtual QString printerSetShared(const QString &name,
+                                     const bool shared) override;
     virtual QString printerSetInfo(const QString &name,
                                    const QString &info) override;
     virtual QString printerAddOption(const QString &name,
@@ -71,15 +75,20 @@
                                   const PrinterJob *options) override;
 
     virtual void cancelJob(const QString &name, const int jobId) override;
+    virtual void holdJob(const QString &name, const int jobId) override;
+    virtual void releaseJob(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() override;
+    virtual QSharedPointer<PrinterJob> printerGetJob(
+            const QString &printerName, const int jobId) override;
 
     virtual QString printerName() const override;
     virtual QString description() const override;
     virtual QString location() const override;
     virtual QString makeAndModel() const override;
+    virtual bool isRemote() const override;
 
     virtual PrinterEnum::State state() const override;
     virtual QList<QPageSize> supportedPageSizes() const override;
@@ -96,6 +105,10 @@
     virtual QStringList availablePrinterNames() override;
     virtual QSharedPointer<Printer> getPrinter(const QString &printerName) override;
     virtual QString defaultPrinterName() override;
+
+    virtual void requestJobExtendedAttributes(
+            QSharedPointer<Printer> printer,
+            QSharedPointer<PrinterJob> job) override;
     virtual void requestPrinterDrivers() override;
     virtual void requestPrinter(const QString &printerName) override;
     virtual QMap<QString, QVariant> printerGetJobAttributes(
@@ -105,6 +118,11 @@
     virtual void refresh() override;
     void createSubscription();
 
+    /* Starts a search for devices. Devices are synonymous with network devices
+    that may potentially be queues. This search will take at minimum 5 seconds,
+    normally longer. */
+    void searchForDevices();
+
 Q_SIGNALS:
     void cancelWorkers();
     void printerDriversLoaded(const QList<PrinterDriver> &drivers);
@@ -120,16 +138,22 @@
     QString getPrinterInstance(const QString &name) const;
     cups_dest_t* getDest(const QString &name) const;
     ppd_file_t* getPpd(const QString &name) const;
+    bool isExtendedAttribute(const QString &attributeName) const;
+
     const QStringList m_knownQualityOptions;
+    const QStringList m_extendedAttributeNames;
     IppClient *m_client;
     QPrinterInfo m_info;
     OrgCupsCupsdNotifierInterface *m_notifier;
     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.
-    QSet<QString> m_activeRequests;
+    QSet<QString> m_activePrinterRequests;
+    QSet<QPair<QString, int>> m_activeJobRequests;
 
 private Q_SLOTS:
+    void onJobLoaded(QString printerName, int jobId,
+                     QMap<QString, QVariant> attributes);
     void onPrinterLoaded(QSharedPointer<Printer> printer);
 };
 

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.cpp	2017-02-21 10:46:29 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.cpp	2017-03-20 13:32:24 +0000
@@ -59,6 +59,16 @@
             ret[option] = QVariant::fromValue(models);
         } else if (option == QLatin1String("AcceptJobs")) {
             ret[option] = true;
+        } else if (option == QLatin1String("StateReasons")) {
+            ret[option] = QLatin1String("");
+        } else if (option == QLatin1String("StateMessage")) {
+            ret[option] = QLatin1String("");
+        } else if (option == QLatin1String("DeviceUri")) {
+            ret[option] = QLatin1String("");
+        } else if (option == QLatin1String("Copies")) {
+            ret[option] = 0;
+        } else if (option == QLatin1String("Shared")) {
+            ret[option] = false;
         } else {
             throw std::invalid_argument("Invalid value for PDF printer: " + option.toStdString());
         }

=== added file 'modules/Ubuntu/Components/Extras/Printers/cups/devicesearcher.cpp'
--- modules/Ubuntu/Components/Extras/Printers/cups/devicesearcher.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/devicesearcher.cpp	2017-03-20 13:32:24 +0000
@@ -0,0 +1,70 @@
+/*
+ * 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 "cups/ippclient.h"
+#include "devicesearcher.h"
+
+#include <QUrl>
+
+DeviceSearcher::DeviceSearcher(IppClient *client, QObject *parent)
+    : QObject(parent)
+    , m_client(client)
+{
+}
+
+DeviceSearcher::~DeviceSearcher()
+{
+    delete m_client;
+}
+
+void DeviceSearcher::load()
+{
+    if (!m_client->getDevices(&DeviceSearcher::deviceCallBack, this)) {
+        Q_EMIT failed(cupsLastErrorString());
+    }
+    Q_EMIT finished();
+}
+
+void DeviceSearcher::deviceCallBack(
+    const char *deviceClass,
+    const char *deviceId,
+    const char *deviceInfo,
+    const char *deviceMakeAndModel,
+    const char *deviceUri,
+    const char *deviceLocation,
+    void *context)
+{
+    auto searcher = qobject_cast<DeviceSearcher*>(static_cast<QObject*>(context));
+    if (!searcher) {
+        qWarning() << Q_FUNC_INFO << "context was not a DeviceSearcher.";
+        return;
+    }
+
+    Device d;
+    d.cls = deviceClass;
+    d.id = deviceId;
+    d.info = deviceInfo;
+    d.makeModel = deviceMakeAndModel;
+    d.uri = deviceUri;
+    d.location = deviceLocation;
+
+    searcher->deviceFound(d);
+}
+
+void DeviceSearcher::deviceFound(const Device &device)
+{
+    Q_EMIT loaded(device);
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/cups/devicesearcher.h'
--- modules/Ubuntu/Components/Extras/Printers/cups/devicesearcher.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/devicesearcher.h	2017-03-20 13:32:24 +0000
@@ -0,0 +1,57 @@
+/*
+ * 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_DEVICESEARCHER_H
+#define USC_PRINTERS_CUPS_DEVICESEARCHER_H
+
+#include "cups/ippclient.h"
+#include "structs.h"
+
+#include <QObject>
+#include <QString>
+
+/* Class representing a device search. It is a worker object due to the time
+such a search takes (minimum 10 seconds). */
+class DeviceSearcher : public QObject
+{
+    Q_OBJECT
+    IppClient *m_client;
+public:
+    explicit DeviceSearcher(IppClient *client = new IppClient,
+                            QObject *parent = Q_NULLPTR);
+    ~DeviceSearcher();
+
+public Q_SLOTS:
+    void load();
+
+private:
+    static void deviceCallBack(
+        const char *cls,
+        const char *id,
+        const char *info,
+        const char *makeAndModel,
+        const char *uri,
+        const char *location,
+        void *context);
+    void deviceFound(const Device &device);
+
+Q_SIGNALS:
+    void loaded(const Device &device);
+    void failed(const QString &errorMessage);
+    void finished();
+};
+
+#endif // USC_PRINTERS_CUPS_DEVICESEARCHER_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp'
--- modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp	2017-02-21 10:46:29 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp	2017-03-20 13:32:24 +0000
@@ -25,6 +25,7 @@
 
 #include <QDebug>
 #include <QDateTime>
+#include <QtAlgorithms>
 #include <QTimeZone>
 #include <QUrl>
 
@@ -173,6 +174,30 @@
     return postRequest(request, ppdFileName.toUtf8(), CupsResourceAdmin);
 }
 
+bool IppClient::printerHoldJob(const QString &printerName, const int jobId)
+{
+    ipp_t *request = ippNewRequest(IPP_HOLD_JOB);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+
+    ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                  "job-id", jobId);
+
+    return sendRequest(request, CupsResourceJobs);
+}
+
+bool IppClient::printerReleaseJob(const QString &printerName, const int jobId)
+{
+    ipp_t *request = ippNewRequest(IPP_RELEASE_JOB);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+
+    ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                  "job-id", jobId);
+
+    return sendRequest(request, CupsResourceJobs);
+}
+
 bool IppClient::printerSetDefault(const QString &printerName)
 {
     return sendNewSimpleRequest(CUPS_SET_DEFAULT, printerName.toUtf8(),
@@ -225,9 +250,46 @@
     }
 }
 
+bool IppClient::printerSetCopies(const QString &printerName, const int &copies)
+{
+    ipp_t *request;
+
+    if (!isPrinterNameValid(printerName)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(printerName));
+        return false;
+    }
+    request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+    ippAddInteger(request, IPP_TAG_PRINTER, IPP_TAG_INTEGER,
+                  "copies-default", copies);
+    /* TODO: The request will fail if this was a printer class, and it should
+    be retried. */
+    return sendRequest(request, CupsResourceAdmin);
+}
+
+bool IppClient::printerSetShared(const QString &printerName, const bool shared)
+{
+    ipp_t *request;
+
+    if (!isPrinterNameValid(printerName)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(printerName));
+        return false;
+    }
+
+    request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+    ippAddBoolean(request, IPP_TAG_OPERATION,
+                  "printer-is-shared", shared ? 1 : 0);
+    /* TODO: The request will fail if this was a printer class, and it should
+    be retried. */
+
+    return sendRequest(request, CupsResourceAdmin);
+}
 
 bool IppClient::printerClassSetInfo(const QString &name,
-                                       const QString &info)
+                                    const QString &info)
 {
     if (!isPrinterNameValid(name)) {
         setInternalStatus(QString("%1 is not a valid printer name.").arg(name));
@@ -336,18 +398,99 @@
     return retval;
 }
 
-QMap<QString, QVariant> IppClient::printerGetJobAttributes(const int jobId)
+QMap<QString, QVariant> IppClient::printerGetAttributes(
+    const QString &printerName, const QStringList &attributes)
+{
+    QMap<QString, QVariant> result;
+    QList<QByteArray*> attrByteArrays;
+    ipp_t *request;
+    ipp_attribute_t *attr;
+
+    if (attributes.isEmpty()) {
+        return result;
+    }
+
+    int i;
+    size_t n = attributes.size();
+    char **attrs;
+    attrs = (char**) malloc ((n + 1) * sizeof (char *));
+
+    /* This is some trickery to compensate for a lack of C array/pointer
+    skills. The VLA attrs gets the underlying data structure of a QByterArray
+    on the heap. When cups is done with it, and in the end of this method,
+    the QByteArrays are deleted, and attrs is freed. */
+    for (i = 0; i < ((int) n); i++) {
+        QByteArray *array = new QByteArray(attributes.value(i).toLocal8Bit());
+        attrByteArrays << array;
+        attrs[i] = array->data();
+    }
+    attrs[n] = NULL;
+
+    request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, QString());
+    ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                  "requested-attributes", attributes.size(), NULL, attrs);
+    auto resource = getResource(CupsResource::CupsResourceRoot);
+
+    ipp_t *reply;
+    reply = cupsDoRequest(m_connection, request, resource.toUtf8());
+
+    if (!isReplyOk(reply, false)) {
+        qWarning() << Q_FUNC_INFO << "failed to get attributes"
+                   << attributes << "for printer" << printerName;
+    } else {
+        for (attr = ippFirstAttribute(reply); attr; attr = ippNextAttribute(reply)) {
+            while (attr && ippGetGroupTag(attr) != IPP_TAG_PRINTER)
+                attr = ippNextAttribute(reply);
+
+            if (!attr)
+                break;
+
+            for (; attr && ippGetGroupTag(attr) == IPP_TAG_PRINTER;
+                 attr = ippNextAttribute(reply)) {
+
+                /* TODO: Here we need to take into account that the returned
+                attributes could be lists and other things. */
+                result[ippGetName(attr)] = getAttributeValue(attr);
+
+                if (!attr)
+                    break;
+            }
+        }
+    }
+
+    if (reply)
+        ippDelete(reply);
+
+    qDeleteAll(attrByteArrays);
+    free(attrs);
+
+    return result;
+}
+
+QMap<QString, QVariant> IppClient::printerGetJobAttributes(const QString &printerName,
+                                                           const int jobId)
 {
     ipp_t *request;
     QMap<QString, QVariant> map;
 
+    // Try to get the lock, if we can't after 5 seconds then fail and return
+    if (!m_thread_lock.tryLock(5000)) {
+        qWarning() << "Unable to get lock for IppClient::printerGetJobAttributes."
+                   << "Unable to load attributes for job:" << jobId << " for "
+                   << printerName;
+        return map;
+    }
+
     // Construct request
     request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
-    QString uri = QStringLiteral("ipp://localhost/jobs/") + QString::number(jobId);
-    qDebug() << "URI:" << uri;
-
-    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri.toStdString().data());
-
+
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+
+    ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                  "job-id", jobId);
 
     // Send request and construct reply
     ipp_t *reply;
@@ -365,7 +508,8 @@
             map.insert(ippGetName(attr), value);
         }
     } else {
-        qWarning() << "Not able to get attributes of job:" << jobId;
+        qWarning() << "Not able to get attributes of job:" << jobId << " for "
+                   << printerName;
     }
 
     // Destruct the reply if valid
@@ -373,6 +517,8 @@
         ippDelete(reply);
     }
 
+    m_thread_lock.unlock();
+
     return map;
 }
 
@@ -972,8 +1118,8 @@
         case IPP_TAG_DATE: {
             time_t time = ippDateToTime(ippGetDate(attr, index));
             QDateTime datetime;
-            datetime.setTimeZone(QTimeZone::systemTimeZone());
             datetime.setTime_t(time);
+            datetime.setTimeZone(QTimeZone::utc());
 
             var = QVariant::fromValue<QDateTime>(datetime);
             break;
@@ -986,3 +1132,11 @@
 
     return var;
 }
+
+bool IppClient::getDevices(cups_device_cb_t callback, void *context) const
+{
+    auto reply = cupsGetDevices(m_connection, CUPS_TIMEOUT_DEFAULT,
+                                CUPS_INCLUDE_ALL, CUPS_EXCLUDE_NONE, callback,
+                                context);
+    return reply == IPP_OK;
+}

=== modified file 'modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h'
--- modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h	2017-02-21 10:46:29 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h	2017-03-20 13:32:24 +0000
@@ -19,11 +19,13 @@
 
 #include "structs.h"
 
+#include <cups/adminutil.h>
 #include <cups/cups.h>
 #include <cups/http.h>
 #include <cups/ipp.h>
 #include <cups/ppd.h>
 
+#include <QMutex>
 #include <QString>
 #include <QStringList>
 
@@ -51,17 +53,25 @@
                                const QString &ppdFileName,
                                const QString &info,
                                const QString &location);
+    bool printerHoldJob(const QString &printerName, const int jobId);
+    bool printerReleaseJob(const QString &printerName, const int jobId);
     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 printerSetCopies(const QString &printerName, const int &copies);
+    bool printerSetShared(const QString &printerName, const bool shared);
     bool printerClassSetInfo(const QString &name, const QString &info);
     bool printerClassSetOption(const QString &name, const QString &option,
                                const QStringList &values);
     ppd_file_t* getPpdFile(const QString &name, const QString &instance) const;
     cups_dest_t* getDest(const QString &name, const QString &instance) const;
 
-    QMap<QString, QVariant> printerGetJobAttributes(const int jobId);
+    // Fetch more attributes, as normally just a small subset is fetched.
+    QMap<QString, QVariant> printerGetAttributes(const QString &printerName,
+        const QStringList &attributes);
+    QMap<QString, QVariant> printerGetJobAttributes(const QString &printerName,
+                                                    const int jobId);
 
     QString getLastError() const;
 
@@ -73,6 +83,7 @@
     );
     int createSubscription();
     void cancelSubscription(const int &subscriptionId);
+    bool getDevices(cups_device_cb_t callback, void *context) const;
 
 private:
     enum CupsResource
@@ -115,6 +126,7 @@
     http_t *m_connection;
     ipp_status_t m_lastStatus = IPP_OK;
     mutable QString m_internalStatus = QString::null;
+    QMutex m_thread_lock;
 };
 
 

=== added file 'modules/Ubuntu/Components/Extras/Printers/cups/jobloader.cpp'
--- modules/Ubuntu/Components/Extras/Printers/cups/jobloader.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/jobloader.cpp	2017-03-20 13:32:24 +0000
@@ -0,0 +1,50 @@
+/*
+ * 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 "jobloader.h"
+
+#include "backend/backend.h"
+
+#include "printers/printers.h"
+
+#include <QDBusConnection>
+#include <QPrinterInfo>
+
+class PrinterCupsBackend;
+JobLoader::JobLoader(PrinterBackend *backend,
+                     QString printerName,
+                     int jobId,
+                     QObject *parent)
+    : QObject(parent)
+    , m_backend(backend)
+    , m_job_id(jobId)
+    , m_printer_name(printerName)
+{
+}
+
+JobLoader::~JobLoader()
+{
+}
+
+void JobLoader::load()
+{
+    QMap<QString, QVariant> map = m_backend->printerGetJobAttributes(
+        m_printer_name, m_job_id
+    );
+
+    Q_EMIT loaded(m_printer_name, m_job_id, map);
+    Q_EMIT finished();
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/cups/jobloader.h'
--- modules/Ubuntu/Components/Extras/Printers/cups/jobloader.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/jobloader.h	2017-03-20 13:32:24 +0000
@@ -0,0 +1,47 @@
+/*
+ * 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_JOBLOADER_H
+#define USC_PRINTERS_CUPS_JOBLOADER_H
+
+#include "printer/printer.h"
+#include "printer/printerjob.h"
+
+#include <QList>
+#include <QObject>
+#include <QSharedPointer>
+
+class JobLoader : public QObject
+{
+    Q_OBJECT
+    PrinterBackend *m_backend;
+    int m_job_id;
+    QString m_printer_name;
+public:
+    explicit JobLoader(PrinterBackend *backend,
+                       QString printerName, int jobId,
+                       QObject *parent = Q_NULLPTR);
+    ~JobLoader();
+
+public Q_SLOTS:
+    void load();
+
+Q_SIGNALS:
+    void finished();
+    void loaded(QString, int, QMap<QString, QVariant>);
+};
+
+#endif // USC_PRINTERS_CUPS_JOBLOADER_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/cups/printerloader.cpp'
--- modules/Ubuntu/Components/Extras/Printers/cups/printerloader.cpp	2017-02-21 10:46:29 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/printerloader.cpp	2017-03-20 13:32:24 +0000
@@ -18,6 +18,7 @@
 #include "backend/backend_cups.h"
 #include "printerloader.h"
 
+#include <QApplication>
 #include <QPrinterInfo>
 
 class PrinterCupsBackend;
@@ -48,6 +49,8 @@
 
     auto p = QSharedPointer<Printer>(new Printer(backend));
 
+    p->moveToThread(QApplication::instance()->thread());
+
     Q_EMIT loaded(p);
     Q_EMIT finished();
 }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/enums.h'
--- modules/Ubuntu/Components/Extras/Printers/enums.h	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/enums.h	2017-03-20 13:32:24 +0000
@@ -101,6 +101,29 @@
         PdfType,
     };
     Q_ENUM(PrinterType)
+
+    enum class DeviceType
+    {
+        UnknownType = 0,
+        LPDType,
+        IppSType,
+        Ipp14Type,
+        HttpType,
+        BehType,
+        SocketType,
+        HttpsType,
+        IppType,
+        HPType,
+        USBType,
+        HPFaxType,
+        DNSSDType,
+    };
+    Q_ENUM(DeviceType)
 };
 
+inline uint qHash(const PrinterEnum::JobState &state, uint seed)
+{
+    return qHash((int) state, seed);
+}
+
 #endif // USC_PRINTERS_ENUMS_H

=== added file 'modules/Ubuntu/Components/Extras/Printers/models/devicemodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/devicemodel.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/devicemodel.cpp	2017-03-20 13:32:24 +0000
@@ -0,0 +1,149 @@
+/*
+ * 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_cups.h"
+#include "models/devicemodel.h"
+
+#include <QDebug>
+
+DeviceModel::DeviceModel(PrinterBackend *backend, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_backend(backend)
+    , m_isSearching(false)
+{
+    connect(m_backend, SIGNAL(deviceFound(const Device&)),
+            this, SLOT(deviceLoaded(const Device&)));
+    connect(m_backend, SIGNAL(deviceSearchFinished()),
+            this, SLOT(deviceSearchFinished()));
+}
+
+DeviceModel::~DeviceModel()
+{
+}
+
+int DeviceModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return m_devices.size();
+}
+
+int DeviceModel::count() const
+{
+    return rowCount();
+}
+
+QVariant DeviceModel::data(const QModelIndex &index, int role) const
+{
+    QVariant ret;
+
+    if ((0 <= index.row()) && (index.row() < m_devices.size())) {
+
+        auto device = m_devices[index.row()];
+
+        switch (role) {
+        case Qt::DisplayRole:
+            ret = device.toString();
+            break;
+        case IdRole:
+            ret = device.id;
+            break;
+        case InfoRole:
+            ret = device.info;
+            break;
+        case UriRole:
+            ret = device.uri;
+            break;
+        case LocationRole:
+            ret = device.location;
+            break;
+        case TypeRole:
+            ret = QVariant::fromValue(device.type());
+            break;
+        case MakeModelRole:
+            ret = device.makeModel;
+            break;
+        }
+    }
+
+    return ret;
+}
+
+QHash<int, QByteArray> DeviceModel::roleNames() const
+{
+    static QHash<int,QByteArray> names;
+
+    if (Q_UNLIKELY(names.empty())) {
+        names[Qt::DisplayRole] = "displayName";
+        names[IdRole] = "id";
+        names[InfoRole] = "info";
+        names[UriRole] = "uri";
+        names[LocationRole] = "location";
+        names[TypeRole] = "type";
+        names[MakeModelRole] = "makeModel";
+    }
+
+    return names;
+}
+
+void DeviceModel::deviceLoaded(const Device &device)
+{
+    if (!deviceWanted(device)) {
+        return;
+    }
+
+    if (!m_devices.contains(device)) {
+        int i = m_devices.size();
+        beginInsertRows(QModelIndex(), i, i);
+        m_devices.append(device);
+        endInsertRows();
+
+        Q_EMIT countChanged();
+    }
+}
+
+bool DeviceModel::deviceWanted(const Device &device)
+{
+    auto parts = device.uri.split(":", QString::SkipEmptyParts);
+    return parts.size() > 1;
+}
+
+void DeviceModel::clear()
+{
+    beginResetModel();
+    m_devices.clear();
+    endResetModel();
+}
+
+void DeviceModel::load()
+{
+    if (m_isSearching) {
+        qWarning() << Q_FUNC_INFO
+                   << "Ignoring load request as search is ongoing.";
+    } else {
+        clear();
+        if (m_backend->type() == PrinterEnum::PrinterType::CupsType) {
+            ((PrinterCupsBackend*) m_backend)->searchForDevices();
+            m_isSearching = true;
+            Q_EMIT searchingChanged();
+        }
+    }
+}
+
+void DeviceModel::deviceSearchFinished()
+{
+    m_isSearching = false;
+    Q_EMIT searchingChanged();
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/models/devicemodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/devicemodel.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/devicemodel.h	2017-03-20 13:32:24 +0000
@@ -0,0 +1,78 @@
+/*
+ * 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_PRINTER_DEVICEMODEL_H
+#define USC_PRINTER_DEVICEMODEL_H
+
+#include "printers_global.h"
+
+#include "structs.h"
+
+#include <QAbstractListModel>
+#include <QList>
+#include <QModelIndex>
+#include <QObject>
+#include <QVariant>
+
+class PRINTERS_DECL_EXPORT DeviceModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(bool searching MEMBER m_isSearching NOTIFY searchingChanged)
+public:
+    explicit DeviceModel(PrinterBackend *backend, QObject *parent = Q_NULLPTR);
+    ~DeviceModel();
+
+    enum Roles
+    {
+        // Qt::DisplayRole holds device name
+        ClassRole = Qt::UserRole,
+        IdRole,
+        InfoRole,
+        UriRole,
+        LocationRole,
+        TypeRole,
+        MakeModelRole,
+        LastRole = MakeModelRole,
+    };
+
+    virtual int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    virtual QHash<int, QByteArray> roleNames() const override;
+
+    int count() const;
+    void load();
+    void clear();
+
+private Q_SLOTS:
+    void deviceLoaded(const Device &device);
+    void deviceSearchFinished();
+
+Q_SIGNALS:
+    void countChanged();
+    void searchingChanged();
+
+private:
+    /* Checks if we want it in the list or not. Wanted is intentionally
+    ambiguous. */
+    bool deviceWanted(const Device &device);
+
+    PrinterBackend *m_backend;
+    QList<Device> m_devices;
+    bool m_isSearching;
+};
+
+#endif // USC_PRINTER_DEVICEMODEL_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp	2017-03-20 13:32:24 +0000
@@ -31,113 +31,190 @@
     : QAbstractListModel(parent)
     , m_backend(backend)
 {
-    update();
-
     QObject::connect(m_backend, &PrinterBackend::jobCreated,
-                     this, &JobModel::jobSignalCatchAll);
+                     this, &JobModel::jobCreated);
     QObject::connect(m_backend, &PrinterBackend::jobState,
-                     this, &JobModel::jobSignalCatchAll);
+                     this, &JobModel::jobState);
     QObject::connect(m_backend, &PrinterBackend::jobCompleted,
-                     this, &JobModel::jobSignalCatchAll);
+                     this, &JobModel::jobCompleted);
+
+    connect(m_backend, SIGNAL(jobLoaded(QString, int, QMap<QString, QVariant>)),
+            this, SLOT(updateJob(QString, int, QMap<QString, QVariant>)));
+
+    // Impressions completed happens via printer state changed
+    QObject::connect(m_backend, &PrinterBackend::printerStateChanged,
+                     &m_signalHandler, &SignalRateLimiter::onPrinterStateChanged);
+
+    QObject::connect(&m_signalHandler, SIGNAL(printerModified(const QString&)),
+                     this, SLOT(jobSignalPrinterModified(const QString&)));
+
+    // Add already existing jobs
+    // TODO: even this should probably be in a background thread?
+    // so that it doesn't block startup?
+    Q_FOREACH(auto job, m_backend->printerGetJobs()) {
+        addJob(job);
+    }
 }
 
 JobModel::~JobModel()
 {
 }
 
-void JobModel::jobSignalCatchAll(
-        const QString &text, const QString &printer_uri,
-        const QString &printer_name, uint printer_state,
-        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
-        uint job_id, uint job_state, const QString &job_state_reasons,
-        const QString &job_name, uint job_impressions_completed)
-{
-    Q_UNUSED(text);
-    Q_UNUSED(printer_uri);
-    Q_UNUSED(printer_name);
-    Q_UNUSED(printer_state);
-    Q_UNUSED(printer_state_reasons);
-    Q_UNUSED(printer_is_accepting_jobs);
-    Q_UNUSED(job_id);
+void JobModel::jobCreated(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+{
+    Q_UNUSED(text);  // "Job Created"
+    Q_UNUSED(printer_uri);
+    Q_UNUSED(printer_state);
+    Q_UNUSED(printer_state_reasons);
+    Q_UNUSED(printer_is_accepting_jobs);
+    Q_UNUSED(job_state_reasons);
+
+    QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(
+        new PrinterJob(printer_name, m_backend, job_id)
+    );
+    job->setImpressionsCompleted(job_impressions_completed);
+    job->setState(static_cast<PrinterEnum::JobState>(job_state));
+    job->setTitle(job_name);
+
+    // Printers listens to rowInserted and spawns a JobLoader to set the
+    // printer of the job, which triggers the extended attributes to be loaded
+    // once complete this triggers JobModel::updateJob
+    addJob(job);
+}
+
+void JobModel::jobState(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printer_uri);
+    Q_UNUSED(printer_state);
+    Q_UNUSED(printer_state_reasons);
+    Q_UNUSED(printer_is_accepting_jobs);
+    Q_UNUSED(job_state_reasons);
+    Q_UNUSED(job_name);
+
+    QSharedPointer<PrinterJob> job = getJob(printer_name, job_id);
+
+    if (job) {
+        job->setImpressionsCompleted(job_impressions_completed);
+        job->setState(static_cast<PrinterEnum::JobState>(job_state));
+
+        updateJob(job);
+    } else {
+        qWarning() << "JobModel::jobState for unknown job: " << job_name << " ("
+                   << job_id << ") for " << printer_name;
+    }
+}
+
+void JobModel::jobCompleted(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printer_uri);
+    Q_UNUSED(printer_state);
+    Q_UNUSED(printer_state_reasons);
+    Q_UNUSED(printer_is_accepting_jobs);
     Q_UNUSED(job_state);
     Q_UNUSED(job_state_reasons);
     Q_UNUSED(job_name);
-
-    auto job = getJobById(job_id);
-    if (job)
-        job->setImpressionsCompleted(job_impressions_completed);
-
-    update();
-}
-
-void JobModel::update()
-{
-    // Store the old count and get the new printers
-    int oldCount = m_jobs.size();
-    QList<QSharedPointer<PrinterJob>> newJobs = m_backend->printerGetJobs();
-
-    // Go through the old model
-    for (int i=0; i < m_jobs.count(); i++) {
-        // Determine if the old printer exists in the new model
-        bool exists = false;
-
-        Q_FOREACH(QSharedPointer<PrinterJob> p, newJobs) {
-            if (p->jobId() == m_jobs.at(i)->jobId()) {
-                exists = true;
-
-                // Ensure the other properties of the job are up to date
-                if (!m_jobs.at(i)->deepCompare(p)) {
-                    m_jobs.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);
-            QSharedPointer<PrinterJob> p = m_jobs.takeAt(i);
-            endRemoveRows();
-
-            i--;  // as we have removed an item decrement
-        }
-    }
-
-    // Go through the new model
-    for (int i=0; i < newJobs.count(); i++) {
-        // Determine if the new printer exists in the old model
-        bool exists = false;
-        int j;
-
-        for (j=0; j < m_jobs.count(); j++) {
-            if (m_jobs.at(j)->jobId() == newJobs.at(i)->jobId()) {
-                exists = true;
-                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_jobs.move(j, i);
-                endMoveRows();
-            }
-        } else {
-            // New printer does not exist insert into model
-            beginInsertRows(QModelIndex(), i, i);
-            m_jobs.insert(i, newJobs.at(i));
-            endInsertRows();
-        }
-    }
-
-    if (oldCount != m_jobs.size()) {
-        Q_EMIT countChanged();
+    Q_UNUSED(job_impressions_completed);
+
+    auto job = getJob(printer_name, job_id);
+    if (job) {
+        removeJob(job);
+    } else {
+        qWarning() << "JobModel::jobCompleted for unknown job: " << job_name << " ("
+                   << job_id << ") for " << printer_name;
+    }
+}
+
+void JobModel::jobSignalPrinterModified(const QString &printerName)
+{
+    // Find the active or pending job and force a refresh
+    // We force refresh pending jobs incase there is a flood of signals
+    // meaning that the jobStateChanged signal might not have happened yet
+    Q_FOREACH(auto job, m_jobs) {
+        if (job->printerName() == printerName
+                && (job->state() == PrinterEnum::JobState::Processing
+                        || job->state() == PrinterEnum::JobState::Pending)) {
+            Q_EMIT forceJobRefresh(printerName, job->jobId());
+        }
+    }
+}
+
+void JobModel::addJob(QSharedPointer<PrinterJob> job)
+{
+    int i = m_jobs.size();
+
+    beginInsertRows(QModelIndex(), i, i);
+    m_jobs.append(job);
+    endInsertRows();
+
+    Q_EMIT countChanged();
+}
+
+void JobModel::removeJob(QSharedPointer<PrinterJob> job)
+{
+    int i = m_jobs.indexOf(job);
+
+    beginRemoveRows(QModelIndex(), i, i);
+    m_jobs.removeAt(i);
+    endRemoveRows();
+
+    Q_EMIT countChanged();
+}
+
+// This is used by JobModel::jobState as it has modified an existing job
+void JobModel::updateJob(QSharedPointer<PrinterJob> job)
+{
+    int i = m_jobs.indexOf(job);
+    QModelIndex idx = index(i);
+    Q_EMIT dataChanged(idx, idx);
+}
+
+// This is used by JobLoader as it gives us the oldJob and a newJob which has
+// the extended attributes loaded. We then load the data from this newJob.
+void JobModel::updateJob(QString printerName, int jobId,
+                         QMap<QString, QVariant> attributes)
+{
+    QSharedPointer<PrinterJob> job = getJob(printerName, jobId);
+
+    int i = m_jobs.indexOf(job);
+    QModelIndex idx = index(i);
+
+    if (i > -1) {
+        job->loadAttributes(attributes);
+
+        Q_EMIT dataChanged(idx, idx);
+    } else {
+        qWarning() << "Tried to updateJob which doesn't exist:" << printerName << jobId;
+    }
+}
+
+void JobModel::updateJobPrinter(QSharedPointer<PrinterJob> job, QSharedPointer<Printer> printer)
+{
+    int i = m_jobs.indexOf(job);
+    QModelIndex idx = index(i);
+
+    if (i > -1) {
+        job->setPrinter(printer);
+
+        Q_EMIT dataChanged(idx, idx);
+    } else {
+        qWarning() << "Tried to updateJobPrinter which doesn't exist:" << printer->name() << job->jobId();
     }
 }
 
@@ -166,7 +243,8 @@
             break;
         case ColorModelRole: {
             if (job->printer()) {
-                ret = job->printer()->supportedColorModels().at(job->colorModel()).text;
+                ColorModel m = job->printer()->supportedColorModels().at(job->colorModel());
+                ret = m.text.isEmpty() ? m.name : m.text;
             } else {
                 qWarning() << "Printer is undefined, no colorModel";
                 ret = "";
@@ -174,13 +252,13 @@
             break;
         }
         case CompletedTimeRole:
-            ret = job->completedTime().toString(QLocale::system().dateTimeFormat());
+            ret = job->completedTime().toLocalTime();
             break;
         case CopiesRole:
             ret = job->copies();
             break;
         case CreationTimeRole:
-            ret = job->creationTime().toString(QLocale::system().dateTimeFormat());
+            ret = job->creationTime().toLocalTime();
             break;
         case DuplexRole: {
             if (job->printer()) {
@@ -194,6 +272,9 @@
         case IdRole:
             ret = job->jobId();
             break;
+        case HeldRole:
+            ret = job->state() == PrinterEnum::JobState::Held;
+            break;
         case ImpressionsCompletedRole:
             ret = job->impressionsCompleted();
             break;
@@ -213,11 +294,12 @@
             ret = QVariant::fromValue<PrinterEnum::PrintRange>(job->printRangeMode());
             break;
         case ProcessingTimeRole:
-            ret = job->processingTime().toString(QLocale::system().dateTimeFormat());
+            ret = job->processingTime().toLocalTime();
             break;
         case QualityRole: {
             if (job->printer()) {
-                ret = job->printer()->supportedPrintQualities().at(job->quality()).text;
+                PrintQuality q = job->printer()->supportedPrintQualities().at(job->quality());
+                ret = q.text.isEmpty() ? q.name : q.text;
             } else {
                 qWarning() << "Printer is undefined, no quality";
                 ret = "";
@@ -231,30 +313,7 @@
             ret = job->size();
             break;
         case StateRole:
-            // TODO: improve, for now have a switch
-            switch (job->state()) {
-            case PrinterEnum::JobState::Aborted:
-                ret = "Aborted";
-                break;
-            case PrinterEnum::JobState::Canceled:
-                ret = "Canceled";
-                break;
-            case PrinterEnum::JobState::Complete:
-                ret = "Compelete";
-                break;
-            case PrinterEnum::JobState::Held:
-                ret = "Held";
-                break;
-            case PrinterEnum::JobState::Pending:
-                ret = "Pending";
-                break;
-            case PrinterEnum::JobState::Processing:
-                ret = "Processing";
-                break;
-            case PrinterEnum::JobState::Stopped:
-                ret = "Stopped";
-                break;
-            }
+            ret = QVariant::fromValue<PrinterEnum::JobState>(job->state());
             break;
         case Qt::DisplayRole:
         case TitleRole:
@@ -263,6 +322,15 @@
         case UserRole:
             ret = job->user();
             break;
+        case LastStateMessageRole: {
+            if (job->printer()) {
+                ret = job->printer()->lastMessage();
+            } else {
+                ret = "";
+            }
+            break;
+        }
+
         }
     }
 
@@ -283,6 +351,7 @@
         names[CreationTimeRole] = "creationTime";
         names[DuplexRole] = "duplexMode";
         names[ImpressionsCompletedRole] = "impressionsCompleted";
+        names[HeldRole] = "held";
         names[LandscapeRole] = "landscape";
         names[MessagesRole] = "messages";
         names[PrinterNameRole] = "printerName";
@@ -315,10 +384,10 @@
     return result;
 }
 
-QSharedPointer<PrinterJob> JobModel::getJobById(const int &id)
+QSharedPointer<PrinterJob> JobModel::getJob(const QString &printerName, const int &id)
 {
     Q_FOREACH(auto job, m_jobs) {
-        if (job->jobId() == id) {
+        if (job->printerName() == printerName && job->jobId() == id) {
             return job;
         }
     }
@@ -367,6 +436,33 @@
     return rowCount();
 }
 
+void JobFilter::filterOnActive()
+{
+    m_activeStates = QSet<PrinterEnum::JobState>{
+        PrinterEnum::JobState::Processing,
+    };
+    m_activeFilterEnabled = true;
+    invalidate();
+}
+
+void JobFilter::filterOnPaused()
+{
+    m_pausedStates = QSet<PrinterEnum::JobState>{
+        PrinterEnum::JobState::Held,
+    };
+    m_pausedFilterEnabled = true;
+    invalidate();
+}
+
+void JobFilter::filterOnQueued()
+{
+    m_queuedStates = QSet<PrinterEnum::JobState>{
+        PrinterEnum::JobState::Pending,
+    };
+    m_queuedFilterEnabled = true;
+    invalidate();
+}
+
 void JobFilter::filterOnPrinterName(const QString &name)
 {
     m_printerName = name;
@@ -386,5 +482,50 @@
         accepts = m_printerName == printerName;
     }
 
+    if (accepts && m_activeFilterEnabled) {
+        PrinterEnum::JobState state = childIndex.model()->data(
+            childIndex, JobModel::StateRole
+        ).value<PrinterEnum::JobState>();
+
+        accepts = m_activeStates.contains(state);
+    }
+
+    if (accepts && m_pausedFilterEnabled) {
+        PrinterEnum::JobState state = childIndex.model()->data(
+            childIndex, JobModel::StateRole
+        ).value<PrinterEnum::JobState>();
+
+        accepts = m_pausedStates.contains(state);
+    }
+
+    if (accepts && m_queuedFilterEnabled) {
+        PrinterEnum::JobState state = childIndex.model()->data(
+            childIndex, JobModel::StateRole
+        ).value<PrinterEnum::JobState>();
+
+        accepts = m_queuedStates.contains(state);
+    }
+
     return accepts;
 }
+
+bool JobFilter::lessThan(const QModelIndex &source_left,
+                         const QModelIndex &source_right) const
+{
+    QVariant leftData = sourceModel()->data(source_left, sortRole());
+    QVariant rightData = sourceModel()->data(source_right, sortRole());
+
+    if (sortRole() == (int) JobModel::CreationTimeRole) {
+        // If creationDateTime is the same, fallback to Id
+        if (leftData.toDateTime() == rightData.toDateTime()) {
+            int leftId = sourceModel()->data(source_left, JobModel::IdRole).toInt();
+            int rightId = sourceModel()->data(source_right, JobModel::IdRole).toInt();
+
+            return leftId < rightId;
+        } else {
+            return leftData.toDateTime() < rightData.toDateTime();
+        }
+    } else {
+        return leftData < rightData;
+    }
+}

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h	2017-02-21 10:46:29 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h	2017-03-20 13:32:24 +0000
@@ -20,6 +20,7 @@
 #include "printers_global.h"
 #include "backend/backend.h"
 #include "printer/printerjob.h"
+#include "printer/signalratelimiter.h"
 
 #include <QAbstractListModel>
 #include <QByteArray>
@@ -30,6 +31,8 @@
 #include <QTimer>
 #include <QVariant>
 
+class PrinterBackend;
+class PrinterJob;
 class PRINTERS_DECL_EXPORT JobModel : public QAbstractListModel
 {
     Q_OBJECT
@@ -51,6 +54,7 @@
         CopiesRole,
         CreationTimeRole,
         DuplexRole,
+        HeldRole,
         ImpressionsCompletedRole,
         LandscapeRole,
         MessagesRole,
@@ -75,23 +79,46 @@
     int count() const;
 
     Q_INVOKABLE QVariantMap get(const int row) const;
-    QSharedPointer<PrinterJob> getJobById(const int &id);
+    QSharedPointer<PrinterJob> getJob(const QString &printerName, const int &id);
+
+    void updateJobPrinter(QSharedPointer<PrinterJob> job, QSharedPointer<Printer> printer);
 private:
+    void addJob(QSharedPointer<PrinterJob> job);
+    void removeJob(QSharedPointer<PrinterJob> job);
+    void updateJob(QSharedPointer<PrinterJob> Job);
+
     PrinterBackend *m_backend;
 
     QList<QSharedPointer<PrinterJob>> m_jobs;
+    SignalRateLimiter m_signalHandler;
 private Q_SLOTS:
-    void update();
-    void jobSignalCatchAll(const QString &text, const QString &printer_uri,
-                           const QString &printer_name, uint printer_state,
-                           const QString &printer_state_reasons,
-                           bool printer_is_accepting_jobs, uint job_id,
-                           uint job_state, const QString &job_state_reasons,
-                           const QString &job_name,
-                           uint job_impressions_completed);
+    void jobCreated(const QString &text, const QString &printer_uri,
+                    const QString &printer_name, uint printer_state,
+                    const QString &printer_state_reasons,
+                    bool printer_is_accepting_jobs, uint job_id,
+                    uint job_state, const QString &job_state_reasons,
+                    const QString &job_name,
+                    uint job_impressions_completed);
+    void jobState(const QString &text, const QString &printer_uri,
+                  const QString &printer_name, uint printer_state,
+                  const QString &printer_state_reasons,
+                  bool printer_is_accepting_jobs, uint job_id,
+                  uint job_state, const QString &job_state_reasons,
+                  const QString &job_name,
+                  uint job_impressions_completed);
+    void jobCompleted(const QString &text, const QString &printer_uri,
+                      const QString &printer_name, uint printer_state,
+                      const QString &printer_state_reasons,
+                      bool printer_is_accepting_jobs, uint job_id,
+                      uint job_state, const QString &job_state_reasons,
+                      const QString &job_name,
+                      uint job_impressions_completed);
+    void jobSignalPrinterModified(const QString &printerName);
+    void updateJob(QString printerName, int jobId, QMap<QString, QVariant> attributes);
 
 Q_SIGNALS:
     void countChanged();
+    void forceJobRefresh(const QString &printerName, const int jobId);
 };
 
 class PRINTERS_DECL_EXPORT JobFilter : public QSortFilterProxyModel
@@ -102,13 +129,19 @@
     explicit JobFilter(QObject *parent = Q_NULLPTR);
     ~JobFilter();
 
-    Q_INVOKABLE QVariantMap get(const int row) const;
-
     void filterOnPrinterName(const QString &name);
     int count() const;
+public Q_SLOTS:
+    QVariantMap get(const int row) const;
+
+    void filterOnActive();
+    void filterOnQueued();
+    void filterOnPaused();
 protected:
     virtual bool filterAcceptsRow(
         int sourceRow, const QModelIndex &sourceParent) const override;
+    virtual bool lessThan(const QModelIndex &source_left,
+                          const QModelIndex &source_right) const;
 
 Q_SIGNALS:
     void countChanged();
@@ -120,6 +153,15 @@
 private:
     QString m_printerName = QString::null;
     bool m_printerNameFilterEnabled = false;
+
+    bool m_activeFilterEnabled = false;
+    QSet<PrinterEnum::JobState> m_activeStates;
+
+    bool m_queuedFilterEnabled = false;
+    QSet<PrinterEnum::JobState> m_queuedStates;
+
+    bool m_pausedFilterEnabled = false;
+    QSet<PrinterEnum::JobState> m_pausedStates;
 };
 
 #endif // USC_JOB_MODEL_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp	2017-03-20 13:32:24 +0000
@@ -22,6 +22,7 @@
 #include "utils.h"
 
 #include <QDebug>
+#include <QUrl>
 
 PrinterModel::PrinterModel(PrinterBackend *backend, QObject *parent)
     : QAbstractListModel(parent)
@@ -31,9 +32,9 @@
     QObject::connect(m_backend, &PrinterBackend::printerAdded,
                      this, &PrinterModel::printerAdded);
     QObject::connect(m_backend, &PrinterBackend::printerModified,
-                     &m_signalHandler, &PrinterSignalHandler::onPrinterModified);
+                     &m_signalHandler, &SignalRateLimiter::onPrinterModified);
     QObject::connect(m_backend, &PrinterBackend::printerStateChanged,
-                     &m_signalHandler, &PrinterSignalHandler::onPrinterModified);
+                     &m_signalHandler, &SignalRateLimiter::onPrinterModified);
     QObject::connect(m_backend, &PrinterBackend::printerDeleted,
                      this, &PrinterModel::printerDeleted);
 
@@ -126,22 +127,6 @@
     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);
@@ -214,6 +199,15 @@
         case Qt::DisplayRole:
             ret = printer->name();
             break;
+        case DeviceUriRole:
+            ret = printer->deviceUri();
+            break;
+        case HostNameRole:
+            ret = QUrl(printer->deviceUri()).host();
+            break;
+        case MakeRole:
+            ret = printer->make();
+            break;
         case ColorModelRole:
             ret = printer->supportedColorModels().indexOf(printer->defaultColorModel());
             break;
@@ -248,6 +242,9 @@
         case DescriptionRole:
             ret = printer->description();
             break;
+        case LocationRole:
+            ret = printer->location();
+            break;
         case PageSizeRole:
             ret = printer->defaultPageSize().name();
             break;
@@ -274,15 +271,27 @@
         case IsRawRole:
             ret = !printer->holdsDefinition();
             break;
+        case IsRemoteRole:
+            ret = printer->isRemote();
+            break;
+        case LastMessageRole:
+            ret = printer->lastMessage();
+            break;
         case JobRole:
             ret = QVariant::fromValue(printer->jobs());
             break;
+        case CopiesRole:
+            ret = printer->copies();
+            break;
         case EnabledRole:
             ret = printer->enabled();
             break;
         case AcceptJobsRole:
             ret = printer->acceptJobs();
             break;
+        case SharedRole:
+            ret = printer->shared();
+            break;
         }
     }
 
@@ -338,6 +347,11 @@
         case AcceptJobsRole:
             printer->setAcceptJobs(value.toBool());
             break;
+        case CopiesRole:
+            printer->setCopies(value.toInt());
+        case SharedRole:
+            printer->setShared(value.toBool());
+            break;
         }
     }
 
@@ -356,12 +370,16 @@
         names[DuplexRole] = "duplexMode";
         names[SupportedDuplexModesRole] = "supportedDuplexModes";
         names[NameRole] = "name";
+        names[DeviceUriRole] = "deviceUri";
+        names[HostNameRole] = "hostname";
+        names[MakeRole] = "make";
         names[EnabledRole] = "printerEnabled";
         names[AcceptJobsRole] = "acceptJobs";
-        names[PdfModeRole] = "pdfMode";
+        names[SharedRole] = "shared";
         names[PrintQualityRole] = "printQuality";
         names[SupportedPrintQualitiesRole] = "supportedPrintQualities";
         names[DescriptionRole] = "description";
+        names[LocationRole] = "location";
         names[PageSizeRole] = "pageSize";
         names[SupportedPageSizesRole] = "supportedPageSizes";
         names[StateRole] = "state";
@@ -369,6 +387,9 @@
         names[IsPdfRole] = "isPdf";
         names[IsLoadedRole] = "isLoaded";
         names[IsRawRole] = "isRaw";
+        names[IsRemoteRole] = "isRemote";
+        names[LastMessageRole] = "lastMessage";
+        names[CopiesRole] = "copies";
         names[JobRole] = "jobs";
     }
 
@@ -447,6 +468,13 @@
     m_pdf = pdf;
 }
 
+void PrinterFilter::filterOnRemote(const bool remote)
+{
+    m_remoteEnabled = true;
+    m_remote = remote;
+    invalidate();
+}
+
 bool PrinterFilter::filterAcceptsRow(int sourceRow,
                                      const QModelIndex &sourceParent) const
 {
@@ -472,6 +500,14 @@
         accepts = m_state == state;
     }
 
+    // If m_remote is true, we only show remote printers.
+    if (accepts && m_remoteEnabled) {
+        const bool isRemote = childIndex.model()->data(
+                childIndex, PrinterModel::IsRemoteRole
+            ).toBool();
+        accepts = m_remote == isRemote;
+    }
+
     return accepts;
 }
 bool PrinterFilter::lessThan(const QModelIndex &left,

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/printermodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/printermodel.h	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/printermodel.h	2017-03-20 13:32:24 +0000
@@ -21,7 +21,7 @@
 
 #include "models/jobmodel.h"
 #include "printer/printer.h"
-#include "printer/printersignalhandler.h"
+#include "printer/signalratelimiter.h"
 
 #include <QAbstractListModel>
 #include <QByteArray>
@@ -47,9 +47,13 @@
         DuplexRole,
         SupportedDuplexModesRole,
         NameRole,
+        DeviceUriRole,
+        HostNameRole,
+        MakeRole,
+        LocationRole,
         EnabledRole,
         AcceptJobsRole,
-        PdfModeRole,
+        SharedRole,
         PrintQualityRole,
         SupportedPrintQualitiesRole,
         DescriptionRole,
@@ -68,6 +72,9 @@
 
         /* Indicates that this printers has no associated PPD. */
         IsRawRole,
+        IsRemoteRole,
+        LastMessageRole,
+        CopiesRole,
         JobRole,
         LastRole = JobRole,
     };
@@ -92,13 +99,12 @@
         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;
 
     QList<QSharedPointer<Printer>> m_printers;
-    PrinterSignalHandler m_signalHandler;
+    SignalRateLimiter m_signalHandler;
 
 private Q_SLOTS:
     void printerLoaded(QSharedPointer<Printer> printer);
@@ -127,6 +133,7 @@
     void filterOnState(const PrinterEnum::State &state);
     void filterOnRecent(const bool recent);
     void filterOnPdf(const bool pdf);
+    void filterOnRemote(const bool remote);
 
     int count() const;
 protected:
@@ -149,6 +156,8 @@
     bool m_recentEnabled = false;
     bool m_pdfEnabled = false;
     bool m_pdf = false;
+    bool m_remoteEnabled = false;
+    bool m_remote = false;
 };
 
 #endif // USC_PRINTER_MODEL_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/plugin.cpp'
--- modules/Ubuntu/Components/Extras/Printers/plugin.cpp	2017-02-21 11:31:44 +0000
+++ modules/Ubuntu/Components/Extras/Printers/plugin.cpp	2017-03-20 13:32:24 +0000
@@ -54,5 +54,7 @@
 
     qmlRegisterUncreatableType<PrinterEnum>(uri, 0, 1, "PrinterEnum", "Is an enum");
     qRegisterMetaType<QList<PrinterDriver>>("QList<PrinterDriver>");
+    qRegisterMetaType<QSharedPointer<PrinterJob>>("QSharedPointer<PrinterJob>");
     qRegisterMetaType<QList<QSharedPointer<Printer>>>("QList<QSharedPointer<Printer>>");
+    qRegisterMetaType<Device>("Device");
 }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printer/printer.cpp'
--- modules/Ubuntu/Components/Extras/Printers/printer/printer.cpp	2017-02-24 17:47:22 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printer.cpp	2017-03-20 13:32:24 +0000
@@ -14,22 +14,26 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "i18n.h"
 #include "utils.h"
 
 #include "printer.h"
 
 #include <QDebug>
+#include <QLocale>
 #include <QQmlEngine>
 
 Printer::Printer(PrinterBackend *backend, QObject *parent)
     : QObject(parent)
     , m_backend(backend)
 {
-    loadColorModel();
-    loadPrintQualities();
-    loadAcceptJobs();
+    loadAttributes();
 
+    m_jobs.setParent(this);
     m_jobs.filterOnPrinterName(name());
+
+    QObject::connect(m_backend, &PrinterBackend::printerStateChanged,
+                     this, &Printer::onPrinterStateChanged);
 }
 
 Printer::~Printer()
@@ -41,48 +45,87 @@
 {
     if (!m_jobs.sourceModel()) {
         m_jobs.setSourceModel(jobModel);
-        m_jobs.sort(JobModel::Roles::IdRole);
     }
 }
 
-void Printer::loadAcceptJobs()
+void Printer::updateAcceptJobs(const QMap<QString, QVariant> &serverAttrs)
 {
-    auto opt = QStringLiteral("AcceptJobs");
-    m_acceptJobs = m_backend->printerGetOption(name(), opt).toBool();
+    m_acceptJobs = serverAttrs.value(QStringLiteral("AcceptJobs")).toBool();
 }
 
-void Printer::loadColorModel()
+void Printer::updateColorModel(const QMap<QString, QVariant> &serverAttrs)
 {
     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>>();
+    m_defaultColorModel = serverAttrs.value(defModel).value<ColorModel>();
+    m_supportedColorModels = serverAttrs.value(models).value<QList<ColorModel>>();
 
     if (m_supportedColorModels.size() == 0) {
         m_supportedColorModels.append(m_defaultColorModel);
     }
 }
 
-void Printer::loadPrintQualities()
+void Printer::updatePrintQualities(const QMap<QString, QVariant> &serverAttrs)
 {
     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>();
+    m_supportedPrintQualities = serverAttrs.value(qualities).value<QList<PrintQuality>>();
+    m_defaultPrintQuality = serverAttrs.value(defQuality).value<PrintQuality>();
 
     if (m_supportedPrintQualities.size() == 0) {
         m_supportedPrintQualities.append(m_defaultPrintQuality);
     }
 }
 
+void Printer::updateLastMessage(const QMap<QString, QVariant> &serverAttrs)
+{
+    m_stateMessage = serverAttrs.value(QStringLiteral("StateMessage")).toString();
+}
+
+
+void Printer::updateDeviceUri(const QMap<QString, QVariant> &serverAttrs)
+{
+    m_deviceUri = serverAttrs.value(QStringLiteral("DeviceUri")).toString();
+}
+
+void Printer::updateCopies(const QMap<QString, QVariant> &serverAttrs)
+{
+    m_copies = serverAttrs.value(QStringLiteral("Copies")).toInt();
+    if (m_copies <= 0)
+        m_copies = 1;
+}
+
+void Printer::updateShared(const QMap<QString, QVariant> &serverAttrs)
+{
+    m_shared = serverAttrs.value(QStringLiteral("Shared")).toBool();
+}
+
+void Printer::loadAttributes()
+{
+    auto opts = QStringList({
+        QStringLiteral("AcceptJobs"),
+        QStringLiteral("DefaultColorModel"),
+        QStringLiteral("SupportedColorModels"),
+        QStringLiteral("DefaultPrintQuality"),
+        QStringLiteral("SupportedPrintQualities"),
+        QStringLiteral("StateMessage"),
+        QStringLiteral("DeviceUri"),
+        QStringLiteral("Copies"),
+        QStringLiteral("Shared"),
+    });
+    auto result = m_backend->printerGetOptions(name(), opts);
+
+    updateAcceptJobs(result);
+    updateColorModel(result);
+    updatePrintQualities(result);
+    updateLastMessage(result);
+    updateDeviceUri(result);
+    updateCopies(result);
+    updateShared(result);
+}
+
 ColorModel Printer::defaultColorModel() const
 {
     return m_defaultColorModel;
@@ -135,11 +178,26 @@
     return m_backend->printerName();
 }
 
+QString Printer::deviceUri() const
+{
+    return m_deviceUri;
+}
+
+QString Printer::make() const
+{
+    return m_backend->makeAndModel();
+}
+
 QString Printer::description() const
 {
     return m_backend->description();
 }
 
+QString Printer::location() const
+{
+    return m_backend->location();
+}
+
 QPageSize Printer::defaultPageSize() const
 {
     return m_backend->defaultPageSize();
@@ -170,6 +228,11 @@
     return m_backend->state();
 }
 
+bool Printer::shared() const
+{
+    return m_shared;
+}
+
 bool Printer::acceptJobs() const
 {
     return m_acceptJobs;
@@ -180,11 +243,21 @@
     return m_backend->holdsDefinition();
 }
 
+bool Printer::isRemote() const
+{
+    return m_backend->isRemote();
+}
+
 PrinterEnum::PrinterType Printer::type() const
 {
     return m_backend->type();
 }
 
+int Printer::copies() const
+{
+    return m_copies;
+}
+
 void Printer::setDefaultColorModel(const ColorModel &colorModel)
 {
     if (defaultColorModel() == colorModel) {
@@ -242,6 +315,16 @@
     }
 }
 
+void Printer::setShared(const bool shared)
+{
+    if (this->shared() != shared) {
+        QString reply = m_backend->printerSetShared(name(), shared);
+        if (!reply.isEmpty()) {
+            qWarning() << Q_FUNC_INFO << "failed to set shared:" << reply;
+        }
+    }
+}
+
 void Printer::setDefaultPrintQuality(const PrintQuality &quality)
 {
     if (defaultPrintQuality() == quality) {
@@ -278,6 +361,20 @@
     m_backend->refresh();
 }
 
+void Printer::setCopies(const int &copies)
+{
+    if (this->copies() == copies) {
+        return;
+    }
+
+    m_backend->printerSetCopies(name(), copies);
+}
+
+QString Printer::lastMessage() const
+{
+    return m_stateMessage;
+}
+
 QAbstractItemModel* Printer::jobs()
 {
     auto ret = &m_jobs;
@@ -296,16 +393,44 @@
             && type() == other->type()
             && acceptJobs() == other->acceptJobs()
             && enabled() == other->enabled()
-            && state() == other->state();
+            && state() == other->state()
+            && lastMessage() == other->lastMessage()
+            && deviceUri() == other->deviceUri()
+            && shared() == other->shared()
+            && copies() == other->copies()
+            && isRemote() == other->isRemote();
 }
 
 void Printer::updateFrom(QSharedPointer<Printer> other)
 {
     PrinterBackend *tmp = m_backend;
+
+    // Copy values from other printer which has been loaded in another thread
+    // Note: do not use loadAttributes otherwise can cause UI block
+    m_acceptJobs = other->m_acceptJobs;
     m_backend = other->m_backend;
+    m_defaultColorModel = other->m_defaultColorModel;
+    m_defaultPrintQuality = other->m_defaultPrintQuality;
+    m_deviceUri = other->m_deviceUri;
+    m_shared = other->m_shared;
+    m_stateMessage = other->m_stateMessage;
+    m_supportedColorModels = other->m_supportedColorModels;
+    m_supportedPrintQualities = other->m_supportedPrintQualities;
+
     other->m_backend = tmp;
-
-    loadColorModel();
-    loadPrintQualities();
-    loadAcceptJobs();
+}
+
+void Printer::onPrinterStateChanged(
+        const QString &text, const QString &printerUri,
+        const QString &printerName, uint printerState,
+        const QString &printerStateReason, bool acceptingJobs)
+{
+    Q_UNUSED(printerUri);
+    Q_UNUSED(printerState);
+    Q_UNUSED(printerStateReason);
+    Q_UNUSED(acceptingJobs);
+
+    if (name() == printerName) {
+        m_stateMessage = text;
+    }
 }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printer/printer.h'
--- modules/Ubuntu/Components/Extras/Printers/printer/printer.h	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printer.h	2017-03-20 13:32:24 +0000
@@ -49,17 +49,24 @@
     QStringList supportedDuplexStrings() const;
     PrinterEnum::DuplexMode defaultDuplexMode() const;
     QString name() const;
+    QString deviceUri() const;
+    QString make() const;
     PrintQuality defaultPrintQuality() const;
     QList<PrintQuality> supportedPrintQualities() const;
     QString description() const;
+    QString location() const;
     QPageSize defaultPageSize() const;
     QList<QPageSize> supportedPageSizes() const;
     PrinterEnum::AccessControl accessControl() const;
     PrinterEnum::ErrorPolicy errorPolicy() const;
     PrinterEnum::State state() const;
+    bool shared() const;
     bool acceptJobs() const;
     bool holdsDefinition() const;
+    bool isRemote() const;
+    QString lastMessage() const;
     QAbstractItemModel* jobs();
+    int copies() const;
 
     PrinterEnum::PrinterType type() const;
 
@@ -68,9 +75,11 @@
     void setDefaultDuplexMode(const PrinterEnum::DuplexMode &duplexMode);
     void setEnabled(const bool enabled);
     void setAcceptJobs(const bool accepting);
+    void setShared(const bool shared);
     void setDefaultPrintQuality(const PrintQuality &quality);
     void setDefaultPageSize(const QPageSize &pageSize);
     void setJobModel(JobModel* jobModel);
+    void setCopies(const int &copies);
 
     bool deepCompare(QSharedPointer<Printer> other) const;
     void updateFrom(QSharedPointer<Printer> other);
@@ -79,10 +88,22 @@
 public Q_SLOTS:
     int printFile(const QString &filepath, const PrinterJob *options);
 
+private Q_SLOTS:
+    void onPrinterStateChanged(
+        const QString &text, const QString &printerUri,
+        const QString &printerName, uint printerState,
+        const QString &printerStateReason, bool acceptingJobs
+    );
+
 private:
-    void loadAcceptJobs();
-    void loadColorModel();
-    void loadPrintQualities();
+    void updateAcceptJobs(const QMap<QString, QVariant> &serverAttrs);
+    void updateColorModel(const QMap<QString, QVariant> &serverAttrs);
+    void updatePrintQualities(const QMap<QString, QVariant> &serverAttrs);
+    void updateLastMessage(const QMap<QString, QVariant> &serverAttrs);
+    void updateDeviceUri(const QMap<QString, QVariant> &serverAttrs);
+    void updateCopies(const QMap<QString, QVariant> &serverAttrs);
+    void updateShared(const QMap<QString, QVariant> &serverAttrs);
+    void loadAttributes();
 
     JobFilter m_jobs;
     PrinterBackend *m_backend;
@@ -91,6 +112,11 @@
     PrintQuality m_defaultPrintQuality;
     QList<PrintQuality> m_supportedPrintQualities;
     bool m_acceptJobs;
+    bool m_shared;
+    QString m_deviceUri;
+    int m_copies;
+
+    QString m_stateMessage;
 };
 
 #endif // USC_PRINTERS_PRINTER_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printer/printerjob.cpp'
--- modules/Ubuntu/Components/Extras/Printers/printer/printerjob.cpp	2017-02-24 17:47:22 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printerjob.cpp	2017-03-20 13:32:24 +0000
@@ -55,6 +55,8 @@
     , m_title(QStringLiteral(""))
     , m_user("")
 {
+    connect(this, SIGNAL(printerAboutToChange(QSharedPointer<Printer>, QSharedPointer<Printer>)),
+            this, SLOT(onPrinterAboutToChange(QSharedPointer<Printer>, QSharedPointer<Printer>)));
 }
 
 PrinterJob::~PrinterJob()
@@ -143,6 +145,69 @@
     return m_landscape;
 }
 
+void PrinterJob::loadAttributes(const QMap<QString, QVariant> &attributes)
+{
+    // Load the extra attributes for the job
+    // NOTE: we don't need to type check them as they have been filtered for us
+
+    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).name == colorModel) {
+            setColorModel(i);
+        }
+    }
+
+    setCompletedTime(attributes.value("CompletedTime").toDateTime());
+    setCreationTime(attributes.value("CreationTime").toDateTime());
+
+    // 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);
+        }
+    }
+
+    setImpressionsCompleted(attributes.value("impressionsCompleted").toInt());
+    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()));
+    }
+
+    setProcessingTime(attributes.value("ProcessingTime").toDateTime());
+
+    // 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");
+
+    // If there was a state then set it
+    if (attributes.contains("State")) {
+        setState(static_cast<PrinterEnum::JobState>(attributes.value("State").toInt()));
+    }
+
+    setSize(attributes.value("Size").toInt());
+    setUser(attributes.value("User").toString());
+}
+
 void PrinterJob::loadDefaults()
 {
     if (!m_printer) {
@@ -150,62 +215,17 @@
         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");
+        loadAttributes(
+            m_backend->printerGetJobAttributes(
+                printerName(), jobId()
+            )
+        );
+    } else {
+        setColorModel(m_printer->supportedColorModels().indexOf(m_printer->defaultColorModel()));
+        setDuplexMode(m_printer->supportedDuplexModes().indexOf(m_printer->defaultDuplexMode()));
+        setQuality(m_printer->supportedPrintQualities().indexOf(m_printer->defaultPrintQuality()));
     }
-
-    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
@@ -373,16 +393,16 @@
 void PrinterJob::setPrinter(QSharedPointer<Printer> printer)
 {
    if (m_printer != printer) {
-       m_printer = printer;
+        Q_EMIT printerAboutToChange(m_printer, printer);
+        m_printer = printer;
 
-       if (printer->name() != m_printerName) {
+        if (printer->name() != m_printerName) {
             m_printerName = printer->name();
             Q_EMIT printerNameChanged();
-       }
+        }
 
-       Q_EMIT printerChanged();
+        Q_EMIT printerChanged();
    }
-   loadDefaults();
 }
 
 void PrinterJob::setPrintRange(const QString &printRange)
@@ -478,33 +498,61 @@
     // Return true if they are the same
     return collate() == other->collate()
             && colorModel() == other->colorModel()
+            && completedTime() == other->completedTime()
             && copies() == other->copies()
+            && creationTime() == other->creationTime()
             && duplexMode() == other->duplexMode()
+            && impressionsCompleted() == other->impressionsCompleted()
             && landscape() == other->landscape()
+            && messages() == other->messages()
             && printRange() == other->printRange()
             && printRangeMode() == other->printRangeMode()
+            && processingTime() == other->processingTime()
             && quality() == other->quality()
             && reverse() == other->reverse()
+            && size() == other->size()
             && state() == other->state()
-            && title() == other->title();
+            && title() == other->title()
+            && user() == other->user();
 }
 
 void PrinterJob::updateFrom(QSharedPointer<PrinterJob> other)
 {
     setCollate(other->collate());
     setColorModel(other->colorModel());
+    setCompletedTime(other->completedTime());
     setCopies(other->copies());
+    setCreationTime(other->creationTime());
     setDuplexMode(other->duplexMode());
+    setImpressionsCompleted(other->impressionsCompleted());
     setLandscape(other->landscape());
+    setMessages(other->messages());
     setPrintRange(other->printRange());
     setPrintRangeMode(other->printRangeMode());
+    setProcessingTime(other->processingTime());
     setQuality(other->quality());
     setReverse(other->reverse());
+    setSize(other->size());
     setState(other->state());
     setTitle(other->title());
+    setUser(other->user());
 }
 
 QString PrinterJob::user() const
 {
     return m_user;
 }
+
+void PrinterJob::onPrinterAboutToChange(QSharedPointer<Printer> old,
+                                        QSharedPointer<Printer> replacement)
+{
+    /* If we have an old printer, and the current copies value matches that
+    of the old printer's, we'll use the new printer's copy value.
+
+    The second case is if there was no old printer. */
+    bool haveOld = old && replacement && (copies() == old->copies());
+    bool noOld = !old && replacement;
+    if (haveOld || noOld) {
+        setCopies(replacement->copies());
+    }
+}

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h'
--- modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h	2017-03-20 13:32:24 +0000
@@ -58,8 +58,6 @@
     Q_PROPERTY(PrinterEnum::JobState state READ state NOTIFY stateChanged)
     Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged)
     Q_PROPERTY(QString user READ user NOTIFY userChanged)
-
-    friend class PrinterCupsBackend;
 public:
     explicit PrinterJob(QString dest,
                         PrinterBackend *backend,
@@ -97,31 +95,34 @@
     PrinterEnum::DuplexMode getDuplexMode() const;
     ColorModel getColorModel() const;
     PrintQuality getPrintQuality() const;
+    void loadAttributes(const QMap<QString, QVariant>& attributes);
+    void loadDefaults();
     Q_INVOKABLE void printFile(const QUrl &url);
     void setCollate(const bool collate);
     void setColorModel(const int colorModel);
+    void setCompletedTime(const QDateTime &completedTime);
     void setCopies(const int copies);
+    void setCreationTime(const QDateTime &creationTime);
     void setDuplexMode(const int duplexMode);
     void setImpressionsCompleted(const int &impressionsCompleted);
+    void setIsTwoSided(const bool isTwoSided);
     void setLandscape(const bool landscape);
+    void setMessages(const QStringList &messages);
     void setPrinter(QSharedPointer<Printer> printer);
     void setPrintRange(const QString &printRange);
     void setPrintRangeMode(const PrinterEnum::PrintRange printRangeMode);
+    void setProcessingTime(const QDateTime &processingTime);
     void setQuality(const int quality);
     void setReverse(const bool reverse);
+    void setSize(const int size);
+    void setState(const PrinterEnum::JobState &state);
     void setTitle(const QString &title);
+    void setUser(const QString &user);
 
     void updateFrom(QSharedPointer<PrinterJob> other);
 private Q_SLOTS:
-    void loadDefaults();
-    void setCompletedTime(const QDateTime &completedTime);
-    void setCreationTime(const QDateTime &creationTime);
-    void setIsTwoSided(const bool isTwoSided);
-    void setMessages(const QStringList &messages);
-    void setProcessingTime(const QDateTime &processingTime);
-    void setSize(const int size);
-    void setState(const PrinterEnum::JobState &state);
-    void setUser(const QString &user);
+    void onPrinterAboutToChange(QSharedPointer<Printer> old,
+                                QSharedPointer<Printer> replacement);
 Q_SIGNALS:
     void collateChanged();
     void colorModelChanged();
@@ -134,6 +135,8 @@
     void isTwoSidedChanged();
     void landscapeChanged();
     void messagesChanged();
+    void printerAboutToChange(QSharedPointer<Printer> old,
+                              QSharedPointer<Printer> replacement);
     void printerChanged();
     void printerNameChanged();
     void printRangeChanged();

=== renamed file 'modules/Ubuntu/Components/Extras/Printers/printer/printersignalhandler.cpp' => 'modules/Ubuntu/Components/Extras/Printers/printer/signalratelimiter.cpp'
--- modules/Ubuntu/Components/Extras/Printers/printer/printersignalhandler.cpp	2017-02-21 10:46:29 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/signalratelimiter.cpp	2017-03-20 13:32:24 +0000
@@ -14,9 +14,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "printersignalhandler.h"
+#include "signalratelimiter.h"
 
-PrinterSignalHandler::PrinterSignalHandler(int triggerEventDelay,
+SignalRateLimiter::SignalRateLimiter(int triggerEventDelay,
                                            QObject *parent)
     : QObject(parent)
 {
@@ -24,11 +24,11 @@
     connect(&m_timer, SIGNAL(timeout()), this, SLOT(process()));
 }
 
-PrinterSignalHandler::~PrinterSignalHandler()
+SignalRateLimiter::~SignalRateLimiter()
 {
 }
 
-void PrinterSignalHandler::process()
+void SignalRateLimiter::process()
 {
     Q_FOREACH(auto printer, m_unprocessed) {
         Q_EMIT printerModified(printer);
@@ -37,7 +37,7 @@
     m_timer.stop();
 }
 
-void PrinterSignalHandler::onPrinterModified(
+void SignalRateLimiter::onPrinterModified(
     const QString &text, const QString &printerUri,
     const QString &printerName, uint printerState,
     const QString &printerStateReason, bool acceptingJobs)
@@ -49,11 +49,22 @@
     Q_UNUSED(printerStateReason);
     Q_UNUSED(acceptingJobs);
 
+    // Track when the first item was added to the unprocessed queue
+    if (m_unprocessed.count() == 0) {
+        m_unprocessed_time = QDateTime::currentDateTime();
+    }
+
     m_unprocessed << printerName;
     m_timer.start();
+
+    // Ensure that process is fired if we have reached four times
+    // longer than the timer, this is due to many signals coming in rapidly
+    if (m_unprocessed_time.msecsTo(QDateTime::currentDateTime()) > m_timer.interval() * 4) {
+        process();
+    }
 }
 
-void PrinterSignalHandler::onPrinterStateChanged(
+void SignalRateLimiter::onPrinterStateChanged(
     const QString &text, const QString &printerUri,
     const QString &printerName, uint printerState,
     const QString &printerStateReason, bool acceptingJobs)
@@ -64,6 +75,17 @@
     Q_UNUSED(printerStateReason);
     Q_UNUSED(acceptingJobs);
 
+    // Track when the first item was added to the unprocessed queue
+    if (m_unprocessed.count() == 0) {
+        m_unprocessed_time = QDateTime::currentDateTime();
+    }
+
     m_unprocessed << printerName;
     m_timer.start();
+
+    // Ensure that process is fired if we have reached four times
+    // longer than the timer, this is due to many signals coming in rapidly
+    if (m_unprocessed_time.msecsTo(QDateTime::currentDateTime()) > m_timer.interval() * 4) {
+        process();
+    }
 }

=== renamed file 'modules/Ubuntu/Components/Extras/Printers/printer/printersignalhandler.h' => 'modules/Ubuntu/Components/Extras/Printers/printer/signalratelimiter.h'
--- modules/Ubuntu/Components/Extras/Printers/printer/printersignalhandler.h	2017-02-21 10:46:29 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/signalratelimiter.h	2017-03-20 13:32:24 +0000
@@ -14,24 +14,26 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef USC_PRINTER_SIGNAL_HANDLER_H
-#define USC_PRINTER_SIGNAL_HANDLER_H
+#ifndef USC_SIGNAL_RATE_LIMITER_H
+#define USC_SIGNAL_RATE_LIMITER_H
 
 #include "printers_global.h"
 
+#include <QDateTime>
 #include <QObject>
 #include <QSet>
 #include <QTimer>
 
-class PRINTERS_DECL_EXPORT PrinterSignalHandler : public QObject
+class PRINTERS_DECL_EXPORT SignalRateLimiter : public QObject
 {
     Q_OBJECT
     QTimer m_timer;
     QSet<QString> m_unprocessed;
+    QDateTime m_unprocessed_time;
 public:
-    explicit PrinterSignalHandler(int triggerEventDelay = 500,
+    explicit SignalRateLimiter(int triggerEventDelay = 500,
                                   QObject *parent = Q_NULLPTR);
-    ~PrinterSignalHandler();
+    ~SignalRateLimiter();
 
 public Q_SLOTS:
     void onPrinterModified(
@@ -52,4 +54,4 @@
     void printerModified(const QString &printerName);
 };
 
-#endif // USC_PRINTER_SIGNAL_HANDLER_H
+#endif // USC_SIGNAL_RATE_LIMITERR_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp'
--- modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp	2017-02-24 13:14:13 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp	2017-03-20 13:32:24 +0000
@@ -15,6 +15,7 @@
  */
 
 #include "backend/backend_cups.h"
+#include "i18n.h"
 #include "printers/printers.h"
 #include "cupsdnotifier.h" // Note: this file was generated.
 
@@ -33,6 +34,7 @@
 Printers::Printers(PrinterBackend *backend, QObject *parent)
     : QObject(parent)
     , m_backend(backend)
+    , m_devices(backend)
     , m_drivers(backend)
     , m_model(backend)
     , m_jobs(backend)
@@ -56,8 +58,20 @@
             const QModelIndex &parent, int first, int) {
         int jobId = m_jobs.data(m_jobs.index(first, 0, parent),
                                 JobModel::Roles::IdRole).toInt();
-        jobAdded(m_jobs.getJobById(jobId));
-    });
+        QString printerName = m_jobs.data(
+            m_jobs.index(first, 0, parent),
+            JobModel::Roles::PrinterNameRole
+        ).toString();
+
+        jobAdded(m_jobs.getJob(printerName, jobId));
+    });
+
+    // If the jobModel forces a refresh, load extended attributes for the job
+    connect(&m_jobs, &JobModel::forceJobRefresh, [this](
+            const QString &printerName, const int jobId) {
+       jobAdded(m_jobs.getJob(printerName, jobId));
+    });
+
     connect(&m_model, &QAbstractItemModel::rowsInserted, [this](
             const QModelIndex &parent, int first, int) {
         auto printer = m_model.data(
@@ -76,6 +90,17 @@
         );
     }
 
+    // Ensure existing jobs have been added, incase some were added before
+    // the connect to rowsInserted was done
+    for (int i = 0; i < m_jobs.rowCount(); i++) {
+        jobAdded(
+            m_jobs.getJob(
+                m_jobs.data(m_jobs.index(i), JobModel::Roles::PrinterNameRole).toString(),
+                m_jobs.data(m_jobs.index(i), JobModel::IdRole).toInt()
+            )
+        );
+    }
+
     if (m_backend->type() == PrinterEnum::PrinterType::CupsType) {
         ((PrinterCupsBackend*) m_backend)->createSubscription();
     }
@@ -103,6 +128,29 @@
     return ret;
 }
 
+QAbstractItemModel* Printers::remotePrinters()
+{
+    m_devices.load();
+    auto ret = &m_devices;
+    QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
+    return ret;
+}
+QAbstractItemModel* Printers::localPrinters()
+{
+    /* Lazily initialize this model. Local printers are discerned from remotes
+    by checking if they are remote. */
+    if (!m_localPrinters.sourceModel()) {
+        m_localPrinters.setSourceModel(&m_model);
+        m_localPrinters.filterOnRemote(false);
+        m_localPrinters.setSortRole(PrinterModel::Roles::DefaultPrinterRole);
+        m_localPrinters.sort(0, Qt::DescendingOrder);
+    }
+
+    auto ret = &m_localPrinters;
+    QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
+    return ret;
+}
+
 QAbstractItemModel* Printers::printJobs()
 {
     auto ret = &m_jobs;
@@ -143,11 +191,33 @@
     return new PrinterJob(printerName, m_backend);
 }
 
+QAbstractItemModel* Printers::createJobFilter()
+{
+    // Note: If called by QML, it gains ownership of the job filter.
+    JobFilter *filter = new JobFilter();
+    filter->setSourceModel(&m_jobs);
+
+    filter->setSortRole(JobModel::Roles::CreationTimeRole);
+    filter->sort(0, Qt::AscendingOrder);
+
+    return filter;
+}
+
 void Printers::cancelJob(const QString &printerName, const int jobId)
 {
     m_backend->cancelJob(printerName, jobId);
 }
 
+void Printers::holdJob(const QString &printerName, const int jobId)
+{
+    m_backend->holdJob(printerName, jobId);
+}
+
+void Printers::releaseJob(const QString &printerName, const int jobId)
+{
+    m_backend->releaseJob(printerName, jobId);
+}
+
 void Printers::setDefaultPrinterName(const QString &name)
 {
     QString reply = m_backend->printerSetDefault(name);
@@ -164,6 +234,11 @@
     }
 }
 
+void Printers::searchForDevices()
+{
+    m_devices.load();
+}
+
 bool Printers::addPrinter(const QString &name, const QString &ppd,
                           const QString &device, const QString &description,
                           const QString &location)
@@ -174,6 +249,9 @@
         m_lastMessage = reply;
         return false;
     }
+
+    provisionPrinter(name);
+
     return true;
 }
 
@@ -189,9 +267,19 @@
         m_lastMessage = reply;
         return false;
     }
+
+    provisionPrinter(name);
+
     return true;
 }
 
+void Printers::provisionPrinter(const QString &name)
+{
+    // We mimic what System Config Printer does here.
+    m_backend->printerSetEnabled(name, true);
+    m_backend->printerSetAcceptJobs(name, true);
+}
+
 bool Printers::removePrinter(const QString &name)
 {
     QString reply = m_backend->printerDelete(name);
@@ -206,8 +294,21 @@
 void Printers::jobAdded(QSharedPointer<PrinterJob> job)
 {
     auto printer = m_model.getPrinterByName(job->printerName());
-    if (printer && job)
-        job->setPrinter(printer);
+
+    // Check if we have a valid printer, does not need to be loaded as JobLoader
+    // creates it's own Backend.
+    if (printer && job) {
+        // TODO: this printer may not be fully loaded
+        // Which has the side affect of colorModel, duplex, quality not working
+        // in PrinterJob as Printer::supportedColorModels etc fail
+        // Potentially trigger loadPrinter and listen for the new printer?
+
+        // Set the printer to the job
+        m_jobs.updateJobPrinter(job, printer);
+
+        // Trigger JobLoader to load extended attributes in the background
+        m_backend->requestJobExtendedAttributes(printer, job);
+    }
 }
 
 void Printers::printerAdded(QSharedPointer<Printer> printer)
@@ -223,10 +324,9 @@
         ).toString();
 
         int jobId = m_jobs.data(idx, JobModel::Roles::IdRole).toInt();
-        auto job = m_jobs.getJobById(jobId);
+        auto job = m_jobs.getJob(printerName, jobId);
         if (printerName == printer->name() && !job->printer()) {
-            job->setPrinter(printer);
-            return;
+            jobAdded(job);
         }
     }
 }
@@ -243,3 +343,28 @@
         m_backend->requestPrinter(name);
     }
 }
+
+void Printers::printTestPage(const QString &name)
+{
+
+    auto printer = m_model.getPrinterByName(name);
+    if (!printer) {
+        qWarning() << Q_FUNC_INFO << "no known printer named" << name;
+        return;
+    }
+
+    auto page = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
+                                       "cups/data/default-testpage.pdf",
+                                       QStandardPaths::LocateFile);
+
+    if (page.isEmpty()) {
+        qCritical() << Q_FUNC_INFO << "Could not find test page.";
+        return;
+    }
+
+    auto job = new PrinterJob(name, m_backend);
+    job->setPrinter(printer);
+    job->setTitle(__("Test page"));
+    job->printFile(QUrl::fromLocalFile(page));
+    job->deleteLater();
+}

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printers/printers.h'
--- modules/Ubuntu/Components/Extras/Printers/printers/printers.h	2017-02-24 12:20:07 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printers/printers.h	2017-03-20 13:32:24 +0000
@@ -19,6 +19,7 @@
 
 #include "printers_global.h"
 
+#include "models/devicemodel.h"
 #include "models/drivermodel.h"
 #include "models/printermodel.h"
 #include "printer/printer.h"
@@ -36,6 +37,8 @@
     Q_OBJECT
     Q_PROPERTY(QAbstractItemModel* allPrinters READ allPrinters CONSTANT)
     Q_PROPERTY(QAbstractItemModel* allPrintersWithPdf READ allPrintersWithPdf CONSTANT)
+    Q_PROPERTY(QAbstractItemModel* remotePrinters READ remotePrinters CONSTANT)
+    Q_PROPERTY(QAbstractItemModel* localPrinters READ localPrinters CONSTANT)
     Q_PROPERTY(QAbstractItemModel* printJobs READ printJobs CONSTANT)
     Q_PROPERTY(QAbstractItemModel* drivers READ drivers CONSTANT)
     Q_PROPERTY(QString driverFilter READ driverFilter WRITE setDriverFilter NOTIFY driverFilterChanged)
@@ -51,6 +54,8 @@
 
     QAbstractItemModel* allPrinters();
     QAbstractItemModel* allPrintersWithPdf();
+    QAbstractItemModel* remotePrinters();
+    QAbstractItemModel* localPrinters();
     QAbstractItemModel* printJobs();
     QAbstractItemModel* drivers();
     QString driverFilter() const;
@@ -62,7 +67,11 @@
 
 public Q_SLOTS:
     PrinterJob* createJob(const QString &printerName);
+    QAbstractItemModel* createJobFilter();
+
     void cancelJob(const QString &printerName, const int jobId);
+    void holdJob(const QString &printerName, const int jobId);
+    void releaseJob(const QString &printerName, const int jobId);
 
     /* Instructs us to start loading drivers and what have you. In most cases,
     the user is likely to merely configure existing printers/jobs. Loading
@@ -70,6 +79,9 @@
     add printers, this method should be called first. */
     void prepareToAddPrinter();
 
+    // Starts a search for devices on local and remote resources.
+    void searchForDevices();
+
     bool addPrinter(const QString &name, const QString &ppd,
                     const QString &device, const QString &description,
                     const QString &location);
@@ -83,6 +95,8 @@
     // Instruct us to start (eagerly) loading a printer.
     void loadPrinter(const QString &name);
 
+    void printTestPage(const QString &name);
+
 private Q_SLOTS:
     void jobAdded(QSharedPointer<PrinterJob> job);
     void printerAdded(QSharedPointer<Printer> printer);
@@ -92,12 +106,16 @@
     void driverFilterChanged();
 
 private:
+    void provisionPrinter(const QString &name);
     PrinterBackend *m_backend;
+    DeviceModel m_devices;
     DriverModel m_drivers;
     PrinterModel m_model;
     JobModel m_jobs;
     PrinterFilter m_allPrinters;
     PrinterFilter m_allPrintersWithPdf;
+    PrinterFilter m_remotePrinters;
+    PrinterFilter m_localPrinters;
     PrinterFilter m_recentPrinters;
     QString m_lastMessage;
 };

=== modified file 'modules/Ubuntu/Components/Extras/Printers/structs.h'
--- modules/Ubuntu/Components/Extras/Printers/structs.h	2017-02-23 14:04:26 +0000
+++ modules/Ubuntu/Components/Extras/Printers/structs.h	2017-03-20 13:32:24 +0000
@@ -84,6 +84,87 @@
     }
 };
 
+struct Device
+{
+public:
+    QString cls;
+    QString id;
+    QString info;
+    QString makeModel;
+    QString uri;
+    QString location;
+    PrinterEnum::DeviceType type()
+    {
+        auto parts = uri.split(":", QString::SkipEmptyParts);
+        QString scheme = parts.size() > 0 ? parts[0] : QStringLiteral("");
+        if (scheme == QStringLiteral("dnssd"))
+            return PrinterEnum::DeviceType::DNSSDType;
+        else if (scheme == QStringLiteral("lpd"))
+            return PrinterEnum::DeviceType::LPDType;
+        else if (scheme == QStringLiteral("ipps"))
+            return PrinterEnum::DeviceType::IppSType;
+        else if (scheme == QStringLiteral("ipp14"))
+            return PrinterEnum::DeviceType::Ipp14Type;
+        else if (scheme == QStringLiteral("http"))
+            return PrinterEnum::DeviceType::HttpType;
+        else if (scheme == QStringLiteral("beh"))
+            return PrinterEnum::DeviceType::BehType;
+        else if (scheme == QStringLiteral("socket"))
+            return PrinterEnum::DeviceType::SocketType;
+        else if (scheme == QStringLiteral("https"))
+            return PrinterEnum::DeviceType::HttpsType;
+        else if (scheme == QStringLiteral("ipp"))
+            return PrinterEnum::DeviceType::IppType;
+        else if (scheme == QStringLiteral("hp"))
+            return PrinterEnum::DeviceType::HPType;
+        else if (scheme == QStringLiteral("usb"))
+            return PrinterEnum::DeviceType::USBType;
+        else if (scheme == QStringLiteral("hpfax"))
+            return PrinterEnum::DeviceType::HPFaxType;
+        else
+            return PrinterEnum::DeviceType::UnknownType;
+    }
+
+    QString toString() const {
+        /* 1. Split the id, which is of format "KEY:VAL; … KEYN:VALN;" into
+               ["KEY:VAL", …, "KEYN:VALN"]
+           2. Split each pair into
+               ["KEY", "VAL"] … ["KEYN", "VALN"]*/
+        QMap<QString, QString> idMap;
+        auto pairs = id.split(";");
+        Q_FOREACH(const QString &pair, pairs) {
+            auto keyValue = pair.split(":");
+
+            /* Sometimes key,val pairs are not terminated by ";". We just
+            use the first value in that case. E.g.:
+                "MFG:HP MDL:Laserfjert;"
+            Will give "HP" as MFG, and "" as MDL. */
+            if (keyValue.size() >= 2) {
+                idMap[keyValue[0]] = keyValue[1];
+            }
+        }
+        auto mfg = idMap.value("MFG", "");
+        auto mdl = idMap.value("MDL", "");
+
+        /* If the MDL field contains CMD, somebody forgot to terminate, and we
+        remove it. */
+        if (mdl.contains("CMD")) {
+            mdl = mdl.split("CMD")[0];
+        }
+
+        return QString("%1 %2").arg(mfg).arg(mdl);
+    }
+
+    bool operator==(const Device &other)
+    {
+        return ((cls == other.cls) && (id == other.id) && (info == other.info) &&
+                (makeModel == other.makeModel) && (uri == other.uri) &&
+                (location == other.location));
+    }
+};
+
+
+
 Q_DECLARE_TYPEINFO(ColorModel, Q_PRIMITIVE_TYPE);
 Q_DECLARE_METATYPE(ColorModel)
 
@@ -94,4 +175,7 @@
 Q_DECLARE_METATYPE(PrinterDriver)
 Q_DECLARE_METATYPE(QList<PrinterDriver>)
 
+Q_DECLARE_TYPEINFO(Device, Q_MOVABLE_TYPE);
+Q_DECLARE_METATYPE(Device)
+
 #endif // USC_PRINTERS_STRUCTS_H

=== modified file 'po/ubuntu-ui-extras.pot'
--- po/ubuntu-ui-extras.pot	2017-02-21 10:46:29 +0000
+++ po/ubuntu-ui-extras.pot	2017-03-20 13:32:24 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: ubuntu-ui-extras\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2017-02-21 10:42+0000\n"
+"POT-Creation-Date: 2017-03-15 17:39+0000\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -17,6 +17,14 @@
 "Content-Type: text/plain; charset=CHARSET\n"
 "Content-Transfer-Encoding: 8bit\n"
 
+#: modules/Ubuntu/Components/Extras/Example/Printers.qml:106
+msgid "Aborted"
+msgstr ""
+
+#: modules/Ubuntu/Components/Extras/Example/Printers.qml:108
+msgid "Active"
+msgstr ""
+
 #: modules/Ubuntu/Components/Extras/PhotoEditor.qml:206
 #: modules/Ubuntu/Components/Extras/PhotoEditor/ExposureAdjuster.qml:81
 msgid "Cancel"
@@ -26,7 +34,7 @@
 msgid "Color"
 msgstr ""
 
-#: modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp:53
+#: modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp:54
 msgid "Create PDF"
 msgstr ""
 
@@ -43,10 +51,18 @@
 msgid "Enhancing photo..."
 msgstr ""
 
+#: modules/Ubuntu/Components/Extras/Example/Printers.qml:104
+msgid "Idle"
+msgstr ""
+
 #: modules/Ubuntu/Components/Extras/Printers/utils.h:61
 msgid "Long Edge (Standard)"
 msgstr ""
 
+#: modules/Ubuntu/Components/Extras/Example/Printers.qml:115
+msgid "No messages"
+msgstr ""
+
 #: modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.cpp:47
 msgid "Normal"
 msgstr ""
@@ -79,6 +95,14 @@
 msgid "Short Edge (Flip)"
 msgstr ""
 
+#: modules/Ubuntu/Components/Extras/Example/Printers.qml:110
+msgid "Stopped"
+msgstr ""
+
+#: modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp:367
+msgid "Test page"
+msgstr ""
+
 #: modules/Ubuntu/Components/Extras/PhotoEditor.qml:197
 msgid "This will undo all edits, including those from previous sessions."
 msgstr ""

=== modified file 'tests/unittests/Printers/CMakeLists.txt'
--- tests/unittests/Printers/CMakeLists.txt	2017-02-21 16:55:36 +0000
+++ tests/unittests/Printers/CMakeLists.txt	2017-03-20 13:32:24 +0000
@@ -22,6 +22,8 @@
 add_executable(testPrintersPrinters tst_printers.cpp ${MOCK_SOURCES})
 target_link_libraries(testPrintersPrinters UbuntuComponentsExtrasPrintersQml Qt5::Test Qt5::Gui)
 add_test(tst_printers testPrintersPrinters)
+set_tests_properties(tst_printers PROPERTIES
+    ENVIRONMENT "XDG_DATA_DIRS=${CMAKE_CURRENT_SOURCE_DIR}/testdata")
 
 add_executable(testPrintersPrinterModel tst_printermodel.cpp ${MOCK_SOURCES})
 target_link_libraries(testPrintersPrinterModel UbuntuComponentsExtrasPrintersQml Qt5::Test Qt5::Gui)
@@ -43,6 +45,14 @@
 target_link_libraries(testPrintersJobFilter UbuntuComponentsExtrasPrintersQml Qt5::Test Qt5::Gui)
 add_test(tst_jobfilter testPrintersJobFilter)
 
-add_executable(testPrintersSignalHandler tst_signalhandler.cpp ${MOCK_SOURCES})
-target_link_libraries(testPrintersSignalHandler UbuntuComponentsExtrasPrintersQml Qt5::Test Qt5::Gui)
-add_test(tst_signalhandler testPrintersSignalHandler)
+add_executable(testPrintersSignalRateLimiter tst_signalratelimiter.cpp ${MOCK_SOURCES})
+target_link_libraries(testPrintersSignalRateLimiter UbuntuComponentsExtrasPrintersQml Qt5::Test Qt5::Gui)
+add_test(tst_signalratelimiter testPrintersSignalRateLimiter)
+
+add_executable(testPrintersDevice tst_printerdevice.cpp ${MOCK_SOURCES})
+target_link_libraries(testPrintersDevice UbuntuComponentsExtrasPrintersQml Qt5::Test Qt5::Gui)
+add_test(tst_printerdevice testPrintersDevice)
+
+add_executable(testPrintersDeviceModel tst_printerdevicemodel.cpp ${MOCK_SOURCES})
+target_link_libraries(testPrintersDeviceModel UbuntuComponentsExtrasPrintersQml Qt5::Test Qt5::Gui)
+add_test(tst_printerdevicemodel testPrintersDeviceModel)

=== modified file 'tests/unittests/Printers/mockbackend.h'
--- tests/unittests/Printers/mockbackend.h	2017-02-24 12:20:07 +0000
+++ tests/unittests/Printers/mockbackend.h	2017-03-20 13:32:24 +0000
@@ -40,7 +40,7 @@
 
     virtual bool holdsDefinition() const override
     {
-        return true;
+        return m_holdsDefinition;
     }
 
     virtual QString printerAdd(const QString &name,
@@ -105,6 +105,19 @@
         return returnValue;
     }
 
+    virtual QString printerSetCopies(const QString &name, const int &copies)
+    {
+        printerOptions[name].insert("Copies", copies);
+        return returnValue;
+    }
+
+    virtual QString printerSetShared(const QString &name,
+                                     const bool shared) override
+    {
+        printerOptions[name].insert("Shared", shared);
+        return returnValue;
+    }
+
     virtual QString printerSetInfo(const QString &name,
                                    const QString &info) override
     {
@@ -163,6 +176,32 @@
         }
     }
 
+    virtual void holdJob(const QString &printerName, const int jobId) override
+    {
+        // Change the faked job state
+        Q_FOREACH(auto job, m_jobs) {
+            if (job->printerName() == printerName
+                    && job->jobId() == jobId) {
+                job->setState(PrinterEnum::JobState::Held);
+            }
+        }
+
+        Q_EMIT jobState("", "", printerName, 1, "", true, jobId, static_cast<uint>(PrinterEnum::JobState::Held), "", "", 1);
+    }
+
+    virtual void releaseJob(const QString &printerName, const int jobId) override
+    {
+        // Change the faked job state
+        Q_FOREACH(auto job, m_jobs) {
+            if (job->printerName() == printerName
+                    && job->jobId() == jobId) {
+                job->setState(PrinterEnum::JobState::Pending);
+            }
+        }
+
+        Q_EMIT jobState("", "", printerName, 1, "", true, jobId, static_cast<uint>(PrinterEnum::JobState::Pending), "", "", 1);
+    }
+
     virtual int printFileToDest(const QString &filepath,
                                 const QString &title,
                                 const cups_dest_t *dest) override
@@ -184,9 +223,39 @@
     virtual QMap<QString, QVariant> printerGetJobAttributes(
             const QString &name, const int jobId) override
     {
-        Q_UNUSED(name);
-        Q_UNUSED(jobId);
-        return QMap<QString, QVariant>();
+        QMap<QString, QVariant> attributes;
+
+        Q_FOREACH(auto job, m_jobs) {
+            if (job->printerName() == name
+                    && job->jobId() == jobId) {
+                // Emulate reverse of PrinterJob::loadAttributes
+                // using local jobs defined in tests
+                attributes.insert("Collate", job->collate());
+                attributes.insert("copies", job->copies());
+                attributes.insert("ColorModel", job->getColorModel().name);
+                attributes.insert("CompletedTime", job->completedTime());
+                attributes.insert("CreationTime", job->creationTime());
+                attributes.insert("Duplex", Utils::duplexModeToPpdChoice(job->getDuplexMode()));
+                attributes.insert("impressionsCompleted", job->impressionsCompleted());
+                attributes.insert("landscape", job->landscape());
+                attributes.insert("messages", job->messages());
+                if (job->printRangeMode() == PrinterEnum::PrintRange::AllPages) {
+                    attributes.insert("page-ranges", QStringList());
+                } else {
+                    attributes.insert("page-ranges", job->printRange().split(QLocale::system().groupSeparator()));
+                }
+                attributes.insert("ProcessingTime", job->processingTime());
+                attributes.insert("Quality", job->getPrintQuality().name);
+                attributes.insert("OutputOrder", job->reverse() ? "Reverse" : "Normal");
+                attributes.insert("State", static_cast<int>(job->state()));
+                attributes.insert("Size", job->size());
+                attributes.insert("User", job->user());
+
+                break;
+            }
+        }
+
+        return attributes;
     }
 
     virtual QString printerName() const override
@@ -209,6 +278,11 @@
         return m_makeAndModel;
     }
 
+    virtual bool isRemote() const override
+    {
+        return m_remote;
+    }
+
     virtual PrinterEnum::State state() const override
     {
         return m_state;
@@ -287,6 +361,17 @@
         m_requestedPrinters << printerName;
     }
 
+    virtual void requestJobExtendedAttributes(QSharedPointer<Printer> printer, QSharedPointer<PrinterJob> job) override
+    {
+        QMap<QString, QVariant> attributes = printerGetJobAttributes(printer->name(), job->jobId());
+
+        Q_EMIT jobLoaded(printer->name(), job->jobId(), attributes);
+    }
+
+    virtual PrinterEnum::PrinterType type() const override
+    {
+        return m_type;
+    }
 
     void mockPrinterAdded(
         const QString &text,
@@ -339,6 +424,34 @@
         );
     }
 
+    void mockJobCompleted(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+    {
+        Q_EMIT jobCompleted(
+            text, printer_uri, printer_name, printer_state,
+            printer_state_reasons, printer_is_accepting_jobs, job_id,
+            job_state, job_state_reasons, job_name, job_impressions_completed
+        );
+    }
+
+    void mockJobState(
+        const QString &text, const QString &printer_uri,
+        const QString &printer_name, uint printer_state,
+        const QString &printer_state_reasons, bool printer_is_accepting_jobs,
+        uint job_id, uint job_state, const QString &job_state_reasons,
+        const QString &job_name, uint job_impressions_completed)
+    {
+        Q_EMIT jobState(
+            text, printer_uri, printer_name, printer_state,
+            printer_state_reasons, printer_is_accepting_jobs, job_id,
+            job_state, job_state_reasons, job_name, job_impressions_completed
+        );
+    }
+
     void mockDriversLoaded(const QList<PrinterDriver> &drivers)
     {
         Q_EMIT printerDriversLoaded(drivers);
@@ -354,6 +467,11 @@
         Q_EMIT printerLoaded(printer);
     }
 
+    void mockDeviceFound(const Device &device)
+    {
+        Q_EMIT deviceFound(device);
+    }
+
     QString returnValue = QString::null;
 
     // Map from printer to key/val.
@@ -366,6 +484,9 @@
     QMap<QString, PrinterEnum::ErrorPolicy> errorPolicies;
     QMap<QString, PrinterEnum::OperationPolicy> operationPolicies;
 
+    bool m_holdsDefinition = true;
+    bool m_remote = false;
+
     QString m_description = QString::null;
     QString m_location = QString::null;
     QString m_makeAndModel = QString::null;
@@ -383,6 +504,8 @@
     QList<QSharedPointer<PrinterJob>> m_jobs;
     QStringList m_requestedPrinters;
 
+    PrinterEnum::PrinterType m_type = PrinterEnum::PrinterType::ProxyType;
+
 Q_SIGNALS:
     void printToFile(const QString &filepath, const QString &title);
 };

=== added directory 'tests/unittests/Printers/testdata'
=== added directory 'tests/unittests/Printers/testdata/cups'
=== added directory 'tests/unittests/Printers/testdata/cups/data'
=== added file 'tests/unittests/Printers/testdata/cups/data/default-testpage.pdf'
=== modified file 'tests/unittests/Printers/tst_jobfilter.cpp'
--- tests/unittests/Printers/tst_jobfilter.cpp	2017-02-21 10:46:29 +0000
+++ tests/unittests/Printers/tst_jobfilter.cpp	2017-03-20 13:32:24 +0000
@@ -32,10 +32,12 @@
         QScopedPointer<MockPrinterBackend> backend(new MockPrinterBackend);
         JobModel model(backend.data());
 
-        auto job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend.data()));
+        auto job = QSharedPointer<PrinterJob>(
+            new PrinterJob("test-printer", backend.data(), 100)
+        );
         backend->m_jobs << job;
         // Trigger update.
-        backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        backend->mockJobCreated("", "", "test-printer", 1, "", true, 100, 3, "", "", 1);
 
         JobFilter filter;
         filter.setSourceModel(&model);

=== modified file 'tests/unittests/Printers/tst_jobmodel.cpp'
--- tests/unittests/Printers/tst_jobmodel.cpp	2017-02-21 10:46:29 +0000
+++ tests/unittests/Printers/tst_jobmodel.cpp	2017-03-20 13:32:24 +0000
@@ -18,12 +18,14 @@
 
 #include "backend/backend.h"
 #include "models/jobmodel.h"
+#include "printers/printers.h"
 
 #include <QDebug>
 #include <QObject>
 #include <QSignalSpy>
 #include <QTest>
 
+
 class TestJobModel : public QObject
 {
     Q_OBJECT
@@ -31,15 +33,23 @@
     void init()
     {
         m_backend = new MockPrinterBackend;
-        m_model = new JobModel(m_backend);
+        m_printers = new Printers(m_backend);
+
+        m_model = static_cast<JobModel *>(m_printers->printJobs());
+
+        PrinterBackend* backend = new MockPrinterBackend("test-printer");
+        auto printer = QSharedPointer<Printer>(new Printer(backend));
+        m_backend->mockPrinterLoaded(printer);
     }
     void cleanup()
     {
-        QSignalSpy destroyedSpy(m_model, SIGNAL(destroyed(QObject*)));
-        m_model->deleteLater();
+        QSignalSpy destroyedSpy(m_printers, SIGNAL(destroyed(QObject*)));
+        m_printers->deleteLater();
         QTRY_COMPARE(destroyedSpy.count(), 1);
-        delete m_backend;
     }
+
+    // Tests for adding/removing/changing things in the model
+
     void testInsert()
     {
         QSignalSpy countSpy(m_model, SIGNAL(countChanged()));
@@ -68,7 +78,7 @@
         catchall handler in the model. */
         QSignalSpy removeSpy(m_model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)));
         m_backend->m_jobs.clear();
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+        m_backend->mockJobCompleted("", "", "", 1, "", true, 100, 1, "", "", 1);
         QCOMPARE(removeSpy.count(), 1);
 
         // Check item was removed
@@ -76,44 +86,451 @@
         QCOMPARE(args.at(1).toInt(), 0);
         QCOMPARE(args.at(2).toInt(), 0);
     }
-    void testMove()
-    {
-        // Add two jobs.
-        auto job1 = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
-        auto job2 = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
-        m_backend->m_jobs << job1 << job2;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
-
-        m_backend->m_jobs.move(0, 1);
-        // Triggers a move.
-        QSignalSpy moveSpy(m_model, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)));
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
-        QCOMPARE(moveSpy.count(), 1);
-        QList<QVariant> args = moveSpy.at(0);
-        QCOMPARE(args.at(1).toInt(), 1);
-        QCOMPARE(args.at(2).toInt(), 1);
-        QCOMPARE(args.at(4).toInt(), 0);
-    }
     void testModify()
     {
         auto jobBefore = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        int impressions_count = 1;
 
         m_backend->m_jobs << jobBefore;
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
-
-        auto jobAfter = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
-        jobAfter->setCopies(100);
-        m_backend->m_jobs.replace(0, jobAfter);
+        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", impressions_count);
 
         // Triggers a change.
         QSignalSpy changedSpy(m_model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&, const QVector<int>&)));
-        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+
+        impressions_count = 5;
+        m_backend->mockJobState("", "", "", 1, "", true, 100, 1, "", "", impressions_count);
+
         QCOMPARE(changedSpy.count(), 1);
     }
 
+    // Tests for the roles in the model exposed to QML
+
+    void testIdRole()
+    {
+        auto job = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 100));
+        m_backend->m_jobs << job;
+        m_backend->mockJobCreated("", "", "", 1, "", true, 100, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 1);
+        QCOMPARE(job->jobId(), 100);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::IdRole).toInt(), 100);
+    }
+    void testCollateRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setCollate(false);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setCollate(true);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::CollateRole).toBool(), false);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::CollateRole).toBool(), true);
+    }
+    void testColorModelRole()
+    {
+        // FIXME: read comment in JobModel::updateJob
+        QSKIP("We are ignoring colorModel for now as it requires a loaded Printer for the PrinterJob.");
+
+        ColorModel a;
+        a.name = "KGray";
+        a.text = "Gray";
+
+        ColorModel b;
+        b.name = "RGB";
+        b.text = "";
+        QList<ColorModel> models({a, b});
+
+        PrinterBackend* backend = new MockPrinterBackend("a-printer");
+        ((MockPrinterBackend*) backend)->printerOptions["a-printer"].insert(
+            "SupportedColorModels", QVariant::fromValue(models)
+        );
+
+        auto printer = QSharedPointer<Printer>(new Printer(backend));
+        m_backend->mockPrinterLoaded(printer);
+//        m_printers->m_printers << printer;
+
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("a-printer", backend, 1));
+        jobA->setPrinter(printer);
+        jobA->loadDefaults();
+        jobA->setColorModel(models.indexOf(a));
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("a-printer", backend, 2));
+        jobB->setPrinter(printer);
+        jobB->loadDefaults();
+        jobB->setColorModel(models.indexOf(b));
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::ColorModelRole).toString(),
+                 a.text);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::ColorModelRole).toString(),
+                 b.name);
+    }
+    void testCompletedTimeRole()
+    {
+        QDateTime dateTimeA = QDateTime::currentDateTime();
+        QDateTime dateTimeB = QDateTime::currentDateTime().addSecs(100);
+
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setCompletedTime(dateTimeA);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setCompletedTime(dateTimeB);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::CompletedTimeRole).toDateTime(),
+                 dateTimeA);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::CompletedTimeRole).toDateTime(),
+                 dateTimeB);
+    }
+    void testCopiesRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setCopies(2);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setCopies(5);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::CopiesRole).toInt(), 2);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::CopiesRole).toInt(), 5);
+    }
+    void testCreationTimeRole()
+    {
+        QDateTime dateTimeA = QDateTime::currentDateTime();
+        QDateTime dateTimeB = QDateTime::currentDateTime().addSecs(100);
+
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setCreationTime(dateTimeA);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setCreationTime(dateTimeB);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::CreationTimeRole).toDateTime(),
+                 dateTimeA);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::CreationTimeRole).toDateTime(),
+                 dateTimeB);
+    }
+    void testDuplexRole()
+    {
+        // FIXME: read comment in JobModel::updateJob
+        QSKIP("We are ignoring duplex for now as it requires a loaded Printer for the PrinterJob.");
+
+        QList<PrinterEnum::DuplexMode> modes({
+            PrinterEnum::DuplexMode::DuplexNone,
+            PrinterEnum::DuplexMode::DuplexLongSide,
+            PrinterEnum::DuplexMode::DuplexShortSide,
+        });
+
+        ((MockPrinterBackend*) m_backend)->m_supportedDuplexModes = modes;
+
+        PrinterBackend* backend = new MockPrinterBackend("test-printer");
+        ((MockPrinterBackend*) backend)->m_supportedDuplexModes = modes;
+
+        auto printer = QSharedPointer<Printer>(new Printer(backend));
+        m_backend->mockPrinterLoaded(printer);
+
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend, 1));
+        jobA->setPrinter(printer);
+        jobA->setDuplexMode(modes.indexOf(PrinterEnum::DuplexMode::DuplexLongSide));
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", backend, 2));
+        jobB->setPrinter(printer);
+        jobB->setDuplexMode(modes.indexOf(PrinterEnum::DuplexMode::DuplexNone));
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::DuplexRole).toString(),
+                 Utils::duplexModeToUIString(PrinterEnum::DuplexMode::DuplexLongSide));
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::DuplexRole).toString(),
+                 Utils::duplexModeToUIString(PrinterEnum::DuplexMode::DuplexNone));
+    }
+    void testHeldRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setState(PrinterEnum::JobState::Pending);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setState(PrinterEnum::JobState::Held);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, static_cast<uint>(jobA->state()), "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, static_cast<uint>(jobB->state()), "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::HeldRole).toBool(), false);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::HeldRole).toBool(), true);
+    }
+    void testImpressionsCompletedRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setImpressionsCompleted(2);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setImpressionsCompleted(5);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", jobA->impressionsCompleted());
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", jobB->impressionsCompleted());
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::ImpressionsCompletedRole).toInt(), 2);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::ImpressionsCompletedRole).toInt(), 5);
+    }
+    void testLandscapeRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setLandscape(false);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setLandscape(true);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::LandscapeRole).toBool(), false);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::LandscapeRole).toBool(), true);
+    }
+    void testMessagesRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setMessages(QStringList() << "a-message" << "b-message");
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setMessages(QStringList() << "c-message" << "d-message");
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::MessagesRole).toStringList(),
+                 QStringList() << "a-message" << "b-message");
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::MessagesRole).toStringList(),
+                 QStringList() << "c-message" << "d-message");
+    }
+    void testPrinterNameRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("a-printer", m_backend, 1));
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("b-printer", m_backend, 2));
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "b-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::PrinterNameRole).toString(), QString("a-printer"));
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::PrinterNameRole).toString(), QString("b-printer"));
+    }
+    void testPrintRangeRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setPrintRange("1-3,5");
+        jobA->setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setPrintRange("-3,6,10-");
+        jobB->setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::PrintRangeRole).toString(), QString("1-3,5"));
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::PrintRangeRole).toString(), QString("-3,6,10-"));
+    }
+    void testPrintRangeModeRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setPrintRangeMode(PrinterEnum::PrintRange::AllPages);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setPrintRange("1-3");
+        jobB->setPrintRangeMode(PrinterEnum::PrintRange::PageRange);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::PrintRangeModeRole).value<PrinterEnum::PrintRange>(), PrinterEnum::PrintRange::AllPages);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::PrintRangeModeRole).value<PrinterEnum::PrintRange>(), PrinterEnum::PrintRange::PageRange);
+    }
+    void testProcessingTimeRole()
+    {
+        QDateTime dateTimeA = QDateTime::currentDateTime();
+        QDateTime dateTimeB = QDateTime::currentDateTime().addSecs(100);
+
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setProcessingTime(dateTimeA);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setProcessingTime(dateTimeB);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::ProcessingTimeRole).toDateTime(),
+                 dateTimeA);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::ProcessingTimeRole).toDateTime(),
+                 dateTimeB);
+    }
+    void testQualityRole()
+    {
+        // FIXME: read comment in JobModel::updateJob
+        QSKIP("We are ignoring quality for now as it requires a loaded Printer for the PrinterJob.");
+
+        PrintQuality a;
+        a.name = "fast-draft";
+        a.text = "Draft";
+
+        PrintQuality b;
+        b.name = "normal";
+        b.text = "";
+        QList<PrintQuality> qualities({a, b});
+
+        PrinterBackend *backend = new MockPrinterBackend("a-printer");
+        ((MockPrinterBackend*) backend)->printerOptions["a-printer"].insert(
+            "SupportedPrintQualities", QVariant::fromValue(qualities)
+        );
+
+        auto printer = QSharedPointer<Printer>(new Printer(backend));
+        m_backend->mockPrinterLoaded(printer);
+
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("a-printer", backend, 1));
+        jobA->setPrinter(printer);
+        jobA->setQuality(qualities.indexOf(a));
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("a-printer", backend, 2));
+        jobB->setPrinter(printer);
+        jobB->setQuality(qualities.indexOf(b));
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "a-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::QualityRole).toString(),
+                 a.text);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::QualityRole).toString(),
+                 b.name);
+    }
+    void testReverseRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setReverse(false);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setReverse(true);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::ReverseRole).toBool(), false);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::ReverseRole).toBool(), true);
+    }
+    void testSizeRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setSize(32);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setSize(64);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::SizeRole).toInt(), 32);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::SizeRole).toInt(), 64);
+    }
+    void testStateRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setState(PrinterEnum::JobState::Pending);
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setState(PrinterEnum::JobState::Processing);
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, static_cast<uint>(jobA->state()), "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, static_cast<uint>(jobB->state()), "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::StateRole).value<PrinterEnum::JobState>(), PrinterEnum::JobState::Pending);
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::StateRole).value<PrinterEnum::JobState>(), PrinterEnum::JobState::Processing);
+    }
+    void testTitleRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setTitle("a-job");
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setTitle("b-job");
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", jobA->title(), 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", jobB->title(), 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::TitleRole).toString(), QString("a-job"));
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::TitleRole).toString(), QString("b-job"));
+    }
+    void testUserRole()
+    {
+        auto jobA = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 1));
+        jobA->setUser("a-user");
+
+        auto jobB = QSharedPointer<PrinterJob>(new PrinterJob("test-printer", m_backend, 2));
+        jobB->setUser("b-user");
+
+        m_backend->m_jobs << jobA << jobB;
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 1, 1, "", "", 1);
+        m_backend->mockJobCreated("", "", "test-printer", 1, "", true, 2, 1, "", "", 1);
+
+        QTRY_COMPARE(m_model->count(), 2);
+        QCOMPARE(m_model->data(m_model->index(0), JobModel::UserRole).toString(), QString("a-user"));
+        QCOMPARE(m_model->data(m_model->index(1), JobModel::UserRole).toString(), QString("b-user"));
+    }
+
 private:
     MockPrinterBackend *m_backend;
     JobModel *m_model;
+    Printers *m_printers;
 };
 
 QTEST_GUILESS_MAIN(TestJobModel)

=== modified file 'tests/unittests/Printers/tst_printer.cpp'
--- tests/unittests/Printers/tst_printer.cpp	2017-02-21 10:46:29 +0000
+++ tests/unittests/Printers/tst_printer.cpp	2017-03-20 13:32:24 +0000
@@ -60,6 +60,54 @@
         m_instance->setDescription(desc);
         QCOMPARE(m_backend->infos.value(m_printerName), desc);
     }
+    void testDeviceUri()
+    {
+        MockPrinterBackend *backend = new MockPrinterBackend(m_printerName);
+        backend->printerOptions[m_printerName].insert(
+            "DeviceUri", "/dev/null");
+        Printer p(backend);
+        QCOMPARE(p.deviceUri(), (QString) "/dev/null");
+    }
+    void testLastMessage()
+    {
+        MockPrinterBackend *backend = new MockPrinterBackend(m_printerName);
+        backend->printerOptions[m_printerName].insert(
+            "StateMessage", "died");
+        Printer p(backend);
+        QCOMPARE(p.lastMessage(), (QString) "died");
+    }
+    void testMakeModel()
+    {
+        m_backend->m_makeAndModel = "make and model";
+        QCOMPARE(m_instance->make(), m_backend->makeAndModel());
+    }
+    void testLocation()
+    {
+        m_backend->m_location = "location";
+        QCOMPARE(m_instance->location(), m_backend->location());
+    }
+    void testCopies()
+    {
+        MockPrinterBackend *backend = new MockPrinterBackend(m_printerName);
+        backend->printerOptions[m_printerName].insert("Copies", "2");
+        Printer p(backend);
+        QCOMPARE(p.copies(), 2);
+    }
+    void testSetCopies()
+    {
+        MockPrinterBackend *backend = new MockPrinterBackend(m_printerName);
+        backend->printerOptions[m_printerName].insert("Copies", "2");
+        Printer p(backend);
+        p.setCopies(5);
+        QCOMPARE(backend->printerOptions[m_printerName].value("Copies").toInt(), 5);
+    }
+    void testRemote()
+    {
+        m_backend->m_remote = false;
+        QCOMPARE(m_instance->isRemote(), m_backend->isRemote());
+        m_backend->m_remote = true;
+        QCOMPARE(m_instance->isRemote(), m_backend->isRemote());
+    }
     void testSupportedDuplexModes_data()
     {
         QTest::addColumn<QList<PrinterEnum::DuplexMode>>("modes");
@@ -263,6 +311,32 @@
         p2.setAcceptJobs(false);
         QVERIFY(!backend->printerOptions[m_printerName]["AcceptJobs"].toBool());
     }
+    void testShared()
+    {
+        MockPrinterBackend *backend = new MockPrinterBackend(m_printerName);
+
+        backend->printerOptions[m_printerName].insert("Shared", false);
+        Printer p(backend);
+        QVERIFY(!p.shared());
+
+        backend->printerOptions[m_printerName].insert("Shared", true);
+        Printer p2(backend);
+        QVERIFY(p2.shared());
+    }
+    void testSetShared()
+    {
+        MockPrinterBackend *backend = new MockPrinterBackend(m_printerName);
+
+        backend->printerOptions[m_printerName].insert("Shared", false);
+        Printer p(backend);
+        p.setShared(true);
+        QVERIFY(backend->printerOptions[m_printerName]["Shared"].toBool());
+
+        backend->printerOptions[m_printerName].insert("Shared", true);
+        Printer p2(backend);
+        p2.setShared(false);
+        QVERIFY(!backend->printerOptions[m_printerName]["Shared"].toBool());
+    }
     void testJobs()
     {