Merge lp:~ahayzen/ubuntu-ui-extras/job-impressions-update into lp:~phablet-team/ubuntu-ui-extras/printer-staging

[Andrew Hayzen]

* Connect job-impressions-completed from cups to PrinterJob::impressionsCompleted()
* In the job model listen to printerStateChanged as changes t job-impressions-completed causes that signal
* Improve the PrinterSignalHandler to limit the maximum wait time of unprocessed signals to four times the timeout
* Add unit test for SignalRateLimiter to check it does perform a flush
* Rename PrinterSignalHandler to SignalRateLimiter

* Connect job-impressions-completed from cups to PrinterJob::impressionsCompleted()
* In the job model listen to printerStateChanged as changes t job-impressions-completed causes that signal
* Improve the PrinterSignalHandler to limit the maximum wait time of unprocessed signals to four times the timeout
* Add unit test for SignalRateLimiter to check it does perform a flush
* Rename PrinterSignalHandler to SignalRateLimiter

[lp:~ahayzen/ubuntu-ui-extras/job-impressions-update]

148. By Andrew Hayzen on 2017-03-09

* Show impressions in the PrinterQueue.qml

[Andrew Hayzen (ahayzen)]

Testing:
- Add a printer which has an address of lpd://127.0.0.1 so that it will spool on the cups server
- Download the serverguide.pdf (which has loads of pages) from [0]
- Open the PrinterQueue.qml example and open the printer you just added
- Add the serverguide.pdf to the printer queue for the printer you just added
- Watch the printing N pages count increment (also note the freezes that happen, eg if there is already a job being rendered when starting the example it can freeze)

0 - http://bazaar.launchpad.net/~ubuntu-docviewer-dev/ubuntu-docviewer-app/lo-viewer/download/head:/serverguide.pdf-20150423201617-20cgubqqf8rhokei-1/serverguide.pdf

[Andrew Hayzen (ahayzen)]

Should job-media-sheets-completed be used instead of job-impressesions-completed? Does this then take duplex into account?

review: Needs Information

[Jonas G. Drange (jonas-drange)]

ack on the rate limiter! good stuff

[Jonas G. Drange (jonas-drange)]

Re: job-media-*, I'd have to read the IPP spec to be sure. Maybe mimic SCP here?

[lp:~ahayzen/ubuntu-ui-extras/job-impressions-update]

149. By Andrew Hayzen on 2017-03-10

* Merge of upstream

[Jonas G. Drange (jonas-drange)]

Got this one:
void PrinterJob::loadDefaults() 12
QObject::connect: Cannot queue arguments of type 'QVector<int>'
(Make sure 'QVector<int>' is registered using qRegisterMetaType().)

Introduced by this branch?

review: Needs Information

[Jonas G. Drange (jonas-drange)]

The window only freezes, no queues are displayed. I think we need to fix that.

And the freezing is introduced by this branch, because using printer-staging trunk, going to Printers.qml -> <printer> -> Jobs enumerates the jobs without the lag.

review: Needs Fixing

[lp:~ahayzen/ubuntu-ui-extras/job-impressions-update]

150. By Andrew Hayzen on 2017-03-13

* Rebase ontop of lp:~ahayzen/ubuntu-ui-extras/job-model-split-update

151. By Andrew Hayzen on 2017-03-13

* Pull of upstream

152. By Andrew Hayzen on 2017-03-13

* Use job-state from extendedJobAttributes so that when there is a signal flood the state is correct

153. By Andrew Hayzen on 2017-03-14

* Pull of upstream

154. By Andrew Hayzen on 2017-03-14

* Try to use job-media-sheets-completed first

155. By Andrew Hayzen on 2017-03-15

* Pull of upstream
* Fix tests (emulation in MockBackend::printerGetJobAttributes)

156. By Andrew Hayzen on 2017-03-15

* Pull of upstream

Unmerged revisions

=== modified file 'modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml'
--- modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml	2017-03-01 13:45:14 +0000
+++ modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml	2017-03-13 12:51:30 +0000
@@ -72,10 +72,7 @@
                     ListItemLayout {
                         id: modelLayout
                         title.text: displayName
-                        subtitle.text: model.title + " (" + 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
                     }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt'
--- modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt	2017-03-08 14:47:16 +0000
+++ modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt	2017-03-13 12:51:30 +0000
@@ -31,6 +31,7 @@
 
     cups/devicesearcher.cpp
     cups/ippclient.cpp
+    cups/jobloader.cpp
     cups/printerdriverloader.cpp
     cups/printerloader.cpp
 
@@ -41,7 +42,7 @@
 
     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-03-06 15:29:04 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp	2017-03-13 12:51:30 +0000
@@ -174,6 +174,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)
 {
@@ -273,6 +281,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-03-09 14:34:05 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend.h	2017-03-13 12:51:30 +0000
@@ -85,6 +85,8 @@
                                 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);
 
@@ -110,6 +112,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);
 
@@ -124,6 +128,8 @@
     void printerDriversLoaded(const QList<PrinterDriver> &drivers);
     void printerDriversFailedToLoad(const QString &errorMessage);
 
+    void jobLoaded(QSharedPointer<PrinterJob> oldJob,
+                   QSharedPointer<PrinterJob> newJob);
     void printerLoaded(QSharedPointer<Printer> printers);
     void deviceFound(const Device &device);
     void deviceSearchFinished();

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp	2017-03-09 14:34:05 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp	2017-03-13 12:51:30 +0000
@@ -16,6 +16,7 @@
 
 #include "backend/backend_cups.h"
 #include "cups/devicesearcher.h"
+#include "cups/jobloader.h"
 #include "cups/printerdriverloader.h"
 #include "cups/printerloader.h"
 #include "utils.h"
@@ -455,12 +456,30 @@
         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(""));
     }
 
+    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 {
@@ -480,6 +499,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>()) {
@@ -497,6 +522,18 @@
         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 (__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;
@@ -516,32 +553,16 @@
     auto jobs = getCupsJobs();
     QList<QSharedPointer<PrinterJob>> list;
 
+    // TODO: once printerGetJob() only gets a single job
+    // use that to build PrinterJob
     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);
     }
@@ -551,6 +572,38 @@
     return list;
 }
 
+QSharedPointer<PrinterJob> PrinterCupsBackend::printerGetJob(
+        const QString &printerName, const int jobId)
+{
+    // FIXME: this gets all the jobs for the printer
+    // can we get a single one?
+    // instead can we ask via IPP?
+    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;
@@ -662,6 +715,34 @@
     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(printer, job, this);
+    loader->moveToThread(thread);
+    connect(thread, SIGNAL(started()), loader, SLOT(load()));
+    connect(loader, SIGNAL(finished()), thread, SLOT(quit()));
+    connect(loader, SIGNAL(finished()), loader, SLOT(deleteLater()));
+    connect(loader, SIGNAL(loaded(QSharedPointer<PrinterJob>, QSharedPointer<PrinterJob>)),
+            this, SIGNAL(jobLoaded(QSharedPointer<PrinterJob>, QSharedPointer<PrinterJob>)));
+    connect(loader, SIGNAL(printerLoaded(QSharedPointer<Printer>)),
+            this, SIGNAL(printerLoaded(QSharedPointer<Printer>)));
+    connect(loader, SIGNAL(loaded(QSharedPointer<PrinterJob>, QSharedPointer<PrinterJob>)),
+            this, SLOT(onJobLoaded(QSharedPointer<PrinterJob>, QSharedPointer<PrinterJob>)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
+    m_activeJobRequests << pair;
+
+    thread->start();
+}
+
 void PrinterCupsBackend::requestPrinter(const QString &printerName)
 {
     if (m_activeRequests.contains(printerName)) {
@@ -679,9 +760,10 @@
     connect(loader, SIGNAL(loaded(QSharedPointer<Printer>)),
             this, SLOT(onPrinterLoaded(QSharedPointer<Printer>)));
     connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
-    thread->start();
 
     m_activeRequests << printerName;
+
+    thread->start();
 }
 
 void PrinterCupsBackend::requestPrinterDrivers()
@@ -698,6 +780,7 @@
     connect(loader, SIGNAL(loaded(const QList<PrinterDriver>&)),
             this, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)));
     connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+
     thread->start();
 }
 
@@ -788,6 +871,15 @@
     return m_extendedAttributeNames.contains(attributeName);
 }
 
+void PrinterCupsBackend::onJobLoaded(QSharedPointer<PrinterJob> oldJob,
+                                     QSharedPointer<PrinterJob> newJob)
+{
+    Q_UNUSED(newJob);
+
+    QPair<QString, int> pair(oldJob->printerName(), oldJob->jobId());
+    m_activeJobRequests.remove(pair);
+}
+
 void PrinterCupsBackend::onPrinterLoaded(QSharedPointer<Printer> printer)
 {
     m_activeRequests.remove(printer->name());

=== modified file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h	2017-03-08 11:30:48 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h	2017-03-13 12:51:30 +0000
@@ -79,6 +79,8 @@
                                 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;
@@ -101,6 +103,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(
@@ -141,8 +147,11 @@
     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<QPair<QString, int>> m_activeJobRequests;
 
 private Q_SLOTS:
+    void onJobLoaded(QSharedPointer<PrinterJob> oldJob,
+                     QSharedPointer<PrinterJob> newJob);
     void onPrinterLoaded(QSharedPointer<Printer> printer);
 };
 

=== 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-13 12:51:30 +0000
@@ -0,0 +1,90 @@
+/*
+ * 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_cups.h"
+
+#include "cups/ippclient.h"
+#include "cupsdnotifier.h" // Note: this file was generated.
+
+#include "printers/printers.h"
+
+#include <QDBusConnection>
+#include <QPrinterInfo>
+
+class PrinterCupsBackend;
+JobLoader::JobLoader(QSharedPointer<Printer> printer,
+                     QSharedPointer<PrinterJob> printerJob,
+                     PrinterBackend *backend,
+                     QObject *parent)
+    : QObject(parent)
+    , m_backend(backend)
+    , m_job(printerJob)
+    , m_printer(printer)
+{
+}
+
+JobLoader::~JobLoader()
+{
+}
+
+void JobLoader::load()
+{
+    QSharedPointer<Printer> printer;
+    PrinterBackend *backend;
+
+    // FIXME: always build a new Printer and IppClient as it isn't thread safe
+    if (true || m_printer->type() == PrinterEnum::PrinterType::ProxyType) {
+        IppClient *client = new IppClient();
+        OrgCupsCupsdNotifierInterface* notifier = new OrgCupsCupsdNotifierInterface(
+                    "", CUPSD_NOTIFIER_DBUS_PATH, QDBusConnection::systemBus());
+        QPrinterInfo info = QPrinterInfo::printerInfo(m_printer->name());
+
+        backend = new PrinterCupsBackend(client, info, notifier);
+        printer = QSharedPointer<Printer>(new Printer(backend));
+    } else {
+        backend = m_backend;
+        printer = m_printer;
+    }
+
+    // Construct a job
+    QSharedPointer<PrinterJob> job = QSharedPointer<PrinterJob>(
+        new PrinterJob(m_printer->name(), backend, m_job->jobId())
+    );
+
+    // Copy things that we don't set in extended attributes
+    job->setImpressionsCompleted(m_job->impressionsCompleted());
+    job->setState(m_job->state());
+    job->setTitle(m_job->title());
+
+    // Set the printer for this thread
+    job->setPrinter(printer);
+
+    // Load the extended attributes of the job
+    job->loadDefaults();
+
+    Q_EMIT loaded(m_job, job);
+
+    // If the given Printer was not loaded expose our loaded one
+    // FIXME: for now skip this, need to check if having different
+    // notifier/ippClient/backend could cause issues?
+    if (false && m_printer->type() == PrinterEnum::PrinterType::ProxyType) {
+        Q_EMIT printerLoaded(printer);
+    }
+
+    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-13 12:51:30 +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/>.
+ */
+
+#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;
+    QSharedPointer<PrinterJob> m_job;
+    QSharedPointer<Printer> m_printer;
+public:
+    explicit JobLoader(QSharedPointer<Printer> printer,
+                       QSharedPointer<PrinterJob> printerJob,
+                       PrinterBackend *backend,
+                       QObject *parent = Q_NULLPTR);
+    ~JobLoader();
+
+public Q_SLOTS:
+    void load();
+
+Q_SIGNALS:
+    void finished();
+    void loaded(QSharedPointer<PrinterJob> oldJob,
+                QSharedPointer<PrinterJob> newJob);
+    void printerLoaded(QSharedPointer<Printer> printer);
+};
+
+#endif // USC_PRINTERS_CUPS_JOBLOADER_H

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp	2017-03-06 13:19:08 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp	2017-03-13 12:51:30 +0000
@@ -31,113 +31,184 @@
     : 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(QSharedPointer<PrinterJob>, QSharedPointer<PrinterJob>)),
+            this, SLOT(updateJob(QSharedPointer<PrinterJob>, QSharedPointer<PrinterJob>)));
+
+    // 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
+    // FIXME: 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)
+{
+    qDebug() << Q_FUNC_INFO << printerName;
+
+    // Find the active job and force a refresh
+    Q_FOREACH(auto job, m_jobs) {
+        if (job->printerName() == printerName
+                && job->state() == PrinterEnum::JobState::Processing) {
+            qDebug() << Q_FUNC_INFO << "Forcing refresh" << job->jobId();
+            Q_EMIT forceJobRefresh(printerName, job->jobId());
+        }
+    }
+}
+
+void JobModel::addJob(QSharedPointer<PrinterJob> job)
+{
+    int i = m_jobs.size();
+    qDebug() << Q_FUNC_INFO << job->jobId() << i;
+
+    beginInsertRows(QModelIndex(), i, i);
+    m_jobs.append(job);
+    endInsertRows();
+
+    Q_EMIT countChanged();
+}
+
+void JobModel::removeJob(QSharedPointer<PrinterJob> job)
+{
+    qDebug() << Q_FUNC_INFO << job->jobId();
+    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)
+{
+    qDebug() << Q_FUNC_INFO << job->jobId();
+
+    int i = m_jobs.indexOf(job);
+    QModelIndex idx = index(i);
+    Q_EMIT dataChanged(idx, idx);
+}
+
+// This is used by JobLoader as it creates a new job to prevent threading issues
+void JobModel::updateJob(QSharedPointer<PrinterJob> oldJob,
+                         QSharedPointer<PrinterJob> newJob)
+{
+    qDebug() << Q_FUNC_INFO << oldJob->jobId() << newJob->jobId();
+
+    int i = m_jobs.indexOf(oldJob);
+    QModelIndex idx = index(i);
+
+    if (i > -1) {
+        // Copy the preloaded Printer (?) so that JobModel always shows correct
+        // attributes, eg colorModel needs Printer::supportedColorModels
+        //
+        // FIXME: does it break anything as the Printer is not from PrinterModel
+        // Maybe all comparisions should just use printerName() ?
+        oldJob->setPrinter(newJob->printer());
+
+        oldJob->updateFrom(newJob);
+        Q_EMIT dataChanged(idx, idx);
+    } else {
+        qWarning() << "Tried to updateJob which doesn't exist:" << newJob->printerName() << newJob->jobId();
     }
 }
 
@@ -307,10 +378,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;
         }
     }

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h	2017-03-06 13:19:08 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h	2017-03-13 12:51:30 +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
@@ -76,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);
+public Q_SLOTS:
+    void updateJob(QSharedPointer<PrinterJob> oldJob,
+                   QSharedPointer<PrinterJob> newJob);
 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);
 
 Q_SIGNALS:
     void countChanged();
+    void forceJobRefresh(const QString &printerName, const int jobId);
 };
 
 class PRINTERS_DECL_EXPORT JobFilter : public QSortFilterProxyModel

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp	2017-03-06 15:29:04 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp	2017-03-13 12:51:30 +0000
@@ -32,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);
 
@@ -127,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);

=== modified file 'modules/Ubuntu/Components/Extras/Printers/models/printermodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/printermodel.h	2017-03-06 15:29:04 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/printermodel.h	2017-03-13 12:51:30 +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>
@@ -98,13 +98,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);

=== modified file 'modules/Ubuntu/Components/Extras/Printers/plugin.cpp'
--- modules/Ubuntu/Components/Extras/Printers/plugin.cpp	2017-03-08 11:29:01 +0000
+++ modules/Ubuntu/Components/Extras/Printers/plugin.cpp	2017-03-13 12:51:30 +0000
@@ -54,6 +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-03-09 15:50:41 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printer.cpp	2017-03-13 12:51:30 +0000
@@ -379,10 +379,20 @@
 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;
-
-    loadAttributes();
 }
 
 void Printer::onPrinterStateChanged(

=== 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-13 12:51:30 +0000
@@ -150,8 +150,6 @@
         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
@@ -165,11 +163,15 @@
         // 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) {
+            if (m_printer->supportedColorModels().at(i).name == colorModel) {
                 setColorModel(i);
             }
         }
 
+        // TODO: do we need to set timezone?
+        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);
@@ -179,6 +181,7 @@
             }
         }
 
+        setImpressionsCompleted(attributes.value("impressionsCompleted").toInt());
         setLandscape(attributes.value("landscape").toBool());
         setMessages(attributes.value("messages").toStringList());
 
@@ -192,6 +195,11 @@
             setPrintRange(pageRanges.join(QLocale::system().groupSeparator()));
         }
 
+        // TODO: do we need timezone?
+//        processingTime.setTimeZone(QTimeZone::systemTimeZone());
+//        processingTime.setTime_t(cupsJob->processing_time);
+        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++) {
@@ -201,11 +209,13 @@
         }
 
         setReverse(attributes.value("OutputOrder").toString() == "Reverse");
+        setSize(attributes.value("Size").toInt());
+        setUser(attributes.value("User").toString());
+    } 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
@@ -382,7 +392,6 @@
 
        Q_EMIT printerChanged();
    }
-   loadDefaults();
 }
 
 void PrinterJob::setPrintRange(const QString &printRange)
@@ -478,30 +487,44 @@
     // 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

=== modified file 'modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h'
--- modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h	2017-03-01 14:17:52 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printer/printerjob.h	2017-03-13 12:51:30 +0000
@@ -95,6 +95,7 @@
     PrinterEnum::DuplexMode getDuplexMode() const;
     ColorModel getColorModel() const;
     PrintQuality getPrintQuality() const;
+    void loadDefaults();
     Q_INVOKABLE void printFile(const QUrl &url);
     void setCollate(const bool collate);
     void setColorModel(const int colorModel);
@@ -118,8 +119,6 @@
     void setUser(const QString &user);
 
     void updateFrom(QSharedPointer<PrinterJob> other);
-private Q_SLOTS:
-    void loadDefaults();
 Q_SIGNALS:
     void collateChanged();
     void colorModelChanged();

=== 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-13 12:51:30 +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-13 12:51:30 +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-03-09 14:34:05 +0000
+++ modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp	2017-03-13 12:51:30 +0000
@@ -58,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(
@@ -78,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();
     }
@@ -271,8 +294,13 @@
 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) {
+        // Trigger JobLoader to load extended attributes in the background
+        m_backend->requestJobExtendedAttributes(printer, job);
+    }
 }
 
 void Printers::printerAdded(QSharedPointer<Printer> printer)
@@ -288,10 +316,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);
         }
     }
 }

=== modified file 'po/ubuntu-ui-extras.pot'
--- po/ubuntu-ui-extras.pot	2017-03-08 16:55:21 +0000
+++ po/ubuntu-ui-extras.pot	2017-03-13 12:51:30 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: ubuntu-ui-extras\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2017-03-08 17:54+0100\n"
+"POT-Creation-Date: 2017-03-13 12:44+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"
@@ -99,7 +99,7 @@
 msgid "Stopped"
 msgstr ""
 
-#: modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp:331
+#: modules/Ubuntu/Components/Extras/Printers/printers/printers.cpp:357
 msgid "Test page"
 msgstr ""
 

=== modified file 'tests/unittests/Printers/CMakeLists.txt'
--- tests/unittests/Printers/CMakeLists.txt	2017-03-08 16:13:02 +0000
+++ tests/unittests/Printers/CMakeLists.txt	2017-03-13 12:51:30 +0000
@@ -45,9 +45,9 @@
 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)

=== renamed file 'tests/unittests/Printers/tst_signalhandler.cpp' => 'tests/unittests/Printers/tst_signalratelimiter.cpp'
--- tests/unittests/Printers/tst_signalhandler.cpp	2017-02-21 10:46:29 +0000
+++ tests/unittests/Printers/tst_signalratelimiter.cpp	2017-03-13 12:51:30 +0000
@@ -14,31 +14,51 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "printer/printersignalhandler.h"
+#include "printer/signalratelimiter.h"
 
+#include <QDateTime>
 #include <QDebug>
 #include <QObject>
 #include <QSignalSpy>
 #include <QTest>
 
-class TestSignalHandler : public QObject
+class TestSignalRateLimiter : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void testEmptyCount()
     {
-        PrinterSignalHandler handler(500);
+        SignalRateLimiter handler(500);
         QSignalSpy modifiedSpy(&handler, SIGNAL(printerModified(const QString&)));
 
-        for (int i = 0; i < 500; i++) {
+        for (int i = 0; i < 20; i++) {
             handler.onPrinterStateChanged("spam!", "ipp://bar/baz", "printer-a", 0, "none", true);
         }
 
         modifiedSpy.wait(1000);
         QCOMPARE(modifiedSpy.count(), 1);
     }
+    void testUnprocessedTime()
+    {
+        // Keep sending jobs with no gap for longer than four times the
+        // event delay. Check that two signals are emitted.
+        // One from the forcing of the signal and one as the timer finishes
+
+        int eventDelay = 200;
+        SignalRateLimiter handler(eventDelay);
+        QSignalSpy modifiedSpy(&handler, SIGNAL(printerModified(const QString&)));
+
+        QDateTime start = QDateTime::currentDateTime();
+
+        while (start.msecsTo(QDateTime::currentDateTime()) < eventDelay * 5) {
+            handler.onPrinterStateChanged("spam!", "ipp://foo/bar", "printer-a", 0, "none", true);
+        }
+
+        modifiedSpy.wait(eventDelay * 2);
+        QCOMPARE(modifiedSpy.count(), 2);
+    }
 };
 
-QTEST_GUILESS_MAIN(TestSignalHandler)
-#include "tst_signalhandler.moc"
+QTEST_GUILESS_MAIN(TestSignalRateLimiter)
+#include "tst_signalratelimiter.moc"