Merge lp:~jonas-drange/ubuntu-settings-components/printers-async into lp:ubuntu-settings-components

[Jonas G. Drange]

Unmerged revisions

231. By Jonas G. Drange on 2017-02-07

more asyncness with proxies

230. By Jonas G. Drange on 2017-02-07

allows cancelling of workers

229. By Jonas G. Drange on 2017-02-07

makes tests pass with the more async approach

228. By Andrew Hayzen on 2017-02-06

* Resolve console warnings - add TODOs in methods that should be implemented where I've put a fake return value for now
* Set a default for switches that compiler thinks it can reach the end of the control without
* Add return values for methods that are not implemented yet
* Add Q_UNUSED for parameters that aren't used

227. By Andrew Hayzen on 2017-02-06

* Link notifications to JobModel - removing polling
* Fix compiler errors that appeared from the previous branch
* Fix logic change in last branch that was wrong way around

226. By Andrew Hayzen on 2017-02-03

* Add updateFrom to Printer and PrinterJob
* Call updateFrom in PrinterModel and JobModel when printers are the same
* Emit dataChanged signal in models when updateFrom returns a change
* Add deepCompare to Printer and PrinterJob

225. By Jonas G. Drange on 2017-02-03

* Deprecate QTimer based update()
* Replace with cups subscription based update()
* Fixes tests.

224. By Andrew Hayzen on 2017-02-02

* Add JobModel which lists the jobs for a certain printer
* Add JobRole to PrinterModel to access jobs
* Add JobState enum to track enums from cups
* Add example Queue which lists jobs for a printer with their name, id, status and allows you to cancel the job by clicking

223. By Andrew Hayzen on 2017-02-02

* Add cancel method to Printers

222. By Andrew Hayzen on 2017-01-31

* Always fit-to-page for now as printing app doesn't know about page sizes or scaling yet

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-09-12 14:18:20 +0000
+++ CMakeLists.txt	2017-02-08 22:01:29 +0000
@@ -8,6 +8,8 @@
 
 include(FindPkgConfig)
 
+include(FindCups)
+
 find_package(Qt5Quick REQUIRED)
 
 set(QT_IMPORTS_DIR ${CMAKE_INSTALL_LIBDIR}/qt5/qml)
@@ -17,6 +19,11 @@
 find_package(Qt5Quick REQUIRED)
 find_package(Qt5Test REQUIRED)
 find_package(Qt5Widgets REQUIRED)
+
+if(NOT CUPS_FOUND)
+message(FATAL_ERROR "Could not find cups.")
+endif()
+
 add_definitions(-DQT_NO_KEYWORDS)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)

=== modified file 'debian/changelog'
--- debian/changelog	2017-01-18 15:20:00 +0000
+++ debian/changelog	2017-02-08 22:01:29 +0000
@@ -1,3 +1,10 @@
+ubuntu-settings-components (0.13+17.04.20161201-0ubuntu2) UNRELEASED; urgency=medium
+
+  * packaging: suggest cups, depend on libcups2-dev
+  * adds cups bindings for printer/job management
+
+ -- Jonas G. Drange <[e-mail]>  Mon, 23 Jan 2017 14:46:41 +0100
+
 ubuntu-settings-components (0.12+17.04.20170118-0ubuntu1) zesty; urgency=medium
 
   [ Pete Woods ]

=== modified file 'debian/control'
--- debian/control	2016-12-07 17:02:20 +0000
+++ debian/control	2017-02-08 22:01:29 +0000
@@ -4,6 +4,8 @@
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: cmake,
                cmake-extras (>= 0.10),
+               libcups2-dev,
+               libqt5printsupport5,
                debhelper (>= 9),
                pkg-config,
                python3:any,
@@ -40,6 +42,7 @@
 Architecture: any
 Multi-Arch: same
 Pre-Depends: dpkg (>= 1.15.6~),
+Suggests: cups,
 Depends: gsettings-ubuntu-schemas (>= 0.0.7),
          qml-module-biometryd,
          qml-module-qtquick-layouts,

=== modified file 'debian/qml-module-ubuntu-settings-components.install'
--- debian/qml-module-ubuntu-settings-components.install	2016-08-17 10:29:44 +0000
+++ debian/qml-module-ubuntu-settings-components.install	2017-02-08 22:01:29 +0000
@@ -1,5 +1,6 @@
 usr/lib/*/qt5/qml/Ubuntu/Settings/Components
 usr/lib/*/qt5/qml/Ubuntu/Settings/Fingerprint
 usr/lib/*/qt5/qml/Ubuntu/Settings/Menus
+usr/lib/*/qt5/qml/Ubuntu/Settings/Printers
 usr/lib/*/qt5/qml/Ubuntu/Settings/Vpn
 usr/share/locale

=== added file 'examples/PrinterQueue.qml'
--- examples/PrinterQueue.qml	1970-01-01 00:00:00 +0000
+++ examples/PrinterQueue.qml	2017-02-08 22:01:29 +0000
@@ -0,0 +1,113 @@
+/*
+ * 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.Settings.Components 0.1
+import Ubuntu.Settings.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
+                    }
+                    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 'examples/Printers.qml'
--- examples/Printers.qml	1970-01-01 00:00:00 +0000
+++ examples/Printers.qml	2017-02-08 22:01:29 +0000
@@ -0,0 +1,452 @@
+/*
+ * 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.Settings.Components 0.1
+import Ubuntu.Settings.Printers 0.1
+
+MainView {
+    width: units.gu(50)
+    height: units.gu(90)
+
+    Component {
+        id: printerPage
+
+        Page {
+            visible: false
+            property var printer
+            header: PageHeader {
+                title: printer.name
+                flickable: printerFlickable
+            }
+
+            Flickable {
+                id: printerFlickable
+                anchors.fill: parent
+
+                Column {
+                    spacing: units.gu(2)
+                    anchors {
+                        top: parent.top
+                        topMargin: units.gu(2)
+                        left: parent.left
+                        right: parent.right
+                    }
+
+                    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
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    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)
+                        }
+                    ]
+                }
+            }
+            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(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
+                    }
+                }
+            }
+        }
+    }
+}

=== modified file 'plugins/Ubuntu/Settings/CMakeLists.txt'
--- plugins/Ubuntu/Settings/CMakeLists.txt	2016-03-18 13:04:57 +0000
+++ plugins/Ubuntu/Settings/CMakeLists.txt	2017-02-08 22:01:29 +0000
@@ -1,4 +1,5 @@
 add_subdirectory(Components)
 add_subdirectory(Fingerprint)
 add_subdirectory(Menus)
+add_subdirectory(Printers)
 add_subdirectory(Vpn)

=== added directory 'plugins/Ubuntu/Settings/Printers'
=== added file 'plugins/Ubuntu/Settings/Printers/CMakeLists.txt'
--- plugins/Ubuntu/Settings/Printers/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/CMakeLists.txt	2017-02-08 22:01:29 +0000
@@ -0,0 +1,47 @@
+project(UbuntuSettingsPrintersQml)
+
+add_definitions(-DUBUNTUSETTINGSPRINTERS_LIBRARY)
+
+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)
+
+qt5_add_dbus_interface(
+    GEN_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/org.cups.cupsd.Notifier.xml
+    cupsdnotifier)
+
+add_library(UbuntuSettingsPrintersQml SHARED
+    ${GEN_SOURCES}
+    backend/backend.cpp
+    backend/backend_cups.cpp
+    backend/backend_pdf.cpp
+    cups/cupsfacade.cpp
+    cups/cupspkhelper.cpp
+    enums.h
+    i18n.cpp
+    models/drivermodel.cpp
+    models/jobmodel.cpp
+    models/printermodel.cpp
+    printer/printer.cpp
+    printer/printerjob.cpp
+    printers/printers.cpp
+    plugin.cpp
+    structs.h
+    utils.h
+)
+
+target_link_libraries(UbuntuSettingsPrintersQml
+    Qt5::DBus
+    Qt5::Gui
+    Qt5::PrintSupport
+    Qt5::Qml
+    Qt5::Concurrent
+    ${CUPS_LIBRARIES}
+)
+
+add_usc_plugin(Ubuntu.Settings.Printers 0.1 Ubuntu/Settings/Printers TARGETS UbuntuSettingsPrintersQml)

=== added directory 'plugins/Ubuntu/Settings/Printers/backend'
=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend.cpp	2017-02-08 22:01:29 +0000
@@ -0,0 +1,361 @@
+/*
+ * 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::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::printerSetLocation(const QString &name,
+                                           const QString &location)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(location);
+    return QString();
+}
+
+QString PrinterBackend::printerSetShared(const QString &name,
+                                         const bool shared)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(shared);
+    return QString();
+}
+
+QString PrinterBackend::printerSetJobSheets(const QString &name,
+                                            const QString &start,
+                                            const QString &end)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(start);
+    Q_UNUSED(end);
+    return QString();
+}
+
+QString PrinterBackend::printerSetErrorPolicy(const QString &name,
+                                              const PrinterEnum::ErrorPolicy &policy)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(policy);
+    return QString();
+}
+
+
+QString PrinterBackend::printerSetOpPolicy(const QString &name,
+                                           const PrinterEnum::OperationPolicy &policy)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(policy);
+    return QString();
+}
+
+QString PrinterBackend::printerSetUsersAllowed(const QString &name,
+                                               const QStringList &users)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(users);
+    return QString();
+}
+
+QString PrinterBackend::printerSetUsersDenied(const QString &name,
+                                              const QStringList &users)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(users);
+    return QString();
+}
+
+QString PrinterBackend::printerAddOptionDefault(const QString &name,
+                                                const QString &option,
+                                                const QStringList &values)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(option);
+    Q_UNUSED(values);
+    return QString();
+}
+
+QString PrinterBackend::printerDeleteOptionDefault(const QString &name,
+                                                   const QString &value)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(value);
+    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
+)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(options);
+    return QMap<QString, QVariant>();
+}
+
+// FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+cups_dest_t* PrinterBackend::makeDest(const QString &name,
+                              const PrinterJob *options)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(options);
+    return Q_NULLPTR;
+}
+
+QList<ColorModel> PrinterBackend::printerGetSupportedColorModels(
+    const QString &name) const
+{
+    Q_UNUSED(name);
+    return QList<ColorModel>();
+}
+
+ColorModel PrinterBackend::printerGetDefaultColorModel(
+    const QString &name) const
+{
+    Q_UNUSED(name);
+    return ColorModel();
+}
+
+QList<PrintQuality> PrinterBackend::printerGetSupportedQualities(
+    const QString &name) const
+{
+    Q_UNUSED(name);
+    return QList<PrintQuality>();
+}
+
+PrintQuality PrinterBackend::printerGetDefaultQuality(
+        const QString &name) const
+{
+    Q_UNUSED(name);
+    return PrintQuality();
+}
+
+void PrinterBackend::cancelJob(const QString &name, const int jobId)
+{
+    Q_UNUSED(jobId);
+    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(const QString &name)
+{
+    Q_UNUSED(name);
+
+    return QList<QSharedPointer<PrinterJob>>{};
+}
+
+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::requestAvailablePrinters()
+{
+}
+
+void PrinterBackend::requestAvailablePrinterDrivers()
+{
+}
+
+PrinterEnum::PrinterType PrinterBackend::type() const
+{
+    return m_type;
+}
+
+void PrinterBackend::refresh()
+{
+}

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend.h	2017-02-08 22:01:29 +0000
@@ -0,0 +1,219 @@
+/*
+ * 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 printerSetEnabled(const QString &name,
+                                      const bool enabled);
+    virtual QString printerSetAcceptJobs(
+        const QString &name,
+        const bool enabled,
+        const QString &reason = QString::null);
+    virtual QString printerSetInfo(const QString &name,
+                                   const QString &info);
+    virtual QString printerSetLocation(const QString &name,
+                                       const QString &location);
+    virtual QString printerSetShared(const QString &name,
+                                     const bool shared);
+    virtual QString printerSetJobSheets(const QString &name,
+                                        const QString &start,
+                                        const QString &end);
+    virtual QString printerSetErrorPolicy(const QString &name,
+                                          const PrinterEnum::ErrorPolicy &policy);
+
+    virtual QString printerSetOpPolicy(const QString &name,
+                                       const PrinterEnum::OperationPolicy &policy);
+    virtual QString printerSetUsersAllowed(const QString &name,
+                                           const QStringList &users);
+    virtual QString printerSetUsersDenied(const QString &name,
+                                          const QStringList &users);
+    virtual QString printerAddOptionDefault(const QString &name,
+                                            const QString &option,
+                                            const QStringList &values);
+    virtual QString printerDeleteOptionDefault(const QString &name,
+                                               const QString &value);
+    virtual QString printerAddOption(const QString &name,
+                                     const QString &option,
+                                     const QStringList &values);
+
+    // TODO: const for both these getters (if possible)!
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const;
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options
+    );
+    // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+    virtual cups_dest_t* makeDest(const QString &name,
+                                  const PrinterJob *options);
+
+    virtual QList<ColorModel> printerGetSupportedColorModels(
+        const QString &name) const;
+    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
+    virtual QList<PrintQuality> printerGetSupportedQualities(
+        const QString &name) const;
+    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
+
+    virtual void cancelJob(const QString &name, const int jobId);
+    virtual int printFileToDest(const QString &filepath,
+                                const QString &title,
+                                const cups_dest_t *dest);
+    virtual QList<QSharedPointer<PrinterJob>> printerGetJobs(const QString &name);
+
+    virtual 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 requestAvailablePrinters();
+    virtual void requestAvailablePrinterDrivers();
+
+    virtual PrinterEnum::PrinterType type() const;
+
+public Q_SLOTS:
+    virtual void refresh();
+
+Q_SIGNALS:
+    void printerDriversLoaded(const QList<PrinterDriver> &drivers);
+    void printerDriversFailedToLoad(const QString &errorMessage);
+
+    void availablePrintersLoaded(QList<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
+    );
+
+protected:
+    const QString m_printerName;
+    PrinterEnum::PrinterType m_type;
+};
+
+#endif // USC_PRINTERS_BACKEND_H

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp	2017-02-08 22:01:29 +0000
@@ -0,0 +1,506 @@
+/*
+ * 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 "utils.h"
+
+#include <QDBusConnection>
+#include <QThread>
+
+PrinterCupsBackend::PrinterCupsBackend(QObject *parent)
+    : PrinterCupsBackend(new CupsFacade(), QPrinterInfo(),
+                         new OrgCupsCupsdNotifierInterface("",
+                                                           CUPSD_NOTIFIER_DBUS_PATH,
+                                                           QDBusConnection::systemBus()),
+                         parent)
+{
+    // Use proper RAII of things we create:
+    m_cups->setParent(this);
+    m_notifier->setParent(this);
+}
+
+PrinterCupsBackend::PrinterCupsBackend(CupsFacade *cups, QPrinterInfo info,
+                                       OrgCupsCupsdNotifierInterface *notifier,
+                                       QObject *parent)
+    : PrinterBackend(info.printerName(), parent)
+    , m_cups(cups)
+    , m_info(info)
+    , m_notifier(notifier)
+{
+    m_type = PrinterEnum::PrinterType::CupsType;
+    connect(m_cups, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)),
+            this, SIGNAL(printerDriversLoaded(const QList<PrinterDriver>&)));
+    connect(m_cups, SIGNAL(printerDriversFailedToLoad(const QString&)),
+            this, SIGNAL(printerDriversFailedToLoad(const QString&)));
+
+    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)));
+}
+
+PrinterCupsBackend::~PrinterCupsBackend()
+{
+    cancelSubscription();
+    Q_EMIT cancelWorkers();
+}
+
+QString PrinterCupsBackend::printerAdd(const QString &name,
+                                       const QString &uri,
+                                       const QString &ppdFile,
+                                       const QString &info,
+                                       const QString &location)
+{
+    return m_cups->printerAdd(name, uri, ppdFile, info, location);
+}
+
+QString PrinterCupsBackend::printerAddWithPpd(const QString &name,
+                                              const QString &uri,
+                                              const QString &ppdFileName,
+                                              const QString &info,
+                                              const QString &location)
+{
+    return m_cups->printerAddWithPpd(name, uri, ppdFileName, info, location);
+}
+
+bool PrinterCupsBackend::holdsDefinition() const
+{
+    return !m_info.isNull();
+}
+
+QString PrinterCupsBackend::printerDelete(const QString &name)
+{
+    // TODO: implement
+    Q_UNUSED(name);
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetEnabled(const QString &name,
+                                              const bool enabled)
+{
+    // TODO: implement
+    Q_UNUSED(name);
+    Q_UNUSED(enabled);
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetAcceptJobs(
+        const QString &name,
+        const bool enabled,
+        const QString &reason)
+{
+    // TODO: implement
+    Q_UNUSED(name);
+    Q_UNUSED(enabled);
+    Q_UNUSED(reason);
+    return QString();
+}
+
+QString PrinterCupsBackend::printerSetInfo(const QString &name,
+                                           const QString &info)
+{
+    return m_cups->printerSetInfo(name, info);
+}
+
+QString PrinterCupsBackend::printerSetLocation(const QString &name,
+                                               const QString &location)
+{
+    return m_cups->printerSetLocation(name, location);
+}
+
+QString PrinterCupsBackend::printerSetShared(const QString &name,
+                                             const bool shared)
+{
+    return m_cups->printerSetShared(name, shared);
+}
+
+QString PrinterCupsBackend::printerSetJobSheets(const QString &name,
+                                                const QString &start,
+                                                const QString &end)
+{
+    return m_cups->printerSetJobSheets(name, start, end);
+}
+
+QString PrinterCupsBackend::printerSetErrorPolicy(const QString &name,
+                                                  const PrinterEnum::ErrorPolicy &policy)
+{
+    return m_cups->printerSetErrorPolicy(name, policy);
+}
+
+QString PrinterCupsBackend::printerSetOpPolicy(const QString &name,
+                                               const PrinterEnum::OperationPolicy &policy)
+{
+    return m_cups->printerSetOpPolicy(name, policy);
+}
+
+QString PrinterCupsBackend::printerSetUsersAllowed(const QString &name,
+                                                   const QStringList &users)
+{
+    return m_cups->printerSetUsersAllowed(name, users);
+}
+
+QString PrinterCupsBackend::printerSetUsersDenied(const QString &name,
+                                                  const QStringList &users)
+{
+    return m_cups->printerSetUsersDenied(name, users);
+}
+
+QString PrinterCupsBackend::printerAddOptionDefault(const QString &name,
+                                                    const QString &option,
+                                                    const QStringList &values)
+{
+    return m_cups->printerAddOptionDefault(name, option, values);
+}
+
+QString PrinterCupsBackend::printerDeleteOptionDefault(const QString &name,
+                                                       const QString &value)
+{
+    return m_cups->printerDeleteOptionDefault(name, value);
+}
+
+QString PrinterCupsBackend::printerAddOption(const QString &name,
+                                             const QString &option,
+                                             const QStringList &values)
+{
+    return m_cups->printerAddOption(name, option, values);
+}
+
+    // TODO: const for both these getters (if possible)!
+QVariant PrinterCupsBackend::printerGetOption(const QString &name,
+                                              const QString &option) const
+{
+    return m_cups->printerGetOption(name, option);
+}
+QMap<QString, QVariant> PrinterCupsBackend::printerGetOptions(
+        const QString &name, const QStringList &options)
+{
+    return m_cups->printerGetOptions(name, options);
+}
+
+// FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+cups_dest_t* PrinterCupsBackend::makeDest(const QString &name,
+                                          const PrinterJob *options)
+{
+    return m_cups->makeDest(name, options);
+}
+
+QList<ColorModel> PrinterCupsBackend::printerGetSupportedColorModels(
+        const QString &name) const
+{
+    return m_cups->printerGetSupportedColorModels(name);
+}
+
+ColorModel PrinterCupsBackend::printerGetDefaultColorModel(
+    const QString &name) const
+{
+    return printerGetOption(name, "DefaultColorModel").value<ColorModel>();
+}
+
+QList<PrintQuality> PrinterCupsBackend::printerGetSupportedQualities(
+        const QString &name) const
+{
+    return m_cups->printerGetSupportedQualities(name);
+}
+
+PrintQuality PrinterCupsBackend::printerGetDefaultQuality(
+        const QString &name) const
+{
+    return printerGetOption(name, "DefaultPrintQuality").value<PrintQuality>();
+}
+
+void PrinterCupsBackend::cancelJob(const QString &name, const int jobId)
+{
+    m_cups->cancelJob(name, jobId);
+}
+
+int PrinterCupsBackend::printFileToDest(const QString &filepath,
+                                        const QString &title,
+                                        const cups_dest_t *dest)
+{
+    return m_cups->printFileToDest(filepath, title, dest);
+}
+
+QList<QSharedPointer<PrinterJob>> PrinterCupsBackend::printerGetJobs(const QString &name)
+{
+    auto jobs = m_cups->printerGetJobs(name);
+    QList<QSharedPointer<PrinterJob>> list;
+
+    Q_FOREACH(auto job, jobs) {
+        auto newJob = QSharedPointer<PrinterJob>(new PrinterJob(name, this, job->id));
+
+        // TODO: needs to extract other properties like copies/duplex etc
+
+        newJob->setState(static_cast<PrinterEnum::JobState>(job->state));
+        newJob->setTitle(QString::fromLocal8Bit(job->title));
+
+        list.append(newJob);
+    }
+
+    return list;
+}
+
+QString PrinterCupsBackend::printerName() const
+{
+    return m_info.printerName();
+}
+
+QString PrinterCupsBackend::description() const
+{
+    return m_info.description();
+}
+
+QString PrinterCupsBackend::location() const
+{
+    // TODO: implement
+    return QString();
+}
+
+QString PrinterCupsBackend::makeAndModel() const
+{
+    // TODO: implement
+    return QString();
+}
+
+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
+{
+    // TODO: implement
+    return false;
+}
+
+QPageSize PrinterCupsBackend::minimumPhysicalPageSize() const
+{
+    // TODO: implement
+    return QPageSize();
+}
+
+QPageSize PrinterCupsBackend::maximumPhysicalPageSize() const
+{
+    // TODO: implement
+    return QPageSize();
+}
+
+QList<int> PrinterCupsBackend::supportedResolutions() const
+{
+    // TODO: implement
+    return QList<int>{};
+}
+
+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));
+        }
+    }
+    return list;
+}
+
+QList<QSharedPointer<Printer>> PrinterCupsBackend::availablePrinters()
+{
+    QList<QSharedPointer<Printer>> list;
+
+    // Use availablePrinterNames as this gives us a name for even null printers
+    Q_FOREACH(QString name, QPrinterInfo::availablePrinterNames()) {
+        auto printer = QSharedPointer<Printer>(new Printer(new PrinterBackend(name)));
+        list.append(printer);
+    }
+
+    // Cups allows a faux PDF printer.
+    list.append(QSharedPointer<Printer>(new Printer(new PrinterPdfBackend(__("Create PDF")))));
+
+    return list;
+}
+
+QStringList PrinterCupsBackend::availablePrinterNames()
+{
+    return QPrinterInfo::availablePrinterNames();
+}
+
+QSharedPointer<Printer> PrinterCupsBackend::getPrinter(const QString &printerName)
+{
+    QPrinterInfo info = QPrinterInfo::printerInfo(printerName);
+
+    if (!info.isNull()) {
+        return QSharedPointer<Printer>(new Printer(new PrinterCupsBackend(m_cups, info, m_notifier)));
+    } else {
+        qWarning() << "Printer is null so skipping (" << printerName << ")";
+    }
+
+    return QSharedPointer<Printer>(Q_NULLPTR);
+}
+
+QString PrinterCupsBackend::defaultPrinterName()
+{
+    return QPrinterInfo::defaultPrinterName();
+}
+
+void PrinterCupsBackend::requestAvailablePrinters()
+{
+    auto thread = new QThread;
+    auto loader = new PrintersLoader(m_cups, m_notifier);
+    loader->moveToThread(thread);
+    connect(thread, SIGNAL(started()), loader, SLOT(load()));
+    connect(this, SIGNAL(cancelWorkers()), loader, SLOT(cancel()));
+    connect(loader, SIGNAL(finished()), thread, SLOT(quit()));
+    connect(loader, SIGNAL(finished()), loader, SLOT(deleteLater()));
+    connect(loader, SIGNAL(loaded(QList<QSharedPointer<Printer>>)),
+            this, SIGNAL(availablePrintersLoaded(QList<QSharedPointer<Printer>>)));
+    connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
+    thread->start();
+}
+
+void PrinterCupsBackend::requestAvailablePrinterDrivers()
+{
+    return m_cups->requestPrinterDrivers();
+}
+
+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_cups->createSubscription();
+}
+
+void PrinterCupsBackend::cancelSubscription()
+{
+    if (m_cupsSubscriptionId > 0)
+        m_cups->cancelSubscription(m_cupsSubscriptionId);
+}
+
+PrintersLoader::PrintersLoader(CupsFacade *cups,
+                               OrgCupsCupsdNotifierInterface* notifier,
+                               QObject *parent)
+    : QObject(parent)
+    , m_cups(cups)
+    , m_notifier(notifier)
+{
+}
+
+PrintersLoader::~PrintersLoader()
+{
+}
+
+void PrintersLoader::load()
+{
+    QList<QSharedPointer<Printer>> list;
+    m_running = true;
+
+    // Use availablePrinterNames as this gives us a name for even null printers
+    Q_FOREACH(QString name, QPrinterInfo::availablePrinterNames()) {
+
+        if (!m_running)
+            break;
+
+        QPrinterInfo info = QPrinterInfo::printerInfo(name);
+
+        if (!info.isNull()) {
+            auto p = QSharedPointer<Printer>(new Printer(new PrinterCupsBackend(m_cups, info, m_notifier)));
+            list.append(p);
+        } else {
+            qWarning() << "Printer is null so skipping (" << name << ")";
+        }
+    }
+
+    // Cups allows a faux PDF printer.
+    auto faux = QSharedPointer<Printer>(new Printer(new PrinterPdfBackend(__("Create PDF"))));
+    list.append(faux);
+
+    Q_EMIT loaded(list);
+    Q_EMIT finished();
+}
+
+void PrintersLoader::cancel()
+{
+    m_running = false;
+}

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend_cups.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend_cups.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_cups.h	2017-02-08 22:01:29 +0000
@@ -0,0 +1,166 @@
+/*
+ * 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/cupsfacade.h"
+#include "cupsdnotifier.h" // Note: this file was generated.
+
+#include <QPrinterInfo>
+
+#define CUPSD_NOTIFIER_DBUS_PATH "/org/cups/cupsd/Notifier"
+
+class PRINTERS_DECL_EXPORT PrinterCupsBackend : public PrinterBackend
+{
+    Q_OBJECT
+public:
+    explicit PrinterCupsBackend(QObject *parent = Q_NULLPTR);
+    explicit PrinterCupsBackend(CupsFacade *cups, QPrinterInfo info,
+                                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 printerSetEnabled(const QString &name,
+                                      const bool enabled) override;
+    virtual QString printerSetAcceptJobs(
+        const QString &name,
+        const bool enabled,
+        const QString &reason = QString::null) override;
+    virtual QString printerSetInfo(const QString &name,
+                                   const QString &info) override;
+    virtual QString printerSetLocation(const QString &name,
+                                       const QString &location) override;
+    virtual QString printerSetShared(const QString &name,
+                                     const bool shared) override;
+    virtual QString printerSetJobSheets(const QString &name,
+                                        const QString &start,
+                                        const QString &end) override;
+    virtual QString printerSetErrorPolicy(const QString &name,
+                                          const PrinterEnum::ErrorPolicy &policy) override;
+
+    virtual QString printerSetOpPolicy(const QString &name,
+                                       const PrinterEnum::OperationPolicy &policy) override;
+    virtual QString printerSetUsersAllowed(const QString &name,
+                                           const QStringList &users) override;
+    virtual QString printerSetUsersDenied(const QString &name,
+                                          const QStringList &users) override;
+    virtual QString printerAddOptionDefault(const QString &name,
+                                            const QString &option,
+                                            const QStringList &values) override;
+    virtual QString printerDeleteOptionDefault(const QString &name,
+                                               const QString &value) override;
+    virtual QString printerAddOption(const QString &name,
+                                     const QString &option,
+                                     const QStringList &values) override;
+
+    // TODO: const for both these getters (if possible)!
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const override;
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options
+    ) override;
+    // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+    virtual cups_dest_t* makeDest(const QString &name,
+                                  const PrinterJob *options) override;
+
+    virtual QList<ColorModel> printerGetSupportedColorModels(
+        const QString &name) const override;
+    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
+    virtual QList<PrintQuality> printerGetSupportedQualities(
+        const QString &name) const override;
+    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
+
+    virtual void cancelJob(const QString &name, const int jobId) override;
+    virtual int printFileToDest(const QString &filepath,
+                                const QString &title,
+                                const cups_dest_t *dest) override;
+    virtual QList<QSharedPointer<PrinterJob>> printerGetJobs(const QString &name) override;
+
+    virtual 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 requestAvailablePrinters() override;
+    virtual void requestAvailablePrinterDrivers() override;
+
+public Q_SLOTS:
+    virtual void refresh() override;
+    void createSubscription();
+
+Q_SIGNALS:
+    void cancelWorkers();
+
+private:
+    void cancelSubscription();
+    CupsFacade *m_cups;
+    QPrinterInfo m_info;
+    OrgCupsCupsdNotifierInterface *m_notifier;
+    int m_cupsSubscriptionId = -1;
+};
+
+class PrintersLoader : public QObject
+{
+    Q_OBJECT
+    CupsFacade *m_cups;
+    OrgCupsCupsdNotifierInterface *m_notifier;
+    bool m_running = false;
+public:
+    explicit PrintersLoader(CupsFacade *cups,
+                            OrgCupsCupsdNotifierInterface* notifier,
+                            QObject *parent = Q_NULLPTR);
+    ~PrintersLoader();
+
+public Q_SLOTS:
+    void load();
+    void cancel();
+
+Q_SIGNALS:
+    void finished();
+    void loaded(QList<QSharedPointer<Printer>> printers);
+};
+
+#endif // USC_PRINTERS_CUPS_BACKEND_H

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp	2017-02-08 22:01:29 +0000
@@ -0,0 +1,124 @@
+/*
+ * 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;
+}
+
+QList<ColorModel> PrinterPdfBackend::printerGetSupportedColorModels(
+    const QString &name) const
+{
+    return QList<ColorModel>{printerGetDefaultColorModel(name)};
+}
+
+ColorModel PrinterPdfBackend::printerGetDefaultColorModel(
+    const QString &name) const
+{
+    Q_UNUSED(name);
+    ColorModel rgb;
+    rgb.colorType = PrinterEnum::ColorModelType::ColorType;
+    rgb.name = "RGB";
+    rgb.text = __("Color");
+    return rgb;
+}
+
+QList<PrintQuality> PrinterPdfBackend::printerGetSupportedQualities(
+    const QString &name) const
+{
+    return QList<PrintQuality>({printerGetDefaultQuality(name)});
+}
+
+PrintQuality PrinterPdfBackend::printerGetDefaultQuality(
+        const QString &name) const
+{
+    Q_UNUSED(name);
+    PrintQuality quality;
+    quality.name = __("Normal");
+    return quality;
+}
+
+QString PrinterPdfBackend::printerName() const
+{
+    return m_printerName;
+}
+
+QString PrinterPdfBackend::description() const
+{
+    return QStringLiteral("");
+}
+
+QString PrinterPdfBackend::location() const
+{
+    return QStringLiteral("");
+}
+
+QString PrinterPdfBackend::makeAndModel() const
+{
+    return QStringLiteral("");
+}
+
+PrinterEnum::State PrinterPdfBackend::state() const
+{
+    return PrinterEnum::State::IdleState;
+}
+
+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 'plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h	2017-02-08 22:01:29 +0000
@@ -0,0 +1,51 @@
+/*
+ * 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 QList<ColorModel> printerGetSupportedColorModels(
+        const QString &name) const override;
+    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
+    virtual QList<PrintQuality> printerGetSupportedQualities(
+        const QString &name) const override;
+    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
+
+    virtual 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;
+};
+
+#endif // USC_PRINTERS_PDF_BACKEND_H

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

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

=== added file 'plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.cpp'
--- plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.cpp	2017-02-08 22:01:29 +0000
@@ -0,0 +1,800 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ * Copyright (C) 2014 John Layt <[e-mail]>
+ * Copyright (C) 2009 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/cupspkhelper.h"
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <QUrl>
+#include <QDebug>
+
+CupsPkHelper::CupsPkHelper()
+    : m_connection(httpConnectEncrypt(cupsServer(),
+                                      ippPort(),
+                                      cupsEncryption()))
+{
+    if (!m_connection) {
+        qCritical("Failed to connect to cupsd");
+    } else {
+        qDebug("Successfully connected to cupsd.");
+    }
+}
+
+CupsPkHelper::~CupsPkHelper()
+{
+    if (m_connection)
+        httpClose(m_connection);
+}
+
+bool CupsPkHelper::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, CphResourceAdmin);
+}
+
+bool CupsPkHelper::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(), CphResourceAdmin);
+}
+
+bool CupsPkHelper::printerClassSetInfo(const QString &name,
+                                       const QString &info)
+{
+    if (!isPrinterNameValid(name)) {
+        setInternalStatus(QString("%1 is not a valid printer name.").arg(info));
+        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 CupsPkHelper::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, CphResourceAdmin);
+
+        unlink(newPpdFile.toUtf8());
+        // TODO: fix leak here.
+    } else {
+        retval = sendRequest(request, CphResourceAdmin);
+    }
+
+    return retval;
+}
+
+
+/* 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 CupsPkHelper::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 CupsPkHelper::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, CphResource::CphResourceAdmin))
+        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 CupsPkHelper::addPrinterUri(ipp_t *request,
+                                 const QString &name)
+{
+    QUrl uri(QString("ipp://localhost/printers/%1").arg(name));
+    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                 "printer-uri", NULL, uri.toEncoded().data());
+}
+
+void CupsPkHelper::addRequestingUsername(ipp_t *request,
+                                         const QString &username)
+{
+    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 CupsPkHelper::getLastError() const
+{
+    return m_internalStatus;
+}
+
+const QString CupsPkHelper::getResource(
+        const CupsPkHelper::CphResource &resource)
+{
+    switch (resource) {
+    case CphResourceRoot:
+        return "/";
+    case CphResourceAdmin:
+        return "/admin/";
+    case CphResourceJobs:
+        return "/jobs/";
+    default:
+        /* that's a fall back -- we don't use
+         * g_assert_not_reached() to avoid crashing. */
+        qCritical("Asking for a resource with no match.");
+        return "/";
+    }
+}
+
+bool CupsPkHelper::isPrinterNameValid(const QString &name)
+{
+    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 CupsPkHelper::isStringValid(const QString &string, const bool checkNull,
+                                 const int maxLength)
+{
+    if (isStringPrintable(string, checkNull, maxLength))
+        return true;
+    return false;
+}
+
+bool CupsPkHelper::isStringPrintable(const QString &string,
+                                     const bool checkNull,
+                                     const int maxLength)
+{
+    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 CupsPkHelper::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 CupsPkHelper::postRequest(ipp_t *request, const QString &file,
+                               const CphResource &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 CupsPkHelper::sendRequest(ipp_t *request, const CphResource &resource)
+{
+    ipp_t *reply;
+    const QString resourceChar = getResource(resource);
+    reply = cupsDoRequest(m_connection, request,
+                          resourceChar.toUtf8());
+    return handleReply(reply);
+}
+
+bool CupsPkHelper::handleReply(ipp_t *reply)
+{
+    bool retval;
+    retval = isReplyOk(reply, false);
+    if (reply)
+        ippDelete(reply);
+
+    return retval;
+}
+
+bool CupsPkHelper::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() << __PRETTY_FUNCTION__ << "Cups HTTP error:" << cupsLastErrorString();
+
+        if (deleteIfReplyNotOk && reply)
+            ippDelete(reply);
+
+        return false;
+    }
+}
+
+void CupsPkHelper::setErrorFromReply(ipp_t *reply)
+{
+    if (reply)
+        m_lastStatus = ippGetStatusCode(reply);
+    else
+        m_lastStatus = cupsLastError();
+}
+
+bool CupsPkHelper::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(CphResource::CphResourceRoot);
+    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 CupsPkHelper::addClassUri(ipp_t *request, const QString &name)
+{
+    QUrl uri(QString("ipp://localhost/printers/%1").arg(name));
+    ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
+                 "printer-uri", NULL, uri.toEncoded().data());
+}
+
+ppd_file_t* CupsPkHelper::getPpdFile(const QString &name,
+                                     const QString &instance) const
+{
+    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* CupsPkHelper::getDest(const QString &name,
+                                   const QString &instance) const
+{
+    cups_dest_t *dest = 0;
+    dest = cupsGetNamedDest(m_connection, name.toUtf8(),
+                            instance.toUtf8());
+    return dest;
+}
+
+ipp_t* CupsPkHelper::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(CphResourceRoot);
+    return cupsDoRequest(m_connection, request,
+                         resourceChar.toUtf8());
+}
+
+int CupsPkHelper::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(CphResourceRoot).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 CupsPkHelper::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(CphResourceRoot).toUtf8());
+    if (!isReplyOk(resp, true)) {
+        return;
+    }
+
+    ippDelete(resp);
+}

=== added file 'plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.h'
--- plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/cupspkhelper.h	2017-02-08 22:01:29 +0000
@@ -0,0 +1,120 @@
+/*
+ * 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_CUPSPKHELPER_H
+#define USC_PRINTERS_CUPSPKHELPER_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
+
+/* This code is only a shim for systems not running the daemon provided by
+cups-pk-helper. Once provided on all platforms, this code should be replaced
+by proper dbus bindings, and subsequently be set on fire.
+
+TODO: rename to CupsPkHelperShim to emphasize its transient nature.
+FIXME: make most of the "is..." methods const.
+*/
+class CupsPkHelper
+{
+public:
+    explicit CupsPkHelper();
+    ~CupsPkHelper();
+
+    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 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;
+
+    QString getLastError() const;
+
+    // This response needs to be free by the caller.
+    ipp_t* createPrinterDriversRequest(
+        const QString &deviceId = "",
+        const QString &language = "",
+        const QString &makeModel = "",
+        const QString &product = "",
+        const QStringList &includeSchemes = QStringList(),
+        const QStringList &excludeSchemes = QStringList()
+    );
+    int createSubscription();
+    void cancelSubscription(const int &subscriptionId);
+
+private:
+    enum CphResource
+    {
+        CphResourceRoot = 0,
+        CphResourceAdmin,
+        CphResourceJobs,
+    };
+
+    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 CphResource &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 CphResource &resource);
+    bool sendRequest(ipp_t *request, const CphResource &resource);
+    bool handleReply(ipp_t *reply);
+    bool isReplyOk(ipp_t *reply, bool deleteIfReplyNotOk);
+    void setErrorFromReply(ipp_t *reply);
+
+    http_t *m_connection;
+    ipp_status_t m_lastStatus = IPP_OK;
+    mutable QString m_internalStatus = QString::null;
+};
+
+
+#endif // USC_PRINTERS_CUPSPKHELPER_H

=== added file 'plugins/Ubuntu/Settings/Printers/enums.h'
--- plugins/Ubuntu/Settings/Printers/enums.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/enums.h	2017-02-08 22:01:29 +0000
@@ -0,0 +1,141 @@
+/*
+ * 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 ColorSpace
+    {
+        NSpace = 0,
+        RGBSpace,
+        RGBKSpace,
+        GraySpace,
+        CMYSpace,
+        CMYKSpace,
+        UnknownSpace,
+    };
+    Q_ENUM(ColorSpace)
+
+    enum class ColorOrganization
+    {
+        ChunkyOrganization = 0,
+        BandedOrganization,
+        PlanarOrganization,
+        UnknownOrganization,
+    };
+    Q_ENUM(ColorOrganization)
+
+    enum class CartridgeType
+    {
+        BlackCartridge = 0,
+        CyanCartridge,
+        MagentaCartridge,
+        YellowCartridge,
+        RedCartridge,
+        GreenCartridge,
+        BlueCartridge,
+        UnknownCartridge,
+        WhiteCartridge,
+    };
+    Q_ENUM(CartridgeType)
+
+    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 'plugins/Ubuntu/Settings/Printers/i18n.cpp'
--- plugins/Ubuntu/Settings/Printers/i18n.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/i18n.cpp	2017-02-08 22:01:29 +0000
@@ -0,0 +1,44 @@
+/*
+ * 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
+//    bindtextdomain(domain, localeDir);
+//    textdomain(domain);
+    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 'plugins/Ubuntu/Settings/Printers/i18n.h'
--- plugins/Ubuntu/Settings/Printers/i18n.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/i18n.h	2017-02-08 22:01:29 +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 'plugins/Ubuntu/Settings/Printers/models'
=== added file 'plugins/Ubuntu/Settings/Printers/models/drivermodel.cpp'
--- plugins/Ubuntu/Settings/Printers/models/drivermodel.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/models/drivermodel.cpp	2017-02-08 22:01:29 +0000
@@ -0,0 +1,181 @@
+/*
+ * 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/cupsfacade.h"
+#include "models/drivermodel.h"
+
+#include <QDebug>
+#include <QtConcurrent>
+
+DriverModel::DriverModel(QObject *parent)
+    : DriverModel(new PrinterCupsBackend, parent)
+{
+}
+
+DriverModel::DriverModel(PrinterBackend *backend, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_backend(backend)
+{
+    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->requestAvailablePrinterDrivers();
+}
+
+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 'plugins/Ubuntu/Settings/Printers/models/drivermodel.h'
--- plugins/Ubuntu/Settings/Printers/models/drivermodel.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/models/drivermodel.h	2017-02-08 22:01:29 +0000
@@ -0,0 +1,83 @@
+/*
+ * 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(QObject *parent = Q_NULLPTR);
+    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 'plugins/Ubuntu/Settings/Printers/models/jobmodel.cpp'
--- plugins/Ubuntu/Settings/Printers/models/jobmodel.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/models/jobmodel.cpp	2017-02-08 22:01:29 +0000
@@ -0,0 +1,248 @@
+/*
+ * 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 "cups/cupsfacade.h"
+
+#include "models/jobmodel.h"
+
+#include <QDebug>
+
+JobModel::JobModel(QObject *parent)
+    : JobModel(QStringLiteral(""), new PrinterCupsBackend, parent)
+{
+}
+
+JobModel::JobModel(const QString &printerName, PrinterBackend *backend,
+                   QObject *parent)
+    : QAbstractListModel(parent)
+    , m_backend(backend)
+    , m_printer_name(printerName)
+{
+    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);
+    Q_UNUSED(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(m_printer_name);
+
+    /* If any printers returned from the backend are irrelevant, we delete
+    them. This a list of indices that corresponds to printers scheduled for
+    deletion in newPrinters. */
+    QList<uint> forDeletion;
+
+    // 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);
+            p->deleteLater();
+            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;
+                forDeletion << i;
+                break;
+            }
+        }
+
+        if (exists) {
+            if (j == i) {  // New printer exists and in correct position
+                continue;
+            } else {
+                // New printer does exist but needs to be moved in old model
+                beginMoveRows(QModelIndex(), j, 1, QModelIndex(), i);
+                m_jobs.move(j, i);
+                endMoveRows();
+            }
+
+            // We can safely delete the newPrinter as it already exists.
+            forDeletion << i;
+        } else {
+            // New printer does not exist insert into model
+            beginInsertRows(QModelIndex(), i, i);
+            m_jobs.insert(i, newJobs.at(i));
+            endInsertRows();
+        }
+    }
+
+    Q_FOREACH(const int &index, forDeletion) {
+        newJobs.at(index)->deleteLater();
+    }
+
+    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 IdRole:
+            ret = job->jobId();
+            break;
+        case OwnerRole:
+            ret = m_printer_name;
+            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;
+        }
+    }
+
+    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[OwnerRole] = "owner";
+        names[StateRole] = "state";
+        names[TitleRole] = "title";
+        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;
+}

=== added file 'plugins/Ubuntu/Settings/Printers/models/jobmodel.h'
--- plugins/Ubuntu/Settings/Printers/models/jobmodel.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/models/jobmodel.h	2017-02-08 22:01:29 +0000
@@ -0,0 +1,80 @@
+/*
+ * 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 "printer/printer.h"
+
+#include <QAbstractListModel>
+#include <QByteArray>
+#include <QModelIndex>
+#include <QObject>
+#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(const QString &printerName, PrinterBackend *backend,
+                      QObject *parent = Q_NULLPTR);
+    ~JobModel();
+
+    enum Roles
+    {
+        // Qt::DisplayRole holds job title
+        IdRole = Qt::UserRole,
+        OwnerRole,
+        StateRole,
+        TitleRole,
+        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;
+private:
+    PrinterBackend *m_backend;
+    QString m_printer_name;
+
+    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();
+};
+
+#endif // USC_JOB_MODEL_H

=== added file 'plugins/Ubuntu/Settings/Printers/models/printermodel.cpp'
--- plugins/Ubuntu/Settings/Printers/models/printermodel.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/models/printermodel.cpp	2017-02-08 22:01:29 +0000
@@ -0,0 +1,555 @@
+/*
+ * 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 "cups/cupsfacade.h"
+#include "models/jobmodel.h"
+#include "models/printermodel.h"
+
+#include <QDebug>
+#include <QQmlEngine>
+
+PrinterModel::PrinterModel(QObject *parent)
+    : PrinterModel(new PrinterCupsBackend, parent)
+{
+}
+
+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,
+                     this, &PrinterModel::printerModified);
+    QObject::connect(m_backend, &PrinterBackend::printerDeleted,
+                     this, &PrinterModel::printerDeleted);
+
+    connect(m_backend, SIGNAL(availablePrintersLoaded(QList<QSharedPointer<Printer>>)),
+            this, SLOT(printersLoaded(QList<QSharedPointer<Printer>>)));
+
+    printersLoaded(m_backend->availablePrinters());
+    update();
+}
+
+PrinterModel::~PrinterModel()
+{
+}
+
+void PrinterModel::printersLoaded(QList<QSharedPointer<Printer>> printers)
+{
+    qWarning() << Q_FUNC_INFO;
+    // Store the old count and get the new printers
+    int oldCount = m_printers.size();
+    QList<QSharedPointer<Printer>> newPrinters = printers;
+
+    // Go through the old model
+    for (int i=0; i < m_printers.count(); i++) {
+        // Determine if the old printer exists in the new model
+        bool exists = false;
+
+        Q_FOREACH(auto newPrinter, newPrinters) {
+            auto oldPrinter = m_printers.at(i);
+            if (newPrinter->name() == oldPrinter->name()) {
+                exists = true;
+                if (!oldPrinter->deepCompare(newPrinter.data())) {
+                    replacePrinter(oldPrinter, newPrinter);
+                }
+                break;
+            }
+        }
+
+        // If it doesn't exist then remove it from the old model
+        if (!exists) {
+            removePrinter(m_printers.at(i));
+            i--;  // as we have removed an item decrement
+        }
+    }
+
+    // Go through the new model
+    for (int i=0; i < newPrinters.count(); i++) {
+        // Determine if the new printer exists in the old model
+        bool exists = false;
+        int j;
+
+        for (j=0; j < m_printers.count(); j++) {
+            auto oldPrinter = m_printers.at(j);
+            auto newPrinter = newPrinters.at(i);
+            if (oldPrinter->name() == newPrinter->name()) {
+                exists = true;
+
+                if (oldPrinter->type() == PrinterEnum::PrinterType::ProxyType) {
+                    replacePrinter(oldPrinter, newPrinter);
+                }
+                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
+                movePrinter(j, i);
+            }
+        } else {
+            // New printer does not exist insert into model
+            addPrinter(newPrinters.at(i));
+        }
+    }
+
+    if (oldCount != m_printers.size()) {
+        Q_EMIT countChanged();
+    }
+}
+
+void PrinterModel::printerModified(
+    const QString &text, const QString &printerUri,
+    const QString &printerName, uint printerState,
+    const QString &printerStateReason, bool acceptingJobs)
+{
+    Q_UNUSED(text);
+    Q_UNUSED(printerUri);
+    Q_UNUSED(printerState);
+    Q_UNUSED(printerStateReason);
+    Q_UNUSED(acceptingJobs);
+    auto oldPrinter = getPrinterByName(printerName);
+    auto newPrinter = m_backend->getPrinter(printerName);
+    if (oldPrinter && newPrinter)
+        replacePrinter(oldPrinter, newPrinter);
+}
+
+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);
+
+    auto printer = m_backend->getPrinter(printerName);
+    if (printer)
+        addPrinter(printer, CountChangeSignal::Emit);
+}
+
+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::update()
+{
+    m_backend->requestAvailablePrinters();
+}
+
+void PrinterModel::movePrinter(const int &from, const int &to)
+{
+    beginMoveRows(QModelIndex(), from, 1, QModelIndex(), to);
+    m_printers.move(from, to);
+    endMoveRows();
+}
+
+// TODO: take a Printer
+void PrinterModel::removePrinter(QSharedPointer<Printer> printer, const CountChangeSignal &notify)
+{
+    int idx = m_printers.indexOf(printer);
+    beginRemoveRows(QModelIndex(), idx, idx);
+    auto p = m_printers.takeAt(idx);
+    JobModel *jobModel = m_job_models.take(p->name());
+    jobModel->deleteLater();
+    endRemoveRows();
+
+    if (notify == CountChangeSignal::Emit)
+        Q_EMIT countChanged();
+}
+
+void PrinterModel::replacePrinter(QSharedPointer<Printer> old,
+                                  QSharedPointer<Printer> newPrinter)
+{
+    qWarning() << "will replace" << old->name() << "with" << newPrinter->name() << (int) newPrinter->type();
+    int i = m_printers.indexOf(old);
+    QModelIndex idx = index(i);
+
+    m_printers.replace(i, 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);
+
+    JobModel *model = new JobModel(printer->name(), m_backend, this);
+    QQmlEngine::setObjectOwnership(model, QQmlEngine::CppOwnership);
+    m_job_models.insert(printer->name(), model);
+
+    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()];
+
+        switch (role) {
+        case NameRole:
+        case Qt::DisplayRole:
+            ret = printer->name();
+            break;
+        case ColorModelRole:
+            ret = printer->supportedColorModels().indexOf(printer->defaultColorModel());
+            break;
+        case SupportedColorModelsRole: {
+                QStringList models;
+                Q_FOREACH(const ColorModel &m, printer->supportedColorModels()) {
+                    models.append(m.text.isEmpty() ? m.name : m.text);
+                }
+                ret = models;
+            }
+            break;
+        // case CopiesRole:
+        //     ret = printer->copies();
+        //     break;
+        case DefaultPrinterRole:
+            ret = printer->isDefault();
+            break;
+        case DuplexRole:
+            ret = printer->supportedDuplexModes().indexOf(printer->defaultDuplexMode());
+            break;
+        case SupportedDuplexModesRole:
+            ret = printer->supportedDuplexStrings();
+            break;
+        // case PrintRangeRole:
+        //     ret = printer->printRange();
+        //     break;
+        // case PrintRangeModeRole:
+        //     ret = printer->printRangeMode();
+        //     break;
+        // case PdfModeRole:
+        //     ret = printer->pdfMode();
+        //     break;
+        case PrintQualityRole:
+            ret = printer->supportedPrintQualities().indexOf(printer->defaultPrintQuality());
+            break;
+        case SupportedPrintQualitiesRole: {
+                QStringList qualities;
+                Q_FOREACH(const PrintQuality &q, printer->supportedPrintQualities()) {
+                    qualities.append(q.text.isEmpty() ? q.name : q.text);
+                }
+                ret = qualities;
+            }
+            break;
+        case DescriptionRole:
+            ret = printer->description();
+            break;
+        case PageSizeRole:
+            ret = printer->defaultPageSize().name();
+            break;
+        case SupportedPageSizesRole: {
+                QStringList sizes;
+                Q_FOREACH(const QPageSize &s, printer->supportedPageSizes()) {
+                    sizes << s.name();
+                }
+                ret = sizes;
+            }
+            break;
+
+        // case AccessControlRole:
+        //     ret = printer->accessControl();
+        //     break;
+        // case ErrorPolicyRole:
+        //     ret = printer->errorPolicy();
+        //     break;
+        // case UsersRole:
+        //     ret = printer->users();
+        //     break;
+        // case StateRole:
+        //     ret = printer->state();
+        //     break;