← Back to branch summary

~ci-train-bot/ubuntu-settings-components/ubuntu-settings-components-ubuntu-zesty-2236

« back to all changes in this revision

Viewing changes to plugins/Ubuntu/Settings/Printers/printers/printers.cpp

  • Committer: Bileto Bot
  • Date: 2017-02-21 16:16:01 UTC
  • mfrom: (176.2.56 printer-components)
  • Revision ID: ci-train-bot@canonical.com-20170221161601-b6xdyrpew24xfnpl
* packaging: suggest cups, depend on libcups2-dev
* adds cups bindings for printer/job management

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/Ubuntu/Settings/Printers/printers/printers.cpp
 
1
/*
 
2
 * Copyright (C) 2017 Canonical, Ltd.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU Lesser General Public License as published by
 
6
 * the Free Software Foundation; version 3.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 * GNU Lesser General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU Lesser General Public License
 
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
15
 */
 
16
 
 
17
#include "backend/backend_cups.h"
 
18
#include "printers/printers.h"
 
19
#include "cupsdnotifier.h" // Note: this file was generated.
 
20
 
 
21
#include <QDBusConnection>
 
22
#include <QPrinterInfo>
 
23
#include <QQmlEngine>
 
24
 
 
25
Printers::Printers(QObject *parent)
 
26
    : Printers(new PrinterCupsBackend(new IppClient(), QPrinterInfo(),
 
27
        new OrgCupsCupsdNotifierInterface("", CUPSD_NOTIFIER_DBUS_PATH,
 
28
                                          QDBusConnection::systemBus())),
 
29
       parent)
 
30
{
 
31
}
 
32
 
 
33
Printers::Printers(PrinterBackend *backend, QObject *parent)
 
34
    : QObject(parent)
 
35
    , m_backend(backend)
 
36
    , m_drivers(backend)
 
37
    , m_model(backend)
 
38
    , m_jobs(backend)
 
39
{
 
40
    m_allPrinters.setSourceModel(&m_model);
 
41
    m_allPrinters.setSortRole(PrinterModel::Roles::DefaultPrinterRole);
 
42
    m_allPrinters.filterOnPdf(false);
 
43
    m_allPrinters.sort(0, Qt::DescendingOrder);
 
44
 
 
45
    m_allPrintersWithPdf.setSourceModel(&m_model);
 
46
    m_allPrintersWithPdf.setSortRole(PrinterModel::Roles::DefaultPrinterRole);
 
47
    m_allPrintersWithPdf.sort(0, Qt::DescendingOrder);
 
48
 
 
49
    // Let Qt be in charge of RAII.
 
50
    m_backend->setParent(this);
 
51
 
 
52
    connect(&m_drivers, SIGNAL(filterComplete()),
 
53
            this, SIGNAL(driverFilterChanged()));
 
54
 
 
55
    connect(&m_jobs, &QAbstractItemModel::rowsInserted, [this](
 
56
            const QModelIndex &parent, int first, int) {
 
57
        int jobId = m_jobs.data(m_jobs.index(first, 0, parent),
 
58
                                JobModel::Roles::IdRole).toInt();
 
59
        jobAdded(m_jobs.getJobById(jobId));
 
60
    });
 
61
    connect(&m_model, &QAbstractItemModel::rowsInserted, [this](
 
62
            const QModelIndex &parent, int first, int) {
 
63
        auto printer = m_model.data(
 
64
            m_model.index(first, 0, parent),
 
65
            PrinterModel::Roles::PrinterRole
 
66
        ).value<QSharedPointer<Printer>>();
 
67
        printerAdded(printer);
 
68
    });
 
69
 
 
70
    // Assign jobmodels to printers right away.
 
71
    for (int i = 0; i < m_model.rowCount(); i++) {
 
72
        printerAdded(m_model.data(
 
73
                m_model.index(i, 0),
 
74
                PrinterModel::Roles::PrinterRole
 
75
            ).value<QSharedPointer<Printer>>()
 
76
        );
 
77
    }
 
78
 
 
79
    if (m_backend->type() == PrinterEnum::PrinterType::CupsType) {
 
80
        ((PrinterCupsBackend*) m_backend)->createSubscription();
 
81
    }
 
82
 
 
83
    // Eagerly load the default printer.
 
84
    if (!m_backend->defaultPrinterName().isEmpty()) {}
 
85
        m_backend->requestPrinter(m_backend->defaultPrinterName());
 
86
}
 
87
 
 
88
Printers::~Printers()
 
89
{
 
90
}
 
91
 
 
92
QAbstractItemModel* Printers::allPrinters()
 
93
{
 
94
    auto ret = &m_allPrinters;
 
95
    QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
 
96
    return ret;
 
97
}
 
98
 
 
99
QAbstractItemModel* Printers::allPrintersWithPdf()
 
100
{
 
101
    auto ret = &m_allPrintersWithPdf;
 
102
    QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
 
103
    return ret;
 
104
}
 
105
 
 
106
QAbstractItemModel* Printers::recentPrinters()
 
107
{
 
108
    // TODO: implement
 
109
    return Q_NULLPTR;
 
110
}
 
111
 
 
112
QAbstractItemModel* Printers::printJobs()
 
113
{
 
114
    auto ret = &m_jobs;
 
115
    QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
 
116
    return ret;
 
117
}
 
118
 
 
119
QAbstractItemModel* Printers::drivers()
 
120
{
 
121
    auto ret = &m_drivers;
 
122
    QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
 
123
    return ret;
 
124
}
 
125
 
 
126
QString Printers::driverFilter() const
 
127
{
 
128
    return m_drivers.filter();
 
129
}
 
130
 
 
131
void Printers::setDriverFilter(const QString &filter)
 
132
{
 
133
    m_drivers.setFilter(filter);
 
134
}
 
135
 
 
136
QString Printers::defaultPrinterName() const
 
137
{
 
138
    return m_backend->defaultPrinterName();
 
139
}
 
140
 
 
141
QString Printers::lastMessage() const
 
142
{
 
143
    return m_lastMessage;
 
144
}
 
145
 
 
146
PrinterJob* Printers::createJob(const QString &printerName)
 
147
{
 
148
    // Note: If called by QML, it gains ownership of this job.
 
149
    return new PrinterJob(printerName, m_backend);
 
150
}
 
151
 
 
152
void Printers::cancelJob(const QString &printerName, const int jobId)
 
153
{
 
154
    m_backend->cancelJob(printerName, jobId);
 
155
}
 
156
 
 
157
void Printers::setDefaultPrinterName(const QString &name)
 
158
{
 
159
    QString reply = m_backend->printerSetDefault(name);
 
160
 
 
161
    if (!reply.isEmpty()) {
 
162
        m_lastMessage = reply;
 
163
    }
 
164
}
 
165
 
 
166
QSharedPointer<Printer> Printers::getPrinterByName(const QString &name)
 
167
{
 
168
    // TODO: implement
 
169
    Q_UNUSED(name);
 
170
 
 
171
    return QSharedPointer<Printer>(Q_NULLPTR);
 
172
}
 
173
QSharedPointer<Printer> Printers::getJobOwner(const int &jobId)
 
174
{
 
175
    // TODO: implement
 
176
    Q_UNUSED(jobId);
 
177
 
 
178
    return QSharedPointer<Printer>(Q_NULLPTR);
 
179
}
 
180
 
 
181
void Printers::prepareToAddPrinter()
 
182
{
 
183
    m_drivers.load();
 
184
}
 
185
 
 
186
bool Printers::addPrinter(const QString &name, const QString &ppd,
 
187
                          const QString &device, const QString &description,
 
188
                          const QString &location)
 
189
{
 
190
    QString reply = m_backend->printerAdd(name, device, ppd, description,
 
191
                                          location);
 
192
    if (!reply.isEmpty()) {
 
193
        m_lastMessage = reply;
 
194
        return false;
 
195
    }
 
196
    return true;
 
197
}
 
198
 
 
199
bool Printers::addPrinterWithPpdFile(const QString &name,
 
200
                                     const QString &ppdFileName,
 
201
                                     const QString &device,
 
202
                                     const QString &description,
 
203
                                     const QString &location)
 
204
{
 
205
    QString reply = m_backend->printerAddWithPpd(name, device, ppdFileName,
 
206
                                                 description, location);
 
207
    if (!reply.isEmpty()) {
 
208
        m_lastMessage = reply;
 
209
        return false;
 
210
    }
 
211
    return true;
 
212
}
 
213
 
 
214
bool Printers::removePrinter(const QString &name)
 
215
{
 
216
    QString reply = m_backend->printerDelete(name);
 
217
 
 
218
    if (!reply.isEmpty()) {
 
219
        m_lastMessage = reply;
 
220
        return false;
 
221
    }
 
222
    return true;
 
223
}
 
224
 
 
225
void Printers::jobAdded(QSharedPointer<PrinterJob> job)
 
226
{
 
227
    auto printer = m_model.getPrinterByName(job->printerName());
 
228
    if (printer && job)
 
229
        job->setPrinter(printer);
 
230
}
 
231
 
 
232
void Printers::printerAdded(QSharedPointer<Printer> printer)
 
233
{
 
234
    printer->setJobModel(&m_jobs);
 
235
 
 
236
    // Loop through jobs and associate a printer with it.
 
237
    for (int i = 0; i < m_jobs.rowCount(); i++) {
 
238
        QModelIndex idx = m_jobs.index(i, 0);
 
239
 
 
240
        QString printerName = m_jobs.data(
 
241
            idx, JobModel::Roles::PrinterNameRole
 
242
        ).toString();
 
243
 
 
244
        int jobId = m_jobs.data(idx, JobModel::Roles::IdRole).toInt();
 
245
        auto job = m_jobs.getJobById(jobId);
 
246
        if (printerName == printer->name() && !job->printer()) {
 
247
            job->setPrinter(printer);
 
248
            return;
 
249
        }
 
250
    }
 
251
}