Merge lp:~jonas-drange/ubuntu-ui-extras/force-serial-test-run into lp:ubuntu-ui-extras

[Jonas G. Drange]

forces serial test run of printer tests

forces serial test run of printer tests

Unmerged revisions

135. By Jonas G. Drange on 2017-02-24

forces serial test run of printer stuff

=== modified file 'debian/control'
--- debian/control	2016-08-24 15:46:52 +0000
+++ debian/control	2017-02-24 13:40:38 +0000
@@ -3,8 +3,10 @@
 Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: cmake (>= 2.8.9),
+               cmake-extras (>= 0.10),
                debhelper (>= 9),
                gettext,
+               libcups2-dev,
                pkg-config,
                python:any,
                qt5-default,
@@ -27,6 +29,7 @@
 Architecture: any
 Depends: ${misc:Depends},
          ${shlibs:Depends},
+         libqt5printsupport5,
          qml-module-qtquick2,
          qml-module-ubuntu-components,
          qml-module-qtquick-window2,

=== modified file 'modules/Ubuntu/Components/Extras/CMakeLists.txt'
--- modules/Ubuntu/Components/Extras/CMakeLists.txt	2016-12-08 14:26:41 +0000
+++ modules/Ubuntu/Components/Extras/CMakeLists.txt	2017-02-24 13:40:38 +0000
@@ -13,4 +13,5 @@
 add_subdirectory(plugin)
 add_subdirectory(Example)
 add_subdirectory(PhotoEditor)
+add_subdirectory(Printers)
 add_subdirectory(TabsBar)

=== added file 'modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml'
--- modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Example/PrinterQueue.qml	2017-02-24 13:40:38 +0000
@@ -0,0 +1,117 @@
+/*
+ * Copyright 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/>.
+ *
+ * Authored by Jonas G. Drange <[e-mail]>
+ *             Andrew Hayzen <[e-mail]>
+ */
+
+import QtQuick 2.4
+import QtQuick.Layouts 1.1
+import Ubuntu.Components 1.3
+import Ubuntu.Components.ListItems 1.3 as ListItems
+import Ubuntu.Components.Extras.Printers 0.1
+
+MainView {
+    width: units.gu(50)
+    height: units.gu(90)
+
+    Component {
+        id: queuePage
+
+        Page {
+            header: PageHeader {
+                title: "Queue: " + printer.name
+                flickable: queueView
+            }
+            visible: false
+
+            property var printer
+
+            ListView {
+                id: queueView
+                anchors {
+                    fill: parent
+                }
+                delegate: ListItem {
+                    height: modelLayout.height + (divider.visible ? divider.height : 0)
+                    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.wrapMode: Text.WrapAtWordBoundaryOrAnywhere
+                        subtitle.maximumLineCount: 3
+                    }
+                    onClicked: {
+                        console.debug("Cancel:", printer.name, model.id);
+                        Printers.cancelJob(printer.name, model.id);
+                    }
+                }
+                model: printer.jobs
+
+                Label {
+                    anchors {
+                        centerIn: parent
+                    }
+                    text: "Empty queue"
+                    visible: queueView.count === 0
+                }
+            }
+        }
+    }
+
+    PageStack {
+        id: pageStack
+
+        Page {
+            id: printersPage
+            header: PageHeader {
+                title: "Printers"
+                flickable: printerList
+            }
+            visible: false
+
+            ListView {
+                id: printerList
+                anchors { fill: parent }
+                model: Printers.allPrintersWithPdf
+                delegate: ListItem {
+                    height: modelLayout.height + (divider.visible ? divider.height : 0)
+                    ListItemLayout {
+                        id: modelLayout
+                        title.text: displayName
+                        title.font.bold: model.default
+                        subtitle.text: description
+
+                        Icon {
+                            id: icon
+                            width: height
+                            height: units.gu(2.5)
+                            name: "printer-symbolic"
+                            SlotsLayout.position: SlotsLayout.First
+                        }
+
+                        ProgressionSlot {}
+                    }
+                    onClicked: pageStack.push(queuePage, { printer: model })
+                }
+            }
+        }
+
+        Component.onCompleted: push(printersPage)
+    }
+}

=== added file 'modules/Ubuntu/Components/Extras/Example/Printers.qml'
--- modules/Ubuntu/Components/Extras/Example/Printers.qml	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Example/Printers.qml	2017-02-24 13:40:38 +0000
@@ -0,0 +1,603 @@
+/*
+ * Copyright 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/>.
+ *
+ * Authored by Jonas G. Drange <[e-mail]>
+ */
+
+import QtQuick 2.4
+import QtQuick.Layouts 1.1
+import Ubuntu.Components 1.3
+import Ubuntu.Components.Popups 1.3
+import Ubuntu.Components.ListItems 1.3 as ListItems
+import Ubuntu.Components.Extras.Printers 0.1
+
+MainView {
+    width: units.gu(50)
+    height: units.gu(90)
+
+    Component {
+        id: printerPage
+
+        Page {
+            visible: false
+            property var printer
+            header: PageHeader {
+                id: printerPageHeader
+                title: printer.name
+                flickable: printerFlickable
+            }
+
+            Component {
+                id: printerPageNotYetLoaded
+
+                Item {
+                    anchors.fill: parent
+                    ActivityIndicator {
+                        anchors.centerIn: parent
+                        running: true
+                    }
+                }
+            }
+
+            Component.onCompleted: {
+                printer.description;
+            }
+
+            Flickable {
+                id: printerFlickable
+                anchors.fill: parent
+
+                Loader {
+                    id: printerPageBitsLoader
+                    anchors.fill: parent
+                    sourceComponent: printer.isLoaded ? printerPageLoaded : printerPageNotYetLoaded
+                }
+            }
+
+            Component {
+                id: printerPageLoaded
+
+                Column {
+                    spacing: units.gu(2)
+                    anchors {
+                        top: parent.top
+                        topMargin: units.gu(2)
+                        left: parent.left
+                        right: parent.right
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Enabled"
+
+                        control: Switch {
+                            checked: printer.printerEnabled
+                            onCheckedChanged: printer.printerEnabled = checked
+                        }
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Accepting jobs"
+
+                        control: Switch {
+                            checked: printer.acceptJobs
+                            onCheckedChanged: printer.acceptJobs = checked
+                        }
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Jobs"
+                        progression: true
+                        onClicked: pageStack.push(jobPage, { printer: printer })
+                    }
+
+                    Label {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                            margins: units.gu(2)
+                        }
+                        text: "Description"
+                    }
+
+                    ListItems.SingleControl {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+
+                        control: TextField {
+                           anchors {
+                                margins: units.gu(1)
+                                left: parent.left
+                                right: parent.right
+
+                            }
+                            text: printer.description
+                            onTextChanged: printer.description = text
+                        }
+                    }
+
+
+                    ListItems.ValueSelector {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        enabled: values.length > 1
+                        text: "Duplex"
+                        values: printer.supportedDuplexModes
+                        onSelectedIndexChanged: printer.duplexMode = selectedIndex
+                        Component.onCompleted: {
+                            if (enabled) {
+                                selectedIndex = printer.duplexMode
+                            }
+                        }
+                    }
+
+                    ListItems.ValueSelector {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Page size"
+                        values: printer.supportedPageSizes
+                        onSelectedIndexChanged: printer.pageSize = selectedIndex
+                        Component.onCompleted: selectedIndex = printer.supportedPageSizes.indexOf(printer.pageSize)
+                    }
+
+                    ListItems.ValueSelector {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        visible: printer.supportedColorModels.length
+                        text: "Color model"
+                        values: printer.supportedColorModels
+                        enabled: values.length > 1
+                        onSelectedIndexChanged: printer.colorModel = selectedIndex
+                        Component.onCompleted: {
+                            if (enabled)
+                                selectedIndex = printer.colorModel
+                        }
+                    }
+
+                    ListItems.ValueSelector {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        visible: printer.supportedPrintQualities.length
+                        text: "Quality"
+                        values: printer.supportedPrintQualities
+                        enabled: values.length > 1
+                        onSelectedIndexChanged: printer.printQuality = selectedIndex
+                        Component.onCompleted: {
+                            if (enabled)
+                                selectedIndex = printer.printQuality
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Component {
+        id: jobPage
+        Page {
+            property var printer
+            header: PageHeader {
+                id: jobPageHeader
+                title: "%1 (%2 jobs)".arg(printer.name).arg(jobList.count)
+                flickable: jobList
+            }
+
+            ListView {
+                id: jobList
+                anchors.fill: parent
+                model: printer.jobs
+                delegate: ListItem {
+                    height: jobLayout.height + (divider.visible ? divider.height : 0)
+                    ListItemLayout {
+                        id: jobLayout
+                        title.text: displayName
+
+                        Icon {
+                            id: icon
+                            width: height
+                            height: units.gu(2.5)
+                            name: "stock_document"
+                            SlotsLayout.position: SlotsLayout.First
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    Component {
+        id: allJobsPage
+        Page {
+            header: PageHeader {
+                id: allJobsHeader
+                title: "Printer jobs"
+                flickable: jobsList
+            }
+
+            ListView {
+                id: jobsList
+                anchors.fill: parent
+                model: Printers.printJobs
+                delegate: ListItem {
+                    height: jobsLayout.height + (divider.visible ? divider.height : 0)
+                    ListItemLayout {
+                        id: jobsLayout
+                        title.text: displayName
+
+                        Icon {
+                            id: icon
+                            width: height
+                            height: units.gu(2.5)
+                            name: "stock_document"
+                            SlotsLayout.position: SlotsLayout.First
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    PageStack {
+        id: pageStack
+
+        Component.onCompleted: push(printersPage)
+
+        Page {
+            id: printersPage
+            header: PageHeader {
+                title: "Printers"
+                flickable: printerList
+                trailingActionBar {
+                    actions: [
+                        Action {
+                            iconName: "add"
+                            text: "Add printer"
+                            onTriggered: pageStack.push(addPrinterPageComponent)
+                        },
+                        Action {
+                            iconName: "document-print"
+                            text: "Printer jobs"
+                            onTriggered: pageStack.push(allJobsPage)
+                        }
+                    ]
+                }
+            }
+            visible: false
+
+            ListView {
+                id: printerList
+                anchors { fill: parent }
+                model: Printers.allPrintersWithPdf
+                delegate: ListItem {
+                    height: modelLayout.height + (divider.visible ? divider.height : 0)
+                    trailingActions: ListItemActions {
+                        actions: [
+                            Action {
+                                iconName: "delete"
+                                onTriggered: {
+                                    if (!Printers.removePrinter(model.name)) {
+                                        console.error('failed to remove printer', Printers.lastMessage);
+                                    }
+                                }
+                            },
+                            Action {
+                                iconName: model.default ? "starred" : "non-starred"
+                                enabled: !model.default
+                                onTriggered: Printers.defaultPrinterName = model.name
+                            }
+
+                        ]
+                    }
+                    ListItemLayout {
+                        id: modelLayout
+                        title.text: displayName
+                        title.font.bold: model.default
+
+                        Icon {
+                            id: icon
+                            width: height
+                            height: units.gu(2.5)
+                            name: "printer-symbolic"
+                            SlotsLayout.position: SlotsLayout.First
+                        }
+
+                        ProgressionSlot {}
+                    }
+                    onClicked: pageStack.push(printerPage, { printer: model })
+                }
+            }
+        }
+    }
+
+    Component {
+        id: addPrinterPageComponent
+        Page {
+            id: addPrinterPage
+            states: [
+                State {
+                    name: "success"
+                    PropertyChanges {
+                        target: okAction
+                        enabled: false
+                    }
+                    PropertyChanges {
+                        target: closeAction
+                        enabled: false
+                    }
+                    PropertyChanges {
+                        target: addPrinterCol
+                        enabled: false
+                    }
+                    StateChangeScript {
+                        script: okTimer.start()
+                    }
+                },
+                State {
+                    name: "failure"
+                    PropertyChanges {
+                        target: errorMessageContainer
+                        visible: true
+                    }
+                }
+            ]
+            header: PageHeader {
+                title: "Add printer"
+                flickable: addPrinterFlickable
+                leadingActionBar.actions: [
+                    Action {
+                        id: closeAction
+                        iconName: "close"
+                        text: "Abort"
+                        onTriggered: pageStack.pop()
+                    }
+                ]
+                trailingActionBar {
+                    actions: [
+                        Action {
+                            id: okAction
+                            iconName: "ok"
+                            text: "Complete"
+                            onTriggered: {
+                                var ret;
+                                if (driverSelector.selectedIndex == 0) {
+                                    ret = Printers.addPrinter(
+                                        printerName.text,
+                                        driversView.selectedDriver,
+                                        printerUri.text,
+                                        printerDescription.text,
+                                        printerLocation.text
+                                    );
+                                } else {
+                                    ret = Printers.addPrinterWithPpdFile(
+                                        printerName.text,
+                                        printerPpd.text,
+                                        printerUri.text,
+                                        printerDescription.text,
+                                        printerLocation.text
+                                    );
+                                }
+                                if (ret) {
+                                    addPrinterPage.state = "success"
+                                } else {
+                                    errorMessage.text = Printers.lastMessage;
+                                    addPrinterPage.state = "failure"
+                                }
+                            }
+                        }
+                    ]
+                }
+            }
+
+            Component.onCompleted: {
+                Printers.prepareToAddPrinter();
+            }
+
+            Timer {
+                id: okTimer
+                interval: 2000
+                onTriggered: pageStack.pop();
+            }
+
+            Flickable {
+                id: addPrinterFlickable
+                anchors.fill: parent
+
+                Column {
+                    id: addPrinterCol
+                    property bool enabled: true
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                    }
+
+                    Item {
+                        id: errorMessageContainer
+                        visible: false
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                            margins: units.gu(2)
+                        }
+                        height: units.gu(6)
+                        Label {
+                            id: errorMessage
+                            anchors {
+                                top: parent.top
+                                topMargin: units.gu(2)
+                                horizontalCenter: parent.horizontalCenter
+                            }
+                        }
+
+                    }
+
+                    ListItems.Standard {
+                        text: "Device URI"
+                        control: TextField {
+                            id: printerUri
+                            placeholderText: "ipp://server.local/my-queue"
+                        }
+                        enabled: parent.enabled
+                    }
+
+                    ListItems.ValueSelector {
+                        id: driverSelector
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Choose driver"
+                        values: [
+                            "Select printer from database",
+                            "Provide PPD file"
+                        ]
+                        enabled: parent.enabled
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Filter drivers"
+                        control: TextField {
+                            id: driverFilter
+                            onTextChanged: Printers.driverFilter = text
+                        }
+                        visible: driverSelector.selectedIndex == 0
+                        enabled: parent.enabled
+                    }
+
+                    ListView {
+                        id: driversView
+                        property string selectedDriver
+                        property bool loading: true
+                        visible: driverSelector.selectedIndex == 0
+                        model: Printers.drivers
+                        anchors { left: parent.left; right: parent.right }
+                        height: units.gu(30)
+                        clip: true
+                        enabled: parent.enabled
+                        highlightFollowsCurrentItem: false
+                        highlight: Rectangle {
+                            z: 0
+                            y: driversView.currentItem.y
+                            width: driversView.currentItem.width
+                            height: driversView.currentItem.height
+                            color: theme.palette.selected.background
+                        }
+                        delegate: ListItem {
+                            height: driverLayout.height + (divider.visible ? divider.height : 0)
+                            ListItemLayout {
+                                id: driverLayout
+                                title.text: displayName
+                                subtitle.text: name
+                                summary.text: deviceId
+                            }
+                            onClicked: {
+                                driversView.selectedDriver = name
+                                driversView.currentIndex = index
+                            }
+                        }
+
+                        ActivityIndicator {
+                            anchors.centerIn: parent
+                            running: parent.loading
+                        }
+
+                        Connections {
+                            target: driversView
+                            onCountChanged: {
+                                target = null;
+                                driversView.loading = false;
+                            }
+                        }
+                    }
+
+                    ListItems.Standard {
+                        text: "PPD File"
+                        visible: driverSelector.selectedIndex == 1
+                        control: TextField {
+                            id: printerPpd
+                            placeholderText: "/usr/share/cups/foo.ppd"
+                        }
+                        enabled: parent.enabled
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Printer name"
+                        control: TextField {
+                            id: printerName
+                            placeholderText: "laserjet"
+                        }
+                        enabled: parent.enabled
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Description (optional)"
+                        control: TextField {
+                            id: printerDescription
+                            placeholderText: "HP Laserjet with Duplexer"
+                        }
+                        enabled: parent.enabled
+                    }
+
+                    ListItems.Standard {
+                        anchors {
+                            left: parent.left
+                            right: parent.right
+                        }
+                        text: "Location (optional)"
+                        control: TextField {
+                            id: printerLocation
+                            placeholderText: "Lab 1"
+                        }
+                        enabled: parent.enabled
+                    }
+                }
+            }
+        }
+    }
+}

=== added directory 'modules/Ubuntu/Components/Extras/Printers'
=== added file 'modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt'
--- modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/CMakeLists.txt	2017-02-24 13:40:38 +0000
@@ -0,0 +1,68 @@
+project(UbuntuComponentsExtrasPrintersQml)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall -Wextra")
+
+add_definitions(-DUBUNTUCOMPONENTSEXTRASPRINTERS_LIBRARY)
+
+include(FindCups)
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CUPS_INCLUDE_DIR})
+
+find_package(Qt5Gui REQUIRED)
+find_package(Qt5PrintSupport REQUIRED)
+find_package(Qt5Qml REQUIRED)
+find_package(Qt5DBus REQUIRED)
+find_package(Qt5Concurrent REQUIRED)
+
+if(NOT CUPS_FOUND)
+message(FATAL_ERROR "Could not find cups.")
+endif()
+
+qt5_add_dbus_interface(
+    GEN_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/org.cups.cupsd.Notifier.xml
+    cupsdnotifier)
+
+add_library(UbuntuComponentsExtrasPrintersQml SHARED
+    ${GEN_SOURCES}
+    backend/backend.cpp
+    backend/backend_cups.cpp
+    backend/backend_pdf.cpp
+
+    cups/ippclient.cpp
+    cups/printerdriverloader.cpp
+    cups/printerloader.cpp
+
+    models/drivermodel.cpp
+    models/jobmodel.cpp
+    models/printermodel.cpp
+
+    printer/printer.cpp
+    printer/printerjob.cpp
+    printer/printersignalhandler.cpp
+    printers/printers.cpp
+
+    enums.h
+    i18n.cpp
+    plugin.cpp
+    structs.h
+    utils.h
+)
+
+target_link_libraries(UbuntuComponentsExtrasPrintersQml
+    Qt5::DBus
+    Qt5::Gui
+    Qt5::PrintSupport
+    Qt5::Qml
+    Qt5::Concurrent
+    ${CUPS_LIBRARIES}
+)
+
+find_package(QmlPlugins)
+
+macro(add_plugin PLUGIN VERSION PATH)
+    export_qmlfiles(${PLUGIN} ${PATH} DESTINATION ${QT_IMPORTS_DIR} ${ARGN})
+    export_qmlplugin(${PLUGIN} ${VERSION} ${PATH} DESTINATION ${QT_IMPORTS_DIR} ${ARGN})
+endmacro()
+
+add_plugin(Ubuntu.Components.Extras.Printers 0.1 Ubuntu/Components/Extras/Printers TARGETS UbuntuComponentsExtrasPrintersQml)

=== added directory 'modules/Ubuntu/Components/Extras/Printers/backend'
=== added file 'modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend.cpp	2017-02-24 13:40:38 +0000
@@ -0,0 +1,272 @@
+/*
+ * 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.h"
+
+PrinterBackend::PrinterBackend(const QString &printerName, QObject *parent)
+    : QObject(parent)
+    , m_printerName(printerName)
+    , m_type(PrinterEnum::PrinterType::ProxyType)
+{
+}
+
+PrinterBackend::~PrinterBackend()
+{
+}
+
+bool PrinterBackend::holdsDefinition() const
+{
+    return false;
+}
+
+QString PrinterBackend::printerAdd(const QString &name,
+                                   const QString &uri,
+                                   const QString &ppdFile,
+                                   const QString &info,
+                                   const QString &location)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(uri);
+    Q_UNUSED(ppdFile);
+    Q_UNUSED(info);
+    Q_UNUSED(location);
+    return QString();
+}
+
+QString PrinterBackend::printerAddWithPpd(const QString &name,
+                                          const QString &uri,
+                                          const QString &ppdFileName,
+                                          const QString &info,
+                                          const QString &location)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(uri);
+    Q_UNUSED(ppdFileName);
+    Q_UNUSED(info);
+    Q_UNUSED(location);
+    return QString();
+}
+
+QString PrinterBackend::printerDelete(const QString &name)
+{
+    Q_UNUSED(name);
+    return QString();
+}
+
+QString PrinterBackend::printerSetDefault(const QString &name)
+{
+    Q_UNUSED(name);
+    return QString();
+}
+
+QString PrinterBackend::printerSetEnabled(const QString &name,
+                                          const bool enabled)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(enabled);
+    return QString();
+}
+
+QString PrinterBackend::printerSetAcceptJobs(
+    const QString &name,
+    const bool enabled,
+    const QString &reason)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(enabled);
+    Q_UNUSED(reason);
+    return QString();
+}
+
+QString PrinterBackend::printerSetInfo(const QString &name,
+                                       const QString &info)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(info);
+    return QString();
+}
+
+QString PrinterBackend::printerAddOption(const QString &name,
+                                         const QString &option,
+                                         const QStringList &values)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(option);
+    Q_UNUSED(values);
+    return QString();
+}
+
+QVariant PrinterBackend::printerGetOption(const QString &name,
+                                          const QString &option) const
+{
+    Q_UNUSED(name);
+    Q_UNUSED(option);
+    return QVariant();
+}
+
+QMap<QString, QVariant> PrinterBackend::printerGetOptions(
+    const QString &name, const QStringList &options) const
+{
+    Q_UNUSED(name);
+    Q_UNUSED(options);
+    return QMap<QString, QVariant>();
+}
+
+cups_dest_t* PrinterBackend::makeDest(const QString &name,
+                              const PrinterJob *options)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(options);
+    return Q_NULLPTR;
+}
+
+void PrinterBackend::cancelJob(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)
+{
+    Q_UNUSED(filepath);
+    Q_UNUSED(title);
+    Q_UNUSED(dest);
+    return -1;
+}
+
+QList<QSharedPointer<PrinterJob>> PrinterBackend::printerGetJobs()
+{
+    return QList<QSharedPointer<PrinterJob>>{};
+}
+
+QMap<QString, QVariant> PrinterBackend::printerGetJobAttributes(
+        const QString &name, const int jobId)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(jobId);
+    return QMap<QString, QVariant>();
+}
+
+QString PrinterBackend::printerName() const
+{
+    return m_printerName;
+}
+
+QString PrinterBackend::description() const
+{
+    return QString();
+}
+
+QString PrinterBackend::location() const
+{
+    return QString();
+}
+
+QString PrinterBackend::makeAndModel() const
+{
+    return QString();
+}
+
+PrinterEnum::State PrinterBackend::state() const
+{
+    return PrinterEnum::State::IdleState;
+}
+
+QList<QPageSize> PrinterBackend::supportedPageSizes() const
+{
+    return QList<QPageSize>();
+}
+
+QPageSize PrinterBackend::defaultPageSize() const
+{
+    return QPageSize();
+}
+
+bool PrinterBackend::supportsCustomPageSizes() const
+{
+    return false;
+}
+
+QPageSize PrinterBackend::minimumPhysicalPageSize() const
+{
+    return QPageSize();
+}
+
+QPageSize PrinterBackend::maximumPhysicalPageSize() const
+{
+    return QPageSize();
+}
+
+QList<int> PrinterBackend::supportedResolutions() const
+{
+    return QList<int>();
+}
+
+PrinterEnum::DuplexMode PrinterBackend::defaultDuplexMode() const
+{
+    return PrinterEnum::DuplexMode::DuplexNone;
+}
+
+QList<PrinterEnum::DuplexMode> PrinterBackend::supportedDuplexModes() const
+{
+    return QList<PrinterEnum::DuplexMode>();
+}
+
+QList<QSharedPointer<Printer>> PrinterBackend::availablePrinters()
+{
+    return QList<QSharedPointer<Printer>>();
+}
+
+QStringList PrinterBackend::availablePrinterNames()
+{
+    return QStringList();
+}
+
+QSharedPointer<Printer> PrinterBackend::getPrinter(const QString &printerName)
+{
+    Q_UNUSED(printerName);
+    return QSharedPointer<Printer>(Q_NULLPTR);
+}
+
+QString PrinterBackend::defaultPrinterName()
+{
+    return QString();
+}
+
+void PrinterBackend::requestPrinterDrivers()
+{
+}
+
+void PrinterBackend::requestPrinter(const QString &printerName)
+{
+    Q_UNUSED(printerName);
+}
+
+PrinterEnum::PrinterType PrinterBackend::type() const
+{
+    return m_type;
+}
+
+void PrinterBackend::setPrinterNameInternal(const QString &printerName)
+{
+    m_printerName = printerName;
+}
+
+void PrinterBackend::refresh()
+{
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/backend/backend.h'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend.h	2017-02-24 13:40:38 +0000
@@ -0,0 +1,201 @@
+/*
+ * 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_BACKEND_H
+#define USC_PRINTERS_BACKEND_H
+
+#include "printer/printer.h"
+#include "printer/printerjob.h"
+
+// TODO: remove cups specific things from this API
+#include <cups/cups.h>
+
+#include <QObject>
+#include <QPageSize>
+#include <QList>
+#include <QString>
+#include <QStringList>
+
+class Printer;
+class PrinterJob;
+class PRINTERS_DECL_EXPORT PrinterBackend : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PrinterBackend(QObject *parent = Q_NULLPTR);
+    explicit PrinterBackend(const QString &printerName,
+                            QObject *parent = Q_NULLPTR);
+    virtual ~PrinterBackend();
+
+    virtual bool holdsDefinition() const;
+
+    // Add a printer using an already existing ppd.
+    virtual QString printerAdd(const QString &name,
+                               const QString &uri,
+                               const QString &ppdFile,
+                               const QString &info,
+                               const QString &location);
+
+    // Add a printer and provide a ppd file.
+    virtual QString printerAddWithPpd(const QString &name,
+                                      const QString &uri,
+                                      const QString &ppdFileName,
+                                      const QString &info,
+                                      const QString &location);
+    virtual QString printerDelete(const QString &name);
+    virtual QString printerSetDefault(const QString &name);
+    virtual QString printerSetEnabled(const QString &name,
+                                      const bool enabled);
+    virtual QString printerSetAcceptJobs(
+        const QString &name,
+        const bool accept,
+        const QString &reason = QString::null);
+    virtual QString printerSetInfo(const QString &name,
+                                   const QString &info);
+    virtual QString printerAddOption(const QString &name,
+                                     const QString &option,
+                                     const QStringList &values);
+
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const;
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options) const;
+    virtual cups_dest_t* makeDest(const QString &name,
+                                  const PrinterJob *options);
+
+    virtual void cancelJob(const QString &name, const int jobId);
+    virtual int printFileToDest(const QString &filepath,
+                                const QString &title,
+                                const cups_dest_t *dest);
+    virtual QList<QSharedPointer<PrinterJob>> printerGetJobs();
+    virtual QMap<QString, QVariant> printerGetJobAttributes(
+        const QString &name, const int jobId);
+
+    virtual QString printerName() const;
+    virtual QString description() const;
+    virtual QString location() const;
+    virtual QString makeAndModel() const;
+
+    virtual PrinterEnum::State state() const;
+    virtual QList<QPageSize> supportedPageSizes() const;
+    virtual QPageSize defaultPageSize() const;
+    virtual bool supportsCustomPageSizes() const;
+
+    virtual QPageSize minimumPhysicalPageSize() const;
+    virtual QPageSize maximumPhysicalPageSize() const;
+    virtual QList<int> supportedResolutions() const;
+    virtual PrinterEnum::DuplexMode defaultDuplexMode() const;
+    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const;
+
+    virtual QList<QSharedPointer<Printer>> availablePrinters();
+    virtual QStringList availablePrinterNames();
+    virtual QSharedPointer<Printer> getPrinter(const QString &printerName);
+    virtual QString defaultPrinterName();
+
+    virtual void requestPrinterDrivers();
+    virtual void requestPrinter(const QString &printerName);
+
+    virtual PrinterEnum::PrinterType type() const;
+
+    virtual void setPrinterNameInternal(const QString &printerName);
+
+public Q_SLOTS:
+    virtual void refresh();
+
+Q_SIGNALS:
+    void printerDriversLoaded(const QList<PrinterDriver> &drivers);
+    void printerDriversFailedToLoad(const QString &errorMessage);
+
+    void printerLoaded(QSharedPointer<Printer> printers);
+
+    void jobCompleted(
+        const QString &text,
+        const QString &printerUri,
+        const QString &printerName,
+        uint printerState,
+        const QString &printerStateReason,
+        bool acceptingJobs,
+        uint jobId,
+        uint jobState,
+        const QString &jobStateReason,
+        const QString &job_name,
+        uint jobImpressionsCompleted
+    );
+    void jobCreated(
+        const QString &text,
+        const QString &printerUri,
+        const QString &printerName,
+        uint printerState,
+        const QString &printerStateReason,
+        bool acceptingJobs,
+        uint jobId,
+        uint jobState,
+        const QString &jobStateReason,
+        const QString &job_name,
+        uint jobImpressionsCompleted
+    );
+    void jobState(
+        const QString &text,
+        const QString &printerUri,
+        const QString &printerName,
+        uint printerState,
+        const QString &printerStateReason,
+        bool acceptingJobs,
+        uint jobId,
+        uint jobState,
+        const QString &jobStateReason,
+        const QString &job_name,
+        uint jobImpressionsCompleted
+    );
+    void printerAdded(
+        const QString &text,
+        const QString &printerUri,
+        const QString &printerName,
+        uint printerState,
+        const QString &printerStateReason,
+        bool acceptingJobs
+    );
+    void printerDeleted(
+        const QString &text,
+        const QString &printerUri,
+        const QString &printerName,
+        uint printerState,
+        const QString &printerStateReason,
+        bool acceptingJobs
+    );
+    void printerModified(
+        const QString &text,
+        const QString &printerUri,
+        const QString &printerName,
+        uint printerState,
+        const QString &printerStateReason,
+        bool acceptingJobs
+    );
+    void printerStateChanged(
+        const QString &text,
+        const QString &printerUri,
+        const QString &printerName,
+        uint printerState,
+        const QString &printerStateReason,
+        bool acceptingJobs
+    );
+
+protected:
+    QString m_printerName;
+    PrinterEnum::PrinterType m_type;
+};
+
+#endif // USC_PRINTERS_BACKEND_H

=== added file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.cpp	2017-02-24 13:40:38 +0000
@@ -0,0 +1,722 @@
+/*
+ * 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 "cups/printerdriverloader.h"
+#include "cups/printerloader.h"
+#include "utils.h"
+
+#include <cups/http.h>
+#include <cups/ipp.h>
+#include <cups/ppd.h>
+
+#include <QLocale>
+#include <QThread>
+#include <QTimeZone>
+
+#define __CUPS_ADD_OPTION(dest, name, value) dest->num_options = \
+    cupsAddOption(name, value, dest->num_options, &dest->options);
+
+#define __CUPS_ATTR_EXISTS(map, attr, type) map.contains(attr) \
+    && map.value(attr).canConvert<type>()
+
+PrinterCupsBackend::PrinterCupsBackend(IppClient *client, QPrinterInfo info,
+                                       OrgCupsCupsdNotifierInterface *notifier,
+                                       QObject *parent)
+    : PrinterBackend(info.printerName(), parent)
+    , m_knownQualityOptions({
+        "Quality", "PrintQuality", "HPPrintQuality", "StpQuality",
+        "OutputMode",})
+    , m_client(client)
+    , m_info(info)
+    , m_notifier(notifier)
+    , m_cupsSubscriptionId(-1)
+{
+    m_type = PrinterEnum::PrinterType::CupsType;
+    connect(m_notifier, SIGNAL(JobCompleted(const QString&, const QString&,
+                                            const QString&, uint,
+                                            const QString&, bool, uint, uint,
+                                            const QString&, const QString&, uint)),
+            this, SIGNAL(jobCompleted(const QString&, const QString&,
+                                      const QString&, uint, const QString&,
+                                      bool, uint, uint, const QString&,
+                                      const QString&, uint)));
+    connect(m_notifier, SIGNAL(JobCreated(const QString&, const QString&,
+                                          const QString&, uint, const QString&,
+                                          bool, uint, uint, const QString&,
+                                          const QString&, uint)),
+            this, SIGNAL(jobCreated(const QString&, const QString&,
+                                    const QString&, uint, const QString&, bool,
+                                    uint, uint, const QString&, const QString&,
+                                    uint)));
+    connect(m_notifier, SIGNAL(JobState(const QString&, const QString&,
+                                        const QString&, uint, const QString&,
+                                        bool, uint, uint, const QString&,
+                                        const QString&, uint)),
+            this, SIGNAL(jobState(const QString&, const QString&,
+                                  const QString&, uint, const QString&, bool,
+                                  uint, uint, const QString&, const QString&,
+                                  uint)));
+    connect(m_notifier, SIGNAL(PrinterAdded(const QString&, const QString&,
+                                            const QString&, uint,
+                                            const QString&, bool)),
+            this, SIGNAL(printerAdded(const QString&, const QString&,
+                                      const QString&, uint,
+                                      const QString&, bool)));
+    connect(m_notifier, SIGNAL(PrinterDeleted(const QString&, const QString&,
+                                              const QString&, uint,
+                                              const QString&, bool)),
+            this, SIGNAL(printerDeleted(const QString&, const QString&,
+                                        const QString&, uint,
+                                        const QString&, bool)));
+    connect(m_notifier, SIGNAL(PrinterModified(const QString&, const QString&,
+                                               const QString&, uint,
+                                               const QString&, bool)),
+            this, SIGNAL(printerModified(const QString&, const QString&,
+                                         const QString&, uint,
+                                         const QString&, bool)));
+    connect(m_notifier, SIGNAL(PrinterStateChanged(const QString&,
+                                                   const QString&,
+                                                   const QString&, uint,
+                                                   const QString&, bool)),
+            this, SIGNAL(printerStateChanged(const QString&, const QString&,
+                                             const QString&, uint,
+                                             const QString&, bool)));
+
+}
+
+PrinterCupsBackend::~PrinterCupsBackend()
+{
+    Q_FOREACH(auto dest, m_dests) {
+        if (dest)
+            cupsFreeDests(1, dest);
+    }
+    Q_FOREACH(auto ppd, m_ppds) {
+        if (ppd)
+            ppdClose(ppd);
+    }
+
+    cancelSubscription();
+    Q_EMIT cancelWorkers();
+}
+
+QString PrinterCupsBackend::printerAdd(const QString &name,
+                                       const QString &uri,
+                                       const QString &ppdFile,
+                                       const QString &info,
+                                       const QString &location)
+{
+    if (!m_client->printerAdd(name, uri, ppdFile, info, location)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+QString PrinterCupsBackend::printerAddWithPpd(const QString &name,
+                                              const QString &uri,
+                                              const QString &ppdFileName,
+                                              const QString &info,
+                                              const QString &location)
+{
+    if (!m_client->printerAddWithPpdFile(name, uri, ppdFileName, info, location)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+bool PrinterCupsBackend::holdsDefinition() const
+{
+    return !m_info.isNull();
+}
+
+QString PrinterCupsBackend::printerDelete(const QString &name)
+{
+    if (!m_client->printerDelete(name)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetDefault(const QString &name)
+{
+    if (!m_client->printerSetDefault(name)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetEnabled(const QString &name,
+                                              const bool enabled)
+{
+    if (!m_client->printerSetEnabled(name, enabled)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetAcceptJobs(
+        const QString &name,
+        const bool accept,
+        const QString &reason)
+{
+    if (!m_client->printerSetAcceptJobs(name, accept, reason)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetInfo(const QString &name,
+                                           const QString &info)
+{
+    if (!m_client->printerClassSetInfo(name, info)) {
+        return m_client->getLastError();
+    }
+    return QString();
+}
+
+QString PrinterCupsBackend::printerAddOption(const QString &name,
+                                             const QString &option,
+                                             const QStringList &values)
+{
+    if (!m_client->printerClassSetOption(name, option, values)) {
+        return m_client->getLastError();
+    }
+
+    return QString();
+}
+
+QVariant PrinterCupsBackend::printerGetOption(const QString &name,
+                                              const QString &option) const
+{
+    auto res = printerGetOptions(name, QStringList({option}));
+    return res[option];
+}
+
+QMap<QString, QVariant> PrinterCupsBackend::printerGetOptions(
+        const QString &name, const QStringList &options) const
+{
+    QMap<QString, QVariant> ret;
+
+    cups_dest_t *dest = getDest(name);
+    ppd_file_t* ppd = getPpd(name);
+
+    if (!dest || !ppd) {
+        return ret;
+    }
+
+    Q_FOREACH(const QString &option, options) {
+        if (option == QStringLiteral("DefaultColorModel")) {
+            ColorModel model;
+            ppd_option_t *ppdColorModel = ppdFindOption(ppd, "ColorModel");
+            if (ppdColorModel) {
+                ppd_choice_t* def = ppdFindChoice(ppdColorModel,
+                                                  ppdColorModel->defchoice);
+                if (def) {
+                    model = Utils::parsePpdColorModel(def->choice,
+                                                      def->text,
+                                                      "ColorModel");
+                }
+            }
+            ret[option] = QVariant::fromValue(model);
+        } else if (option == QStringLiteral("DefaultPrintQuality")) {
+            PrintQuality quality;
+            Q_FOREACH(const QString opt, m_knownQualityOptions) {
+                ppd_option_t *ppdQuality = ppdFindOption(ppd, opt.toUtf8());
+                if (ppdQuality) {
+                    ppd_choice_t* def = ppdFindChoice(ppdQuality,
+                                                      ppdQuality->defchoice);
+                    if (def) {
+                        quality = Utils::parsePpdPrintQuality(def->choice,
+                                                              def->text, opt);
+                    }
+                }
+            }
+            ret[option] = QVariant::fromValue(quality);
+        } else if (option == QStringLiteral("SupportedPrintQualities")) {
+            QList<PrintQuality> qualities;
+            Q_FOREACH(const QString &opt, m_knownQualityOptions) {
+                ppd_option_t *qualityOpt = ppdFindOption(ppd, opt.toUtf8());
+                if (qualityOpt) {
+                    for (int i = 0; i < qualityOpt->num_choices; ++i) {
+                        qualities.append(
+                            Utils::parsePpdPrintQuality(
+                                qualityOpt->choices[i].choice,
+                                qualityOpt->choices[i].text,
+                                opt
+                            )
+                        );
+                    }
+                }
+            }
+            ret[option] = QVariant::fromValue(qualities);
+        } else if (option == QStringLiteral("SupportedColorModels")) {
+            QList<ColorModel> models;
+            ppd_option_t *colorModels = ppdFindOption(ppd, "ColorModel");
+            if (colorModels) {
+                for (int i = 0; i < colorModels->num_choices; ++i) {
+                    models.append(
+                        Utils::parsePpdColorModel(
+                            colorModels->choices[i].choice,
+                            colorModels->choices[i].text,
+                            QStringLiteral("ColorModel")
+                        )
+                    );
+                }
+            }
+            ret[option] = QVariant::fromValue(models);
+        } else if (option == QStringLiteral("AcceptJobs")) {
+            // "true" if the destination is accepting new jobs, "false" if not.
+            QString res = cupsGetOption("printer-is-accepting-jobs",
+                                        dest->num_options, dest->options);
+            ret[option] = res.contains("true");
+        } else {
+            ppd_option_t *val = ppdFindOption(ppd, option.toUtf8());
+
+            if (val) {
+                qWarning() << "asking for" << option << "returns" << val->text;
+            } else {
+                qWarning() << "option" << option << "yielded no option";
+            }
+        }
+    }
+    return ret;
+}
+
+cups_dest_t* PrinterCupsBackend::makeDest(const QString &name,
+                                          const PrinterJob *options)
+{
+    cups_dest_t *dest = getDest(name);
+
+    if (options->collate()) {
+        __CUPS_ADD_OPTION(dest, "Collate", "True");
+    } else {
+        __CUPS_ADD_OPTION(dest, "Collate", "False");
+    }
+
+    if (options->copies() > 1) {
+        __CUPS_ADD_OPTION(dest, "copies", QString::number(options->copies()).toLocal8Bit());
+    }
+
+    __CUPS_ADD_OPTION(dest, "ColorModel", options->getColorModel().name.toLocal8Bit());
+    __CUPS_ADD_OPTION(dest, "Duplex", Utils::duplexModeToPpdChoice(options->getDuplexMode()).toLocal8Bit());
+
+    if (options->landscape()) {
+        __CUPS_ADD_OPTION(dest, "landscape", "");
+    }
+
+    if (options->printRangeMode() == PrinterEnum::PrintRange::PageRange
+            && !options->printRange().isEmpty()) {
+        __CUPS_ADD_OPTION(dest, "page-ranges", options->printRange().toLocal8Bit());
+    }
+
+    PrintQuality quality = options->getPrintQuality();
+    __CUPS_ADD_OPTION(dest, quality.originalOption.toLocal8Bit(),
+                      quality.name.toLocal8Bit());
+
+    if (options->reverse()) {
+        __CUPS_ADD_OPTION(dest, "OutputOrder", "Reverse");
+    } else {
+        __CUPS_ADD_OPTION(dest, "OutputOrder", "Normal");
+    }
+
+    // Always scale to fit the page for now
+    __CUPS_ADD_OPTION(dest, "fit-to-page", "True");
+
+    return dest;
+}
+
+void PrinterCupsBackend::cancelJob(const QString &name, const int jobId)
+{
+    int ret = cupsCancelJob(name.toLocal8Bit(), jobId);
+
+    if (!ret) {
+        qWarning() << "Failed to cancel job:" << jobId << "for" << name;
+    }
+}
+
+int PrinterCupsBackend::printFileToDest(const QString &filepath,
+                                        const QString &title,
+                                        const cups_dest_t *dest)
+{
+    qDebug() << "Printing:" << filepath << title << dest->name << dest->num_options;
+    return cupsPrintFile(dest->name,
+                         filepath.toLocal8Bit(),
+                         title.toLocal8Bit(),
+                         dest->num_options,
+                         dest->options);
+}
+
+
+QList<cups_job_t *> PrinterCupsBackend::getCupsJobs(const QString &name)
+{
+    QList<cups_job_t *> list;
+    cups_job_t *jobs;
+
+    // Get a list of the jobs that are 'mine' and only active ones
+    // https://www.cups.org/doc/api-cups.html#cupsGetJobs
+    int count;
+    if (name.isEmpty()) {
+        count = cupsGetJobs(&jobs, NULL, 1, CUPS_WHICHJOBS_ACTIVE);
+    } else {
+        count = cupsGetJobs(&jobs, name.toLocal8Bit(), 1, CUPS_WHICHJOBS_ACTIVE);
+    }
+
+    for (int i=0; i < count; i++) {
+        list.append(&jobs[i]);
+    }
+
+    return list;
+}
+
+QMap<QString, QVariant> PrinterCupsBackend::printerGetJobAttributes(
+    const QString &name, const int jobId)
+{
+    Q_UNUSED(name);
+    QMap<QString, QVariant> rawMap = m_client->printerGetJobAttributes(jobId);
+    QMap<QString, QVariant> map;
+
+    // Filter attributes to know values
+    // Do this here so we can use things such as m_knownQualityOptions
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "Collate", bool)) {
+        map.insert("Collate", rawMap.value("Collate"));
+    } else {
+        map.insert("Collate", QVariant(true));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "copies", int)) {
+        map.insert("copies", rawMap.value("copies"));
+    } else {
+        map.insert("copies", QVariant(1));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "ColorModel", QString)) {
+        map.insert("ColorModel", rawMap.value("ColorModel"));
+    } else {
+        map.insert("ColorModel", QVariant(""));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "Duplex", QString)) {
+        map.insert("Duplex", rawMap.value("Duplex"));
+    } else {
+        map.insert("Duplex", QVariant(""));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "landscape", bool)) {
+        map.insert("landscape", rawMap.value("landscape"));
+    } else {
+        map.insert("landscape", QVariant(false));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "page-ranges", QList<QVariant>)) {
+        QList<QVariant> range = rawMap.value("page-ranges").toList();
+        QStringList rangeStrings;
+
+        Q_FOREACH(QVariant var, range) {
+            rangeStrings << var.toString();
+        }
+
+        map.insert("page-ranges", QVariant(rangeStrings));
+    } else {
+        map.insert("page-ranges", QVariant(QStringList()));
+    }
+
+    Q_FOREACH(QString qualityOption, m_knownQualityOptions) {
+        if (rawMap.contains(qualityOption)
+                && rawMap.value(qualityOption).canConvert<QString>()) {
+            map.insert("quality", rawMap.value(qualityOption).toString());
+        }
+    }
+
+    if (!map.contains("quality")) {
+        map.insert("quality", QVariant(""));
+    }
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "OutputOrder", QString)) {
+        map.insert("OutputOrder", rawMap.value("OutputOrder"));
+    } else {
+        map.insert("OutputOrder", "Normal");
+    }
+
+    // Generate a list of messages
+    // TODO: for now just using job-printer-state-message, are there others?
+    QStringList messages;
+
+    if (__CUPS_ATTR_EXISTS(rawMap, "job-printer-state-message", QString)) {
+        messages << rawMap.value("job-printer-state-message").toString();
+    }
+
+    map.insert("messages", QVariant(messages));
+
+    return map;
+}
+
+
+QList<QSharedPointer<PrinterJob>> PrinterCupsBackend::printerGetJobs()
+{
+    auto jobs = getCupsJobs();
+    QList<QSharedPointer<PrinterJob>> list;
+
+    Q_FOREACH(auto job, jobs) {
+        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);
+    }
+    if (!list.isEmpty())
+        cupsFreeJobs(list.size(), jobs.first());
+
+    return list;
+}
+
+QString PrinterCupsBackend::printerName() const
+{
+    return m_printerName;
+}
+
+QString PrinterCupsBackend::description() const
+{
+    return m_info.description();
+}
+
+QString PrinterCupsBackend::location() const
+{
+    return m_info.location();
+}
+
+QString PrinterCupsBackend::makeAndModel() const
+{
+    return m_info.makeAndModel();
+}
+
+PrinterEnum::State PrinterCupsBackend::state() const
+{
+    switch (m_info.state()) {
+    case QPrinter::Active:
+        return PrinterEnum::State::ActiveState;
+    case QPrinter::Aborted:
+        return PrinterEnum::State::AbortedState;
+    case QPrinter::Error:
+        return PrinterEnum::State::ErrorState;
+    case QPrinter::Idle:
+    default:
+        return PrinterEnum::State::IdleState;
+    }
+}
+
+QList<QPageSize> PrinterCupsBackend::supportedPageSizes() const
+{
+    return m_info.supportedPageSizes();
+}
+
+QPageSize PrinterCupsBackend::defaultPageSize() const
+{
+    return m_info.defaultPageSize();
+}
+
+bool PrinterCupsBackend::supportsCustomPageSizes() const
+{
+    return m_info.supportsCustomPageSizes();
+}
+
+QPageSize PrinterCupsBackend::minimumPhysicalPageSize() const
+{
+    return m_info.minimumPhysicalPageSize();
+}
+
+QPageSize PrinterCupsBackend::maximumPhysicalPageSize() const
+{
+    return m_info.maximumPhysicalPageSize();
+}
+
+QList<int> PrinterCupsBackend::supportedResolutions() const
+{
+    return m_info.supportedResolutions();
+}
+
+PrinterEnum::DuplexMode PrinterCupsBackend::defaultDuplexMode() const
+{
+    return Utils::qDuplexModeToDuplexMode(m_info.defaultDuplexMode());
+}
+
+QList<PrinterEnum::DuplexMode> PrinterCupsBackend::supportedDuplexModes() const
+{
+    QList<PrinterEnum::DuplexMode> list;
+    Q_FOREACH(const QPrinter::DuplexMode mode, m_info.supportedDuplexModes()) {
+        if (mode != QPrinter::DuplexAuto) {
+            list.append(Utils::qDuplexModeToDuplexMode(mode));
+        }
+    }
+
+    if (list.isEmpty())
+        list.append(PrinterEnum::DuplexMode::DuplexNone);
+
+    return list;
+}
+
+QList<QSharedPointer<Printer>> PrinterCupsBackend::availablePrinters()
+{
+    return QList<QSharedPointer<Printer>>();
+}
+
+QStringList PrinterCupsBackend::availablePrinterNames()
+{
+    return QPrinterInfo::availablePrinterNames();
+}
+
+QSharedPointer<Printer> PrinterCupsBackend::getPrinter(const QString &printerName)
+{
+    QPrinterInfo info = QPrinterInfo::printerInfo(printerName);
+    return QSharedPointer<Printer>(new Printer(new PrinterCupsBackend(m_client, info, m_notifier)));
+}
+
+QString PrinterCupsBackend::defaultPrinterName()
+{
+    return QPrinterInfo::defaultPrinterName();
+}
+
+void PrinterCupsBackend::requestPrinter(const QString &printerName)
+{
+    if (m_activeRequests.contains(printerName)) {
+        return;
+    }
+
+    auto thread = new QThread;
+    auto loader = new PrinterLoader(printerName, m_client, m_notifier);
+    loader->moveToThread(thread);
+    connect(thread, SIGNAL(started()), loader, SLOT(load()));
+    connect(loader, SIGNAL(finished()), thread, SLOT(quit()));
+    connect(loader, SIGNAL(finished()), loader, SLOT(deleteLater()));
+    connect(loader, SIGNAL(loaded(QSharedPointer<Printer>)),
+            this, SIGNAL(printerLoaded(QSharedPointer<Printer>)));
+    connect(loader, SIGNAL(loaded(QSharedPointer<Printer>)),
+            this, SLOT(onPrinterLoaded(QSharedPointer<Printer>)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+    thread->start();
+
+    m_activeRequests << printerName;
+}
+
+void PrinterCupsBackend::requestPrinterDrivers()
+{
+    auto thread = new QThread;
+    auto loader = new PrinterDriverLoader();
+    loader->moveToThread(thread);
+    connect(loader, SIGNAL(error(const QString&)),
+            this, SIGNAL(printerDriversFailedToLoad(const QString&)));
+    connect(this, SIGNAL(requestPrinterDriverCancel()), loader, SLOT(cancel()));
+    connect(thread, SIGNAL(started()), loader, SLOT(process()));
+    connect(loader, SIGNAL(finished()), thread, SLOT(quit()));
+    connect(loader, SIGNAL(finished()), loader, SLOT(deleteLater()));
+    connect(loader, SIGNAL(loaded(const QList<PrinterDriver>&)),
+            this, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+    thread->start();
+}
+
+void PrinterCupsBackend::cancelPrinterDriverRequest()
+{
+    Q_EMIT requestPrinterDriverCancel();
+}
+
+void PrinterCupsBackend::refresh()
+{
+    if (m_printerName.isEmpty()) {
+        throw std::invalid_argument("Trying to refresh unnamed printer.");
+    } else {
+        m_info = QPrinterInfo::printerInfo(m_printerName);
+    }
+}
+
+void PrinterCupsBackend::createSubscription()
+{
+    m_cupsSubscriptionId = m_client->createSubscription();;
+}
+
+void PrinterCupsBackend::cancelSubscription()
+{
+    if (m_cupsSubscriptionId > 0)
+        m_client->cancelSubscription(m_cupsSubscriptionId);
+}
+
+QString PrinterCupsBackend::getPrinterInstance(const QString &name) const
+{
+    const auto parts = name.splitRef(QLatin1Char('/'));
+    QString instance;
+    if (parts.size() > 1)
+        instance = parts.at(1).toString();
+
+    return instance;
+}
+
+QString PrinterCupsBackend::getPrinterName(const QString &name) const
+{
+    return name.splitRef(QLatin1Char('/')).first().toString();
+}
+
+cups_dest_t* PrinterCupsBackend::getDest(const QString &name) const
+{
+    QString printerName = getPrinterName(name);
+    QString instance = getPrinterInstance(name);
+
+    if (m_dests.contains(name)) {
+        return m_dests[name];
+    } else {
+        m_dests[name] = m_client->getDest(printerName, instance);
+        return m_dests[name];
+    }
+}
+
+ppd_file_t* PrinterCupsBackend::getPpd(const QString &name) const
+{
+    QString printerName = getPrinterName(name);
+    QString instance = getPrinterInstance(name);
+
+    if (m_ppds.contains(name)) {
+        return m_ppds[name];
+    } else {
+        m_ppds[name] = m_client->getPpdFile(printerName, instance);
+        return m_ppds[name];
+    }
+}
+
+void PrinterCupsBackend::onPrinterLoaded(QSharedPointer<Printer> printer)
+{
+    m_activeRequests.remove(printer->name());
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_cups.h	2017-02-24 13:40:38 +0000
@@ -0,0 +1,136 @@
+/*
+ * 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_BACKEND_H
+#define USC_PRINTERS_CUPS_BACKEND_H
+
+#include "backend/backend.h"
+#include "cups/ippclient.h"
+#include "cupsdnotifier.h" // Note: this file was generated.
+
+#include <cups/cups.h>
+
+#include <QPrinterInfo>
+#include <QSet>
+
+class PRINTERS_DECL_EXPORT PrinterCupsBackend : public PrinterBackend
+{
+    Q_OBJECT
+public:
+    explicit PrinterCupsBackend(IppClient *client, QPrinterInfo info,
+                                OrgCupsCupsdNotifierInterface* notifier,
+                                QObject *parent = Q_NULLPTR);
+    virtual ~PrinterCupsBackend() override;
+
+    virtual bool holdsDefinition() const override;
+
+    virtual QString printerAdd(const QString &name,
+                               const QString &uri,
+                               const QString &ppdFile,
+                               const QString &info,
+                               const QString &location) override;
+    virtual QString printerAddWithPpd(const QString &name,
+                                      const QString &uri,
+                                      const QString &ppdFileName,
+                                      const QString &info,
+                                      const QString &location) override;
+    virtual QString printerDelete(const QString &name) override;
+    virtual QString printerSetDefault(const QString &name) override;
+    virtual QString printerSetEnabled(const QString &name,
+                                      const bool enabled) override;
+    virtual QString printerSetAcceptJobs(
+        const QString &name,
+        const bool accept,
+        const QString &reason = QString::null) override;
+    virtual QString printerSetInfo(const QString &name,
+                                   const QString &info) override;
+    virtual QString printerAddOption(const QString &name,
+                                     const QString &option,
+                                     const QStringList &values) override;
+
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const override;
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options
+    ) const override;
+    // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+    virtual cups_dest_t* makeDest(const QString &name,
+                                  const PrinterJob *options) override;
+
+    virtual void cancelJob(const QString &name, const int jobId) override;
+    virtual int printFileToDest(const QString &filepath,
+                                const QString &title,
+                                const cups_dest_t *dest) override;
+    virtual QList<QSharedPointer<PrinterJob>> printerGetJobs() override;
+
+    virtual QString printerName() const override;
+    virtual QString description() const override;
+    virtual QString location() const override;
+    virtual QString makeAndModel() const override;
+
+    virtual PrinterEnum::State state() const override;
+    virtual QList<QPageSize> supportedPageSizes() const override;
+    virtual QPageSize defaultPageSize() const override;
+    virtual bool supportsCustomPageSizes() const override;
+
+    virtual QPageSize minimumPhysicalPageSize() const override;
+    virtual QPageSize maximumPhysicalPageSize() const override;
+    virtual QList<int> supportedResolutions() const override;
+    virtual PrinterEnum::DuplexMode defaultDuplexMode() const override;
+    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override;
+
+    virtual QList<QSharedPointer<Printer>> availablePrinters() override;
+    virtual QStringList availablePrinterNames() override;
+    virtual QSharedPointer<Printer> getPrinter(const QString &printerName) override;
+    virtual QString defaultPrinterName() override;
+    virtual void requestPrinterDrivers() override;
+    virtual void requestPrinter(const QString &printerName) override;
+    virtual QMap<QString, QVariant> printerGetJobAttributes(
+        const QString &name, const int jobId) override;
+
+public Q_SLOTS:
+    virtual void refresh() override;
+    void createSubscription();
+
+Q_SIGNALS:
+    void cancelWorkers();
+    void printerDriversLoaded(const QList<PrinterDriver> &drivers);
+    void printerDriversFailedToLoad(const QString &errorMessage);
+    void requestPrinterDriverCancel();
+
+private:
+    void cancelSubscription();
+    void cancelPrinterDriverRequest();
+    QList<cups_job_t *> getCupsJobs(const QString &name = QStringLiteral());
+
+    QString getPrinterName(const QString &name) const;
+    QString getPrinterInstance(const QString &name) const;
+    cups_dest_t* getDest(const QString &name) const;
+    ppd_file_t* getPpd(const QString &name) const;
+    const QStringList m_knownQualityOptions;
+    IppClient *m_client;
+    QPrinterInfo m_info;
+    OrgCupsCupsdNotifierInterface *m_notifier;
+    int m_cupsSubscriptionId;
+    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;
+
+private Q_SLOTS:
+    void onPrinterLoaded(QSharedPointer<Printer> printer);
+};
+
+#endif // USC_PRINTERS_CUPS_BACKEND_H

=== added file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.cpp'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.cpp	2017-02-24 13:40:38 +0000
@@ -0,0 +1,119 @@
+/*
+ * 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 "i18n.h"
+#include "backend/backend_pdf.h"
+
+PrinterPdfBackend::PrinterPdfBackend(const QString &printerName,
+                                     QObject *parent)
+    : PrinterBackend(printerName, parent)
+{
+    m_type = PrinterEnum::PrinterType::PdfType;
+}
+
+QVariant PrinterPdfBackend::printerGetOption(const QString &name,
+                                             const QString &option) const
+{
+    auto res = printerGetOptions(name, QStringList({option}));
+    return res[option];
+}
+
+QMap<QString, QVariant> PrinterPdfBackend::printerGetOptions(
+    const QString &name, const QStringList &options) const
+{
+    Q_UNUSED(name);
+
+    QMap<QString, QVariant> ret;
+
+    ColorModel rgb;
+    rgb.colorType = PrinterEnum::ColorModelType::ColorType;
+    rgb.name = "RGB";
+    rgb.text = __("Color");
+
+    PrintQuality quality;
+    quality.name = __("Normal");
+
+    Q_FOREACH(const QString &option, options) {
+        if (option == QLatin1String("DefaultColorModel")) {
+            ret[option] = QVariant::fromValue(rgb);
+        } else if (option == QLatin1String("DefaultPrintQuality")) {
+            ret[option] = QVariant::fromValue(quality);
+        } else if (option == QLatin1String("SupportedPrintQualities")) {
+            auto qualities = QList<PrintQuality>({quality});
+            ret[option] = QVariant::fromValue(qualities);
+        } else if (option == QLatin1String("SupportedColorModels")) {
+            auto models = QList<ColorModel>{rgb};
+            ret[option] = QVariant::fromValue(models);
+        } else if (option == QLatin1String("AcceptJobs")) {
+            ret[option] = true;
+        } else {
+            throw std::invalid_argument("Invalid value for PDF printer: " + option.toStdString());
+        }
+    }
+
+    return ret;
+}
+
+QString PrinterPdfBackend::printerName() const
+{
+    return m_printerName;
+}
+
+PrinterEnum::State PrinterPdfBackend::state() const
+{
+    return PrinterEnum::State::IdleState;
+}
+
+QList<QPageSize> PrinterPdfBackend::supportedPageSizes() const
+{
+    return QList<QPageSize>{QPageSize(QPageSize::A4)};
+}
+
+QPageSize PrinterPdfBackend::defaultPageSize() const
+{
+    return QPageSize(QPageSize::A4);
+}
+
+bool PrinterPdfBackend::supportsCustomPageSizes() const
+{
+    return false;
+}
+
+QPageSize PrinterPdfBackend::minimumPhysicalPageSize() const
+{
+    return QPageSize(QPageSize::A4);
+}
+
+QPageSize PrinterPdfBackend::maximumPhysicalPageSize() const
+{
+    return QPageSize(QPageSize::A4);
+}
+
+QList<int> PrinterPdfBackend::supportedResolutions() const
+{
+    return QList<int>{};
+}
+
+PrinterEnum::DuplexMode PrinterPdfBackend::defaultDuplexMode() const
+{
+    return PrinterEnum::DuplexMode::DuplexNone;
+}
+
+QList<PrinterEnum::DuplexMode> PrinterPdfBackend::supportedDuplexModes() const
+{
+    return QList<PrinterEnum::DuplexMode>{PrinterEnum::DuplexMode::DuplexNone};
+}
+

=== added file 'modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.h'
--- modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/backend/backend_pdf.h	2017-02-24 13:40:38 +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_PDF_BACKEND_H
+#define USC_PRINTERS_PDF_BACKEND_H
+
+#include "backend/backend.h"
+
+class PRINTERS_DECL_EXPORT PrinterPdfBackend : public PrinterBackend
+{
+public:
+    explicit PrinterPdfBackend(const QString &printerName,
+                               QObject *parent = Q_NULLPTR);
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const override;
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options
+    ) const override;
+
+    virtual QString printerName() const override;
+
+    virtual PrinterEnum::State state() const override;
+    virtual QList<QPageSize> supportedPageSizes() const override;
+    virtual QPageSize defaultPageSize() const override;
+    virtual bool supportsCustomPageSizes() const override;
+
+    virtual QPageSize minimumPhysicalPageSize() const override;
+    virtual QPageSize maximumPhysicalPageSize() const override;
+    virtual QList<int> supportedResolutions() const override;
+    virtual PrinterEnum::DuplexMode defaultDuplexMode() const override;
+    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override;
+};
+
+#endif // USC_PRINTERS_PDF_BACKEND_H

=== added directory 'modules/Ubuntu/Components/Extras/Printers/cups'
=== added file 'modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp'
--- modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/ippclient.cpp	2017-02-24 13:40:38 +0000
@@ -0,0 +1,988 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ * Copyright (C) 2014 John Layt <[e-mail]>
+ * Copyright (C) 2002, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2013, 2014 Red Hat, Inc.
+ * Copyright (C) 2008 Novell, Inc.
+ *
+ * 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 <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <QDebug>
+#include <QDateTime>
+#include <QTimeZone>
+#include <QUrl>
+
+IppClient::IppClient()
+    : m_connection(httpConnectEncrypt(cupsServer(),
+                                      ippPort(),
+                                      cupsEncryption()))
+{
+    if (!m_connection) {
+        qCritical("Failed to connect to cupsd");
+    } else {
+        qDebug("Successfully connected to cupsd.");
+    }
+}
+
+IppClient::~IppClient()
+{
+    if (m_connection)
+        httpClose(m_connection);
+}
+
+bool IppClient::printerDelete(const QString &printerName)
+{
+    return sendNewSimpleRequest(CUPS_DELETE_PRINTER, printerName.toUtf8(),
+                                CupsResource::CupsResourceAdmin);
+}
+
+bool IppClient::printerAdd(const QString &printerName,
+                           const QString &printerUri,
+                           const QString &ppdFile,
+                           const QString &info,
+                           const QString &location)
+{
+    ipp_t *request;
+
+    if (!isPrinterNameValid(printerName)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(printerName));
+        return false;
+    }
+
+    if (!isStringValid(info)) {
+        setInternalStatus(QString("%1 is not a valid description.").arg(info));
+        return false;
+    }
+
+    if (!isStringValid(location)) {
+        setInternalStatus(QString("%1 is not a valid location.").arg(location));
+        return false;
+    }
+
+    if (!isStringValid(ppdFile)) {
+        setInternalStatus(QString("%1 is not a valid ppd file.").arg(ppdFile));
+        return false;
+    }
+
+    if (!isStringValid(printerUri)) {
+        setInternalStatus(QString("%1 is not a valid printer uri.").arg(printerUri));
+        return false;
+    }
+
+
+    request = ippNewRequest (CUPS_ADD_MODIFY_PRINTER);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+
+    ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME,
+                 "printer-name", NULL, printerName.toUtf8());
+
+    if (!ppdFile.isEmpty()) {
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME,
+                     "ppd-name", NULL, ppdFile.toUtf8());
+    }
+    if (!printerUri.isEmpty()) {
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_URI,
+                     "device-uri", NULL, printerUri.toUtf8());
+    }
+    if (!info.isEmpty()) {
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT,
+                     "printer-info", NULL, info.toUtf8());
+    }
+    if (!location.isEmpty()) {
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT,
+                     "printer-location", NULL, location.toUtf8());
+    }
+
+    return sendRequest(request, CupsResourceAdmin);
+}
+
+bool IppClient::printerAddWithPpdFile(const QString &printerName,
+                                      const QString &printerUri,
+                                      const QString &ppdFileName,
+                                      const QString &info,
+                                      const QString &location)
+{
+    ipp_t *request;
+
+    if (!isPrinterNameValid(printerName)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(printerName));
+        return false;
+    }
+
+    if (!isStringValid(info)) {
+        setInternalStatus(QString("%1 is not a valid description.").arg(info));
+        return false;
+    }
+
+    if (!isStringValid(location)) {
+        setInternalStatus(QString("%1 is not a valid location.").arg(location));
+        return false;
+    }
+
+    if (!isStringValid(ppdFileName)) {
+        setInternalStatus(QString("%1 is not a valid ppd file name.").arg(ppdFileName));
+        return false;
+    }
+
+    if (!isStringValid(printerUri)) {
+        setInternalStatus(QString("%1 is not a valid printer uri.").arg(printerUri));
+        return false;
+    }
+
+    request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+
+    ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME,
+                 "printer-name", NULL, printerName.toUtf8());
+
+    /* In this specific case of ADD_MODIFY, the URI can be NULL/empty since
+     * we provide a complete PPD. And cups fails if we pass an empty
+     * string. */
+    if (!printerUri.isEmpty()) {
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_URI,
+                     "device-uri", NULL, printerUri.toUtf8());
+    }
+
+    if (!info.isEmpty()) {
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT,
+                     "printer-info", NULL, info.toUtf8());
+    }
+    if (!location.isEmpty()) {
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT,
+                     "printer-location", NULL, location.toUtf8());
+    }
+
+    return postRequest(request, ppdFileName.toUtf8(), CupsResourceAdmin);
+}
+
+bool IppClient::printerSetDefault(const QString &printerName)
+{
+    return sendNewSimpleRequest(CUPS_SET_DEFAULT, printerName.toUtf8(),
+                                CupsResource::CupsResourceAdmin);
+}
+
+bool IppClient::printerSetEnabled(const QString &printerName,
+                                  const bool enabled)
+{
+    ipp_op_t op;
+    op = enabled ? IPP_RESUME_PRINTER : IPP_PAUSE_PRINTER;
+    return sendNewSimpleRequest(op, printerName, CupsResourceAdmin);
+}
+
+/* reason must be empty if accept is true */
+bool IppClient::printerSetAcceptJobs(const QString &printerName,
+                                     const bool accept,
+                                     const QString &reason)
+{
+    ipp_t *request;
+
+    if (accept && !reason.isEmpty()) {
+        setInternalStatus("Accepting jobs does not take a reason.");
+        return false;
+    }
+
+    if (!isPrinterNameValid(printerName)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(printerName));
+        return false;
+    }
+
+    if (!isStringValid(reason)) {
+        setInternalStatus(QString("%1 is not a valid reason.").arg(reason));
+        return false;
+    }
+
+    if (accept) {
+        return sendNewSimpleRequest(CUPS_ACCEPT_JOBS, printerName.toUtf8(),
+                                    CupsResourceAdmin);
+    } else {
+        request = ippNewRequest(CUPS_REJECT_JOBS);
+        addPrinterUri(request, printerName);
+        addRequestingUsername(request, NULL);
+
+        if (!reason.isEmpty())
+            ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_TEXT,
+                         "printer-state-message", NULL, reason.toUtf8());
+
+        return sendRequest(request, CupsResourceAdmin);
+    }
+}
+
+
+bool IppClient::printerClassSetInfo(const QString &name,
+                                       const QString &info)
+{
+    if (!isPrinterNameValid(name)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(name));
+        return false;
+    }
+
+    if (!isStringValid(info)) {
+        setInternalStatus(QString("%1 is not a valid description.").arg(info));
+        return false;
+    }
+
+    return sendNewPrinterClassRequest(name, IPP_TAG_PRINTER, IPP_TAG_TEXT,
+                                      "printer-info", info);
+}
+
+bool IppClient::printerClassSetOption(const QString &name,
+                                      const QString &option,
+                                      const QStringList &values)
+{
+    bool isClass;
+    int length = 0;
+    ipp_t *request;
+    ipp_attribute_t *attr;
+    QString newPpdFile;
+    bool retval;
+
+    if (!isPrinterNameValid(name)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(name));
+        return false;
+    }
+
+    if (!isStringValid(option)) {
+        setInternalStatus(QString("%1 is not a valid option.").arg(option));
+        return false;
+    }
+
+    Q_FOREACH(const QString &val, values) {
+        if (!isStringValid(val)) {
+            setInternalStatus(QString("%1 is not a valid value.").arg(val));
+            return false;
+        }
+        length++;
+    }
+
+    if (length == 0) {
+        setInternalStatus("No valid values.");
+        return false;
+    }
+
+    isClass = printerIsClass(name);
+
+    /* We permit only one value to change in PPD file because we are setting
+     * default value in it. */
+    if (!isClass && length == 1) {
+        cups_option_t *options = NULL;
+        int numOptions = 0;
+        QString ppdfile;
+
+        numOptions = cupsAddOption(option.toUtf8(),
+                                   values[0].toUtf8(),
+                                   numOptions, &options);
+
+        ppdfile = QString(cupsGetPPD(name.toUtf8()));
+
+        newPpdFile = preparePpdForOptions(ppdfile.toUtf8(),
+                                          options, numOptions).toLatin1().data();
+
+        unlink(ppdfile.toUtf8());
+        cupsFreeOptions(numOptions, options);
+    }
+
+    if (isClass) {
+        request = ippNewRequest(CUPS_ADD_MODIFY_CLASS);
+        addClassUri(request, name);
+    } else {
+        request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER);
+        addPrinterUri(request, name);
+    }
+
+    addRequestingUsername(request, NULL);
+
+    if (length == 1) {
+        ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME,
+                     option.toUtf8(),
+                     NULL,
+                     values[0].toUtf8());
+    } else {
+        int i;
+
+        attr = ippAddStrings(request, IPP_TAG_PRINTER, IPP_TAG_NAME,
+                             option.toUtf8(), length, NULL, NULL);
+
+        for (i = 0; i < length; i++)
+            ippSetString(request, &attr, i, values[i].toUtf8());
+    }
+
+    if (!newPpdFile.isEmpty()) {
+        retval = postRequest(request, newPpdFile, CupsResourceAdmin);
+
+        unlink(newPpdFile.toUtf8());
+        // TODO: fix leak here.
+    } else {
+        retval = sendRequest(request, CupsResourceAdmin);
+    }
+
+    return retval;
+}
+
+QMap<QString, QVariant> IppClient::printerGetJobAttributes(const int jobId)
+{
+    ipp_t *request;
+    QMap<QString, QVariant> 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());
+
+
+    // Send request and construct reply
+    ipp_t *reply;
+    const QString resourceChar = getResource(CupsResourceRoot);
+    reply = cupsDoRequest(m_connection, request,
+                          resourceChar.toUtf8());
+
+    // Check if the reply is OK
+    if (isReplyOk(reply, false)) {
+        // Loop through the attributes
+        ipp_attribute_t *attr;
+
+        for (attr = ippFirstAttribute(reply); attr; attr = ippNextAttribute(reply)) {
+            QVariant value = getAttributeValue(attr);
+            map.insert(ippGetName(attr), value);
+        }
+    } else {
+        qWarning() << "Not able to get attributes of job:" << jobId;
+    }
+
+    // Destruct the reply if valid
+    if (reply) {
+        ippDelete(reply);
+    }
+
+    return map;
+}
+
+
+/* This function sets given options to specified values in file 'ppdfile'.
+ * This needs to be done because of applications which use content of PPD files
+ * instead of IPP attributes.
+ * CUPS doesn't do this automatically (but hopefully will starting with 1.6) */
+QString IppClient::preparePpdForOptions(const QString &ppdfile,
+                                        cups_option_t *options, int numOptions)
+{
+    auto ppdfile_c = ppdfile.toUtf8();
+    ppd_file_t *ppd;
+    bool ppdchanged = false;
+    QString result;
+    QString error;
+    char newppdfile[PATH_MAX];
+    cups_file_t  *in = NULL;
+    cups_file_t  *out = NULL;
+    char line[CPH_STR_MAXLEN];
+    char keyword[CPH_STR_MAXLEN];
+    char *keyptr;
+    ppd_choice_t *choice;
+    QString value;
+    QLatin1String defaultStr("*Default");
+
+    ppd = ppdOpenFile(ppdfile_c);
+    if (!ppd) {
+        error = QString("Unable to open PPD file \"%1\": %2")
+                .arg(ppdfile).arg(strerror(errno));
+        setInternalStatus(error);
+        goto out;
+    }
+
+    in = cupsFileOpen(ppdfile_c, "r");
+    if (!in) {
+        error = QString("Unable to open PPD file \"%1\": %2")
+            .arg(ppdfile).arg(strerror(errno));
+        setInternalStatus(error);
+        goto out;
+    }
+
+    out = cupsTempFile2(newppdfile, sizeof(newppdfile));
+    if (!out) {
+        setInternalStatus("Unable to create temporary file");
+        goto out;
+    }
+
+    /* Mark default values and values of options we are changing. */
+    ppdMarkDefaults(ppd);
+    cupsMarkOptions(ppd, numOptions, options);
+
+    while (cupsFileGets(in, line, sizeof(line))) {
+        QString line_qs(line);
+        if (!line_qs.startsWith(defaultStr)) {
+            cupsFilePrintf(out, "%s\n", line);
+        } else {
+            /* This part parses lines with *Default on their
+             * beginning. For instance:
+             *   "*DefaultResolution: 1200dpi" becomes:
+             *     - keyword: Resolution
+             *     - keyptr: 1200dpi
+             */
+            strncpy(keyword, line + defaultStr.size(), sizeof(keyword));
+
+            for (keyptr = keyword; *keyptr; keyptr++)
+                    if (*keyptr == ':' || isspace (*keyptr & 255))
+                            break;
+
+            *keyptr++ = '\0';
+            while (isspace (*keyptr & 255))
+                    keyptr++;
+
+            QString keyword_sq(keyword);
+            QString keyptr_qs(keyptr);
+
+            /* We have to change PageSize if any of PageRegion,
+             * PageSize, PaperDimension or ImageableArea changes.
+             * We change PageRegion if PageSize is not available. */
+            if (keyword_sq == "PageRegion" ||
+                keyword_sq == "PageSize" ||
+                keyword_sq == "PaperDimension" ||
+                keyword_sq == "ImageableArea") {
+
+                choice = ppdFindMarkedChoice(ppd, "PageSize");
+                if (!choice)
+                    choice = ppdFindMarkedChoice(ppd, "PageRegion");
+            } else {
+                choice = ppdFindMarkedChoice(ppd, keyword);
+            }
+
+
+            QString choice_qs;
+            if (choice) {
+                choice_qs = choice->choice;
+            }
+
+            if (choice && choice_qs != keyptr_qs) {
+                /* We have to set the value in PPD manually if
+                 * a custom value was passed in:
+                 * cupsMarkOptions() marks the choice as
+                 * "Custom". We want to set this value with our
+                 * input. */
+                if (choice_qs != "Custom") {
+                    cupsFilePrintf(out,
+                                   "*Default%s: %s\n",
+                                   keyword,
+                                   choice->choice);
+                    ppdchanged = true;
+                } else {
+                    value = cupsGetOption(keyword, numOptions, options);
+                    if (!value.isEmpty()) {
+                        cupsFilePrintf(out,
+                                       "*Default%s: %s\n",
+                                       keyword,
+                                       value.toStdString().c_str());
+                        ppdchanged = true;
+                    } else {
+                        cupsFilePrintf(out, "%s\n", line);
+                    }
+                }
+            } else {
+                cupsFilePrintf(out, "%s\n", line);
+            }
+        }
+    }
+
+    if (ppdchanged)
+        result = QString::fromUtf8(newppdfile);
+    else
+        unlink(newppdfile);
+
+out:
+    if (in)
+        cupsFileClose(in);
+    if (out)
+        cupsFileClose(out);
+    if (ppd)
+        ppdClose(ppd);
+
+    return result;
+}
+
+
+bool IppClient::sendNewPrinterClassRequest(const QString &printerName,
+                                           ipp_tag_t group, ipp_tag_t type,
+                                           const QString &name,
+                                           const QString &value)
+{
+    ipp_t *request;
+
+    request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, QString());
+    ippAddString(request, group, type, name.toUtf8(), NULL,
+                 value.toUtf8());
+
+    if (sendRequest(request, CupsResource::CupsResourceAdmin))
+        return true;
+
+    // it failed, maybe it was a class?
+    if (m_lastStatus != IPP_NOT_POSSIBLE) {
+        return false;
+    }
+
+    // TODO: implement class modification <here>.
+    return false;
+}
+
+void IppClient::addPrinterUri(ipp_t *request, const QString &name)
+{
+    QUrl uri(QString("ipp://localhost/printers/%1").arg(name));
+    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                 "printer-uri", NULL, uri.toEncoded().data());
+}
+
+void IppClient::addRequestingUsername(ipp_t *request, const QString &username)
+{
+    if (!username.isEmpty())
+        ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                     "requesting-user-name", NULL,
+                     username.toUtf8());
+    else
+        ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
+                     "requesting-user-name", NULL, cupsUser());
+}
+
+QString IppClient::getLastError() const
+{
+    return m_internalStatus;
+}
+
+const QString IppClient::getResource(const IppClient::CupsResource &resource)
+{
+    switch (resource) {
+    case CupsResourceRoot:
+        return "/";
+    case CupsResourceAdmin:
+        return "/admin/";
+    case CupsResourceJobs:
+        return "/jobs/";
+    default:
+        qCritical("Asking for a resource with no match.");
+        return "/";
+    }
+}
+
+bool IppClient::isPrinterNameValid(const QString &name)
+{
+    int i;
+    int len;
+
+    /* Quoting the lpadmin man page:
+     *    CUPS allows printer names to contain any printable character
+     *    except SPACE, TAB, "/", or  "#".
+     * On top of that, validate_name() in lpadmin.c (from cups) checks that
+     * the string is 127 characters long, or shorter. */
+
+    /* no empty string */
+    if (name.isEmpty())
+        return false;
+
+    len = name.size();
+    /* no string that is too long; see comment at the beginning of the
+     * validation code block */
+    if (len > 127)
+        return false;
+
+    /* only printable characters, no space, no /, no # */
+    for (i = 0; i < len; i++) {
+        const QChar c = name.at(i);
+        if (!c.isPrint())
+            return false;
+        if (c.isSpace())
+            return false;
+        if (c == '/' || c == '#')
+            return false;
+    }
+    return true;
+}
+
+bool IppClient::isStringValid(const QString &string, const bool checkNull,
+                              const int maxLength)
+{
+    if (isStringPrintable(string, checkNull, maxLength))
+        return true;
+    return false;
+}
+
+bool IppClient::isStringPrintable(const QString &string, const bool checkNull,
+                                  const int maxLength)
+{
+    int i;
+    int len;
+
+    /* no null string */
+    if (string.isNull())
+        return !checkNull;
+
+    len = string.size();
+    if (maxLength > 0 && len > maxLength)
+        return false;
+
+    /* only printable characters */
+    for (i = 0; i < len; i++) {
+        const QChar c = string.at(i);
+        if (!c.isPrint())
+            return false;
+    }
+    return true;
+}
+
+void IppClient::setInternalStatus(const QString &status)
+{
+    if (!m_internalStatus.isNull()) {
+        m_internalStatus = QString::null;
+    }
+
+    if (status.isNull()) {
+        m_internalStatus = QString::null;
+    } else {
+        m_internalStatus = status;
+
+        // Only used for errors for now.
+        qCritical() << status;
+    }
+}
+
+bool IppClient::postRequest(ipp_t *request, const QString &file,
+                            const CupsResource &resource)
+{
+    ipp_t *reply;
+    QString resourceChar;
+
+    resourceChar = getResource(resource);
+
+    if (!file.isEmpty())
+        reply = cupsDoFileRequest(m_connection, request, resourceChar.toUtf8(),
+                                  file.toUtf8());
+    else
+        reply = cupsDoFileRequest(m_connection, request, resourceChar.toUtf8(),
+                                  NULL);
+
+    return handleReply(reply);
+}
+
+
+bool IppClient::sendRequest(ipp_t *request, const CupsResource &resource)
+{
+    ipp_t *reply;
+    const QString resourceChar = getResource(resource);
+    reply = cupsDoRequest(m_connection, request,
+                          resourceChar.toUtf8());
+    return handleReply(reply);
+}
+
+bool IppClient::sendNewSimpleRequest(ipp_op_t op, const QString &printerName,
+                                     const IppClient::CupsResource &resource)
+{
+    ipp_t *request;
+
+    if (!isPrinterNameValid(printerName))
+        return false;
+
+    request = ippNewRequest(op);
+    addPrinterUri(request, printerName);
+    addRequestingUsername(request, NULL);
+
+    return sendRequest(request, resource);
+}
+
+bool IppClient::handleReply(ipp_t *reply)
+{
+    bool retval;
+    retval = isReplyOk(reply, false);
+    if (reply)
+        ippDelete(reply);
+
+    return retval;
+}
+
+bool IppClient::isReplyOk(ipp_t *reply, bool deleteIfReplyNotOk)
+{
+    /* reset the internal status: we'll use the cups status */
+    m_lastStatus = IPP_STATUS_CUPS_INVALID;
+
+    if (reply && ippGetStatusCode(reply) <= IPP_OK_CONFLICT) {
+        m_lastStatus = IPP_OK;
+        return true;
+    } else {
+        setErrorFromReply(reply);
+        qWarning() << Q_FUNC_INFO << "Cups HTTP error:" << cupsLastErrorString();
+
+        if (deleteIfReplyNotOk && reply)
+            ippDelete(reply);
+
+        return false;
+    }
+}
+
+void IppClient::setErrorFromReply(ipp_t *reply)
+{
+    if (reply)
+        m_lastStatus = ippGetStatusCode(reply);
+    else
+        m_lastStatus = cupsLastError();
+}
+
+bool IppClient::printerIsClass(const QString &name)
+{
+    const char * const attrs[1] = { "member-names" };
+    ipp_t *request;
+    QString resource;
+    ipp_t *reply;
+    bool retval;
+
+    // Class/Printer name validation is equal.
+    if (!isPrinterNameValid(name)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(name));
+        return false;
+    }
+
+    request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
+    addClassUri(request, name);
+    addRequestingUsername(request, QString());
+    ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
+                  "requested-attributes", 1, NULL, attrs);
+
+    resource = getResource(CupsResource::CupsResourceRoot);
+    reply = cupsDoRequest(m_connection, request, resource.toUtf8());
+
+    if (!isReplyOk(reply, true))
+        return true;
+
+    /* Note: we need to look if the attribute is there, since we get a
+     * reply if the name is a printer name and not a class name. The
+     * attribute is the only way to distinguish the two cases. */
+    retval = ippFindAttribute(reply, attrs[0], IPP_TAG_NAME) != NULL;
+
+    if (reply)
+        ippDelete(reply);
+
+    return retval;
+}
+
+void IppClient::addClassUri(ipp_t *request, const QString &name)
+{
+    QUrl uri(QString("ipp://localhost/printers/%1").arg(name));
+    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                 "printer-uri", NULL, uri.toEncoded().data());
+}
+
+ppd_file_t* IppClient::getPpdFile(const QString &name,
+                                  const QString &instance) const
+{
+    Q_UNUSED(instance);
+
+    ppd_file_t* file = 0;
+    const char *ppdFile = cupsGetPPD(name.toUtf8());
+    if (ppdFile) {
+        file = ppdOpenFile(ppdFile);
+        unlink(ppdFile);
+    }
+    if (file) {
+        ppdMarkDefaults(file);
+    } else {
+        file = 0;
+    }
+
+    return file;
+}
+
+cups_dest_t* IppClient::getDest(const QString &name,
+                                const QString &instance) const
+{
+    cups_dest_t *dest = 0;
+
+    if (instance.isEmpty()) {
+        dest = cupsGetNamedDest(m_connection, name.toUtf8(), NULL);
+    } else {
+        dest = cupsGetNamedDest(m_connection, name.toUtf8(), instance.toUtf8());
+    }
+    return dest;
+}
+
+ipp_t* IppClient::createPrinterDriversRequest(
+    const QString &deviceId, const QString &language, const QString &makeModel,
+    const QString &product, const QStringList &includeSchemes,
+    const QStringList &excludeSchemes
+)
+{
+    Q_UNUSED(includeSchemes);
+    Q_UNUSED(excludeSchemes);
+
+    ipp_t *request;
+
+    request = ippNewRequest(CUPS_GET_PPDS);
+
+    if (!deviceId.isEmpty())
+    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_TEXT, "ppd-device-id",
+                 NULL, deviceId.toUtf8());
+    if (!language.isEmpty())
+    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE, "ppd-language",
+                 NULL, language.toUtf8());
+    if (!makeModel.isEmpty())
+    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_TEXT, "ppd-make-and-model",
+                 NULL, makeModel.toUtf8());
+    if (!product.isEmpty())
+    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_TEXT, "ppd-product",
+                 NULL, product.toUtf8());
+
+    // Do the request and get return the response.
+    const QString resourceChar = getResource(CupsResourceRoot);
+    return cupsDoRequest(m_connection, request,
+                         resourceChar.toUtf8());
+}
+
+int IppClient::createSubscription()
+{
+    ipp_t *req;
+    ipp_t *resp;
+    ipp_attribute_t *attr;
+    int subscriptionId = -1;
+
+    req = ippNewRequest(IPP_CREATE_PRINTER_SUBSCRIPTION);
+    ippAddString(req, IPP_TAG_OPERATION, IPP_TAG_URI,
+                 "printer-uri", NULL, "/");
+    ippAddString(req, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
+                 "notify-events", NULL, "all");
+    ippAddString(req, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
+                 "notify-recipient-uri", NULL, "dbus://");
+    ippAddInteger(req, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
+                  "notify-lease-duration", 0);
+
+    resp = cupsDoRequest(m_connection, req,
+                         getResource(CupsResourceRoot).toUtf8());
+    if (!isReplyOk(resp, true)) {
+        return subscriptionId;
+    }
+
+    attr = ippFindAttribute(resp, "notify-subscription-id", IPP_TAG_INTEGER);
+
+    if (!attr) {
+        qWarning() << "ipp-create-printer-subscription response doesn't"
+                       "  contain subscription id.";
+    } else {
+        subscriptionId = ippGetInteger(attr, 0);
+    }
+
+    ippDelete (resp);
+
+    return subscriptionId;
+}
+
+void IppClient::cancelSubscription(const int &subscriptionId)
+{
+    ipp_t *req;
+    ipp_t *resp;
+
+    if (subscriptionId <= 0) {
+        return;
+    }
+
+    req = ippNewRequest(IPP_CANCEL_SUBSCRIPTION);
+    ippAddString(req, IPP_TAG_OPERATION, IPP_TAG_URI,
+                 "printer-uri", NULL, "/");
+    ippAddInteger(req, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                  "notify-subscription-id", subscriptionId);
+
+    resp = cupsDoRequest(m_connection, req,
+                         getResource(CupsResourceRoot).toUtf8());
+    if (!isReplyOk(resp, true)) {
+        return;
+    }
+
+    ippDelete(resp);
+}
+
+QVariant IppClient::getAttributeValue(ipp_attribute_t *attr, int index) const
+{
+    QVariant var;
+
+    if (ippGetCount(attr) > 1 && index < 0) {
+        QList<QVariant> list;
+
+        for (int i=0; i < ippGetCount(attr); i++) {
+            list.append(getAttributeValue(attr, i));
+        }
+
+        var = QVariant::fromValue<QList<QVariant>>(list);
+    } else {
+        if (index == -1) {
+            index = 0;
+        }
+
+        switch (ippGetValueTag(attr)) {
+        case IPP_TAG_NAME:
+        case IPP_TAG_TEXT:
+        case IPP_TAG_KEYWORD:
+        case IPP_TAG_URI:
+        case IPP_TAG_CHARSET:
+        case IPP_TAG_MIMETYPE:
+        case IPP_TAG_LANGUAGE:
+            var = QVariant::fromValue<QString>(ippGetString(attr, index, NULL));
+            break;
+        case IPP_TAG_INTEGER:
+        case IPP_TAG_ENUM:
+            var = QVariant::fromValue<int>(ippGetInteger(attr, index));
+            break;
+        case IPP_TAG_BOOLEAN:
+            var = QVariant::fromValue<bool>(ippGetBoolean(attr, index));
+            break;
+        case IPP_TAG_RANGE: {
+            QString range;
+            int upper;
+            int lower = ippGetRange(attr, index, &upper);
+
+            // Build a string similar to "1-3" "5-" "8" "-4"
+            if (lower != INT_MIN) {
+                range += QString::number(lower);
+            }
+
+            if (lower != upper) {
+                range += QStringLiteral("-");
+
+                if (upper != INT_MAX) {
+                    range += QString::number(upper);
+                }
+            }
+
+            var = QVariant(range);
+            break;
+        }
+        case IPP_TAG_NOVALUE:
+            var = QVariant();
+            break;
+        case IPP_TAG_DATE: {
+            time_t time = ippDateToTime(ippGetDate(attr, index));
+            QDateTime datetime;
+            datetime.setTimeZone(QTimeZone::systemTimeZone());
+            datetime.setTime_t(time);
+
+            var = QVariant::fromValue<QDateTime>(datetime);
+            break;
+        }
+        default:
+            qWarning() << "Unknown IPP value tab 0x" << ippGetValueTag(attr);
+            break;
+        }
+    }
+
+    return var;
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h'
--- modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/cups/ippclient.h	2017-02-24 13:40:38 +0000
@@ -0,0 +1,121 @@
+/*
+ * 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_IPPCLIENT_H
+#define USC_PRINTERS_CUPS_IPPCLIENT_H
+
+#include "structs.h"
+
+#include <cups/cups.h>
+#include <cups/http.h>
+#include <cups/ipp.h>
+#include <cups/ppd.h>
+
+#include <QString>
+#include <QStringList>
+
+/* From https://bugzilla.novell.com/show_bug.cgi?id=447444#c5
+ * We need to define a maximum length for strings to avoid cups
+ * thinking there are multiple lines.
+ */
+#define CPH_STR_MAXLEN 512
+
+class IppClient
+{
+public:
+    explicit IppClient();
+    ~IppClient();
+
+    bool printerDelete(const QString &printerName);
+    bool printerAdd(const QString &printerName,
+                    const QString &printerUri,
+                    const QString &ppdFile,
+                    const QString &info,
+                    const QString &location);
+
+    bool printerAddWithPpdFile(const QString &printerName,
+                               const QString &printerUri,
+                               const QString &ppdFileName,
+                               const QString &info,
+                               const QString &location);
+    bool printerSetDefault(const QString &printerName);
+    bool printerSetEnabled(const QString &printerName, const bool enabled);
+    bool printerSetAcceptJobs(const QString &printerName, const bool accept,
+                              const QString &reason);
+    bool printerClassSetInfo(const QString &name, const QString &info);
+    bool printerClassSetOption(const QString &name, const QString &option,
+                               const QStringList &values);
+    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);
+
+    QString getLastError() const;
+
+    // Note: This response needs to be free by the caller.
+    ipp_t* createPrinterDriversRequest(
+        const QString &deviceId, const QString &language,
+        const QString &makeModel, const QString &product,
+        const QStringList &includeSchemes, const QStringList &excludeSchemes
+    );
+    int createSubscription();
+    void cancelSubscription(const int &subscriptionId);
+
+private:
+    enum CupsResource
+    {
+        CupsResourceRoot = 0,
+        CupsResourceAdmin,
+        CupsResourceJobs,
+    };
+
+    bool sendNewPrinterClassRequest(const QString &printerName,
+                                    ipp_tag_t group,
+                                    ipp_tag_t type,
+                                    const QString &name,
+                                    const QString &value);
+    static void addPrinterUri(ipp_t *request, const QString &name);
+    static void addRequestingUsername(ipp_t *request, const QString &username);
+    static const QString getResource(const CupsResource &resource);
+    static bool isPrinterNameValid(const QString &name);
+    static void addClassUri(ipp_t *request, const QString &name);
+    static bool isStringValid(const QString &string,
+                              const bool checkNull = false,
+                              const int maxLength = 512);
+    static bool isStringPrintable(const QString &string, const bool checkNull,
+                                  const int maxLength);
+    QString preparePpdForOptions(const QString &ppdfile,
+                                 cups_option_t *options,
+                                 int numOptions);
+    bool printerIsClass(const QString &name);
+    void setInternalStatus(const QString &status);
+    bool postRequest(ipp_t *request, const QString &file,
+                     const CupsResource &resource);
+    bool sendRequest(ipp_t *request, const CupsResource &resource);
+    bool sendNewSimpleRequest(ipp_op_t op, const QString &printerName,
+                              const CupsResource &resource);
+    bool handleReply(ipp_t *reply);
+    bool isReplyOk(ipp_t *reply, bool deleteIfReplyNotOk);
+    void setErrorFromReply(ipp_t *reply);
+    QVariant getAttributeValue(ipp_attribute_t *attr, int index=-1) const;
+
+    http_t *m_connection;
+    ipp_status_t m_lastStatus = IPP_OK;
+    mutable QString m_internalStatus = QString::null;
+};
+
+
+#endif // USC_PRINTERS_CUPS_IPPCLIENT_H

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

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

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

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

=== added file 'modules/Ubuntu/Components/Extras/Printers/enums.h'
--- modules/Ubuntu/Components/Extras/Printers/enums.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/enums.h	2017-02-24 13:40:38 +0000
@@ -0,0 +1,106 @@
+/*
+ * 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_ENUMS_H
+#define USC_PRINTERS_ENUMS_H
+
+#include "printers_global.h"
+
+#include <QtCore/QObject>
+
+class PRINTERS_DECL_EXPORT PrinterEnum
+{
+    Q_GADGET
+
+public:
+    enum class AccessControl
+    {
+        AccessAllow = 0,
+        AccessDeny,
+    };
+    Q_ENUM(AccessControl)
+
+    enum class ColorModelType
+    {
+        GrayType = 0,
+        ColorType,
+        UnknownType,
+    };
+    Q_ENUM(ColorModelType)
+
+    enum class DuplexMode
+    {
+        DuplexNone = 0,
+        DuplexLongSide,
+        DuplexShortSide,
+    };
+    Q_ENUM(DuplexMode)
+
+    enum class ErrorPolicy
+    {
+        RetryOnError = 0,
+        AbortOnError,
+        StopPrinterOnError,
+        RetryCurrentOnError,
+    };
+    Q_ENUM(ErrorPolicy)
+
+    // Match enums from ipp_jstate_t
+    enum class JobState
+    {
+        Pending = 3,
+        Held,
+        Processing,
+        Stopped,
+        Canceled,
+        Aborted,
+        Complete,
+    };
+    Q_ENUM(JobState)
+
+    enum class OperationPolicy
+    {
+        DefaultOperation = 0,
+        AuthenticatedOperation,
+    };
+    Q_ENUM(OperationPolicy)
+
+    enum class PrintRange
+    {
+        AllPages = 0,
+        PageRange,
+    };
+    Q_ENUM(PrintRange)
+
+    enum class State
+    {
+        IdleState = 0,
+        ActiveState,
+        AbortedState,
+        ErrorState,
+    };
+    Q_ENUM(State)
+
+    enum class PrinterType
+    {
+        ProxyType = 0, // Represents a printer not yet loaded.
+        CupsType,
+        PdfType,
+    };
+    Q_ENUM(PrinterType)
+};
+
+#endif // USC_PRINTERS_ENUMS_H

=== added file 'modules/Ubuntu/Components/Extras/Printers/i18n.cpp'
--- modules/Ubuntu/Components/Extras/Printers/i18n.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/i18n.cpp	2017-02-24 13:40:38 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2014, 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/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ *              Andrew Hayzen <[e-mail]>
+ */
+
+#define NO_TR_OVERRIDE
+#include "i18n.h"
+
+#include <libintl.h>
+
+const char *thisDomain = "";
+
+void initTr(const char *domain, const char *localeDir)
+{
+    // Don't bind the domain or set textdomain as it changes the Apps domain
+    // as well. Instead store the domain and use it in the lookups
+    Q_UNUSED(localeDir);
+
+    thisDomain = domain;
+}
+
+QString __(const char *text, const char *domain)
+{
+    Q_UNUSED(domain);
+
+    // Use the stored domain
+    return QString::fromUtf8(dgettext(thisDomain, text));
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/i18n.h'
--- modules/Ubuntu/Components/Extras/Printers/i18n.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/i18n.h	2017-02-24 13:40:38 +0000
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2014, 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/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ *              Andrew Hayzen <[e-mail]>
+ */
+
+#ifndef I18N_H
+#define I18N_H
+
+#include <QtCore/QString>
+
+void initTr(const char *domain, const char *localeDir);
+QString __(const char *text, const char *domain = 0);
+
+#endif // I18N_H
+

=== added directory 'modules/Ubuntu/Components/Extras/Printers/models'
=== added file 'modules/Ubuntu/Components/Extras/Printers/models/drivermodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/drivermodel.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/drivermodel.cpp	2017-02-24 13:40:38 +0000
@@ -0,0 +1,175 @@
+/*
+ * 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/drivermodel.h"
+
+#include <QDebug>
+#include <QtConcurrent>
+
+DriverModel::DriverModel(PrinterBackend *backend, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_backend(backend)
+{
+    connect(m_backend, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)),
+            this, SLOT(printerDriversLoaded(const QList<PrinterDriver>&)));
+
+    QObject::connect(&m_watcher,
+                     &QFutureWatcher<PrinterDriver>::finished,
+                     this,
+                     &DriverModel::filterFinished);
+
+}
+
+DriverModel::~DriverModel()
+{
+    cancel();
+}
+
+int DriverModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return m_drivers.size();
+}
+
+int DriverModel::count() const
+{
+    return rowCount();
+}
+
+QVariant DriverModel::data(const QModelIndex &index, int role) const
+{
+    QVariant ret;
+
+    if ((0 <= index.row()) && (index.row() < m_drivers.size())) {
+
+        auto driver = m_drivers[index.row()];
+
+        switch (role) {
+        case Qt::DisplayRole:
+            ret = driver.toString();
+            break;
+        case NameRole:
+            ret = driver.name;
+            break;
+        case DeviceIdRole:
+            ret = driver.deviceId;
+            break;
+        case LanguageRole:
+            ret = driver.language;
+            break;
+        case MakeModelRole:
+            ret = driver.makeModel;
+            break;
+        }
+    }
+
+    return ret;
+}
+
+QHash<int, QByteArray> DriverModel::roleNames() const
+{
+    static QHash<int,QByteArray> names;
+
+    if (Q_UNLIKELY(names.empty())) {
+        names[Qt::DisplayRole] = "displayName";
+        names[NameRole] = "name";
+        names[DeviceIdRole] = "deviceId";
+        names[LanguageRole] = "language";
+        names[MakeModelRole] = "makeModel";
+    }
+
+    return names;
+}
+
+void DriverModel::setFilter(const QString& pattern)
+{
+    QList<QByteArray> needles;
+    Q_FOREACH(const QString patternPart, pattern.toLower().split(" ")) {
+        needles.append(patternPart.toUtf8());
+    }
+    QList<PrinterDriver> list;
+
+    if (m_watcher.isRunning())
+        m_watcher.cancel();
+
+    if (pattern.isEmpty()) {
+        setModel(m_originalDrivers);
+        m_filter = pattern;
+        return;
+    }
+
+    if (!m_filter.isEmpty() && !m_drivers.isEmpty() &&
+            pattern.startsWith(m_filter))
+        list = m_drivers; // search in the smaller list
+    else
+        list = m_originalDrivers; //search in the whole list
+
+    m_filter = pattern;
+
+    QFuture<PrinterDriver> future(QtConcurrent::filtered(list,
+            [needles] (const PrinterDriver &driver) {
+                QByteArray haystack = driver.makeModel.toLower();
+                Q_FOREACH(const QByteArray needle, needles) {
+                    if (!haystack.contains(needle)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        )
+    );
+
+    Q_EMIT filterBegin();
+
+    m_watcher.setFuture(future);
+}
+
+QString DriverModel::filter() const
+{
+    return m_filter;
+}
+
+void DriverModel::filterFinished()
+{
+    setModel(m_watcher.future().results());
+}
+
+void DriverModel::load()
+{
+    m_backend->requestPrinterDrivers();
+}
+
+void DriverModel::cancel()
+{
+    if (m_watcher.isRunning())
+        m_watcher.cancel();
+}
+
+void DriverModel::printerDriversLoaded(const QList<PrinterDriver> &drivers)
+{
+    m_originalDrivers = drivers;
+    setModel(m_originalDrivers);
+}
+
+void DriverModel::setModel(const QList<PrinterDriver> &drivers)
+{
+    beginResetModel();
+    m_drivers = drivers;
+    endResetModel();
+
+    Q_EMIT filterComplete();
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/models/drivermodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/drivermodel.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/drivermodel.h	2017-02-24 13:40:38 +0000
@@ -0,0 +1,82 @@
+/*
+ * 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_DRIVERMODEL_H
+#define USC_PRINTER_DRIVERMODEL_H
+
+#include "printers_global.h"
+
+#include "structs.h"
+
+#include <QAbstractListModel>
+#include <QFutureWatcher>
+#include <QModelIndex>
+#include <QObject>
+#include <QVariant>
+
+class PRINTERS_DECL_EXPORT DriverModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+public:
+    explicit DriverModel(PrinterBackend *backend, QObject *parent = Q_NULLPTR);
+    ~DriverModel();
+
+    enum Roles
+    {
+        // Qt::DisplayRole holds driver name
+        NameRole = Qt::UserRole,
+        DeviceIdRole,
+        LanguageRole,
+        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;
+
+    QString filter() const;
+    void setFilter(const QString& pattern);
+
+public Q_SLOTS:
+    // Start loading the model.
+    void load();
+
+    // Cancel loading of the model.
+    void cancel();
+
+private Q_SLOTS:
+    void printerDriversLoaded(const QList<PrinterDriver> &drivers);
+    void filterFinished();
+
+Q_SIGNALS:
+    void countChanged();
+    void filterBegin();
+    void filterComplete();
+
+private:
+    void setModel(const QList<PrinterDriver> &drivers);
+    PrinterBackend *m_backend;
+    QList<PrinterDriver> m_drivers;
+    QList<PrinterDriver> m_originalDrivers;
+    QString m_filter;
+    QFutureWatcher<PrinterDriver> m_watcher;
+};
+
+#endif // USC_PRINTER_DRIVERMODEL_H

=== added file 'modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/jobmodel.cpp	2017-02-24 13:40:38 +0000
@@ -0,0 +1,390 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "utils.h"
+
+#include "backend/backend_cups.h"
+
+#include "models/jobmodel.h"
+
+#include <QDebug>
+
+JobModel::JobModel(QObject *parent) : QAbstractListModel(parent)
+{
+}
+
+JobModel::JobModel(PrinterBackend *backend,
+                   QObject *parent)
+    : QAbstractListModel(parent)
+    , m_backend(backend)
+{
+    update();
+
+    QObject::connect(m_backend, &PrinterBackend::jobCreated,
+                     this, &JobModel::jobSignalCatchAll);
+    QObject::connect(m_backend, &PrinterBackend::jobState,
+                     this, &JobModel::jobSignalCatchAll);
+    QObject::connect(m_backend, &PrinterBackend::jobCompleted,
+                     this, &JobModel::jobSignalCatchAll);
+}
+
+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);
+    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();
+    }
+}
+
+int JobModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return m_jobs.size();
+}
+
+int JobModel::count() const
+{
+    return rowCount();
+}
+
+QVariant JobModel::data(const QModelIndex &index, int role) const
+{
+    QVariant ret;
+
+    if ((0<=index.row()) && (index.row()<m_jobs.size())) {
+
+        auto job = m_jobs[index.row()];
+
+        switch (role) {
+        case CollateRole:
+            ret = job->collate();
+            break;
+        case ColorModelRole: {
+            if (job->printer()) {
+                ret = job->printer()->supportedColorModels().at(job->colorModel()).text;
+            } else {
+                qWarning() << "Printer is undefined, no colorModel";
+                ret = "";
+            }
+            break;
+        }
+        case CompletedTimeRole:
+            ret = job->completedTime().toString(QLocale::system().dateTimeFormat());
+            break;
+        case CopiesRole:
+            ret = job->copies();
+            break;
+        case CreationTimeRole:
+            ret = job->creationTime().toString(QLocale::system().dateTimeFormat());
+            break;
+        case DuplexRole: {
+            if (job->printer()) {
+                ret = job->printer()->supportedDuplexStrings().at(job->duplexMode());
+            } else {
+                qWarning() << "Printer is undefined, no duplexMode";
+                ret = "";
+            }
+            break;
+        }
+        case IdRole:
+            ret = job->jobId();
+            break;
+        case ImpressionsCompletedRole:
+            ret = job->impressionsCompleted();
+            break;
+        case LandscapeRole:
+            ret = job->landscape();
+            break;
+        case MessagesRole:
+            ret = job->messages();
+            break;
+        case PrinterNameRole:
+            ret = job->printerName();
+            break;
+        case PrintRangeRole:
+            ret = job->printRange();
+            break;
+        case PrintRangeModeRole:
+            ret = QVariant::fromValue<PrinterEnum::PrintRange>(job->printRangeMode());
+            break;
+        case ProcessingTimeRole:
+            ret = job->processingTime().toString(QLocale::system().dateTimeFormat());
+            break;
+        case QualityRole: {
+            if (job->printer()) {
+                ret = job->printer()->supportedPrintQualities().at(job->quality()).text;
+            } else {
+                qWarning() << "Printer is undefined, no quality";
+                ret = "";
+            }
+            break;
+        }
+        case ReverseRole:
+            ret = job->reverse();
+            break;
+        case SizeRole:
+            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;
+            }
+            break;
+        case Qt::DisplayRole:
+        case TitleRole:
+            ret = job->title();
+            break;
+        case UserRole:
+            ret = job->user();
+            break;
+        }
+    }
+
+    return ret;
+}
+
+QHash<int, QByteArray> JobModel::roleNames() const
+{
+    static QHash<int,QByteArray> names;
+
+    if (Q_UNLIKELY(names.empty())) {
+        names[Qt::DisplayRole] = "displayName";
+        names[IdRole] = "id";
+        names[CollateRole] = "collate";
+        names[ColorModelRole] = "colorModel";
+        names[CompletedTimeRole] = "completedTime";
+        names[CopiesRole] = "copies";
+        names[CreationTimeRole] = "creationTime";
+        names[DuplexRole] = "duplexMode";
+        names[ImpressionsCompletedRole] = "impressionsCompleted";
+        names[LandscapeRole] = "landscape";
+        names[MessagesRole] = "messages";
+        names[PrinterNameRole] = "printerName";
+        names[PrintRangeRole] = "printRange";
+        names[PrintRangeModeRole] = "printRangeMode";
+        names[ProcessingTimeRole] = "processingTime";
+        names[QualityRole] = "quality";
+        names[ReverseRole] = "reverse";
+        names[SizeRole] = "size";
+        names[StateRole] = "state";
+        names[TitleRole] = "title";
+        names[UserRole] = "user";
+        names[LastStateMessageRole] = "lastStateMessage";
+    }
+
+    return names;
+}
+
+QVariantMap JobModel::get(const int row) const
+{
+    QHashIterator<int, QByteArray> iterator(roleNames());
+    QVariantMap result;
+    QModelIndex modelIndex = index(row, 0);
+
+    while (iterator.hasNext()) {
+        iterator.next();
+        result[iterator.value()] = modelIndex.data(iterator.key());
+    }
+
+    return result;
+}
+
+QSharedPointer<PrinterJob> JobModel::getJobById(const int &id)
+{
+    Q_FOREACH(auto job, m_jobs) {
+        if (job->jobId() == id) {
+            return job;
+        }
+    }
+    return QSharedPointer<PrinterJob>(Q_NULLPTR);
+}
+
+
+JobFilter::JobFilter(QObject *parent) : QSortFilterProxyModel(parent)
+{
+    connect(this, SIGNAL(sourceModelChanged()), SLOT(onSourceModelChanged()));
+}
+
+JobFilter::~JobFilter()
+{
+}
+
+QVariantMap JobFilter::get(const int row) const
+{
+    QHashIterator<int, QByteArray> iterator(roleNames());
+    QVariantMap result;
+    QModelIndex modelIndex = index(row, 0);
+
+    while (iterator.hasNext()) {
+        iterator.next();
+        result[iterator.value()] = modelIndex.data(iterator.key());
+    }
+
+    return result;
+}
+
+void JobFilter::onSourceModelChanged()
+{
+    connect((JobModel*) sourceModel(),
+            SIGNAL(countChanged()),
+            this,
+            SIGNAL(countChanged()));
+}
+
+void JobFilter::onSourceModelCountChanged()
+{
+    Q_EMIT countChanged();
+}
+
+int JobFilter::count() const
+{
+    return rowCount();
+}
+
+void JobFilter::filterOnPrinterName(const QString &name)
+{
+    m_printerName = name;
+    m_printerNameFilterEnabled = true;
+    invalidate();
+}
+
+bool JobFilter::filterAcceptsRow(int sourceRow,
+                                 const QModelIndex &sourceParent) const
+{
+    bool accepts = true;
+    QModelIndex childIndex = sourceModel()->index(sourceRow, 0, sourceParent);
+
+    if (accepts && m_printerNameFilterEnabled) {
+        QString printerName = childIndex.model()->data(
+            childIndex, JobModel::PrinterNameRole).toString();
+        accepts = m_printerName == printerName;
+    }
+
+    return accepts;
+}

=== added file 'modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h'
--- modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/jobmodel.h	2017-02-24 13:40:38 +0000
@@ -0,0 +1,125 @@
+/*
+ * 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_JOB_MODEL_H
+#define USC_JOB_MODEL_H
+
+#include "printers_global.h"
+#include "backend/backend.h"
+#include "printer/printerjob.h"
+
+#include <QAbstractListModel>
+#include <QByteArray>
+#include <QModelIndex>
+#include <QObject>
+#include <QSharedPointer>
+#include <QSortFilterProxyModel>
+#include <QTimer>
+#include <QVariant>
+
+class PRINTERS_DECL_EXPORT JobModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+public:
+    explicit JobModel(QObject *parent = Q_NULLPTR);
+    explicit JobModel(PrinterBackend *backend,
+                      QObject *parent = Q_NULLPTR);
+    ~JobModel();
+
+    enum Roles
+    {
+        // Qt::DisplayRole holds job title
+        IdRole = Qt::UserRole,
+        CollateRole,
+        ColorModelRole,
+        CompletedTimeRole,
+        CopiesRole,
+        CreationTimeRole,
+        DuplexRole,
+        ImpressionsCompletedRole,
+        LandscapeRole,
+        MessagesRole,
+        PrinterNameRole,
+        PrintRangeRole,
+        PrintRangeModeRole,
+        ProcessingTimeRole,
+        QualityRole,
+        ReverseRole,
+        SizeRole,
+        StateRole,
+        TitleRole,
+        UserRole,
+        LastStateMessageRole,
+        LastRole = LastStateMessageRole,
+    };
+
+    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;
+
+    Q_INVOKABLE QVariantMap get(const int row) const;
+    QSharedPointer<PrinterJob> getJobById(const int &id);
+private:
+    PrinterBackend *m_backend;
+
+    QList<QSharedPointer<PrinterJob>> m_jobs;
+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);
+
+Q_SIGNALS:
+    void countChanged();
+};
+
+class PRINTERS_DECL_EXPORT JobFilter : public QSortFilterProxyModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+public:
+    explicit JobFilter(QObject *parent = Q_NULLPTR);
+    ~JobFilter();
+
+    Q_INVOKABLE QVariantMap get(const int row) const;
+
+    void filterOnPrinterName(const QString &name);
+    int count() const;
+protected:
+    virtual bool filterAcceptsRow(
+        int sourceRow, const QModelIndex &sourceParent) const override;
+
+Q_SIGNALS:
+    void countChanged();
+
+private Q_SLOTS:
+    void onSourceModelChanged();
+    void onSourceModelCountChanged();
+
+private:
+    QString m_printerName = QString::null;
+    bool m_printerNameFilterEnabled = false;
+};
+
+#endif // USC_JOB_MODEL_H

=== added file 'modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp'
--- modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Components/Extras/Printers/models/printermodel.cpp	2017-02-24 13:40:38 +0000
@@ -0,0 +1,503 @@
+/*
+ * 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 "backend/backend_pdf.h"
+#include "i18n.h"
+#include "models/jobmodel.h"
+#include "models/printermodel.h"
+#include "utils.h"
+
+#include <QDebug>
+
+PrinterModel::PrinterModel(PrinterBackend *backend, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_backend(backend)
+{
+
+    QObject::connect(m_backend, &PrinterBackend::printerAdded,
+                     this, &PrinterModel::printerAdded);
+    QObject::connect(m_backend, &PrinterBackend::printerModified,
+                     &m_signalHandler, &PrinterSignalHandler::onPrinterModified);
+    QObject::connect(m_backend, &PrinterBackend::printerStateChanged,
+                     &m_signalHandler, &PrinterSignalHandler::onPrinterModified);
+    QObject::connect(m_backend, &PrinterBackend::printerDeleted,
+                     this, &PrinterModel::printerDeleted);
+
+    connect(&m_signalHandler, SIGNAL(printerModified(const QString&)),
+            this, SLOT(printerModified(const QString&)));
+    connect(m_backend, SIGNAL(printerLoaded(QSharedPointer<Printer>)),
+            this, SLOT(printerLoaded(QSharedPointer<Printer>)));
+
+    // Create printer proxies for every printerName.
+    Q_FOREACH(auto printerName, m_backend->availablePrinterNames()) {
+        auto p = QSharedPointer<Printer>(new Printer(new PrinterBackend(printerName)));
+        addPrinter(p, CountChangeSignal::Defer);
+    }
+
+    // Add a PDF printer.
+    auto pdfPrinter = QSharedPointer<Printer>(
+        new Printer(new PrinterPdfBackend(__("Create PDF")))
+    );
+    addPrinter(pdfPrinter, CountChangeSignal::Defer);
+
+    Q_EMIT countChanged();
+}
+
+PrinterModel::~PrinterModel()
+{
+}
+
+void PrinterModel::printerLoaded(QSharedPointer<Printer> printer)
+{
+    // Find and possibly replace an old printer.
+    for (int i=0; i < m_printers.count(); i++) {
+        auto oldPrinter = m_printers.at(i);
+        if (printer->name() == oldPrinter->name()) {
+            if (!oldPrinter->deepCompare(printer)) {
+                updatePrinter(oldPrinter, printer);
+            }
+
+            // We're done.
+            return;
+        }
+    }
+
+    addPrinter(printer, CountChangeSignal::Emit);
+}
+
+void PrinterModel::printerModified(const QString &printerName)
+{
+    // These signals might be emitted of a now deleted printer.
+    if (getPrinterByName(printerName))
+        m_backend->requestPrinter(printerName);
+}
+
+void PrinterModel::printerAdded(
+    const QString &text, const QString &printerUri,
+    const QString &printerName, uint printerState,
+    const QString &printerStateReason, bool acceptingJobs)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printerUri);
+    Q_UNUSED(printerState);
+    Q_UNUSED(printerStateReason);
+    Q_UNUSED(acceptingJobs);
+
+    m_backend->requestPrinter(printerName);
+}
+
+void PrinterModel::printerDeleted(
+    const QString &text, const QString &printerUri,
+    const QString &printerName, uint printerState,
+    const QString &printerStateReason, bool acceptingJobs)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printerUri);
+    Q_UNUSED(printerState);
+    Q_UNUSED(printerStateReason);
+    Q_UNUSED(acceptingJobs);
+
+    auto printer = getPrinterByName(printerName);
+    if (printer) {
+        removePrinter(printer, CountChangeSignal::Emit);
+    }
+}
+
+QSharedPointer<Printer> PrinterModel::getPrinterByName(const QString &printerName)
+{
+    Q_FOREACH(auto p, m_printers) {
+        if (p->name() == printerName)
+            return p;
+    }
+    return QSharedPointer<Printer>(Q_NULLPTR);
+}
+
+void PrinterModel::movePrinter(const int &from, const int &to)
+{
+    int size = m_printers.size();
+    if (from < 0 || to < 0 || from >= size || to >= size) {
+        qWarning() << Q_FUNC_INFO << "Illegal move operation from"
+                   << from << "to" << to << ". Size was" << size;
+        return;
+    }
+    if (!beginMoveRows(QModelIndex(), from, from, QModelIndex(), to)) {
+        qWarning() << Q_FUNC_INFO << "failed to move rows.";
+        return;
+    }
+    m_printers.move(from, to);
+    endMoveRows();
+}
+
+void PrinterModel::removePrinter(QSharedPointer<Printer> printer, const CountChangeSignal &notify)
+{
+    int idx = m_printers.indexOf(printer);
+    beginRemoveRows(QModelIndex(), idx, idx);
+    m_printers.removeAt(idx);
+    endRemoveRows();
+
+    if (notify == CountChangeSignal::Emit)
+        Q_EMIT countChanged();
+}
+
+void PrinterModel::updatePrinter(QSharedPointer<Printer> old,
+                                  QSharedPointer<Printer> newPrinter)
+{
+    int i = m_printers.indexOf(old);
+    QModelIndex idx = index(i);
+    old->updateFrom(newPrinter);
+    Q_EMIT dataChanged(idx, idx);
+}
+
+void PrinterModel::addPrinter(QSharedPointer<Printer> printer, const CountChangeSignal &notify)
+{
+    int i = m_printers.size();
+    beginInsertRows(QModelIndex(), i, i);
+    m_printers.append(printer);
+    endInsertRows();
+
+    if (notify == CountChangeSignal::Emit)
+        Q_EMIT countChanged();
+}
+
+int PrinterModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return m_printers.size();
+}
+
+int PrinterModel::count() const
+{
+    return rowCount();
+}
+
+QVariant PrinterModel::data(const QModelIndex &index, int role) const
+{
+    QVariant ret;
+
+    if ((0<=index.row()) && (index.row()<m_printers.size())) {
+
+        auto printer = m_printers[index.row()];
+
+
+        /* If printer is a proxy (not loaded), determine if the requested role
+        is something async and that we need to request the data. */
+        if (printer->type() == PrinterEnum::PrinterType::ProxyType) {
+            switch (role) {
+            case Qt::DisplayRole:
+            case NameRole:
+            case DefaultPrinterRole:
+            case PrinterRole:
+            case IsPdfRole:
+            case IsLoadedRole:
+                break; // All of these can be inferred from the name (lazily).
+            default:
+                m_backend->requestPrinter(printer->name());
+            }
+        }
+
+        switch (role) {
+        case NameRole:
+        case Qt::DisplayRole:
+            ret = printer->name();
+            break;