← Back to branch summary

~jonas-drange/ubuntu-settings-components/quality-read-write

« back to all changes in this revision

Viewing changes to plugins/Ubuntu/Settings/Printers/dbus/cupspkhelpermechanism.h

  • Committer: Jonas G. Drange
  • Date: 2017-01-07 23:11:03 UTC
  • Revision ID: jonas.drange@canonical.com-20170107231103-k7crr08g6nx58wu8
remove some stuffs not priority for now, add something that builds

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/Ubuntu/Settings/Printers/dbus/cupspkhelpermechanism.h
1
 
/*
2
 
 * This file was generated by qdbusxml2cpp version 0.8
3
 
 * Command line was: qdbusxml2cpp -v -i metatypes.h org.opensuse.CupsPkHelper.Mechanism.xml -p cupspkhelpermechanism
4
 
 *
5
 
 * qdbusxml2cpp is Copyright (C) 2016 The Qt Company Ltd.
6
 
 *
7
 
 * This is an auto-generated file.
8
 
 * Do not edit! All changes made to it will be lost.
9
 
 */
10
 
 
11
 
#ifndef CUPSPKHELPERMECHANISM_H
12
 
#define CUPSPKHELPERMECHANISM_H
13
 
 
14
 
#include <QtCore/QObject>
15
 
#include <QtCore/QByteArray>
16
 
#include <QtCore/QList>
17
 
#include <QtCore/QMap>
18
 
#include <QtCore/QString>
19
 
#include <QtCore/QStringList>
20
 
#include <QtCore/QVariant>
21
 
#include <QtDBus/QtDBus>
22
 
#include "metatypes.h"
23
 
 
24
 
/*
25
 
 * Proxy class for interface org.opensuse.CupsPkHelper.Mechanism
26
 
 */
27
 
class OrgOpensuseCupsPkHelperMechanismInterface: public QDBusAbstractInterface
28
 
{
29
 
    Q_OBJECT
30
 
public:
31
 
    static inline const char *staticInterfaceName()
32
 
    { return "org.opensuse.CupsPkHelper.Mechanism"; }
33
 
 
34
 
public:
35
 
    OrgOpensuseCupsPkHelperMechanismInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0);
36
 
 
37
 
    ~OrgOpensuseCupsPkHelperMechanismInterface();
38
 
 
39
 
public Q_SLOTS: // METHODS
40
 
    inline QDBusPendingReply<QString> ClassAddPrinter(const QString &name, const QString &printer)
41
 
    {
42
 
        QList<QVariant> argumentList;
43
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(printer);
44
 
        return asyncCallWithArgumentList(QStringLiteral("ClassAddPrinter"), argumentList);
45
 
    }
46
 
 
47
 
    inline QDBusPendingReply<QString> ClassDelete(const QString &name)
48
 
    {
49
 
        QList<QVariant> argumentList;
50
 
        argumentList << QVariant::fromValue(name);
51
 
        return asyncCallWithArgumentList(QStringLiteral("ClassDelete"), argumentList);
52
 
    }
53
 
 
54
 
    inline QDBusPendingReply<QString> ClassDeletePrinter(const QString &name, const QString &printer)
55
 
    {
56
 
        QList<QVariant> argumentList;
57
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(printer);
58
 
        return asyncCallWithArgumentList(QStringLiteral("ClassDeletePrinter"), argumentList);
59
 
    }
60
 
 
61
 
    inline QDBusPendingReply<QString, QStringMap> DevicesGet(int timeout, int limit, const QStringList &include_schemes, const QStringList &exclude_schemes)
62
 
    {
63
 
        QList<QVariant> argumentList;
64
 
        argumentList << QVariant::fromValue(timeout) << QVariant::fromValue(limit) << QVariant::fromValue(include_schemes) << QVariant::fromValue(exclude_schemes);
65
 
        return asyncCallWithArgumentList(QStringLiteral("DevicesGet"), argumentList);
66
 
    }
67
 
    inline QDBusReply<QString> DevicesGet(int timeout, int limit, const QStringList &include_schemes, const QStringList &exclude_schemes, QStringMap &devices)
68
 
    {
69
 
        QList<QVariant> argumentList;
70
 
        argumentList << QVariant::fromValue(timeout) << QVariant::fromValue(limit) << QVariant::fromValue(include_schemes) << QVariant::fromValue(exclude_schemes);
71
 
        QDBusMessage reply = callWithArgumentList(QDBus::Block, QStringLiteral("DevicesGet"), argumentList);
72
 
        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == 2) {
73
 
            devices = qdbus_cast<QStringMap>(reply.arguments().at(1));
74
 
        }
75
 
        return reply;
76
 
    }
77
 
 
78
 
    inline QDBusPendingReply<QString> FileGet(const QString &resource, const QString &filename)
79
 
    {
80
 
        QList<QVariant> argumentList;
81
 
        argumentList << QVariant::fromValue(resource) << QVariant::fromValue(filename);
82
 
        return asyncCallWithArgumentList(QStringLiteral("FileGet"), argumentList);
83
 
    }
84
 
 
85
 
    inline QDBusPendingReply<QString> FilePut(const QString &resource, const QString &filename)
86
 
    {
87
 
        QList<QVariant> argumentList;
88
 
        argumentList << QVariant::fromValue(resource) << QVariant::fromValue(filename);
89
 
        return asyncCallWithArgumentList(QStringLiteral("FilePut"), argumentList);
90
 
    }
91
 
 
92
 
    inline Q_DECL_DEPRECATED QDBusPendingReply<QString> JobCancel(int jobid)
93
 
    {
94
 
        QList<QVariant> argumentList;
95
 
        argumentList << QVariant::fromValue(jobid);
96
 
        return asyncCallWithArgumentList(QStringLiteral("JobCancel"), argumentList);
97
 
    }
98
 
 
99
 
    inline QDBusPendingReply<QString> JobCancelPurge(int jobid, bool purge)
100
 
    {
101
 
        QList<QVariant> argumentList;
102
 
        argumentList << QVariant::fromValue(jobid) << QVariant::fromValue(purge);
103
 
        return asyncCallWithArgumentList(QStringLiteral("JobCancelPurge"), argumentList);
104
 
    }
105
 
 
106
 
    inline QDBusPendingReply<QString> JobRestart(int jobid)
107
 
    {
108
 
        QList<QVariant> argumentList;
109
 
        argumentList << QVariant::fromValue(jobid);
110
 
        return asyncCallWithArgumentList(QStringLiteral("JobRestart"), argumentList);
111
 
    }
112
 
 
113
 
    inline QDBusPendingReply<QString> JobSetHoldUntil(int jobid, const QString &job_hold_until)
114
 
    {
115
 
        QList<QVariant> argumentList;
116
 
        argumentList << QVariant::fromValue(jobid) << QVariant::fromValue(job_hold_until);
117
 
        return asyncCallWithArgumentList(QStringLiteral("JobSetHoldUntil"), argumentList);
118
 
    }
119
 
 
120
 
    inline QDBusPendingReply<QString> PrinterAdd(const QString &name, const QString &uri, const QString &ppd, const QString &info, const QString &location)
121
 
    {
122
 
        QList<QVariant> argumentList;
123
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(uri) << QVariant::fromValue(ppd) << QVariant::fromValue(info) << QVariant::fromValue(location);
124
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterAdd"), argumentList);
125
 
    }
126
 
 
127
 
    inline QDBusPendingReply<QString> PrinterAddOption(const QString &name, const QString &option, const QStringList &values)
128
 
    {
129
 
        QList<QVariant> argumentList;
130
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(option) << QVariant::fromValue(values);
131
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterAddOption"), argumentList);
132
 
    }
133
 
 
134
 
    inline QDBusPendingReply<QString> PrinterAddOptionDefault(const QString &name, const QString &option, const QStringList &values)
135
 
    {
136
 
        QList<QVariant> argumentList;
137
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(option) << QVariant::fromValue(values);
138
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterAddOptionDefault"), argumentList);
139
 
    }
140
 
 
141
 
    inline QDBusPendingReply<QString> PrinterAddWithPpdFile(const QString &name, const QString &uri, const QString &ppd, const QString &info, const QString &location)
142
 
    {
143
 
        QList<QVariant> argumentList;
144
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(uri) << QVariant::fromValue(ppd) << QVariant::fromValue(info) << QVariant::fromValue(location);
145
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterAddWithPpdFile"), argumentList);
146
 
    }
147
 
 
148
 
    inline QDBusPendingReply<QString> PrinterDelete(const QString &name)
149
 
    {
150
 
        QList<QVariant> argumentList;
151
 
        argumentList << QVariant::fromValue(name);
152
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterDelete"), argumentList);
153
 
    }
154
 
 
155
 
    inline QDBusPendingReply<QString> PrinterDeleteOptionDefault(const QString &name, const QString &option)
156
 
    {
157
 
        QList<QVariant> argumentList;
158
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(option);
159
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterDeleteOptionDefault"), argumentList);
160
 
    }
161
 
 
162
 
    inline QDBusPendingReply<QString> PrinterSetAcceptJobs(const QString &name, bool enabled, const QString &reason)
163
 
    {
164
 
        QList<QVariant> argumentList;
165
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(enabled) << QVariant::fromValue(reason);
166
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetAcceptJobs"), argumentList);
167
 
    }
168
 
 
169
 
    inline QDBusPendingReply<QString> PrinterSetDefault(const QString &name)
170
 
    {
171
 
        QList<QVariant> argumentList;
172
 
        argumentList << QVariant::fromValue(name);
173
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetDefault"), argumentList);
174
 
    }
175
 
 
176
 
    inline QDBusPendingReply<QString> PrinterSetDevice(const QString &name, const QString &device)
177
 
    {
178
 
        QList<QVariant> argumentList;
179
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(device);
180
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetDevice"), argumentList);
181
 
    }
182
 
 
183
 
    inline QDBusPendingReply<QString> PrinterSetEnabled(const QString &name, bool enabled)
184
 
    {
185
 
        QList<QVariant> argumentList;
186
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(enabled);
187
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetEnabled"), argumentList);
188
 
    }
189
 
 
190
 
    inline QDBusPendingReply<QString> PrinterSetErrorPolicy(const QString &name, const QString &policy)
191
 
    {
192
 
        QList<QVariant> argumentList;
193
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(policy);
194
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetErrorPolicy"), argumentList);
195
 
    }
196
 
 
197
 
    inline QDBusPendingReply<QString> PrinterSetInfo(const QString &name, const QString &info)
198
 
    {
199
 
        QList<QVariant> argumentList;
200
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(info);
201
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetInfo"), argumentList);
202
 
    }
203
 
 
204
 
    inline QDBusPendingReply<QString> PrinterSetJobSheets(const QString &name, const QString &start, const QString &end)
205
 
    {
206
 
        QList<QVariant> argumentList;
207
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(start) << QVariant::fromValue(end);
208
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetJobSheets"), argumentList);
209
 
    }
210
 
 
211
 
    inline QDBusPendingReply<QString> PrinterSetLocation(const QString &name, const QString &location)
212
 
    {
213
 
        QList<QVariant> argumentList;
214
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(location);
215
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetLocation"), argumentList);
216
 
    }
217
 
 
218
 
    inline QDBusPendingReply<QString> PrinterSetOpPolicy(const QString &name, const QString &policy)
219
 
    {
220
 
        QList<QVariant> argumentList;
221
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(policy);
222
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetOpPolicy"), argumentList);
223
 
    }
224
 
 
225
 
    inline QDBusPendingReply<QString> PrinterSetShared(const QString &name, bool shared)
226
 
    {
227
 
        QList<QVariant> argumentList;
228
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(shared);
229
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetShared"), argumentList);
230
 
    }
231
 
 
232
 
    inline QDBusPendingReply<QString> PrinterSetUsersAllowed(const QString &name, const QStringList &users)
233
 
    {
234
 
        QList<QVariant> argumentList;
235
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(users);
236
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetUsersAllowed"), argumentList);
237
 
    }
238
 
 
239
 
    inline QDBusPendingReply<QString> PrinterSetUsersDenied(const QString &name, const QStringList &users)
240
 
    {
241
 
        QList<QVariant> argumentList;
242
 
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(users);
243
 
        return asyncCallWithArgumentList(QStringLiteral("PrinterSetUsersDenied"), argumentList);
244
 
    }
245
 
 
246
 
    inline QDBusPendingReply<QString, QStringMap> ServerGetSettings()
247
 
    {
248
 
        QList<QVariant> argumentList;
249
 
        return asyncCallWithArgumentList(QStringLiteral("ServerGetSettings"), argumentList);
250
 
    }
251
 
    inline QDBusReply<QString> ServerGetSettings(QStringMap &settings)
252
 
    {
253
 
        QList<QVariant> argumentList;
254
 
        QDBusMessage reply = callWithArgumentList(QDBus::Block, QStringLiteral("ServerGetSettings"), argumentList);
255
 
        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == 2) {
256
 
            settings = qdbus_cast<QStringMap>(reply.arguments().at(1));
257
 
        }
258
 
        return reply;
259
 
    }
260
 
 
261
 
    inline QDBusPendingReply<QString> ServerSetSettings(const QStringMap &settings)
262
 
    {
263
 
        QList<QVariant> argumentList;
264
 
        argumentList << QVariant::fromValue(settings);
265
 
        return asyncCallWithArgumentList(QStringLiteral("ServerSetSettings"), argumentList);
266
 
    }
267
 
 
268
 
Q_SIGNALS: // SIGNALS
269
 
};
270
 
 
271
 
namespace org {
272
 
  namespace opensuse {
273
 
    namespace CupsPkHelper {
274
 
      typedef ::OrgOpensuseCupsPkHelperMechanismInterface Mechanism;
275
 
    }
276
 
  }
277
 
}
278
 
#endif