1
=== modified file '.bzrignore'
2
--- .bzrignore	2012-02-02 14:49:11 +0000
3
+++ .bzrignore	2017-01-10 21:54:44 +0000
4
@@ -27,3 +27,5 @@
5
27
src/*.lo
27
src/*.lo
6
28
src/cups-notifier.[ch]
28
src/cups-notifier.[ch]
7
29
29
8
30
build/
9
31
10
30
32
11
=== removed file 'AUTHORS'
12
--- AUTHORS	2012-01-11 14:29:38 +0000
13
+++ AUTHORS	1970-01-01 00:00:00 +0000
14
@@ -1,2 +0,0 @@
15
1
Lars Uebernickel <lars.uebernickel@canonical.com>
16
2
17
3
0
18
=== added file 'CMakeLists.txt'
19
--- CMakeLists.txt	1970-01-01 00:00:00 +0000
20
+++ CMakeLists.txt	2017-01-10 21:54:44 +0000
21
@@ -0,0 +1,54 @@
22
1
project(indicator-printers C CXX)
23
2
cmake_minimum_required(VERSION 2.8.9)
24
3
25
4
### Need to have own copy of gdbuscodegen module
26
5
list (APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
27
6
28
7
### Install path variables
29
8
include (GNUInstallDirs)
30
9
if (EXISTS "/etc/debian_version") # Workaround for libexecdir on debian
31
10
  set (CMAKE_INSTALL_LIBEXECDIR "${CMAKE_INSTALL_LIBDIR}")
32
11
  set (CMAKE_INSTALL_FULL_LIBEXECDIR "${CMAKE_INSTALL_FULL_LIBDIR}")
33
12
endif ()
34
13
set (CMAKE_INSTALL_PKGLIBEXECDIR "${CMAKE_INSTALL_LIBEXECDIR}/${CMAKE_PROJECT_NAME}")
35
14
set (CMAKE_INSTALL_FULL_PKGLIBEXECDIR "${CMAKE_INSTALL_FULL_LIBEXECDIR}/${CMAKE_PROJECT_NAME}")
36
15
37
16
### Always Be Testing
38
17
enable_testing()
39
18
40
19
### Set variables for our binary build targets
41
20
set(SERVICE_LIB_NAME "indicator-printers")
42
21
set(SERVICE_EXEC_NAME "indicator-printers-service")
43
22
44
23
### Some default compile flags
45
24
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2 -g -fPIC")
46
25
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O2 -g -Wextra -Wall -Werror -Werror=conversion-null -Wno-ignored-qualifiers -fPIC")
47
26
48
27
### Find deps
49
28
find_package(PkgConfig REQUIRED)
50
29
find_package(Intltool REQUIRED)
51
30
find_package(Threads)
52
31
53
32
pkg_check_modules(SERVICE_DEPS REQUIRED
54
33
  gio-unix-2.0>=2.36
55
34
  glib-2.0>=2.36
56
35
  properties-cpp
57
36
)
58
37
59
38
### Find libcups
60
39
find_program(CUPS_CONFIG cups-config)
61
40
execute_process(COMMAND ${CUPS_CONFIG} --cflags OUTPUT_VARIABLE CUPS_CFLAGS OUTPUT_STRIP_TRAILING_WHITESPACE)
62
41
execute_process(COMMAND ${CUPS_CONFIG} --libs OUTPUT_VARIABLE CUPS_LIBS OUTPUT_STRIP_TRAILING_WHITESPACE)
63
42
64
43
### Add sub-directories
65
44
add_subdirectory(data)
66
45
add_subdirectory(src)
67
46
add_subdirectory(tests)
68
47
69
48
### Enable coverage reporting
70
49
find_package(CoverageReport)
71
50
ENABLE_COVERAGE_REPORT(
72
51
  TARGETS ${SERVICE_LIB_NAME} ${SERVICE_EXEC_NAME}
73
52
  TESTS test-libindicator-printers
74
53
  FILTER /usr/include ${CMAKE_BINARY_DIR}/*
75
54
)
76
0
55
77
=== added file 'COPYING'
78
--- COPYING	1970-01-01 00:00:00 +0000
79
+++ COPYING	2017-01-10 21:54:44 +0000
80
@@ -0,0 +1,674 @@
81
1
                    GNU GENERAL PUBLIC LICENSE
82
2
                       Version 3, 29 June 2007
83
3
84
4
 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
85
5
 Everyone is permitted to copy and distribute verbatim copies
86
6
 of this license document, but changing it is not allowed.
87
7
88
8
                            Preamble
89
9
90
10
  The GNU General Public License is a free, copyleft license for
91
11
software and other kinds of works.
92
12
93
13
  The licenses for most software and other practical works are designed
94
14
to take away your freedom to share and change the works.  By contrast,
95
15
the GNU General Public License is intended to guarantee your freedom to
96
16
share and change all versions of a program--to make sure it remains free
97
17
software for all its users.  We, the Free Software Foundation, use the
98
18
GNU General Public License for most of our software; it applies also to
99
19
any other work released this way by its authors.  You can apply it to
100
20
your programs, too.
101
21
102
22
  When we speak of free software, we are referring to freedom, not
103
23
price.  Our General Public Licenses are designed to make sure that you
104
24
have the freedom to distribute copies of free software (and charge for
105
25
them if you wish), that you receive source code or can get it if you
106
26
want it, that you can change the software or use pieces of it in new
107
27
free programs, and that you know you can do these things.
108
28
109
29
  To protect your rights, we need to prevent others from denying you
110
30
these rights or asking you to surrender the rights.  Therefore, you have
111
31
certain responsibilities if you distribute copies of the software, or if
112
32
you modify it: responsibilities to respect the freedom of others.
113
33
114
34
  For example, if you distribute copies of such a program, whether
115
35
gratis or for a fee, you must pass on to the recipients the same
116
36
freedoms that you received.  You must make sure that they, too, receive
117
37
or can get the source code.  And you must show them these terms so they
118
38
know their rights.
119
39
120
40
  Developers that use the GNU GPL protect your rights with two steps:
121
41
(1) assert copyright on the software, and (2) offer you this License
122
42
giving you legal permission to copy, distribute and/or modify it.
123
43
124
44
  For the developers' and authors' protection, the GPL clearly explains
125
45
that there is no warranty for this free software.  For both users' and
126
46
authors' sake, the GPL requires that modified versions be marked as
127
47
changed, so that their problems will not be attributed erroneously to
128
48
authors of previous versions.
129
49
130
50
  Some devices are designed to deny users access to install or run
131
51
modified versions of the software inside them, although the manufacturer
132
52
can do so.  This is fundamentally incompatible with the aim of
133
53
protecting users' freedom to change the software.  The systematic
134
54
pattern of such abuse occurs in the area of products for individuals to
135
55
use, which is precisely where it is most unacceptable.  Therefore, we
136
56
have designed this version of the GPL to prohibit the practice for those
137
57
products.  If such problems arise substantially in other domains, we
138
58
stand ready to extend this provision to those domains in future versions
139
59
of the GPL, as needed to protect the freedom of users.
140
60
141
61
  Finally, every program is threatened constantly by software patents.
142
62
States should not allow patents to restrict development and use of
143
63
software on general-purpose computers, but in those that do, we wish to
144
64
avoid the special danger that patents applied to a free program could
145
65
make it effectively proprietary.  To prevent this, the GPL assures that
146
66
patents cannot be used to render the program non-free.
147
67
148
68
  The precise terms and conditions for copying, distribution and
149
69
modification follow.
150
70
151
71
                       TERMS AND CONDITIONS
152
72
153
73
  0. Definitions.
154
74
155
75
  "This License" refers to version 3 of the GNU General Public License.
156
76
157
77
  "Copyright" also means copyright-like laws that apply to other kinds of
158
78
works, such as semiconductor masks.
159
79
160
80
  "The Program" refers to any copyrightable work licensed under this
161
81
License.  Each licensee is addressed as "you".  "Licensees" and
162
82
"recipients" may be individuals or organizations.
163
83
164
84
  To "modify" a work means to copy from or adapt all or part of the work
165
85
in a fashion requiring copyright permission, other than the making of an
166
86
exact copy.  The resulting work is called a "modified version" of the
167
87
earlier work or a work "based on" the earlier work.
168
88
169
89
  A "covered work" means either the unmodified Program or a work based
170
90
on the Program.
171
91
172
92
  To "propagate" a work means to do anything with it that, without
173
93
permission, would make you directly or secondarily liable for
174
94
infringement under applicable copyright law, except executing it on a
175
95
computer or modifying a private copy.  Propagation includes copying,
176
96
distribution (with or without modification), making available to the
177
97
public, and in some countries other activities as well.
178
98
179
99
  To "convey" a work means any kind of propagation that enables other
180
100
parties to make or receive copies.  Mere interaction with a user through
181
101
a computer network, with no transfer of a copy, is not conveying.
182
102
183
103
  An interactive user interface displays "Appropriate Legal Notices"
184
104
to the extent that it includes a convenient and prominently visible
185
105
feature that (1) displays an appropriate copyright notice, and (2)
186
106
tells the user that there is no warranty for the work (except to the
187
107
extent that warranties are provided), that licensees may convey the
188
108
work under this License, and how to view a copy of this License.  If
189
109
the interface presents a list of user commands or options, such as a
190
110
menu, a prominent item in the list meets this criterion.
191
111
192
112
  1. Source Code.
193
113
194
114
  The "source code" for a work means the preferred form of the work
195
115
for making modifications to it.  "Object code" means any non-source
196
116
form of a work.
197
117
198
118
  A "Standard Interface" means an interface that either is an official
199
119
standard defined by a recognized standards body, or, in the case of
200
120
interfaces specified for a particular programming language, one that
201
121
is widely used among developers working in that language.
202
122
203
123
  The "System Libraries" of an executable work include anything, other
204
124
than the work as a whole, that (a) is included in the normal form of
205
125
packaging a Major Component, but which is not part of that Major
206
126
Component, and (b) serves only to enable use of the work with that
207
127
Major Component, or to implement a Standard Interface for which an
208
128
implementation is available to the public in source code form.  A
209
129
"Major Component", in this context, means a major essential component
210
130
(kernel, window system, and so on) of the specific operating system
211
131
(if any) on which the executable work runs, or a compiler used to
212
132
produce the work, or an object code interpreter used to run it.
213
133
214
134
  The "Corresponding Source" for a work in object code form means all
215
135
the source code needed to generate, install, and (for an executable
216
136
work) run the object code and to modify the work, including scripts to
217
137
control those activities.  However, it does not include the work's
218
138
System Libraries, or general-purpose tools or generally available free
219
139
programs which are used unmodified in performing those activities but
220
140
which are not part of the work.  For example, Corresponding Source
221
141
includes interface definition files associated with source files for
222
142
the work, and the source code for shared libraries and dynamically
223
143
linked subprograms that the work is specifically designed to require,
224
144
such as by intimate data communication or control flow between those
225
145
subprograms and other parts of the work.
226
146
227
147
  The Corresponding Source need not include anything that users
228
148
can regenerate automatically from other parts of the Corresponding
229
149
Source.
230
150
231
151
  The Corresponding Source for a work in source code form is that
232
152
same work.
233
153
234
154
  2. Basic Permissions.
235
155
236
156
  All rights granted under this License are granted for the term of
237
157
copyright on the Program, and are irrevocable provided the stated
238
158
conditions are met.  This License explicitly affirms your unlimited
239
159
permission to run the unmodified Program.  The output from running a
240
160
covered work is covered by this License only if the output, given its
241
161
content, constitutes a covered work.  This License acknowledges your
242
162
rights of fair use or other equivalent, as provided by copyright law.
243
163
244
164
  You may make, run and propagate covered works that you do not
245
165
convey, without conditions so long as your license otherwise remains
246
166
in force.  You may convey covered works to others for the sole purpose
247
167
of having them make modifications exclusively for you, or provide you
248
168
with facilities for running those works, provided that you comply with
249
169
the terms of this License in conveying all material for which you do
250
170
not control copyright.  Those thus making or running the covered works
251
171
for you must do so exclusively on your behalf, under your direction
252
172
and control, on terms that prohibit them from making any copies of
253
173
your copyrighted material outside their relationship with you.
254
174
255
175
  Conveying under any other circumstances is permitted solely under
256
176
the conditions stated below.  Sublicensing is not allowed; section 10
257
177
makes it unnecessary.
258
178
259
179
  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
260
180
261
181
  No covered work shall be deemed part of an effective technological
262
182
measure under any applicable law fulfilling obligations under article
263
183
11 of the WIPO copyright treaty adopted on 20 December 1996, or
264
184
similar laws prohibiting or restricting circumvention of such
265
185
measures.
266
186
267
187
  When you convey a covered work, you waive any legal power to forbid
268
188
circumvention of technological measures to the extent such circumvention
269
189
is effected by exercising rights under this License with respect to
270
190
the covered work, and you disclaim any intention to limit operation or
271
191
modification of the work as a means of enforcing, against the work's
272
192
users, your or third parties' legal rights to forbid circumvention of
273
193
technological measures.
274
194
275
195
  4. Conveying Verbatim Copies.
276
196
277
197
  You may convey verbatim copies of the Program's source code as you
278
198
receive it, in any medium, provided that you conspicuously and
279
199
appropriately publish on each copy an appropriate copyright notice;
280
200
keep intact all notices stating that this License and any
281
201
non-permissive terms added in accord with section 7 apply to the code;
282
202
keep intact all notices of the absence of any warranty; and give all
283
203
recipients a copy of this License along with the Program.
284
204
285
205
  You may charge any price or no price for each copy that you convey,
286
206
and you may offer support or warranty protection for a fee.
287
207
288
208
  5. Conveying Modified Source Versions.
289
209
290
210
  You may convey a work based on the Program, or the modifications to
291
211
produce it from the Program, in the form of source code under the
292
212
terms of section 4, provided that you also meet all of these conditions:
293
213
294
214
    a) The work must carry prominent notices stating that you modified
295
215
    it, and giving a relevant date.
296
216
297
217
    b) The work must carry prominent notices stating that it is
298
218
    released under this License and any conditions added under section
299
219
    7.  This requirement modifies the requirement in section 4 to
300
220
    "keep intact all notices".
301
221
302
222
    c) You must license the entire work, as a whole, under this
303
223
    License to anyone who comes into possession of a copy.  This
304
224
    License will therefore apply, along with any applicable section 7
305
225
    additional terms, to the whole of the work, and all its parts,
306
226
    regardless of how they are packaged.  This License gives no
307
227
    permission to license the work in any other way, but it does not
308
228
    invalidate such permission if you have separately received it.
309
229
310
230
    d) If the work has interactive user interfaces, each must display
311
231
    Appropriate Legal Notices; however, if the Program has interactive
312
232
    interfaces that do not display Appropriate Legal Notices, your
313
233
    work need not make them do so.
314
234
315
235
  A compilation of a covered work with other separate and independent
316
236
works, which are not by their nature extensions of the covered work,
317
237
and which are not combined with it such as to form a larger program,
318
238
in or on a volume of a storage or distribution medium, is called an
319
239
"aggregate" if the compilation and its resulting copyright are not
320
240
used to limit the access or legal rights of the compilation's users
321
241
beyond what the individual works permit.  Inclusion of a covered work
322
242
in an aggregate does not cause this License to apply to the other
323
243
parts of the aggregate.
324
244
325
245
  6. Conveying Non-Source Forms.
326
246
327
247
  You may convey a covered work in object code form under the terms
328
248
of sections 4 and 5, provided that you also convey the
329
249
machine-readable Corresponding Source under the terms of this License,
330
250
in one of these ways:
331
251
332
252
    a) Convey the object code in, or embodied in, a physical product
333
253
    (including a physical distribution medium), accompanied by the
334
254
    Corresponding Source fixed on a durable physical medium
335
255
    customarily used for software interchange.
336
256
337
257
    b) Convey the object code in, or embodied in, a physical product
338
258
    (including a physical distribution medium), accompanied by a
339
259
    written offer, valid for at least three years and valid for as
340
260
    long as you offer spare parts or customer support for that product
341
261
    model, to give anyone who possesses the object code either (1) a
342
262
    copy of the Corresponding Source for all the software in the
343
263
    product that is covered by this License, on a durable physical
344
264
    medium customarily used for software interchange, for a price no
345
265
    more than your reasonable cost of physically performing this
346
266
    conveying of source, or (2) access to copy the
347
267
    Corresponding Source from a network server at no charge.
348
268
349
269
    c) Convey individual copies of the object code with a copy of the
350
270
    written offer to provide the Corresponding Source.  This
351
271
    alternative is allowed only occasionally and noncommercially, and
352
272
    only if you received the object code with such an offer, in accord
353
273
    with subsection 6b.
354
274
355
275
    d) Convey the object code by offering access from a designated
356
276
    place (gratis or for a charge), and offer equivalent access to the
357
277
    Corresponding Source in the same way through the same place at no
358
278
    further charge.  You need not require recipients to copy the
359
279
    Corresponding Source along with the object code.  If the place to
360
280
    copy the object code is a network server, the Corresponding Source
361
281
    may be on a different server (operated by you or a third party)
362
282
    that supports equivalent copying facilities, provided you maintain
363
283
    clear directions next to the object code saying where to find the
364
284
    Corresponding Source.  Regardless of what server hosts the
365
285
    Corresponding Source, you remain obligated to ensure that it is
366
286
    available for as long as needed to satisfy these requirements.
367
287
368
288
    e) Convey the object code using peer-to-peer transmission, provided
369
289
    you inform other peers where the object code and Corresponding
370
290
    Source of the work are being offered to the general public at no
371
291
    charge under subsection 6d.
372
292
373
293
  A separable portion of the object code, whose source code is excluded
374
294
from the Corresponding Source as a System Library, need not be
375
295
included in conveying the object code work.
376
296
377
297
  A "User Product" is either (1) a "consumer product", which means any
378
298
tangible personal property which is normally used for personal, family,
379
299
or household purposes, or (2) anything designed or sold for incorporation
380
300
into a dwelling.  In determining whether a product is a consumer product,
381
301
doubtful cases shall be resolved in favor of coverage.  For a particular
382
302
product received by a particular user, "normally used" refers to a
383
303
typical or common use of that class of product, regardless of the status
384
304
of the particular user or of the way in which the particular user
385
305
actually uses, or expects or is expected to use, the product.  A product
386
306
is a consumer product regardless of whether the product has substantial
387
307
commercial, industrial or non-consumer uses, unless such uses represent
388
308
the only significant mode of use of the product.
389
309
390
310
  "Installation Information" for a User Product means any methods,
391
311
procedures, authorization keys, or other information required to install
392
312
and execute modified versions of a covered work in that User Product from
393
313
a modified version of its Corresponding Source.  The information must
394
314
suffice to ensure that the continued functioning of the modified object
395
315
code is in no case prevented or interfered with solely because
396
316
modification has been made.
397
317
398
318
  If you convey an object code work under this section in, or with, or
399
319
specifically for use in, a User Product, and the conveying occurs as
400
320
part of a transaction in which the right of possession and use of the
401
321
User Product is transferred to the recipient in perpetuity or for a
402
322
fixed term (regardless of how the transaction is characterized), the
403
323
Corresponding Source conveyed under this section must be accompanied
404
324
by the Installation Information.  But this requirement does not apply
405
325
if neither you nor any third party retains the ability to install
406
326
modified object code on the User Product (for example, the work has
407
327
been installed in ROM).
408
328
409
329
  The requirement to provide Installation Information does not include a
410
330
requirement to continue to provide support service, warranty, or updates
411
331
for a work that has been modified or installed by the recipient, or for
412
332
the User Product in which it has been modified or installed.  Access to a
413
333
network may be denied when the modification itself materially and
414
334
adversely affects the operation of the network or violates the rules and
415
335
protocols for communication across the network.
416
336
417
337
  Corresponding Source conveyed, and Installation Information provided,
418
338
in accord with this section must be in a format that is publicly
419
339
documented (and with an implementation available to the public in
420
340
source code form), and must require no special password or key for
421
341
unpacking, reading or copying.
422
342
423
343
  7. Additional Terms.
424
344
425
345
  "Additional permissions" are terms that supplement the terms of this
426
346
License by making exceptions from one or more of its conditions.
427
347
Additional permissions that are applicable to the entire Program shall
428
348
be treated as though they were included in this License, to the extent
429
349
that they are valid under applicable law.  If additional permissions
430
350
apply only to part of the Program, that part may be used separately
431
351
under those permissions, but the entire Program remains governed by
432
352
this License without regard to the additional permissions.
433
353
434
354
  When you convey a copy of a covered work, you may at your option
435
355
remove any additional permissions from that copy, or from any part of
436
356
it.  (Additional permissions may be written to require their own
437
357
removal in certain cases when you modify the work.)  You may place
438
358
additional permissions on material, added by you to a covered work,
439
359
for which you have or can give appropriate copyright permission.
440
360
441
361
  Notwithstanding any other provision of this License, for material you
442
362
add to a covered work, you may (if authorized by the copyright holders of
443
363
that material) supplement the terms of this License with terms:
444
364
445
365
    a) Disclaiming warranty or limiting liability differently from the
446
366
    terms of sections 15 and 16 of this License; or
447
367
448
368
    b) Requiring preservation of specified reasonable legal notices or
449
369
    author attributions in that material or in the Appropriate Legal
450
370
    Notices displayed by works containing it; or
451
371
452
372
    c) Prohibiting misrepresentation of the origin of that material, or
453
373
    requiring that modified versions of such material be marked in
454
374
    reasonable ways as different from the original version; or
455
375
456
376
    d) Limiting the use for publicity purposes of names of licensors or
457
377
    authors of the material; or
458
378
459
379
    e) Declining to grant rights under trademark law for use of some
460
380
    trade names, trademarks, or service marks; or
461
381
462
382
    f) Requiring indemnification of licensors and authors of that
463
383
    material by anyone who conveys the material (or modified versions of
464
384
    it) with contractual assumptions of liability to the recipient, for
465
385
    any liability that these contractual assumptions directly impose on
466
386
    those licensors and authors.
467
387
468
388
  All other non-permissive additional terms are considered "further
469
389
restrictions" within the meaning of section 10.  If the Program as you
470
390
received it, or any part of it, contains a notice stating that it is
471
391
governed by this License along with a term that is a further
472
392
restriction, you may remove that term.  If a license document contains
473
393
a further restriction but permits relicensing or conveying under this
474
394
License, you may add to a covered work material governed by the terms
475
395
of that license document, provided that the further restriction does
476
396
not survive such relicensing or conveying.
477
397
478
398
  If you add terms to a covered work in accord with this section, you
479
399
must place, in the relevant source files, a statement of the
480
400
additional terms that apply to those files, or a notice indicating
481
401
where to find the applicable terms.
482
402
483
403
  Additional terms, permissive or non-permissive, may be stated in the
484
404
form of a separately written license, or stated as exceptions;
485
405
the above requirements apply either way.
486
406
487
407
  8. Termination.
488
408
489
409
  You may not propagate or modify a covered work except as expressly
490
410
provided under this License.  Any attempt otherwise to propagate or
491
411
modify it is void, and will automatically terminate your rights under
492
412
this License (including any patent licenses granted under the third
493
413
paragraph of section 11).
494
414
495
415
  However, if you cease all violation of this License, then your
496
416
license from a particular copyright holder is reinstated (a)
497
417
provisionally, unless and until the copyright holder explicitly and
498
418
finally terminates your license, and (b) permanently, if the copyright
499
419
holder fails to notify you of the violation by some reasonable means
500
420
prior to 60 days after the cessation.
501
421
502
422
  Moreover, your license from a particular copyright holder is
503
423
reinstated permanently if the copyright holder notifies you of the
504
424
violation by some reasonable means, this is the first time you have
505
425
received notice of violation of this License (for any work) from that
506
426
copyright holder, and you cure the violation prior to 30 days after
507
427
your receipt of the notice.
508
428
509
429
  Termination of your rights under this section does not terminate the
510
430
licenses of parties who have received copies or rights from you under
511
431
this License.  If your rights have been terminated and not permanently
512
432
reinstated, you do not qualify to receive new licenses for the same
513
433
material under section 10.
514
434
515
435
  9. Acceptance Not Required for Having Copies.
516
436
517
437
  You are not required to accept this License in order to receive or
518
438
run a copy of the Program.  Ancillary propagation of a covered work
519
439
occurring solely as a consequence of using peer-to-peer transmission
520
440
to receive a copy likewise does not require acceptance.  However,
521
441
nothing other than this License grants you permission to propagate or
522
442
modify any covered work.  These actions infringe copyright if you do
523
443
not accept this License.  Therefore, by modifying or propagating a
524
444
covered work, you indicate your acceptance of this License to do so.
525
445
526
446
  10. Automatic Licensing of Downstream Recipients.
527
447
528
448
  Each time you convey a covered work, the recipient automatically
529
449
receives a license from the original licensors, to run, modify and
530
450
propagate that work, subject to this License.  You are not responsible
531
451
for enforcing compliance by third parties with this License.
532
452
533
453
  An "entity transaction" is a transaction transferring control of an
534
454
organization, or substantially all assets of one, or subdividing an
535
455
organization, or merging organizations.  If propagation of a covered
536
456
work results from an entity transaction, each party to that
537
457
transaction who receives a copy of the work also receives whatever
538
458
licenses to the work the party's predecessor in interest had or could
539
459
give under the previous paragraph, plus a right to possession of the
540
460
Corresponding Source of the work from the predecessor in interest, if
541
461
the predecessor has it or can get it with reasonable efforts.
542
462
543
463
  You may not impose any further restrictions on the exercise of the
544
464
rights granted or affirmed under this License.  For example, you may
545
465
not impose a license fee, royalty, or other charge for exercise of
546
466
rights granted under this License, and you may not initiate litigation
547
467
(including a cross-claim or counterclaim in a lawsuit) alleging that
548
468
any patent claim is infringed by making, using, selling, offering for
549
469
sale, or importing the Program or any portion of it.
550
470
551
471
  11. Patents.
552
472
553
473
  A "contributor" is a copyright holder who authorizes use under this
554
474
License of the Program or a work on which the Program is based.  The
555
475
work thus licensed is called the contributor's "contributor version".
556
476
557
477
  A contributor's "essential patent claims" are all patent claims
558
478
owned or controlled by the contributor, whether already acquired or
559
479
hereafter acquired, that would be infringed by some manner, permitted
560
480
by this License, of making, using, or selling its contributor version,
561
481
but do not include claims that would be infringed only as a
562
482
consequence of further modification of the contributor version.  For
563
483
purposes of this definition, "control" includes the right to grant
564
484
patent sublicenses in a manner consistent with the requirements of
565
485
this License.
566
486
567
487
  Each contributor grants you a non-exclusive, worldwide, royalty-free
568
488
patent license under the contributor's essential patent claims, to
569
489
make, use, sell, offer for sale, import and otherwise run, modify and
570
490
propagate the contents of its contributor version.
571
491
572
492
  In the following three paragraphs, a "patent license" is any express
573
493
agreement or commitment, however denominated, not to enforce a patent
574
494
(such as an express permission to practice a patent or covenant not to
575
495
sue for patent infringement).  To "grant" such a patent license to a
576
496
party means to make such an agreement or commitment not to enforce a
577
497
patent against the party.
578
498
579
499
  If you convey a covered work, knowingly relying on a patent license,
580
500
and the Corresponding Source of the work is not available for anyone
581
501
to copy, free of charge and under the terms of this License, through a
582
502
publicly available network server or other readily accessible means,
583
503
then you must either (1) cause the Corresponding Source to be so
584
504
available, or (2) arrange to deprive yourself of the benefit of the
585
505
patent license for this particular work, or (3) arrange, in a manner
586
506
consistent with the requirements of this License, to extend the patent
587
507
license to downstream recipients.  "Knowingly relying" means you have
588
508
actual knowledge that, but for the patent license, your conveying the
589
509
covered work in a country, or your recipient's use of the covered work
590
510
in a country, would infringe one or more identifiable patents in that
591
511
country that you have reason to believe are valid.
592
512
593
513
  If, pursuant to or in connection with a single transaction or
594
514
arrangement, you convey, or propagate by procuring conveyance of, a
595
515
covered work, and grant a patent license to some of the parties
596
516
receiving the covered work authorizing them to use, propagate, modify
597
517
or convey a specific copy of the covered work, then the patent license
598
518
you grant is automatically extended to all recipients of the covered
599
519
work and works based on it.
600
520
601
521
  A patent license is "discriminatory" if it does not include within
602
522
the scope of its coverage, prohibits the exercise of, or is
603
523
conditioned on the non-exercise of one or more of the rights that are
604
524
specifically granted under this License.  You may not convey a covered
605
525
work if you are a party to an arrangement with a third party that is
606
526
in the business of distributing software, under which you make payment
607
527
to the third party based on the extent of your activity of conveying
608
528
the work, and under which the third party grants, to any of the
609
529
parties who would receive the covered work from you, a discriminatory
610
530
patent license (a) in connection with copies of the covered work
611
531
conveyed by you (or copies made from those copies), or (b) primarily
612
532
for and in connection with specific products or compilations that
613
533
contain the covered work, unless you entered into that arrangement,
614
534
or that patent license was granted, prior to 28 March 2007.
615
535
616
536
  Nothing in this License shall be construed as excluding or limiting
617
537
any implied license or other defenses to infringement that may
618
538
otherwise be available to you under applicable patent law.
619
539
620
540
  12. No Surrender of Others' Freedom.
621
541
622
542
  If conditions are imposed on you (whether by court order, agreement or
623
543
otherwise) that contradict the conditions of this License, they do not
624
544
excuse you from the conditions of this License.  If you cannot convey a
625
545
covered work so as to satisfy simultaneously your obligations under this
626
546
License and any other pertinent obligations, then as a consequence you may
627
547
not convey it at all.  For example, if you agree to terms that obligate you
628
548
to collect a royalty for further conveying from those to whom you convey
629
549
the Program, the only way you could satisfy both those terms and this
630
550
License would be to refrain entirely from conveying the Program.
631
551
632
552
  13. Use with the GNU Affero General Public License.
633
553
634
554
  Notwithstanding any other provision of this License, you have
635
555
permission to link or combine any covered work with a work licensed
636
556
under version 3 of the GNU Affero General Public License into a single
637
557
combined work, and to convey the resulting work.  The terms of this
638
558
License will continue to apply to the part which is the covered work,
639
559
but the special requirements of the GNU Affero General Public License,
640
560
section 13, concerning interaction through a network will apply to the
641
561
combination as such.
642
562
643
563
  14. Revised Versions of this License.
644
564
645
565
  The Free Software Foundation may publish revised and/or new versions of
646
566
the GNU General Public License from time to time.  Such new versions will
647
567
be similar in spirit to the present version, but may differ in detail to
648
568
address new problems or concerns.
649
569
650
570
  Each version is given a distinguishing version number.  If the
651
571
Program specifies that a certain numbered version of the GNU General
652
572
Public License "or any later version" applies to it, you have the
653
573
option of following the terms and conditions either of that numbered
654
574
version or of any later version published by the Free Software
655
575
Foundation.  If the Program does not specify a version number of the
656
576
GNU General Public License, you may choose any version ever published
657
577
by the Free Software Foundation.
658
578
659
579
  If the Program specifies that a proxy can decide which future
660
580
versions of the GNU General Public License can be used, that proxy's
661
581
public statement of acceptance of a version permanently authorizes you
662
582
to choose that version for the Program.
663
583
664
584
  Later license versions may give you additional or different
665
585
permissions.  However, no additional obligations are imposed on any
666
586
author or copyright holder as a result of your choosing to follow a
667
587
later version.
668
588
669
589
  15. Disclaimer of Warranty.
670
590
671
591
  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
672
592
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
673
593
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
674
594
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
675
595
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
676
596
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
677
597
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
678
598
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
679
599
680
600
  16. Limitation of Liability.
681
601
682
602
  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
683
603
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
684
604
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
685
605
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
686
606
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
687
607
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
688
608
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
689
609
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
690
610
SUCH DAMAGES.
691
611
692
612
  17. Interpretation of Sections 15 and 16.
693
613
694
614
  If the disclaimer of warranty and limitation of liability provided
695
615
above cannot be given local legal effect according to their terms,
696
616
reviewing courts shall apply local law that most closely approximates
697
617
an absolute waiver of all civil liability in connection with the
698
618
Program, unless a warranty or assumption of liability accompanies a
699
619
copy of the Program in return for a fee.
700
620
701
621
                     END OF TERMS AND CONDITIONS
702
622
703
623
            How to Apply These Terms to Your New Programs
704
624
705
625
  If you develop a new program, and you want it to be of the greatest
706
626
possible use to the public, the best way to achieve this is to make it
707
627
free software which everyone can redistribute and change under these terms.
708
628
709
629
  To do so, attach the following notices to the program.  It is safest
710
630
to attach them to the start of each source file to most effectively
711
631
state the exclusion of warranty; and each file should have at least
712
632
the "copyright" line and a pointer to where the full notice is found.
713
633
714
634
    <one line to give the program's name and a brief idea of what it does.>
715
635
    Copyright (C) <year>  <name of author>
716
636
717
637
    This program is free software: you can redistribute it and/or modify
718
638
    it under the terms of the GNU General Public License as published by
719
639
    the Free Software Foundation, either version 3 of the License, or
720
640
    (at your option) any later version.
721
641
722
642
    This program is distributed in the hope that it will be useful,
723
643
    but WITHOUT ANY WARRANTY; without even the implied warranty of
724
644
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
725
645
    GNU General Public License for more details.
726
646
727
647
    You should have received a copy of the GNU General Public License
728
648
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
729
649
730
650
Also add information on how to contact you by electronic and paper mail.
731
651
732
652
  If the program does terminal interaction, make it output a short
733
653
notice like this when it starts in an interactive mode:
734
654
735
655
    <program>  Copyright (C) <year>  <name of author>
736
656
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
737
657
    This is free software, and you are welcome to redistribute it
738
658
    under certain conditions; type `show c' for details.
739
659
740
660
The hypothetical commands `show w' and `show c' should show the appropriate
741
661
parts of the General Public License.  Of course, your program's commands
742
662
might be different; for a GUI interface, you would use an "about box".
743
663
744
664
  You should also get your employer (if you work as a programmer) or school,
745
665
if any, to sign a "copyright disclaimer" for the program, if necessary.
746
666
For more information on this, and how to apply and follow the GNU GPL, see
747
667
<http://www.gnu.org/licenses/>.
748
668
749
669
  The GNU General Public License does not permit incorporating your program
750
670
into proprietary programs.  If your program is a subroutine library, you
751
671
may consider it more useful to permit linking proprietary applications with
752
672
the library.  If this is what you want to do, use the GNU Lesser General
753
673
Public License instead of this License.  But first, please read
754
674
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
755
0
675
756
=== removed file 'ChangeLog'
757
=== removed file 'Makefile.am'
758
--- Makefile.am	2012-03-27 22:12:02 +0000
759
+++ Makefile.am	1970-01-01 00:00:00 +0000
760
@@ -1,6 +0,0 @@
761
1
762
2
SUBDIRS = src data test po
763
3
764
4
DISTCHECK_CONFIGURE_FLAGS = --enable-localinstall
765
5
766
6
include $(top_srcdir)/Makefile.am.coverage
767
7
0
768
=== removed file 'Makefile.am.coverage'
769
--- Makefile.am.coverage	2012-03-27 22:12:02 +0000
770
+++ Makefile.am.coverage	1970-01-01 00:00:00 +0000
771
@@ -1,48 +0,0 @@
772
1
773
2
# Coverage targets
774
3
775
4
.PHONY: clean-gcno clean-gcda \
776
5
	coverage-html generate-coverage-html clean-coverage-html \
777
6
	coverage-gcovr generate-coverage-gcovr clean-coverage-gcovr
778
7
779
8
clean-local: clean-gcno clean-coverage-html clean-coverage-gcovr
780
9
781
10
if HAVE_GCOV
782
11
783
12
clean-gcno:
784
13
	@echo Removing old coverage instrumentation
785
14
	-find -name '*.gcno' -print | xargs -r rm
786
15
787
16
clean-gcda:
788
17
	@echo Removing old coverage results
789
18
	-find -name '*.gcda' -print | xargs -r rm
790
19
  
791
20
coverage-html: clean-gcda
792
21
	-$(MAKE) $(AM_MAKEFLAGS) -k check
793
22
	$(MAKE) $(AM_MAKEFLAGS) generate-coverage-html
794
23
  
795
24
generate-coverage-html:
796
25
	@echo Collecting coverage data
797
26
	$(LCOV) --directory $(top_builddir) --capture --output-file coverage.info --no-checksum --compat-libtool
798
27
	LANG=C $(GENHTML) --prefix $(top_builddir) --output-directory coveragereport --title "Code Coverage" --legend --show-details coverage.info
799
28
  
800
29
clean-coverage-html: clean-gcda
801
30
	-$(LCOV) --directory $(top_builddir) -z
802
31
	-rm -rf coverage.info coveragereport
803
32
804
33
if HAVE_GCOVR
805
34
806
35
coverage-gcovr: clean-gcda
807
36
	-$(MAKE) $(AM_MAKEFLAGS) -k check
808
37
	$(MAKE) $(AM_MAKEFLAGS) generate-coverage-gcovr
809
38
	
810
39
generate-coverage-gcovr:
811
40
	@echo Generating coverage GCOVR report
812
41
	$(GCOVR) -x -r $(top_builddir) -o $(top_builddir)/coverage.xml
813
42
	
814
43
clean-coverage-gcovr: clean-gcda
815
44
	-rm -rf $(top_builddir)/coverage.xml
816
45
817
46
endif # HAVE_GCOVR
818
47
819
48
endif # HAVE_GCOV
820
49
0
821
=== removed file 'NEWS'
822
=== removed file 'autogen.sh'
823
--- autogen.sh	2012-01-11 14:29:38 +0000
824
+++ autogen.sh	1970-01-01 00:00:00 +0000
825
@@ -1,9 +0,0 @@
826
1
#!/bin/sh
827
2
828
3
which gnome-autogen.sh || {
829
4
    echo "Could not find 'gnome-autgen.sh'. Is gnome-common installed?"
830
5
    exit 1
831
6
}
832
7
833
8
. gnome-autogen.sh
834
9
835
10
0
836
=== added directory 'cmake'
837
=== added file 'cmake/GdbusCodegen.cmake'
838
--- cmake/GdbusCodegen.cmake	1970-01-01 00:00:00 +0000
839
+++ cmake/GdbusCodegen.cmake	2017-01-10 21:54:44 +0000
840
@@ -0,0 +1,36 @@
841
1
cmake_minimum_required(VERSION 2.6)
842
2
if(POLICY CMP0011)
843
3
  cmake_policy(SET CMP0011 NEW)
844
4
endif(POLICY CMP0011)
845
5
846
6
find_program(GDBUS_CODEGEN NAMES gdbus-codegen DOC "gdbus-codegen executable")
847
7
if(NOT GDBUS_CODEGEN)
848
8
  message(FATAL_ERROR "Excutable gdbus-codegen not found")
849
9
endif()
850
10
851
11
macro(add_gdbus_codegen outfiles name prefix service_xml)
852
12
  add_custom_command(
853
13
    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
854
14
    COMMAND "${GDBUS_CODEGEN}"
855
15
        --interface-prefix "${prefix}"
856
16
        --generate-c-code "${name}"
857
17
        "${service_xml}"
858
18
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
859
19
    DEPENDS ${ARGN} "${service_xml}"
860
20
  )
861
21
  list(APPEND ${outfiles} "${CMAKE_CURRENT_BINARY_DIR}/${name}.c")
862
22
endmacro(add_gdbus_codegen)
863
23
864
24
macro(add_gdbus_codegen_with_namespace outfiles name prefix namespace service_xml)
865
25
  add_custom_command(
866
26
    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" "${CMAKE_CURRENT_BINARY_DIR}/${name}.c"
867
27
    COMMAND "${GDBUS_CODEGEN}"
868
28
        --interface-prefix "${prefix}"
869
29
        --generate-c-code "${name}"
870
30
        --c-namespace "${namespace}"
871
31
        "${service_xml}"
872
32
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
873
33
    DEPENDS ${ARGN} "${service_xml}"
874
34
  )
875
35
  list(APPEND ${outfiles} "${CMAKE_CURRENT_BINARY_DIR}/${name}.c")
876
36
endmacro(add_gdbus_codegen_with_namespace)
877
0
37
878
=== removed file 'configure.ac'
879
--- configure.ac	2016-07-19 15:43:40 +0000
880
+++ configure.ac	1970-01-01 00:00:00 +0000
881
@@ -1,105 +0,0 @@
882
1
883
2
AC_INIT(indicator-printers, 0.1.6)
884
3
885
4
AC_PREREQ(2.53)
886
5
AM_INIT_AUTOMAKE([])
887
6
888
7
AC_PROG_CC
889
8
AC_PROG_INSTALL
890
9
AC_PROG_LIBTOOL
891
10
AM_PROG_CC_C_O
892
11
AM_SILENT_RULES([yes])
893
12
AC_CONFIG_MACRO_DIR([m4])
894
13
895
14
AC_DEFUN([AC_DEFINE_PATH], [
896
15
	test "x$prefix" = xNONE && prefix="$ac_default_prefix"
897
16
	test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
898
17
	ac_define_path=`eval echo [$]$2`
899
18
	ac_define_path=`eval echo [$]ac_define_path`
900
19
	$1="$ac_define_path"
901
20
	AC_SUBST($1)
902
21
	ifelse($3, ,
903
22
		AC_DEFINE_UNQUOTED($1, "$ac_define_path"),
904
23
		AC_DEFINE_UNQUOTED($1, "$ac_define_path", $3))
905
24
])
906
25
907
26
IT_PROG_INTLTOOL([0.35.0])
908
27
GETTEXT_PACKAGE=indicator-printers
909
28
AC_SUBST(GETTEXT_PACKAGE)
910
29
AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, "$GETTEXT_PACKAGE", [gettext package])
911
30
AC_DEFINE_PATH(GNOMELOCALEDIR, "${datadir}/locale", [locale directory])
912
31
AM_GLIB_GNU_GETTEXT
913
32
914
33
AC_CONFIG_HEADER(config.h)
915
34
AC_CONFIG_FILES([
916
35
    Makefile
917
36
    src/Makefile
918
37
    data/Makefile
919
38
    data/upstart/Makefile
920
39
    test/Makefile
921
40
    po/Makefile.in
922
41
])
923
42
924
43
PKG_CHECK_MODULES(APPLET, gtk+-3.0 >= 3.0
925
44
                          indicator3-0.4 >= 0.2
926
45
                          dbusmenu-gtk3-0.4 >= 0.2)
927
46
PKG_CHECK_MODULES(SERVICE, gtk+-3.0 >= 3.0
928
47
                           indicator3-0.4 >= 0.2
929
48
                           dbusmenu-glib-0.4 >= 0.2)
930
49
931
50
AC_PATH_PROG(CUPS_CONFIG, cups-config, no)
932
51
if test "x$CUPS_CONFIG" = "xno"; then
933
52
    AC_MSG_ERROR([could not find cups-config])
934
53
fi
935
54
AC_CHECK_HEADER(cups/cups.h,,AC_MSG_ERROR([could not find cups.h]))
936
55
CUPS_CFLAGS+=`$CUPS_CONFIG --cflags`
937
56
CUPS_LIBS+=`$CUPS_CONFIG --libs`
938
57
SERVICE_CFLAGS="$SERVICE_CFLAGS $CUPS_CFLAGS"
939
58
SERVICE_LIBS="$SERVICE_LIBS $CUPS_LIBS"
940
59
941
60
SYSTEMD_USERDIR=`$PKG_CONFIG --variable=systemduserunitdir systemd`
942
61
AC_SUBST(SYSTEMD_USERDIR)
943
62
944
63
with_localinstall="no"
945
64
AC_ARG_ENABLE(localinstall, AS_HELP_STRING([--enable-localinstall],
946
65
                                           [install all files locally (for distcheck)]),
947
66
              with_localinstall=$enableval,
948
67
              with_localinstall=no)
949
68
950
69
if test "x$with_localinstall" = "xyes"; then
951
70
	INDICATORDIR="${libdir}/indicators/2/"
952
71
	INDICATORICONSDIR="${datadir}/libindicate/icons/"
953
72
else
954
73
	INDICATORDIR=`$PKG_CONFIG --variable=indicatordir indicator3-0.4`
955
74
	INDICATORICONSDIR=`$PKG_CONFIG --variable=iconsdir indicator3-0.4`
956
75
fi
957
76
AC_SUBST(INDICATORDIR)
958
77
AC_SUBST(INDICATORICONSDIR)
959
78
960
79
###########################
961
80
# DBus Service Info
962
81
###########################
963
82
964
83
if test "x$with_localinstall" = "xyes"; then
965
84
	DBUSSERVICEDIR="${datadir}/dbus-1/services/"
966
85
else
967
86
	DBUSSERVICEDIR=`$PKG_CONFIG --variable=session_bus_services_dir dbus-1`
968
87
fi
969
88
AC_SUBST(DBUSSERVICEDIR)
970
89
971
90
###########################
972
91
# gcov coverage reporting
973
92
###########################
974
93
975
94
m4_include([m4/gcov.m4])
976
95
AC_TDD_GCOV
977
96
AM_CONDITIONAL([HAVE_GCOV], [test "x$ac_cv_check_gcov" = xyes])
978
97
AM_CONDITIONAL([HAVE_LCOV], [test "x$ac_cv_check_lcov" = xyes])
979
98
AM_CONDITIONAL([HAVE_GCOVR], [test "x$ac_cv_check_gcovr" = xyes])
980
99
AC_SUBST(COVERAGE_CFLAGS)
981
100
AC_SUBST(COVERAGE_LDFLAGS)
982
101
983
102
AC_SUBST(AM_CFLAGS, "-Wall")
984
103
985
104
AC_OUTPUT
986
105
987
106
0
988
=== added file 'data/CMakeLists.txt'
989
--- data/CMakeLists.txt	1970-01-01 00:00:00 +0000
990
+++ data/CMakeLists.txt	2017-01-10 21:54:44 +0000
991
@@ -0,0 +1,64 @@
992
1
##
993
2
##  Systemd Unit File
994
3
##
995
4
996
5
# where to install
997
6
# Uncomment when we drop Vivid
998
7
# pkg_get_variable(SYSTEMD_USER_DIR systemd systemduserunitdir)
999
8
set (SYSTEMD_USER_DIR "/usr/lib/systemd/user")
1000
9
message (STATUS "${SYSTEMD_USER_DIR} is the systemd user unit file install dir")
1001
10
1002
11
set (SYSTEMD_USER_NAME "${CMAKE_PROJECT_NAME}.service")
1003
12
set (SYSTEMD_USER_FILE "${CMAKE_CURRENT_BINARY_DIR}/${SYSTEMD_USER_NAME}")
1004
13
set (SYSTEMD_USER_FILE_IN "${CMAKE_CURRENT_SOURCE_DIR}/${SYSTEMD_USER_NAME}.in")
1005
14
1006
15
# build it
1007
16
set (pkglibexecdir "${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}")
1008
17
configure_file ("${SYSTEMD_USER_FILE_IN}" "${SYSTEMD_USER_FILE}")
1009
18
1010
19
# install it
1011
20
install (FILES "${SYSTEMD_USER_FILE}"
1012
21
         DESTINATION "${SYSTEMD_USER_DIR}")
1013
22
1014
23
##
1015
24
##  Upstart systemd override Job File
1016
25
##
1017
26
1018
27
set (UPSTART_SYSTEMD_OVERRIDE_DIR "${CMAKE_INSTALL_FULL_DATADIR}/upstart/systemd-session/upstart")
1019
28
message (STATUS "${UPSTART_SYSTEMD_OVERRIDE_DIR} is the Upstart override Job File for systemd dir")
1020
29
1021
30
install (FILES "${CMAKE_CURRENT_SOURCE_DIR}/${CMAKE_PROJECT_NAME}.override"
1022
31
         DESTINATION "${UPSTART_SYSTEMD_OVERRIDE_DIR}")
1023
32
1024
33
##
1025
34
##  Upstart Job File
1026
35
##
1027
36
1028
37
# where to install
1029
38
set (UPSTART_JOB_DIR "${CMAKE_INSTALL_FULL_DATADIR}/upstart/sessions")
1030
39
message (STATUS "${UPSTART_JOB_DIR} is the Upstart Job File install dir")
1031
40
1032
41
set (UPSTART_JOB_NAME "${CMAKE_PROJECT_NAME}.conf")
1033
42
set (UPSTART_JOB_FILE "${CMAKE_CURRENT_BINARY_DIR}/${UPSTART_JOB_NAME}")
1034
43
set (UPSTART_JOB_FILE_IN "${CMAKE_CURRENT_SOURCE_DIR}/${UPSTART_JOB_NAME}.in")
1035
44
1036
45
# build it
1037
46
configure_file ("${UPSTART_JOB_FILE_IN}" "${UPSTART_JOB_FILE}")
1038
47
1039
48
# install it
1040
49
install (FILES "${UPSTART_JOB_FILE}"
1041
50
         DESTINATION "${UPSTART_JOB_DIR}")
1042
51
1043
52
##
1044
53
##  Unity Indicator File
1045
54
##
1046
55
1047
56
# where to install
1048
57
set (UNITY_INDICATOR_DIR "${CMAKE_INSTALL_FULL_DATAROOTDIR}/unity/indicators")
1049
58
message (STATUS "${UNITY_INDICATOR_DIR} is the Unity Indicator install dir")
1050
59
1051
60
set (UNITY_INDICATOR_NAME "com.canonical.indicator.printers")
1052
61
set (UNITY_INDICATOR_FILE "${CMAKE_CURRENT_SOURCE_DIR}/${UNITY_INDICATOR_NAME}")
1053
62
1054
63
install (FILES "${UNITY_INDICATOR_FILE}"
1055
64
         DESTINATION "${UNITY_INDICATOR_DIR}")
1056
0
65
1057
=== removed file 'data/Makefile.am'
1058
--- data/Makefile.am	2016-07-19 15:43:40 +0000
1059
+++ data/Makefile.am	1970-01-01 00:00:00 +0000
1060
@@ -1,55 +0,0 @@
1061
1
1062
2
BUILT_SOURCES=
1063
3
CLEANFILES=
1064
4
EXTRA_DIST=
1065
5
1066
6
SUBDIRS = upstart
1067
7
1068
8
#
1069
9
# the systemd unit file
1070
10
#
1071
11
1072
12
systemddir = $(SYSTEMD_USERDIR)
1073
13
systemd_DATA = indicator-printers.service
1074
14
systemd_in = $(systemd_DATA:.service=.service.in)
1075
15
$(systemd_DATA): $(systemd_in)
1076
16
	$(AM_V_GEN) $(SED) -e "s|\@pkglibexecdir\@|$(pkglibexecdir)|" $< > $@
1077
17
BUILT_SOURCES += $(systemd_DATA)
1078
18
EXTRA_DIST += $(systemd_in)
1079
19
CLEANFILES += $(systemd_DATA)
1080
20
1081
21
#
1082
22
# the systemd upstart override
1083
23
#
1084
24
1085
25
upstart_overridedir = $(datadir)/upstart/systemd-session/upstart
1086
26
upstart_override_DATA = indicator-printers.override
1087
27
EXTRA_DIST += $(upstart_override_DATA)
1088
28
1089
29
#
1090
30
# the upstart job file
1091
31
#
1092
32
1093
33
upstart_jobsdir = $(datadir)/upstart/sessions
1094
34
upstart_jobs_DATA = indicator-printers.conf
1095
35
upstart_jobs_in = $(upstart_jobs_DATA:.conf=.conf.in)
1096
36
$(upstart_jobs_DATA): $(upstart_jobs_in)
1097
37
	$(AM_V_GEN) $(SED) -e "s|\@pkglibexecdir\@|$(pkglibexecdir)|" $< > $@
1098
38
BUILT_SOURCES += $(upstart_jobs_DATA)
1099
39
CLEANFILES += $(upstart_jobs_DATA)
1100
40
EXTRA_DIST += $(upstart_jobs_in)
1101
41
1102
42
#
1103
43
# the xdg autostart job file
1104
44
#
1105
45
1106
46
xdg_autostartdir = /etc/xdg/autostart
1107
47
xdg_autostart_DATA = indicator-printers.desktop
1108
48
xdg_autostart_in = $(xdg_autostart_DATA:.desktop=.desktop.in)
1109
49
$(xdg_autostart_DATA): $(xdg_autostart_in)
1110
50
	$(AM_V_GEN) $(SED) -e "s|\@pkglibexecdir\@|$(pkglibexecdir)|" $< > $@
1111
51
BUILT_SOURCES += $(xdg_autostart_DATA)
1112
52
CLEANFILES += $(xdg_autostart_DATA)
1113
53
EXTRA_DIST += $(xdg_autostart_in)
1114
54
1115
55
1116
56
0
1117
=== added file 'data/com.canonical.indicator.printers'
1118
--- data/com.canonical.indicator.printers	1970-01-01 00:00:00 +0000
1119
+++ data/com.canonical.indicator.printers	2017-01-10 21:54:44 +0000
1120
@@ -0,0 +1,20 @@
1121
1
[Indicator Service]
1122
2
Name=indicator-printers
1123
3
ObjectPath=/com/canonical/indicator/printers
1124
4
Position=90
1125
5
1126
6
[desktop]
1127
7
ObjectPath=/com/canonical/indicator/printers/menu
1128
8
1129
9
[desktop_greeter]
1130
10
ObjectPath=/com/canonical/indicator/printers/menu
1131
11
1132
12
[desktop_lockscreen]
1133
13
ObjectPath=/com/canonical/indicator/printers/menu
1134
14
1135
15
[phone]
1136
16
ObjectPath=/com/canonical/indicator/printers/menu
1137
17
1138
18
[phone_greeter]
1139
19
ObjectPath=/com/canonical/indicator/printers/menu
1140
20
1141
0
21
1142
=== removed file 'data/indicator-printers.desktop.in'
1143
--- data/indicator-printers.desktop.in	2014-02-20 16:08:19 +0000
1144
+++ data/indicator-printers.desktop.in	1970-01-01 00:00:00 +0000
1145
@@ -1,8 +0,0 @@
1146
1
[Desktop Entry]
1147
2
Type=Application
1148
3
Name=Indicator Printers
1149
4
Exec=@pkglibexecdir@/indicator-printers-service
1150
5
OnlyShowIn=Unity;
1151
6
NoDisplay=true
1152
7
StartupNotify=false
1153
8
Terminal=false
1154
9
0
1155
=== removed directory 'data/upstart'
1156
=== removed file 'data/upstart/Makefile.am'
1157
--- data/upstart/Makefile.am	2014-02-20 16:06:20 +0000
1158
+++ data/upstart/Makefile.am	1970-01-01 00:00:00 +0000
1159
@@ -1,17 +0,0 @@
1160
1
BUILT_SOURCES=
1161
2
CLEANFILES=
1162
3
EXTRA_DIST=
1163
4
1164
5
#
1165
6
# the upstart xdg autostart override
1166
7
#
1167
8
1168
9
xdg_autostartdir = $(datadir)/upstart/xdg/autostart
1169
10
xdg_autostart_DATA = indicator-printers.desktop
1170
11
xdg_autostart_in = $(xdg_autostart_DATA:.desktop=.desktop.in)
1171
12
$(xdg_autostart_DATA): $(xdg_autostart_in)
1172
13
	$(AM_V_GEN) $(SED) -e "s|\@pkglibexecdir\@|$(pkglibexecdir)|" $< > $@
1173
14
BUILT_SOURCES += $(xdg_autostart_DATA)
1174
15
CLEANFILES += $(xdg_autostart_DATA)
1175
16
EXTRA_DIST += $(xdg_autostart_in)
1176
17
1177
18
0
1178
=== removed file 'data/upstart/indicator-printers.desktop.in'
1179
--- data/upstart/indicator-printers.desktop.in	2014-02-20 16:08:19 +0000
1180
+++ data/upstart/indicator-printers.desktop.in	1970-01-01 00:00:00 +0000
1181
@@ -1,9 +0,0 @@
1182
1
[Desktop Entry]
1183
2
Type=Application
1184
3
Name=Indicator Printers
1185
4
Exec=@pkglibexecdir@/indicator-printers-service
1186
5
OnlyShowIn=Unity;
1187
6
NoDisplay=true
1188
7
StartupNotify=false
1189
8
Terminal=false
1190
9
Hidden=true
1191
10
0
1192
=== modified file 'debian/control'
1193
--- debian/control	2016-11-24 23:20:47 +0000
1194
+++ debian/control	2017-01-10 21:54:44 +0000
1195
@@ -2,26 +2,24 @@
1196
2
Section: gnome
2
Section: gnome
1197
3
Priority: extra
3
Priority: extra
1198
4
Maintainer: Ubuntu Desktop Team <ubuntu-desktop@lists.ubuntu.com>
4
Maintainer: Ubuntu Desktop Team <ubuntu-desktop@lists.ubuntu.com>
1213
5
XSBC-Original-Maintainer: Lars Uebernickel <lars.uebernickel@canonical.com>
5
Build-Depends:
1214
6
Build-Depends: debhelper (>= 9),
6
 cmake,
1215
7
               autotools-dev,
7
 cmake-extras (>= 0.10),
1216
8
               dh-autoreconf,
8
 debhelper (>= 9),
1217
9
               gnome-common,
9
 dbus,
1218
10
               python,
10
 dh-translations,
1219
11
               libglib2.0-dev (>= 2.43.2),
11
 gcovr,
1220
12
               libgtk-3-dev,
12
 googletest | google-mock,
1221
13
               libdbusmenu-glib-dev (>= 0.5.90),
13
 intltool,
1222
14
               libdbusmenu-gtk3-dev (>= 0.5.90),
14
 lcov,
1223
15
               libindicator3-dev (>= 0.3.91),
15
 libcups2-dev,
1224
16
               libcups2-dev,
16
 libglib2.0-dev (>= 2.35.4),
1225
17
               systemd,
17
 libproperties-cpp-dev,
1226
18
Standards-Version: 3.9.2
18
 systemd,
1227
19
Standards-Version: 3.9.6
1228
19
Homepage: https://launchpad.net/indicator-printers
20
Homepage: https://launchpad.net/indicator-printers
1234
20
# If you aren't a member of ~indicator-applet-developers but need to upload
21
Vcs-Bzr: lp:indicator-printers
1235
21
# packaging changes, just go ahead.  ~indicator-applet-developers will notice
22
X-Ubuntu-Use-Langpack: yes
1231
22
# and sync up the code again.
1232
23
Vcs-Bzr: https://code.launchpad.net/~indicator-applet-developers/indicator-printers/trunk.13.04
1233
24
Vcs-Browser: https://bazaar.launchpad.net/~indicator-applet-developers/indicator-printers/trunk.13.04/files
1236
25
23
1237
26
Package: indicator-printers
24
Package: indicator-printers
1238
27
Architecture: any
25
Architecture: any
1239
@@ -30,7 +28,6 @@
1240
30
         cups (>= 1.5),
28
         cups (>= 1.5),
1241
31
         indicator-common,
29
         indicator-common,
1242
32
Recommends: indicator-applet (>= 0.2) | indicator-renderer,
30
Recommends: indicator-applet (>= 0.2) | indicator-renderer,
1243
33
            system-config-printer,
1244
34
Description: indicator showing active print jobs
31
Description: indicator showing active print jobs
1245
35
 This indicator is designed to let you view and control active print jobs.
32
 This indicator is designed to let you view and control active print jobs.
1246
36
 .
33
 .
1247
37
34
1248
=== modified file 'debian/copyright'
1249
--- debian/copyright	2012-02-16 16:23:19 +0000
1250
+++ debian/copyright	2017-01-10 21:54:44 +0000
1251
@@ -1,10 +1,9 @@
1252
1
Format: http://dep.debian.net/deps/dep5/
1
Format: http://dep.debian.net/deps/dep5/
1253
2
Upstream-Name: indicator-printers
2
Upstream-Name: indicator-printers
1254
3
Upstream-Contact: Lars Uebernickel <lars.uebernickel@canonical.com>
1255
4
Source: https://launchpad.net/indicator-printers
3
Source: https://launchpad.net/indicator-printers
1256
5
4
1257
6
Files: *
5
Files: *
1259
7
Copyright: 2012 Canonical Ltd
6
Copyright: 2012, 2016-2017 Canonical Ltd
1260
8
License: GPL-3
7
License: GPL-3
1261
9
 This program is free software: you can redistribute it and/or modify
8
 This program is free software: you can redistribute it and/or modify
1262
10
 it under the terms of the GNU General Public License as published by
9
 it under the terms of the GNU General Public License as published by
1263
11
10
1264
=== modified file 'debian/rules'
1265
--- debian/rules	2012-11-20 15:32:37 +0000
1266
+++ debian/rules	2017-01-10 21:54:44 +0000
1267
@@ -1,22 +1,7 @@
1268
1
#!/usr/bin/make -f
1
#!/usr/bin/make -f
1269
2
1270
3
1271
4
CFLAGS += -Wno-error=deprecated-declarations
1272
5
LDFLAGS += -Wl,-z,defs -Wl,--as-needed
2
LDFLAGS += -Wl,-z,defs -Wl,--as-needed
1273
6
3
1274
7
export DPKG_GENSYMBOLS_CHECK_LEVEL = 4
4
export DPKG_GENSYMBOLS_CHECK_LEVEL = 4
1275
8
5
1276
9
%:
6
%:
1290
10
	dh $@ --with autoreconf
7
	dh $@ --parallel --buildsystem cmake --fail-missing
1278
11
1279
12
override_dh_autoreconf:
1280
13
	NOCONFIGURE=1 dh_autoreconf ./autogen.sh
1281
14
1282
15
override_dh_auto_configure:
1283
16
	dh_auto_configure -- \
1284
17
		--disable-static
1285
18
1286
19
override_dh_install:
1287
20
	find debian/indicator-printers -name \*.la -delete
1288
21
	find debian/indicator-printers -name \*.a -delete
1289
22
	dh_install --fail-missing
1291
23
8
1292
=== removed file 'debian/watch'
1293
--- debian/watch	2012-02-16 16:23:19 +0000
1294
+++ debian/watch	1970-01-01 00:00:00 +0000
1295
@@ -1,2 +0,0 @@
1296
1
version=3
1297
2
https://launchpad.net/indicator-printers/+download .*/indicator-printers-([0-9.]+)\.tar\.gz
1298
3
0
1299
=== removed directory 'm4'
1300
=== removed file 'm4/gcov.m4'
1301
--- m4/gcov.m4	2012-03-27 22:12:02 +0000
1302
+++ m4/gcov.m4	1970-01-01 00:00:00 +0000
1303
@@ -1,86 +0,0 @@
1304
1
# Checks for existence of coverage tools:
1305
2
#  * gcov
1306
3
#  * lcov
1307
4
#  * genhtml
1308
5
#  * gcovr
1309
6
# 
1310
7
# Sets ac_cv_check_gcov to yes if tooling is present
1311
8
# and reports the executables to the variables LCOV, GCOVR and GENHTML.
1312
9
AC_DEFUN([AC_TDD_GCOV],
1313
10
[
1314
11
  AC_ARG_ENABLE(gcov,
1315
12
  AS_HELP_STRING([--enable-gcov],
1316
13
		 [enable coverage testing with gcov]),
1317
14
  [use_gcov=$enableval], [use_gcov=no])
1318
15
1319
16
  if test "x$use_gcov" = "xyes"; then
1320
17
  # we need gcc:
1321
18
  if test "$GCC" != "yes"; then
1322
19
    AC_MSG_ERROR([GCC is required for --enable-gcov])
1323
20
  fi
1324
21
1325
22
  # Check if ccache is being used
1326
23
  AC_CHECK_PROG(SHTOOL, shtool, shtool)
1327
24
  case `$SHTOOL path $CC` in
1328
25
    *ccache*[)] gcc_ccache=yes;;
1329
26
    *[)] gcc_ccache=no;;
1330
27
  esac
1331
28
1332
29
  if test "$gcc_ccache" = "yes" && (test -z "$CCACHE_DISABLE" || test "$CCACHE_DISABLE" != "1"); then
1333
30
    AC_MSG_ERROR([ccache must be disabled when --enable-gcov option is used. You can disable ccache by setting environment variable CCACHE_DISABLE=1.])
1334
31
  fi
1335
32
1336
33
  lcov_version_list="1.6 1.7 1.8 1.9"
1337
34
  AC_CHECK_PROG(LCOV, lcov, lcov)
1338
35
  AC_CHECK_PROG(GENHTML, genhtml, genhtml)
1339
36
1340
37
  if test "$LCOV"; then
1341
38
    AC_CACHE_CHECK([for lcov version], glib_cv_lcov_version, [
1342
39
      glib_cv_lcov_version=invalid
1343
40
      lcov_version=`$LCOV -v 2>/dev/null | $SED -e 's/^.* //'`
1344
41
      for lcov_check_version in $lcov_version_list; do
1345
42
        if test "$lcov_version" = "$lcov_check_version"; then
1346
43
          glib_cv_lcov_version="$lcov_check_version (ok)"
1347
44
        fi
1348
45
      done
1349
46
    ])
1350
47
  else
1351
48
    lcov_msg="To enable code coverage reporting you must have one of the following lcov versions installed: $lcov_version_list"
1352
49
    AC_MSG_ERROR([$lcov_msg])
1353
50
  fi
1354
51
1355
52
  case $glib_cv_lcov_version in
1356
53
    ""|invalid[)]
1357
54
      lcov_msg="You must have one of the following versions of lcov: $lcov_version_list (found: $lcov_version)."
1358
55
      AC_MSG_ERROR([$lcov_msg])
1359
56
      LCOV="exit 0;"
1360
57
      ;;
1361
58
  esac
1362
59
1363
60
  if test -z "$GENHTML"; then
1364
61
    AC_MSG_ERROR([Could not find genhtml from the lcov package])
1365
62
  fi
1366
63
1367
64
  ac_cv_check_gcov=yes
1368
65
  ac_cv_check_lcov=yes
1369
66
1370
67
  # Remove all optimization flags from CFLAGS
1371
68
  changequote({,})
1372
69
  CFLAGS=`echo "$CFLAGS" | $SED -e 's/-O[0-9]*//g'`
1373
70
  changequote([,])
1374
71
1375
72
  # Add the special gcc flags
1376
73
  COVERAGE_CFLAGS="-O0 -fprofile-arcs -ftest-coverage"
1377
74
  COVERAGE_CXXFLAGS="-O0 -fprofile-arcs -ftest-coverage"	
1378
75
  COVERAGE_LDFLAGS="-lgcov"
1379
76
1380
77
  # Check availability of gcovr
1381
78
  AC_CHECK_PROG(GCOVR, gcovr, gcovr)
1382
79
  if test -z "$GCOVR"; then
1383
80
    ac_cv_check_gcovr=no
1384
81
  else
1385
82
    ac_cv_check_gcovr=yes
1386
83
  fi
1387
84
1388
85
fi
1389
86
]) # AC_TDD_GCOV
1390
87
0
1391
=== added file 'po/CMakeLists.txt'
1392
--- po/CMakeLists.txt	1970-01-01 00:00:00 +0000
1393
+++ po/CMakeLists.txt	2017-01-10 21:54:44 +0000
1394
@@ -0,0 +1,12 @@
1395
1
find_package(Intltool REQUIRED)
1396
2
1397
3
intltool_update_potfile(
1398
4
    KEYWORDS "_" "_:1,2" "N_" "N_:1,2"
1399
5
    GETTEXT_PACKAGE ${GETTEXT_PACKAGE}
1400
6
    COPYRIGHT_HOLDER "Canonical Ltd."
1401
7
)
1402
8
1403
9
intltool_install_translations(
1404
10
    ALL
1405
11
    GETTEXT_PACKAGE ${GETTEXT_PACKAGE}
1406
12
)
1407
0
13
1408
=== removed file 'po/POTFILES.in'
1409
--- po/POTFILES.in	2012-02-16 16:25:33 +0000
1410
+++ po/POTFILES.in	1970-01-01 00:00:00 +0000
1411
@@ -1,6 +0,0 @@
1412
1
[encoding: UTF-8]
1413
2
src/indicator-menu-item.c
1414
3
src/indicator-printers.c
1415
4
src/indicator-printers-menu.c
1416
5
src/indicator-printers-service.c
1417
6
src/indicator-printer-state-notifier.c
1418
7
0
1419
=== added file 'src/CMakeLists.txt'
1420
--- src/CMakeLists.txt	1970-01-01 00:00:00 +0000
1421
+++ src/CMakeLists.txt	2017-01-10 21:54:44 +0000
1422
@@ -0,0 +1,62 @@
1423
1
add_definitions(
1424
2
  -DGETTEXT_PACKAGE=\"${PROJECT_NAME}\"
1425
3
  -DGETTEXT_LOCALEDIR=\"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LOCALEDIR}\"
1426
4
  -DG_LOG_DOMAIN=\"${CMAKE_PROJECT_NAME}\"
1427
5
)
1428
6
1429
7
include_directories(
1430
8
  ${CMAKE_CURRENT_SOURCE_DIR}
1431
9
  ${CMAKE_CURRENT_BINARY_DIR}
1432
10
  ${SERVICE_DEPS_INCLUDE_DIRS}
1433
11
)
1434
12
link_directories(
1435
13
  ${SERVICE_DEPS_LIBRARY_DIRS}
1436
14
)
1437
15
1438
16
include (GdbusCodegen)
1439
17
add_gdbus_codegen(SERVICE_GENERATED_SOURCES cups-cupsd-notifier
1440
18
                  org.cups.cupsd
1441
19
                  ${CMAKE_CURRENT_SOURCE_DIR}/org.cups.cupsd.Notifier.xml)
1442
20
1443
21
add_library(${SERVICE_LIB_NAME} STATIC
1444
22
  actions-live.cpp
1445
23
  actions-live.h
1446
24
  actions.cpp
1447
25
  actions.h
1448
26
  client.h
1449
27
  cups-client.cpp
1450
28
  cups-client.h
1451
29
  exporter.cpp
1452
30
  exporter.h
1453
31
  menu.cpp
1454
32
  menu.h
1455
33
  job.h
1456
34
  printer.h
1457
35
  utils.cpp
1458
36
  utils.h
1459
37
  ${SERVICE_GENERATED_SOURCES}
1460
38
)
1461
39
1462
40
target_link_libraries(${SERVICE_LIB_NAME}
1463
41
  ${SERVICE_DEPS_LIBRARIES}
1464
42
  ${CUPS_LIBS}
1465
43
)
1466
44
1467
45
1468
46
add_executable(${SERVICE_EXEC_NAME}
1469
47
  main.cpp
1470
48
)
1471
49
1472
50
target_link_libraries(${SERVICE_EXEC_NAME}
1473
51
  ${SERVICE_LIB_NAME}
1474
52
  ${SERVICE_DEPS_LIBRARIES}
1475
53
  ${CUPS_LIBS}
1476
54
1477
55
  ${CMAKE_THREAD_LIBS_INIT}
1478
56
)
1479
57
1480
58
install(
1481
59
  TARGETS ${SERVICE_EXEC_NAME}
1482
60
  RUNTIME
1483
61
  DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}/${PROJECT_NAME}
1484
62
)
1485
0
63
1486
=== added file 'src/actions-live.cpp'
1487
--- src/actions-live.cpp	1970-01-01 00:00:00 +0000
1488
+++ src/actions-live.cpp	2017-01-10 21:54:44 +0000
1489
@@ -0,0 +1,104 @@
1490
1
/*
1491
2
 * Copyright 2016-2017 Canonical Ltd.
1492
3
 *
1493
4
 * This program is free software: you can redistribute it and/or modify it
1494
5
 * under the terms of the GNU General Public License version 3, as published
1495
6
 * by the Free Software Foundation.
1496
7
 *
1497
8
 * This program is distributed in the hope that it will be useful, but
1498
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
1499
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1500
11
 * PURPOSE.  See the GNU General Public License for more details.
1501
12
 *
1502
13
 * You should have received a copy of the GNU General Public License along
1503
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
1504
15
 */
1505
16
1506
17
#include "actions-live.h"
1507
18
1508
19
//#include <url-dispatcher.h>
1509
20
1510
21
#include <glib.h>
1511
22
1512
23
#include <sstream>
1513
24
1514
25
namespace unity {
1515
26
namespace indicator {
1516
27
namespace printers {
1517
28
1518
29
/***
1519
30
****
1520
31
***/
1521
32
1522
33
LiveActions::LiveActions():
1523
34
    Actions()
1524
35
{
1525
36
}
1526
37
1527
38
void LiveActions::execute_command(const std::string& cmdstr)
1528
39
{
1529
40
    const auto cmd = cmdstr.c_str();
1530
41
    g_debug("Issuing command '%s'", cmd);
1531
42
1532
43
    GError* error = nullptr;
1533
44
    if (!g_spawn_command_line_async(cmd, &error))
1534
45
    {
1535
46
        g_warning("Unable to start \"%s\": %s", cmd, error->message);
1536
47
        g_error_free(error);
1537
48
    }
1538
49
}
1539
50
1540
51
void LiveActions::dispatch_url(const std::string& url)
1541
52
{
1542
53
    g_debug("Dispatching url '%s'", url.c_str());
1543
54
    //url_dispatch_send(url.c_str(), nullptr, nullptr);
1544
55
}
1545
56
1546
57
/***
1547
58
****
1548
59
***/
1549
60
1550
61
LiveActions::Desktop LiveActions::get_desktop()
1551
62
{
1552
63
    static bool cached = false;
1553
64
    static LiveActions::Desktop result = LiveActions::OTHER;
1554
65
1555
66
    if (cached) {
1556
67
        return result;
1557
68
    }
1558
69
1559
70
    // check for unity8
1560
71
    if (g_getenv ("MIR_SOCKET") != nullptr) {
1561
72
        result = LiveActions::UNITY8;
1562
73
     } else {
1563
74
        const gchar *xdg_current_desktop = g_getenv ("XDG_CURRENT_DESKTOP");
1564
75
        if (xdg_current_desktop != NULL) {
1565
76
            gchar **desktop_names = g_strsplit (xdg_current_desktop, ":", 0);
1566
77
            for (size_t i = 0; desktop_names[i]; ++i) {
1567
78
                if (!g_strcmp0 (desktop_names[i], "Unity")) {
1568
79
                    result = LiveActions::UNITY7;
1569
80
                    break;
1570
81
                }
1571
82
            }
1572
83
            g_strfreev (desktop_names);
1573
84
        }
1574
85
    }
1575
86
    cached = true;
1576
87
    return result;
1577
88
}
1578
89
1579
90
void LiveActions::open_settings_app()
1580
91
{
1581
92
    switch(get_desktop()) {
1582
93
    case LiveActions::UNITY8:
1583
94
        dispatch_url("settings:///system/printers");
1584
95
        break;
1585
96
    default:
1586
97
        execute_command("system-config-printer");
1587
98
    }
1588
99
}
1589
100
1590
101
1591
102
} // namespace printers
1592
103
} // namespace indicator
1593
104
} // namespace unity
1594
0
105
1595
=== added file 'src/actions-live.h'
1596
--- src/actions-live.h	1970-01-01 00:00:00 +0000
1597
+++ src/actions-live.h	2017-01-10 21:54:44 +0000
1598
@@ -0,0 +1,54 @@
1599
1
/*
1600
2
 * Copyright 2016-2017 Canonical Ltd.
1601
3
 *
1602
4
 * This program is free software: you can redistribute it and/or modify it
1603
5
 * under the terms of the GNU General Public License version 3, as published
1604
6
 * by the Free Software Foundation.
1605
7
 *
1606
8
 * This program is distributed in the hope that it will be useful, but
1607
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
1608
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1609
11
 * PURPOSE.  See the GNU General Public License for more details.
1610
12
 *
1611
13
 * You should have received a copy of the GNU General Public License along
1612
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
1613
15
 */
1614
16
1615
17
#pragma once
1616
18
1617
19
#include "actions.h"
1618
20
1619
21
namespace unity {
1620
22
namespace indicator {
1621
23
namespace printers {
1622
24
1623
25
/**
1624
26
 * \brief Production implementation of the Actions interface.
1625
27
 *
1626
28
 * Open a URL or launch a command for an action.
1627
29
 *
1628
30
 * @see MockActions
1629
31
 */
1630
32
class LiveActions: public Actions
1631
33
{
1632
34
public:
1633
35
    enum Desktop {
1634
36
        OTHER = 0,
1635
37
        UNITY7,
1636
38
        UNITY8,
1637
39
    };
1638
40
1639
41
    explicit LiveActions();
1640
42
    virtual ~LiveActions() =default;
1641
43
1642
44
    void open_settings_app() override;
1643
45
1644
46
protected:
1645
47
    virtual Desktop get_desktop();
1646
48
    virtual void execute_command(const std::string& command);
1647
49
    virtual void dispatch_url(const std::string& url);
1648
50
};
1649
51
1650
52
} // namespace printers
1651
53
} // namespace indicator
1652
54
} // namespace unity
1653
0
55
1654
=== added file 'src/actions.cpp'
1655
--- src/actions.cpp	1970-01-01 00:00:00 +0000
1656
+++ src/actions.cpp	2017-01-10 21:54:44 +0000
1657
@@ -0,0 +1,73 @@
1658
1
/*
1659
2
 * Copyright 2016-2017 Canonical Ltd.
1660
3
 *
1661
4
 * This program is free software: you can redistribute it and/or modify it
1662
5
 * under the terms of the GNU General Public License version 3, as published
1663
6
 * by the Free Software Foundation.
1664
7
 *
1665
8
 * This program is distributed in the hope that it will be useful, but
1666
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
1667
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1668
11
 * PURPOSE.  See the GNU General Public License for more details.
1669
12
 *
1670
13
 * You should have received a copy of the GNU General Public License along
1671
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
1672
15
 */
1673
16
1674
17
#include "actions.h"
1675
18
1676
19
#include <glib.h>
1677
20
#include <gio/gio.h>
1678
21
1679
22
namespace unity {
1680
23
namespace indicator {
1681
24
namespace printers {
1682
25
1683
26
/***
1684
27
****
1685
28
***/
1686
29
1687
30
namespace
1688
31
{
1689
32
1690
33
GVariant* create_default_header_state()
1691
34
{
1692
35
    GVariantBuilder b;
1693
36
    g_variant_builder_init(&b, G_VARIANT_TYPE_VARDICT);
1694
37
    g_variant_builder_add(&b, "{sv}", "accessible-desc", g_variant_new_string("accessible-desc"));
1695
38
    g_variant_builder_add(&b, "{sv}", "label", g_variant_new_string("label"));
1696
39
    g_variant_builder_add(&b, "{sv}", "title", g_variant_new_string("title"));
1697
40
    g_variant_builder_add(&b, "{sv}", "visible", g_variant_new_boolean(true));
1698
41
    return g_variant_builder_end(&b);
1699
42
}
1700
43
1701
44
} // unnamed namespace
1702
45
1703
46
/***
1704
47
****
1705
48
***/
1706
49
1707
50
Actions::Actions():
1708
51
    m_actions(g_simple_action_group_new())
1709
52
{
1710
53
    // add the header actions
1711
54
    auto v = create_default_header_state();
1712
55
    auto a = g_simple_action_new_stateful("printers", nullptr, v);
1713
56
    g_action_map_add_action(G_ACTION_MAP(m_actions), G_ACTION(a));
1714
57
    g_object_unref(a);
1715
58
}
1716
59
1717
60
Actions::~Actions()
1718
61
{
1719
62
    g_clear_object(&m_actions);
1720
63
}
1721
64
1722
65
GActionGroup* Actions::action_group()
1723
66
{
1724
67
    return G_ACTION_GROUP(m_actions);
1725
68
}
1726
69
1727
70
1728
71
} // namespace printers
1729
72
} // namespace indicator
1730
73
} // namespace unity
1731
0
74
1732
=== added file 'src/actions.h'
1733
--- src/actions.h	1970-01-01 00:00:00 +0000
1734
+++ src/actions.h	2017-01-10 21:54:44 +0000
1735
@@ -0,0 +1,57 @@
1736
1
/*
1737
2
 * Copyright 2016-2017 Canonical Ltd.
1738
3
 *
1739
4
 * This program is free software: you can redistribute it and/or modify it
1740
5
 * under the terms of the GNU General Public License version 3, as published
1741
6
 * by the Free Software Foundation.
1742
7
 *
1743
8
 * This program is distributed in the hope that it will be useful, but
1744
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
1745
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1746
11
 * PURPOSE.  See the GNU General Public License for more details.
1747
12
 *
1748
13
 * You should have received a copy of the GNU General Public License along
1749
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
1750
15
 */
1751
16
1752
17
#pragma once
1753
18
1754
19
#include <memory> // shared_ptr
1755
20
#include <string>
1756
21
1757
22
#include <gio/gio.h> // GSimpleActionGroup
1758
23
1759
24
namespace unity {
1760
25
namespace indicator {
1761
26
namespace printers {
1762
27
1763
28
/**
1764
29
 * \brief Interface for all the actions that can be activated by users.
1765
30
 *
1766
31
 * This is a simple C++ wrapper around our GActionGroup that gets exported
1767
32
 * onto the bus. Subclasses implement the actual code that should be run
1768
33
 * when a particular action is triggered.
1769
34
 */
1770
35
class Actions
1771
36
{
1772
37
public:
1773
38
1774
39
    virtual void open_settings_app() = 0;
1775
40
1776
41
    GActionGroup* action_group();
1777
42
1778
43
protected:
1779
44
    explicit Actions();
1780
45
    virtual ~Actions();
1781
46
1782
47
private:
1783
48
    GSimpleActionGroup* m_actions = nullptr;
1784
49
1785
50
    // we've got raw pointers in here, so disable copying
1786
51
    Actions(const Actions&) = delete;
1787
52
    Actions& operator=(const Actions&) = delete;
1788
53
};
1789
54
1790
55
} // namespace printers
1791
56
} // namespace indicator
1792
57
} // namespace unity
1793
0
58
1794
=== added file 'src/client.h'
1795
--- src/client.h	1970-01-01 00:00:00 +0000
1796
+++ src/client.h	2017-01-10 21:54:44 +0000
1797
@@ -0,0 +1,56 @@
1798
1
/*
1799
2
 * Copyright 2016-2017 Canonical Ltd.
1800
3
 *
1801
4
 * This program is free software: you can redistribute it and/or modify it
1802
5
 * under the terms of the GNU General Public License version 3, as published
1803
6
 * by the Free Software Foundation.
1804
7
 *
1805
8
 * This program is distributed in the hope that it will be useful, but
1806
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
1807
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1808
11
 * PURPOSE.  See the GNU General Public License for more details.
1809
12
 *
1810
13
 * You should have received a copy of the GNU General Public License along
1811
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
1812
15
 */
1813
16
1814
17
#pragma once
1815
18
1816
19
#include "job.h"
1817
20
#include "printer.h"
1818
21
1819
22
#include <core/signal.h>
1820
23
1821
24
1822
25
namespace unity {
1823
26
namespace indicator {
1824
27
namespace printers {
1825
28
1826
29
    class Client {
1827
30
    public:
1828
31
        explicit Client() = default;
1829
32
        virtual ~Client() = default;
1830
33
1831
34
        // Signals corresponding to printers
1832
35
        virtual core::Signal<const Printer&>& printer_state_changed() = 0;
1833
36
1834
37
        // Signals corresponding to jobs
1835
38
        virtual core::Signal<const Job&>& job_state_changed() = 0;
1836
39
1837
40
        // Methods to manage notification monitoring
1838
41
        virtual void create_subscription() = 0;
1839
42
        virtual void renew_subscription() = 0;
1840
43
        virtual void cancel_subscription() = 0;
1841
44
1842
45
        // To iniitalize the indicator with current jobs
1843
46
        virtual void refresh() = 0;
1844
47
1845
48
    private:
1846
49
        // disable copying 
1847
50
        Client(const Client&) = delete; 
1848
51
        Client& operator=(const Client&) = delete; 
1849
52
    };
1850
53
1851
54
} // printers
1852
55
} // indicators
1853
56
} // unity
1854
0
57
1855
=== added file 'src/cups-client.cpp'
1856
--- src/cups-client.cpp	1970-01-01 00:00:00 +0000
1857
+++ src/cups-client.cpp	2017-01-10 21:54:44 +0000
1858
@@ -0,0 +1,328 @@
1859
1
/*
1860
2
 * Copyright 2016-2017 Canonical Ltd.
1861
3
 *
1862
4
 * This program is free software: you can redistribute it and/or modify it
1863
5
 * under the terms of the GNU General Public License version 3, as published
1864
6
 * by the Free Software Foundation.
1865
7
 *
1866
8
 * This program is distributed in the hope that it will be useful, but
1867
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
1868
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1869
11
 * PURPOSE.  See the GNU General Public License for more details.
1870
12
 *
1871
13
 * You should have received a copy of the GNU General Public License along
1872
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
1873
15
 */
1874
16
1875
17
#include "cups-client.h"
1876
18
#include "cups-cupsd-notifier.h"
1877
19
1878
20
#include <cups/cups.h>
1879
21
1880
22
#include <stdexcept>
1881
23
1882
24
namespace unity {
1883
25
namespace indicator {
1884
26
namespace printers {
1885
27
1886
28
#define NOTIFY_LEASE_DURATION (24 * 60 * 60)
1887
29
1888
30
1889
31
class CupsClient::Impl {
1890
32
public:
1891
33
    Impl()
1892
34
    {
1893
35
        GError *error = nullptr;
1894
36
1895
37
        m_notifier_proxy = notifier_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
1896
38
                                                           G_DBUS_PROXY_FLAGS_NONE,
1897
39
                                                           nullptr,
1898
40
                                                           CUPS_DBUS_PATH,
1899
41
                                                           nullptr,
1900
42
                                                           &error);
1901
43
1902
44
        if (error != nullptr) {
1903
45
            std::string msg{"Error creating cups notifier proxy: "};
1904
46
            throw std::runtime_error(msg + error->message);
1905
47
            g_clear_error(&error);
1906
48
        }
1907
49
1908
50
        g_object_connect(m_notifier_proxy,
1909
51
                         "signal::job-created", on_job_changed, this,
1910
52
                         "signal::job-state", on_job_changed, this,
1911
53
                         "signal::job-completed", on_job_changed, this,
1912
54
                         "signal::printer-state-changed", on_printer_state_changed, this,
1913
55
                         nullptr);
1914
56
    }
1915
57
1916
58
    ~Impl()
1917
59
    {
1918
60
        if (m_notifier_proxy != nullptr) {
1919
61
            g_signal_handlers_disconnect_by_data(m_notifier_proxy, this);
1920
62
            g_clear_object(&m_notifier_proxy);
1921
63
        }
1922
64
1923
65
        // Cancel the subscription from cups, so its notifier can exit.
1924
66
        cancel_subscription();
1925
67
    }
1926
68
1927
69
    // Signals to propagate
1928
70
    core::Signal<const Printer&>& printer_state_changed()
1929
71
    {
1930
72
        return m_printer_state_changed;
1931
73
    }
1932
74
1933
75
    core::Signal<const Job&>& job_state_changed()
1934
76
    {
1935
77
        return m_job_state_changed;
1936
78
    }
1937
79
1938
80
    void create_subscription()
1939
81
    {
1940
82
        ipp_t *req;
1941
83
        ipp_t *resp;
1942
84
        ipp_attribute_t *attr;
1943
85
1944
86
        req = ippNewRequest (IPP_CREATE_PRINTER_SUBSCRIPTION);
1945
87
        ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
1946
88
                      "printer-uri", NULL, "/");
1947
89
        ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
1948
90
                      "notify-events", NULL, "all");
1949
91
        ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
1950
92
                      "notify-recipient-uri", NULL, "dbus://");
1951
93
        ippAddInteger (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
1952
94
                       "notify-lease-duration", NOTIFY_LEASE_DURATION);
1953
95
1954
96
        resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
1955
97
        if (!resp || cupsLastError() != IPP_OK) {
1956
98
            g_warning ("Error subscribing to CUPS notifications: %s\n",
1957
99
                       cupsLastErrorString ());
1958
100
            return;
1959
101
        }
1960
102
1961
103
        attr = ippFindAttribute (resp, "notify-subscription-id", IPP_TAG_INTEGER);
1962
104
        if (attr) {
1963
105
            m_subscription_id = ippGetInteger (attr, 0);
1964
106
        } else {
1965
107
            g_warning ("ipp-create-printer-subscription response doesn't contain "
1966
108
                       "subscription id.\n");
1967
109
        }
1968
110
        ippDelete (resp);
1969
111
1970
112
        // Set up to renew the subscription a minute before it expires
1971
113
        g_timeout_add_seconds(NOTIFY_LEASE_DURATION - 60,
1972
114
                              on_subscription_timeout,
1973
115
                              this);
1974
116
    }
1975
117
1976
118
    void renew_subscription()
1977
119
    {
1978
120
        ipp_t *req;
1979
121
        ipp_t *resp;
1980
122
1981
123
        req = ippNewRequest (IPP_RENEW_SUBSCRIPTION);
1982
124
        ippAddInteger (req, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
1983
125
                       "notify-subscription-id", m_subscription_id);
1984
126
        ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
1985
127
                      "printer-uri", NULL, "/");
1986
128
        ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
1987
129
                      "notify-recipient-uri", NULL, "dbus://");
1988
130
        ippAddInteger (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
1989
131
                       "notify-lease-duration", NOTIFY_LEASE_DURATION);
1990
132
1991
133
        resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
1992
134
        if (!resp || cupsLastError() != IPP_OK) {
1993
135
            g_warning ("Error renewing CUPS subscription %d: %s\n",
1994
136
                       m_subscription_id, cupsLastErrorString ());
1995
137
            create_subscription();
1996
138
        }
1997
139
1998
140
        ippDelete (resp);
1999
141
    }
2000
142
2001
143
    void cancel_subscription()
2002
144
    {
2003
145
        ipp_t *req;
2004
146
        ipp_t *resp;
2005
147
2006
148
        if (m_subscription_id <= 0) {
2007
149
            return;
2008
150
        }
2009
151
2010
152
        req = ippNewRequest (IPP_CANCEL_SUBSCRIPTION);
2011
153
        ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
2012
154
                      "printer-uri", NULL, "/");
2013
155
        ippAddInteger (req, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
2014
156
                       "notify-subscription-id", m_subscription_id);
2015
157
2016
158
        resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
2017
159
        if (!resp || cupsLastError() != IPP_OK) {
2018
160
            g_warning ("Error unsubscribing to CUPS notifications: %s\n",
2019
161
                       cupsLastErrorString ());
2020
162
            return;
2021
163
        }
2022
164
2023
165
        ippDelete (resp);
2024
166
    }
2025
167
2026
168
    void refresh()
2027
169
    {
2028
170
        int num_dests;
2029
171
        cups_dest_t* dests;
2030
172
2031
173
        num_dests = cupsGetDests(&dests);
2032
174
        for (int i = 0; i < num_dests; i++) {
2033
175
            auto printer = get_printer_info(dests[i].name);
2034
176
2035
177
            cups_job_t* jobs;
2036
178
            const auto num_jobs = cupsGetJobs(&jobs, dests[i].name,
2037
179
                                              true, CUPS_WHICHJOBS_ACTIVE);
2038
180
            for (int j = 0; j < num_jobs; j++) {
2039
181
                Job job;
2040
182
                job.id = jobs[j].id;
2041
183
                job.state = static_cast<Job::State>(jobs[j].state);
2042
184
                job.name = jobs[j].title;
2043
185
2044
186
                job.printer = printer;
2045
187
2046
188
                m_job_state_changed(job);
2047
189
            }
2048
190
            cupsFreeJobs(num_jobs, jobs);
2049
191
        }
2050
192
        cupsFreeDests(num_dests, dests);
2051
193
    }
2052
194
2053
195
private:
2054
196
    // Method to get Printer object from the name
2055
197
    Printer get_printer_info(const std::string& name)
2056
198
    {
2057
199
        int num_dests;
2058
200
        cups_dest_t* dests;
2059
201
        cups_dest_t* our_dest;
2060
202
        Printer printer;
2061
203
        printer.name = name;
2062
204
2063
205
        num_dests = cupsGetDests(&dests);
2064
206
        our_dest = cupsGetDest(name.c_str(), nullptr,
2065
207
                               num_dests, dests);
2066
208
        
2067
209
        // Get the printer's description
2068
210
        auto description = cupsGetOption("printer-info",
2069
211
                                         our_dest->num_options,
2070
212
                                         our_dest->options);
2071
213
        if (description != nullptr) {
2072
214
            printer.description = description;
2073
215
        }
2074
216
2075
217
        cupsFreeDests(num_dests, dests);
2076
218
        return printer;
2077
219
    }
2078
220
 
2079
221
    static gboolean on_subscription_timeout(gpointer gthis)
2080
222
    {
2081
223
        static_cast<Impl*>(gthis)->renew_subscription();
2082
224
        return G_SOURCE_CONTINUE;
2083
225
    }
2084
226
2085
227
    static void on_job_changed (Notifier*,
2086
228
            const char* printer_text,
2087
229
            const char* printer_uri,
2088
230
            const char *printer_name,
2089
231
            unsigned int printer_state,
2090
232
            const char *printer_state_reasons,
2091
233
            bool printer_is_accepting_jobs,
2092
234
            unsigned int job_id,
2093
235
            unsigned int job_state,
2094
236
            const char *job_state_reasons,
2095
237
            const char *job_name,
2096
238
            unsigned int job_impressions_completed,
2097
239
            gpointer gthis)
2098
240
    {
2099
241
        auto self = static_cast<Impl*>(gthis);
2100
242
2101
243
        auto printer = self->get_printer_info(printer_name);
2102
244
        printer.state = static_cast<Printer::State>(printer_state);
2103
245
        printer.text = printer_text;
2104
246
        printer.uri = printer_uri;
2105
247
        printer.state_reasons = printer_state_reasons;
2106
248
        printer.accepting_jobs = printer_is_accepting_jobs;
2107
249
2108
250
        Job job;
2109
251
        job.printer = printer;
2110
252
        job.state = static_cast<Job::State>(job_state);
2111
253
        job.id = job_id;
2112
254
        job.name = job_name;
2113
255
        job.state_reasons = job_state_reasons;
2114
256
        job.impressions_completed = job_impressions_completed;
2115
257
2116
258
        self->m_job_state_changed(job);
2117
259
    }
2118
260
2119
261
    static void on_printer_state_changed(Notifier*,
2120
262
                                         const char* text,
2121
263
                                         const char* uri,
2122
264
                                         const char* name,
2123
265
                                         unsigned int state,
2124
266
                                         const char* state_reasons,
2125
267
                                         bool is_accepting_jobs,
2126
268
                                         gpointer gthis)
2127
269
    {
2128
270
        auto self = static_cast<Impl*>(gthis);
2129
271
2130
272
        auto printer = self->get_printer_info(name);
2131
273
        printer.state = static_cast<Printer::State>(state);
2132
274
        printer.text = text;
2133
275
        printer.uri = uri;
2134
276
        printer.state_reasons = state_reasons;
2135
277
        printer.accepting_jobs = is_accepting_jobs;
2136
278
        self->m_printer_state_changed(printer);
2137
279
    }
2138
280
2139
281
    int m_subscription_id = 0;
2140
282
    Notifier* m_notifier_proxy = nullptr;
2141
283
    core::Signal<const Printer&> m_printer_state_changed;
2142
284
    core::Signal<const Job&> m_job_state_changed;
2143
285
};
2144
286
2145
287
CupsClient::CupsClient() :
2146
288
    p(new Impl())
2147
289
{
2148
290
}
2149
291
2150
292
CupsClient::~CupsClient()
2151
293
{
2152
294
}
2153
295
2154
296
core::Signal<const Printer&>& CupsClient::printer_state_changed()
2155
297
{
2156
298
    return p->printer_state_changed();
2157
299
}
2158
300
2159
301
core::Signal<const Job&>& CupsClient::job_state_changed()
2160
302
{
2161
303
    return p->job_state_changed();
2162
304
}
2163
305
2164
306
void CupsClient::create_subscription()
2165
307
{
2166
308
    p->create_subscription();
2167
309
}
2168
310
2169
311
void CupsClient::renew_subscription()
2170
312
{
2171
313
    p->renew_subscription();
2172
314
}
2173
315
2174
316
void CupsClient::cancel_subscription()
2175
317
{
2176
318
    p->cancel_subscription();
2177
319
}
2178
320
2179
321
void CupsClient::refresh()
2180
322
{
2181
323
    p->refresh();
2182
324
}
2183
325
2184
326
} // printers
2185
327
} // indicators
2186
328
} // unity
2187
0
329
2188
=== added file 'src/cups-client.h'
2189
--- src/cups-client.h	1970-01-01 00:00:00 +0000
2190
+++ src/cups-client.h	2017-01-10 21:54:44 +0000
2191
@@ -0,0 +1,65 @@
2192
1
/*
2193
2
 * Copyright 2016-2017 Canonical Ltd.
2194
3
 *
2195
4
 * This program is free software: you can redistribute it and/or modify it
2196
5
 * under the terms of the GNU General Public License version 3, as published
2197
6
 * by the Free Software Foundation.
2198
7
 *
2199
8
 * This program is distributed in the hope that it will be useful, but
2200
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
2201
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2202
11
 * PURPOSE.  See the GNU General Public License for more details.
2203
12
 *
2204
13
 * You should have received a copy of the GNU General Public License along
2205
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
2206
15
 */
2207
16
2208
17
#pragma once
2209
18
2210
19
#include "client.h"
2211
20
#include "job.h"
2212
21
#include "printer.h"
2213
22
2214
23
#include <core/signal.h>
2215
24
2216
25
#include <memory>
2217
26
2218
27
namespace unity {
2219
28
namespace indicator {
2220
29
namespace printers {
2221
30
2222
31
#define CUPS_DBUS_NAME "org.cups.cupsd.Notifier"
2223
32
#define CUPS_DBUS_PATH "/org/cups/cupsd/Notifier"
2224
33
#define CUPS_DBUS_INTERFACE "org.cups.cupsd.Notifier"
2225
34
2226
35
    class CupsClient : public Client {
2227
36
    public:
2228
37
        CupsClient();
2229
38
        virtual ~CupsClient();
2230
39
2231
40
        // Signals corresponding to printers
2232
41
        core::Signal<const Printer&>& printer_state_changed() override;
2233
42
2234
43
        // Signals corresponding to jobs
2235
44
        core::Signal<const Job&>& job_state_changed() override;
2236
45
2237
46
        // Methods to manage notification monitoring
2238
47
        virtual void create_subscription() override;
2239
48
        virtual void renew_subscription() override;
2240
49
        virtual void cancel_subscription() override;
2241
50
2242
51
        // To initialize the indicator with current jobs
2243
52
        virtual void refresh() override;
2244
53
2245
54
    private:
2246
55
        class Impl;
2247
56
        std::unique_ptr<Impl> p;
2248
57
2249
58
        // disable copying 
2250
59
        CupsClient(const CupsClient&) = delete; 
2251
60
        CupsClient& operator=(const CupsClient&) = delete; 
2252
61
    };
2253
62
2254
63
} // printers
2255
64
} // indicators
2256
65
} // unity
2257
0
66
2258
=== added file 'src/exporter.cpp'
2259
--- src/exporter.cpp	1970-01-01 00:00:00 +0000
2260
+++ src/exporter.cpp	2017-01-10 21:54:44 +0000
2261
@@ -0,0 +1,158 @@
2262
1
/*
2263
2
 * Copyright 2016-2017 Canonical Ltd.
2264
3
 *
2265
4
 * This program is free software: you can redistribute it and/or modify it
2266
5
 * under the terms of the GNU General Public License version 3, as published
2267
6
 * by the Free Software Foundation.
2268
7
 *
2269
8
 * This program is distributed in the hope that it will be useful, but
2270
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
2271
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2272
11
 * PURPOSE.  See the GNU General Public License for more details.
2273
12
 *
2274
13
 * You should have received a copy of the GNU General Public License along
2275
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
2276
15
 */
2277
16
2278
17
#include "exporter.h"
2279
18
2280
19
#include <core/signal.h>
2281
20
2282
21
namespace unity {
2283
22
namespace indicator {
2284
23
namespace printers {
2285
24
2286
25
class Exporter::Impl
2287
26
{
2288
27
public:
2289
28
2290
29
    Impl()
2291
30
    {
2292
31
    }
2293
32
2294
33
    ~Impl()
2295
34
    {
2296
35
        if (m_bus != nullptr) {
2297
36
            if (m_exported_menu_id) {
2298
37
                g_dbus_connection_unexport_menu_model(m_bus, m_exported_menu_id);
2299
38
            }
2300
39
2301
40
            if (m_exported_actions_id) {
2302
41
                g_dbus_connection_unexport_action_group(m_bus,
2303
42
                                                        m_exported_actions_id);
2304
43
            }
2305
44
        }
2306
45
2307
46
        if (m_own_id) {
2308
47
            g_bus_unown_name(m_own_id);
2309
48
        }
2310
49
2311
50
        g_clear_object(&m_bus);
2312
51
    }
2313
52
2314
53
    core::Signal<> name_lost;
2315
54
2316
55
    void publish(const std::shared_ptr<Actions>& actions,
2317
56
                 const std::shared_ptr<Client>& client)
2318
57
    {
2319
58
        m_actions = actions;
2320
59
        m_client = client;
2321
60
        m_menu.reset(new Menu(m_actions, m_client));
2322
61
        m_own_id = g_bus_own_name(G_BUS_TYPE_SESSION,
2323
62
                                  INDICATOR_BUS_NAME,
2324
63
                                  G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT,
2325
64
                                  on_bus_acquired,
2326
65
                                  nullptr,
2327
66
                                  on_name_lost,
2328
67
                                  this,
2329
68
                                  nullptr);
2330
69
    }
2331
70
2332
71
private:
2333
72
    static void on_bus_acquired(GDBusConnection* connection,
2334
73
                                const gchar* name,
2335
74
                                gpointer gthis)
2336
75
    {
2337
76
        g_debug("bus acquired: %s", name);
2338
77
        static_cast<Impl*>(gthis)->on_bus_acquired(connection, name);
2339
78
    }
2340
79
2341
80
    void on_bus_acquired(GDBusConnection* bus, const gchar* /*name*/)
2342
81
    {
2343
82
        m_bus = static_cast<GDBusConnection*>(g_object_ref(G_OBJECT(bus)));
2344
83
2345
84
        // export the actions
2346
85
        GError * error = nullptr;
2347
86
        const auto id = g_dbus_connection_export_action_group(m_bus,
2348
87
                                                              INDICATOR_BUS_PATH,
2349
88
                                                              m_actions->action_group(),
2350
89
                                                              &error);
2351
90
        if (id)
2352
91
        {
2353
92
            m_exported_actions_id = id;
2354
93
        }
2355
94
        else
2356
95
        {
2357
96
            g_warning("cannot export action group: %s", error->message);
2358
97
            g_clear_error(&error);
2359
98
        }
2360
99
2361
100
        // export the menus
2362
101
        const auto path = std::string(INDICATOR_BUS_PATH) + "/menu";
2363
102
        m_exported_menu_id = g_dbus_connection_export_menu_model(m_bus,
2364
103
                                                                 path.c_str(),
2365
104
                                                                 m_menu->menu_model(),
2366
105
                                                                 &error);
2367
106
        if (error != nullptr) {
2368
107
            g_warning("cannot export menu: %s", error->message);
2369
108
            g_clear_error(&error);
2370
109
        }
2371
110
2372
111
        m_client->create_subscription();
2373
112
        m_client->refresh();
2374
113
    }
2375
114
2376
115
    static void on_name_lost(GDBusConnection*, const gchar* name,
2377
116
                             gpointer gthis)
2378
117
    {
2379
118
        g_debug("name lost: %s", name);
2380
119
        static_cast<Impl*>(gthis)->name_lost();
2381
120
    }
2382
121
2383
122
2384
123
    guint m_exported_menu_id = 0;
2385
124
    guint m_own_id = 0;
2386
125
    guint m_exported_actions_id = 0;
2387
126
    GDBusConnection* m_bus = nullptr;
2388
127
    std::shared_ptr<Actions> m_actions;
2389
128
    std::shared_ptr<Client> m_client;
2390
129
    std::shared_ptr<Menu> m_menu;
2391
130
};
2392
131
2393
132
2394
133
2395
134
Exporter::Exporter():
2396
135
    p(new Impl())
2397
136
{
2398
137
}
2399
138
2400
139
2401
140
Exporter::~Exporter()
2402
141
{
2403
142
}
2404
143
2405
144
core::Signal<>& Exporter::name_lost()
2406
145
{
2407
146
    return p->name_lost;
2408
147
}
2409
148
2410
149
void Exporter::publish(const std::shared_ptr<Actions>& actions,
2411
150
                       const std::shared_ptr<Client>& client)
2412
151
{
2413
152
    p->publish(actions, client);
2414
153
}
2415
154
2416
155
2417
156
} // namespace printers
2418
157
} // namespace indicator
2419
158
} // namespace unity
2420
0
159
2421
=== added file 'src/exporter.h'
2422
--- src/exporter.h	1970-01-01 00:00:00 +0000
2423
+++ src/exporter.h	2017-01-10 21:54:44 +0000
2424
@@ -0,0 +1,60 @@
2425
1
/*
2426
2
 * Copyright 2016-2017 Canonical Ltd.
2427
3
 *
2428
4
 * This program is free software: you can redistribute it and/or modify it
2429
5
 * under the terms of the GNU General Public License version 3, as published
2430
6
 * by the Free Software Foundation.
2431
7
 *
2432
8
 * This program is distributed in the hope that it will be useful, but
2433
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
2434
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2435
11
 * PURPOSE.  See the GNU General Public License for more details.
2436
12
 *
2437
13
 * You should have received a copy of the GNU General Public License along
2438
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
2439
15
 */
2440
16
2441
17
#pragma once
2442
18
2443
19
#include "actions.h"
2444
20
#include "client.h"
2445
21
#include "menu.h"
2446
22
2447
23
#include <core/signal.h>
2448
24
2449
25
#include <memory> // std::shared_ptr
2450
26
#include <vector>
2451
27
2452
28
namespace unity {
2453
29
namespace indicator {
2454
30
namespace printers {
2455
31
2456
32
#define INDICATOR_BUS_NAME "com.canonical.indicator.printers"
2457
33
#define INDICATOR_BUS_PATH "/com/canonical/indicator/printers"
2458
34
2459
35
/**
2460
36
 * \brief Exports actions and menu to DBus. 
2461
37
 */
2462
38
class Exporter
2463
39
{
2464
40
public:
2465
41
    Exporter();
2466
42
    virtual ~Exporter();
2467
43
2468
44
    core::Signal<>& name_lost();
2469
45
2470
46
    void publish(const std::shared_ptr<Actions>& actions,
2471
47
                 const std::shared_ptr<Client>& client);
2472
48
2473
49
private:
2474
50
    class Impl;
2475
51
    std::unique_ptr<Impl> p;
2476
52
2477
53
    // disable copying 
2478
54
    Exporter(const Exporter&) = delete; 
2479
55
    Exporter& operator=(const Exporter&) = delete; 
2480
56
};
2481
57
2482
58
} // namespace printers
2483
59
} // namespace indicator
2484
60
} // namespace unity
2485
0
61
2486
=== removed file 'src/indicator-menu-item.c'
2487
--- src/indicator-menu-item.c	2012-02-12 15:10:07 +0000
2488
+++ src/indicator-menu-item.c	1970-01-01 00:00:00 +0000
2489
@@ -1,404 +0,0 @@
2490
1
/*
2491
2
 * Copyright 2012 Canonical Ltd.
2492
3
 *
2493
4
 * Authors: Lars Uebernickel <lars.uebernickel@canonical.com>
2494
5
 *
2495
6
 * This program is free software: you can redistribute it and/or modify it
2496
7
 * under the terms of the GNU General Public License version 3, as published
2497
8
 * by the Free Software Foundation.
2498
9
 *
2499
10
 * This program is distributed in the hope that it will be useful, but
2500
11
 * WITHOUT ANY WARRANTY; without even the implied warranties of
2501
12
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2502
13
 * PURPOSE.  See the GNU General Public License for more details.
2503
14
 *
2504
15
 * You should have received a copy of the GNU General Public License along
2505
16
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
2506
17
 */
2507
18
2508
19
#include "indicator-menu-item.h"
2509
20
2510
21
#include <math.h>
2511
22
2512
23
2513
24
G_DEFINE_TYPE (IndicatorMenuItem, indicator_menu_item, GTK_TYPE_MENU_ITEM)
2514
25
2515
26
2516
27
struct _IndicatorMenuItemPrivate
2517
28
{
2518
29
    GtkImage *image;
2519
30
    GtkWidget *label;
2520
31
    GtkWidget *right_label;
2521
32
    gboolean right_is_lozenge;
2522
33
};
2523
34
2524
35
2525
36
enum {
2526
37
    PROP_0,
2527
38
    PROP_ICON,
2528
39
    PROP_ICON_NAME,
2529
40
    PROP_LABEL,
2530
41
    PROP_RIGHT,
2531
42
    PROP_RIGHT_IS_LOZENGE,
2532
43
    N_PROPERTIES
2533
44
};
2534
45
2535
46
static GParamSpec *properties[N_PROPERTIES];
2536
47
2537
48
2538
49
static gint
2539
50
gtk_widget_get_font_size (GtkWidget *widget)
2540
51
{
2541
52
    const PangoFontDescription *font;
2542
53
2543
54
    font = gtk_style_context_get_font (gtk_widget_get_style_context (widget),
2544
55
                                       gtk_widget_get_state_flags (widget));
2545
56
2546
57
    return pango_font_description_get_size (font) / PANGO_SCALE;
2547
58
}
2548
59
2549
60
static void
2550
61
cairo_lozenge (cairo_t *cr, double x, double y, double w, double h)
2551
62
{
2552
63
    double radius = MIN (w / 2.0, h / 2.0);
2553
64
    double x1 = x + w - radius;
2554
65
    double x2 = x + radius;
2555
66
    double y1 = y + radius;
2556
67
    double y2 = y + h - radius;
2557
68
2558
69
    cairo_move_to (cr, x+radius, y);
2559
70
    cairo_arc (cr, x1, y1, radius, M_PI * 1.5, M_PI * 2);
2560
71
    cairo_arc (cr, x1, y2, radius, 0,          M_PI * 0.5);
2561
72
    cairo_arc (cr, x2, y2, radius, M_PI * 0.5, M_PI);
2562
73
    cairo_arc (cr, x2, y1, radius, M_PI,       M_PI * 1.5);
2563
74
}
2564
75
2565
76
static gboolean
2566
77
detail_label_draw (GtkWidget *widget,
2567
78
                   cairo_t *cr,
2568
79
                   gpointer data)
2569
80
{
2570
81
    GtkAllocation allocation;
2571
82
    double x, y, w, h;
2572
83
    GdkRGBA color;
2573
84
    PangoLayout *layout;
2574
85
    PangoRectangle layout_extents;
2575
86
    gboolean is_lozenge = *(gboolean *)data;
2576
87
    gint font_size = gtk_widget_get_font_size (widget);
2577
88
2578
89
    /* let the label handle the drawing if it's not a lozenge */
2579
90
    if (!is_lozenge)
2580
91
        return FALSE;
2581
92
2582
93
    layout = gtk_label_get_layout (GTK_LABEL(widget));
2583
94
    pango_layout_get_extents (layout, NULL, &layout_extents);
2584
95
    pango_extents_to_pixels (&layout_extents, NULL);
2585
96
2586
97
    gtk_widget_get_allocation (widget, &allocation);
2587
98
    x = -font_size / 2.0;
2588
99
    y = 1;
2589
100
    w = allocation.width;
2590
101
    h = MIN (allocation.height, layout_extents.height + 4);
2591
102
2592
103
    if (layout_extents.width == 0)
2593
104
        return TRUE;
2594
105
2595
106
    gtk_style_context_get_color (gtk_widget_get_style_context (widget),
2596
107
                                 gtk_widget_get_state_flags (widget),
2597
108
                                 &color);
2598
109
    gdk_cairo_set_source_rgba (cr, &color);
2599
110
2600
111
    cairo_set_line_width (cr, 1.0);
2601
112
    cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
2602
113
    cairo_lozenge (cr, x - font_size / 2.0, y, w + font_size, h);
2603
114
2604
115
    x += (w - layout_extents.width) / 2.0;
2605
116
    y += (h - layout_extents.height) / 2.0;
2606
117
    cairo_move_to (cr, floor (x), floor (y));
2607
118
    pango_cairo_layout_path (cr, layout);
2608
119
    cairo_fill (cr);
2609
120
2610
121
    return TRUE;
2611
122
}
2612
123
2613
124
2614
125
static void
2615
126
indicator_menu_item_get_property (GObject    *object,
2616
127
                                  guint       property_id,
2617
128
                                  GValue     *value,
2618
129
                                  GParamSpec *pspec)
2619
130
{
2620
131
    IndicatorMenuItem *self = INDICATOR_MENU_ITEM (object);
2621
132
2622
133
    switch (property_id)
2623
134
    {
2624
135
        case PROP_ICON:
2625
136
            g_value_set_object (value, indicator_menu_item_get_icon (self));
2626
137
            break;
2627
138
2628
139
        case PROP_ICON_NAME:
2629
140
            g_value_set_string (value, indicator_menu_item_get_icon_name (self));
2630
141
            break;
2631
142
2632
143
        case PROP_LABEL:
2633
144
            g_value_set_string (value, gtk_label_get_label (GTK_LABEL (self->priv->label)));
2634
145
            break;
2635
146
2636
147
        case PROP_RIGHT:
2637
148
            g_value_set_string (value, gtk_label_get_label (GTK_LABEL (self->priv->right_label)));
2638
149
            break;
2639
150
2640
151
        case PROP_RIGHT_IS_LOZENGE:
2641
152
            g_value_set_boolean (value, self->priv->right_is_lozenge);
2642
153
            break;
2643
154
2644
155
        default:
2645
156
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2646
157
    }
2647
158
}
2648
159
2649
160
2650
161
static void
2651
162
indicator_menu_item_set_property (GObject      *object,
2652
163
                                  guint         property_id,
2653
164
                                  const GValue *value,
2654
165
                                  GParamSpec   *pspec)
2655
166
{
2656
167
    switch (property_id)
2657
168
    {
2658
169
        case PROP_ICON:
2659
170
            indicator_menu_item_set_icon (INDICATOR_MENU_ITEM (object),
2660
171
                                          g_value_get_object (value));
2661
172
            break;
2662
173
2663
174
        case PROP_ICON_NAME:
2664
175
            indicator_menu_item_set_icon_name (INDICATOR_MENU_ITEM (object),
2665
176
                                               g_value_get_string (value));
2666
177
            break;
2667
178
2668
179
        case PROP_LABEL:
2669
180
            indicator_menu_item_set_label (INDICATOR_MENU_ITEM (object),
2670
181
                                           g_value_get_string (value));
2671
182
            break;
2672
183
2673
184
        case PROP_RIGHT:
2674
185
            indicator_menu_item_set_right (INDICATOR_MENU_ITEM (object),
2675
186
                                           g_value_get_string (value));
2676
187
            break;
2677
188
2678
189
        case PROP_RIGHT_IS_LOZENGE:
2679
190
            indicator_menu_item_set_right_is_lozenge (INDICATOR_MENU_ITEM (object),
2680
191
                                                      g_value_get_boolean (value));
2681
192
            break;
2682
193
2683
194
2684
195
        default:
2685
196
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2686
197
    }
2687
198
}
2688
199
2689
200
2690
201
static void
2691
202
indicator_menu_item_dispose (GObject *object)
2692
203
{
2693
204
    IndicatorMenuItem *self = INDICATOR_MENU_ITEM (object);
2694
205
2695
206
    g_clear_object (&self->priv->image);
2696
207
    g_clear_object (&self->priv->label);
2697
208
    g_clear_object (&self->priv->right_label);
2698
209
2699
210
    G_OBJECT_CLASS (indicator_menu_item_parent_class)->dispose (object);
2700
211
}
2701
212
2702
213
2703
214
static void
2704
215
indicator_menu_item_class_init (IndicatorMenuItemClass *klass)
2705
216
{
2706
217
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
2707
218
2708
219
    g_type_class_add_private (klass, sizeof (IndicatorMenuItemPrivate));
2709
220
2710
221
    object_class->get_property = indicator_menu_item_get_property;
2711
222
    object_class->set_property = indicator_menu_item_set_property;
2712
223
    object_class->dispose = indicator_menu_item_dispose;
2713
224
2714
225
    properties[PROP_ICON] = g_param_spec_object ("icon",
2715
226
                                                 "Icon",
2716
227
                                                 "Icon for this menu item",
2717
228
                                                 GDK_TYPE_PIXBUF,
2718
229
                                                 G_PARAM_READWRITE);
2719
230
2720
231
    properties[PROP_ICON_NAME] = g_param_spec_string ("icon-name",
2721
232
                                                      "Icon name",
2722
233
                                                      "Name of the themed icon",
2723
234
                                                      "",
2724
235
                                                      G_PARAM_READWRITE);
2725
236
2726
237
    properties[PROP_LABEL] = g_param_spec_string ("label",
2727
238
                                                  "Label",
2728
239
                                                  "The text for the main label",
2729
240
                                                  "",
2730
241
                                                  G_PARAM_READWRITE);
2731
242
2732
243
    properties[PROP_RIGHT] = g_param_spec_string ("right",
2733
244
                                                  "Right",
2734
245
                                                  "The text on the right side of the menu item",
2735
246
                                                  "",
2736
247
                                                  G_PARAM_READWRITE);
2737
248
2738
249
    properties[PROP_RIGHT_IS_LOZENGE] = g_param_spec_boolean ("right-is-lozenge",
2739
250
                                                              "Right is a lozenge",
2740
251
                                                              "Whether the right label is displayed as a lonzenge",
2741
252
                                                              FALSE,
2742
253
                                                              G_PARAM_READWRITE);
2743
254
2744
255
    g_object_class_install_properties (object_class, N_PROPERTIES, properties);
2745
256
}
2746
257
2747
258
2748
259
static void
2749
260
indicator_menu_item_init (IndicatorMenuItem *self)
2750
261
{
2751
262
    IndicatorMenuItemPrivate *priv;
2752
263
    gint spacing;
2753
264
    GtkWidget *hbox;
2754
265
2755
266
    priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
2756
267
                                        INDICATOR_TYPE_MENU_ITEM,
2757
268
                                        IndicatorMenuItemPrivate);
2758
269
    self->priv = priv;
2759
270
2760
271
    gtk_widget_style_get (GTK_WIDGET (self),
2761
272
                          "toggle-spacing", &spacing,
2762
273
                          NULL);
2763
274
2764
275
    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, spacing);
2765
276
2766
277
    priv->image = g_object_new (GTK_TYPE_IMAGE, NULL);
2767
278
    g_object_ref_sink (priv->image);
2768
279
    gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (priv->image), FALSE, FALSE, 0);
2769
280
2770
281
    priv->label = g_object_new (GTK_TYPE_LABEL,
2771
282
                                "xalign", 0.0,
2772
283
                                NULL);
2773
284
    g_object_ref_sink (priv->label);
2774
285
    gtk_box_pack_start (GTK_BOX (hbox), priv->label, TRUE, TRUE, 0);
2775
286
2776
287
    priv->right_label = g_object_new (GTK_TYPE_LABEL,
2777
288
                                      "xalign", 1.0,
2778
289
                                      "width-chars", 2,
2779
290
                                      NULL);
2780
291
    gtk_style_context_add_class (gtk_widget_get_style_context (priv->right_label),
2781
292
                                 "accelerator");
2782
293
    g_signal_connect (priv->right_label,
2783
294
                      "draw",
2784
295
                      G_CALLBACK (detail_label_draw),
2785
296
                      &priv->right_is_lozenge);
2786
297
    g_object_ref_sink (priv->right_label);
2787
298
    gtk_box_pack_start (GTK_BOX (hbox),
2788
299
                        priv->right_label,
2789
300
                        FALSE,
2790
301
                        FALSE,
2791
302
                        gtk_widget_get_font_size (priv->right_label) / 2.0 + 1);
2792
303
2793
304
    gtk_container_add (GTK_CONTAINER (self), hbox);
2794
305
2795
306
    priv->right_is_lozenge = FALSE;
2796
307
}
2797
308
2798
309
2799
310
IndicatorMenuItem *
2800
311
indicator_menu_item_new (void)
2801
312
{
2802
313
    return g_object_new (INDICATOR_TYPE_MENU_ITEM, NULL);
2803
314
}
2804
315
2805
316
2806
317
const gchar *
2807
318
indicator_menu_item_get_label (IndicatorMenuItem *self)
2808
319
{
2809
320
    return gtk_label_get_label (GTK_LABEL (self->priv->label));
2810
321
}
2811
322
2812
323
2813
324
void
2814
325
indicator_menu_item_set_label (IndicatorMenuItem *self,
2815
326
                               const gchar *text)
2816
327
{
2817
328
    gtk_label_set_label (GTK_LABEL (self->priv->label), text);
2818
329
    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LABEL]);
2819
330
}
2820
331
2821
332
2822
333
const gchar *
2823
334
indicator_menu_item_get_right (IndicatorMenuItem *self)
2824
335
{
2825
336
    return gtk_label_get_label (GTK_LABEL (self->priv->right_label));
2826
337
}
2827
338
2828
339
2829
340
void
2830
341
indicator_menu_item_set_right (IndicatorMenuItem *self,
2831
342
                               const gchar *text)
2832
343
{
2833
344
    gtk_label_set_label (GTK_LABEL (self->priv->right_label), text);
2834
345
    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_RIGHT]);
2835
346
}
2836
347
2837
348
2838
349
gboolean
2839
350
indicator_menu_item_get_right_is_lozenge (IndicatorMenuItem *self)
2840
351
{
2841
352
    return self->priv->right_is_lozenge;
2842
353
}
2843
354
2844
355
2845
356
void
2846
357
indicator_menu_item_set_right_is_lozenge (IndicatorMenuItem *self,
2847
358
                                          gboolean is_lozenge)
2848
359
{
2849
360
    self->priv->right_is_lozenge = is_lozenge;
2850
361
    gtk_widget_queue_draw (self->priv->right_label);
2851
362
    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_RIGHT_IS_LOZENGE]);
2852
363
}
2853
364
2854
365
2855
366
GdkPixbuf *
2856
367
indicator_menu_item_get_icon (IndicatorMenuItem *self)
2857
368
{
2858
369
    if (gtk_image_get_storage_type (self->priv->image) == GTK_IMAGE_PIXBUF)
2859
370
        return gtk_image_get_pixbuf (self->priv->image);
2860
371
    else
2861
372
        return NULL;
2862
373
}
2863
374
2864
375
2865
376
void
2866
377
indicator_menu_item_set_icon (IndicatorMenuItem *self,
2867
378
                              GdkPixbuf *icon)
2868
379
{
2869
380
    gtk_image_set_from_pixbuf (self->priv->image, icon);
2870
381
    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ICON]);
2871
382
}
2872
383
2873
384
2874
385
const gchar *
2875
386
indicator_menu_item_get_icon_name (IndicatorMenuItem *self)
2876
387
{
2877
388
    const gchar *name = NULL;
2878
389
2879
390
    if (gtk_image_get_storage_type (self->priv->image) == GTK_IMAGE_ICON_NAME)
2880
391
        gtk_image_get_icon_name (self->priv->image, &name, NULL);
2881
392
2882
393
    return name;
2883
394
}
2884
395
2885
396
2886
397
void
2887
398
indicator_menu_item_set_icon_name (IndicatorMenuItem *self,
2888
399
                                   const gchar *name)
2889
400
{
2890
401
    gtk_image_set_from_icon_name (self->priv->image, name, GTK_ICON_SIZE_MENU);
2891
402
    g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ICON_NAME]);
2892
403
}
2893
404
2894
405
0
2895
=== removed file 'src/indicator-menu-item.h'
2896
--- src/indicator-menu-item.h	2012-02-12 13:20:44 +0000
2897
+++ src/indicator-menu-item.h	1970-01-01 00:00:00 +0000
2898
@@ -1,82 +0,0 @@
2899
1
/*
2900
2
 * Copyright 2012 Canonical Ltd.
2901
3
 *
2902
4
 * Authors: Lars Uebernickel <lars.uebernickel@canonical.com>
2903
5
 *
2904
6
 * This program is free software: you can redistribute it and/or modify it
2905
7
 * under the terms of the GNU General Public License version 3, as published
2906
8
 * by the Free Software Foundation.
2907
9
 *
2908
10
 * This program is distributed in the hope that it will be useful, but
2909
11
 * WITHOUT ANY WARRANTY; without even the implied warranties of
2910
12
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2911
13
 * PURPOSE.  See the GNU General Public License for more details.
2912
14
 *
2913
15
 * You should have received a copy of the GNU General Public License along
2914
16
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
2915
17
 */
2916
18
2917
19
#ifndef INDICATOR_MENU_ITEM_H
2918
20
#define INDICATOR_MENU_ITEM_H
2919
21
2920
22
#include <gtk/gtk.h>
2921
23
2922
24
G_BEGIN_DECLS
2923
25
2924
26
#define INDICATOR_TYPE_MENU_ITEM indicator_menu_item_get_type()
2925
27
2926
28
#define INDICATOR_MENU_ITEM(obj) \
2927
29
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
2928
30
  INDICATOR_TYPE_MENU_ITEM, IndicatorMenuItem))
2929
31
2930
32
#define INDICATOR_MENU_ITEM_CLASS(klass) \
2931
33
  (G_TYPE_CHECK_CLASS_CAST ((klass), \
2932
34
  INDICATOR_TYPE_MENU_ITEM, IndicatorMenuItemClass))
2933
35
2934
36
#define INDICATOR_IS_MENU_ITEM(obj) \
2935
37
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
2936
38
  INDICATOR_TYPE_MENU_ITEM))
2937
39
2938
40
#define INDICATOR_IS_MENU_ITEM_CLASS(klass) \
2939
41
  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
2940
42
  INDICATOR_TYPE_MENU_ITEM))
2941
43
2942
44
#define INDICATOR_MENU_ITEM_GET_CLASS(obj) \
2943
45
  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
2944
46
  INDICATOR_TYPE_MENU_ITEM, IndicatorMenuItemClass))
2945
47
2946
48
typedef struct _IndicatorMenuItem IndicatorMenuItem;
2947
49
typedef struct _IndicatorMenuItemClass IndicatorMenuItemClass;
2948
50
typedef struct _IndicatorMenuItemPrivate IndicatorMenuItemPrivate;
2949
51
2950
52
struct _IndicatorMenuItem
2951
53
{
2952
54
    GtkMenuItem parent;
2953
55
    IndicatorMenuItemPrivate *priv;
2954
56
};
2955
57
2956
58
struct _IndicatorMenuItemClass
2957
59
{
2958
60
    GtkMenuItemClass parent_class;
2959
61
};
2960
62
2961
63
GType indicator_menu_item_get_type (void) G_GNUC_CONST;
2962
64
2963
65
IndicatorMenuItem *indicator_menu_item_new (void);
2964
66
2965
67
const gchar * indicator_menu_item_get_label (IndicatorMenuItem *self);
2966
68
void indicator_menu_item_set_label (IndicatorMenuItem *self, const gchar *text);
2967
69
const gchar * indicator_menu_item_get_right (IndicatorMenuItem *self);
2968
70
void indicator_menu_item_set_right (IndicatorMenuItem *self, const gchar *text);
2969
71
2970
72
gboolean indicator_menu_item_get_right_is_lozenge (IndicatorMenuItem *self);
2971
73
void indicator_menu_item_set_right_is_lozenge (IndicatorMenuItem *self, gboolean is_lozenge);
2972
74
const gchar * indicator_menu_item_get_icon_name (IndicatorMenuItem *self);
2973
75
void indicator_menu_item_set_icon (IndicatorMenuItem *self, GdkPixbuf *icon);
2974
76
GdkPixbuf * indicator_menu_item_get_icon (IndicatorMenuItem *self);
2975
77
void indicator_menu_item_set_icon_name (IndicatorMenuItem *self, const gchar *name);
2976
78
2977
79
G_END_DECLS
2978
80
2979
81
#endif
2980
82
2981
83
0
2982
=== removed file 'src/indicator-printers-menu.c'
2983
--- src/indicator-printers-menu.c	2012-03-03 10:40:46 +0000
2984
+++ src/indicator-printers-menu.c	1970-01-01 00:00:00 +0000
2985
@@ -1,339 +0,0 @@
2986
1
/*
2987
2
 * Copyright 2012 Canonical Ltd.
2988
3
 *
2989
4
 * Authors: Lars Uebernickel <lars.uebernickel@canonical.com>
2990
5
 *
2991
6
 * This program is free software: you can redistribute it and/or modify it
2992
7
 * under the terms of the GNU General Public License version 3, as published
2993
8
 * by the Free Software Foundation.
2994
9
 *
2995
10
 * This program is distributed in the hope that it will be useful, but
2996
11
 * WITHOUT ANY WARRANTY; without even the implied warranties of
2997
12
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
2998
13
 * PURPOSE.  See the GNU General Public License for more details.
2999
14
 *
3000
15
 * You should have received a copy of the GNU General Public License along
3001
16
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
3002
17
 */
3003
18
3004
19
#include "indicator-printers-menu.h"
3005
20
3006
21
#include <glib/gi18n.h>
3007
22
3008
23
#include <cups/cups.h>
3009
24
3010
25
#include "spawn-printer-settings.h"
3011
26
3012
27
3013
28
G_DEFINE_TYPE (IndicatorPrintersMenu, indicator_printers_menu, G_TYPE_OBJECT)
3014
29
3015
30
3016
31
struct _IndicatorPrintersMenuPrivate
3017
32
{
3018
33
    DbusmenuMenuitem *root;
3019
34
    GHashTable *printers;    /* printer name -> dbusmenuitem */
3020
35
    CupsNotifier *cups_notifier;
3021
36
};
3022
37
3023
38
3024
39
enum {
3025
40
    PROP_0,
3026
41
    PROP_CUPS_NOTIFIER,
3027
42
    NUM_PROPERTIES
3028
43
};
3029
44
3030
45
GParamSpec *properties[NUM_PROPERTIES];
3031
46
3032
47
3033
48
static void
3034
49
dispose (GObject *object)
3035
50
{
3036
51
    IndicatorPrintersMenu *self = INDICATOR_PRINTERS_MENU (object);
3037
52
3038
53
    if (self->priv->printers) {
3039
54
        g_hash_table_unref (self->priv->printers);
3040
55
        self->priv->printers = NULL;
3041
56
    }
3042
57
3043
58
    g_clear_object (&self->priv->root);
3044
59
    g_clear_object (&self->priv->cups_notifier);
3045
60
3046
61
    G_OBJECT_CLASS (indicator_printers_menu_parent_class)->dispose (object);
3047
62
}
3048
63
3049
64
3050
65
void
3051
66
set_property (GObject        *object,
3052
67
              guint           property_id,
3053
68
              const GValue   *value,
3054
69
              GParamSpec     *pspec)
3055
70
{
3056
71
    IndicatorPrintersMenu *self = INDICATOR_PRINTERS_MENU (object);
3057
72
3058
73
    switch (property_id) {
3059
74
        case PROP_CUPS_NOTIFIER:
3060
75
            indicator_printers_menu_set_cups_notifier (self,
3061
76
                                                       g_value_get_object (value));
3062
77
            break;
3063
78
3064
79
        default:
3065
80
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3066
81
    }
3067
82
}
3068
83
3069
84
3070
85
void
3071
86
get_property (GObject        *object,
3072
87
              guint           property_id,
3073
88
              GValue         *value,
3074
89
              GParamSpec     *pspec)
3075
90
{
3076
91
    IndicatorPrintersMenu *self = INDICATOR_PRINTERS_MENU (object);
3077
92
3078
93
    switch (property_id) {
3079
94
        case PROP_CUPS_NOTIFIER:
3080
95
            g_value_set_object (value,
3081
96
                                indicator_printers_menu_get_cups_notifier (self));
3082
97
            break;
3083
98
3084
99
        default:
3085
100
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3086
101
    }
3087
102
}
3088
103
3089
104
3090
105
static void
3091
106
indicator_printers_menu_class_init (IndicatorPrintersMenuClass *klass)
3092
107
{
3093
108
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
3094
109
3095
110
    g_type_class_add_private (klass, sizeof (IndicatorPrintersMenuPrivate));
3096
111
3097
112
    object_class->dispose = dispose;
3098
113
    object_class->get_property = get_property;
3099
114
    object_class->set_property = set_property;
3100
115
3101
116
    properties[PROP_CUPS_NOTIFIER] = g_param_spec_object ("cups-notifier",
3102
117
                                                          "Cups Notifier",
3103
118
                                                          "A cups notifier object",
3104
119
                                                          CUPS_TYPE_NOTIFIER,
3105
120
                                                          G_PARAM_READWRITE);
3106
121
3107
122
    g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
3108
123
}
3109
124
3110
125
3111
126
static void
3112
127
on_printer_item_activated (DbusmenuMenuitem *menuitem,
3113
128
                           guint timestamp,
3114
129
                           gpointer user_data)
3115
130
{
3116
131
    const gchar *printer = user_data;
3117
132
    spawn_printer_settings_with_args ("--show-jobs %s", printer);
3118
133
}
3119
134
3120
135
3121
136
static void
3122
137
update_indicator_visibility (IndicatorPrintersMenu *self)
3123
138
{
3124
139
    GList *it;
3125
140
    gboolean is_visible = FALSE;
3126
141
3127
142
    for (it = dbusmenu_menuitem_get_children (self->priv->root);
3128
143
         it;
3129
144
         it = g_list_next (it))
3130
145
    {
3131
146
        DbusmenuMenuitem *child = it->data;
3132
147
        if ((is_visible = dbusmenu_menuitem_property_get_bool (child, "visible")))
3133
148
            break;
3134
149
    }
3135
150
3136
151
    dbusmenu_menuitem_property_set_bool (self->priv->root, "visible", is_visible);
3137
152
}
3138
153
3139
154
3140
155
static void
3141
156
update_printer_menuitem (IndicatorPrintersMenu *self,
3142
157
                         const char *printer,
3143
158
                         int state)
3144
159
{
3145
160
    DbusmenuMenuitem *item;
3146
161
    int njobs;
3147
162
    cups_job_t *jobs;
3148
163
3149
164
    njobs = cupsGetJobs (&jobs, printer, 1, CUPS_WHICHJOBS_ACTIVE);
3150
165
    cupsFreeJobs (njobs, jobs);
3151
166
3152
167
    if (njobs < 0) {
3153
168
        g_warning ("printer '%s' does not exist\n", printer);
3154
169
        return;
3155
170
    }
3156
171
3157
172
    item = g_hash_table_lookup (self->priv->printers, printer);
3158
173
3159
174
    if (!item) {
3160
175
        item = dbusmenu_menuitem_new ();
3161
176
        dbusmenu_menuitem_property_set (item, "type", "indicator-item");
3162
177
        dbusmenu_menuitem_property_set (item, "indicator-icon-name", "printer");
3163
178
        dbusmenu_menuitem_property_set (item, "indicator-label", printer);
3164
179
        g_signal_connect_data (item, "item-activated",
3165
180
                               G_CALLBACK (on_printer_item_activated),
3166
181
                               g_strdup (printer), (GClosureNotify) g_free, 0);
3167
182
3168
183
        dbusmenu_menuitem_child_append(self->priv->root, item);
3169
184
        g_hash_table_insert (self->priv->printers, g_strdup (printer), item);
3170
185
    }
3171
186
3172
187
    if (njobs == 0) {
3173
188
        dbusmenu_menuitem_property_set_bool (item, "visible", FALSE);
3174
189
        update_indicator_visibility (self);
3175
190
        return;
3176
191
    }
3177
192
3178
193
    /* there are jobs for this printer. Make sure the indicator and the menu
3179
194
     * item for that printer are shown */
3180
195
    dbusmenu_menuitem_property_set_bool (self->priv->root, "visible", TRUE);
3181
196
    dbusmenu_menuitem_property_set_bool (item, "visible", TRUE);
3182
197
3183
198
    switch (state) {
3184
199
        case IPP_PRINTER_STOPPED:
3185
200
            dbusmenu_menuitem_property_set (item, "indicator-right", _("Paused"));
3186
201
            dbusmenu_menuitem_property_set_bool (item, "indicator-right-is-lozenge", FALSE);
3187
202
            break;
3188
203
3189
204
        case IPP_PRINTER_PROCESSING: {
3190
205
            gchar *jobstr = g_strdup_printf ("%d", njobs);
3191
206
            dbusmenu_menuitem_property_set (item, "indicator-right", jobstr);
3192
207
            dbusmenu_menuitem_property_set_bool (item, "indicator-right-is-lozenge", TRUE);
3193
208
            g_free (jobstr);
3194
209
            break;
3195
210
        }
3196
211
    }
3197
212
}
3198
213
3199
214
3200
215
static void
3201
216
update_all_printer_menuitems (IndicatorPrintersMenu *self)
3202
217
{
3203
218
    int ndests, i;
3204
219
    cups_dest_t *dests;
3205
220
3206
221
    ndests = cupsGetDests (&dests);
3207
222
    for (i = 0; i < ndests; i++) {
3208
223
        int state = atoi (cupsGetOption ("printer-state",
3209
224
                                         dests[i].num_options,
3210
225
                                         dests[i].options));
3211
226
        update_printer_menuitem (self, dests[i].name, state);
3212
227
    }
3213
228
    cupsFreeDests (ndests, dests);
3214
229
}
3215
230
3216
231
3217
232
static void
3218
233
update_job (CupsNotifier *cups_notifier,
3219
234
            const gchar *text,
3220
235
            const gchar *printer_uri,
3221
236
            const gchar *printer_name,
3222
237
            guint printer_state,
3223
238
            const gchar *printer_state_reasons,
3224
239
            gboolean printer_is_accepting_jobs,
3225
240
            guint job_id,
3226
241
            guint job_state,
3227
242
            const gchar *job_state_reasons,
3228
243
            const gchar *job_name,
3229
244
            guint job_impressions_completed,
3230
245
            gpointer user_data)
3231
246
{
3232
247
    IndicatorPrintersMenu *self = INDICATOR_PRINTERS_MENU (user_data);
3233
248
3234
249
    /* CUPS doesn't send the printer's name for these events.  Update all menu
3235
250
     * items as a temporary workaround */
3236
251
    if (job_state == IPP_JOB_CANCELLED ||
3237
252
        job_state == IPP_JOB_ABORTED ||
3238
253
        job_state == IPP_JOB_COMPLETED)
3239
254
        update_all_printer_menuitems (self);
3240
255
    else
3241
256
        update_printer_menuitem (self, printer_name, printer_state);
3242
257
}
3243
258
3244
259
3245
260
static void
3246
261
on_printer_state_changed (CupsNotifier *object,
3247
262
                          const gchar *text,
3248
263
                          const gchar *printer_uri,
3249
264
                          const gchar *printer_name,
3250
265
                          guint printer_state,
3251
266
                          const gchar *printer_state_reasons,
3252
267
                          gboolean printer_is_accepting_jobs,
3253
268
                          gpointer user_data)
3254
269
{
3255
270
    IndicatorPrintersMenu *self = INDICATOR_PRINTERS_MENU (user_data);
3256
271
3257
272
    update_printer_menuitem (self, printer_name, printer_state);
3258
273
}
3259
274
3260
275
3261
276
static void
3262
277
indicator_printers_menu_init (IndicatorPrintersMenu *self)
3263
278
{
3264
279
    self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
3265
280
                                              INDICATOR_TYPE_PRINTERS_MENU,
3266
281
                                              IndicatorPrintersMenuPrivate);
3267
282
3268
283
    self->priv->root = dbusmenu_menuitem_new ();
3269
284
    dbusmenu_menuitem_property_set_bool (self->priv->root, "visible", FALSE);
3270
285
3271
286
    self->priv->printers = g_hash_table_new_full (g_str_hash,
3272
287
                                                  g_str_equal,
3273
288
                                                  g_free,
3274
289
                                                  g_object_unref);
3275
290
3276
291
    /* create initial menu items */
3277
292
    update_all_printer_menuitems (self);
3278
293
}
3279
294
3280
295
3281
296
IndicatorPrintersMenu *
3282
297
indicator_printers_menu_new (void)
3283
298
{
3284
299
    return g_object_new (INDICATOR_TYPE_PRINTERS_MENU, NULL);
3285
300
}
3286
301
3287
302
3288
303
DbusmenuMenuitem *
3289
304
indicator_printers_menu_get_root (IndicatorPrintersMenu *self)
3290
305
{
3291
306
    return self->priv->root;
3292
307
}
3293
308
3294
309
3295
310
CupsNotifier *
3296
311
indicator_printers_menu_get_cups_notifier (IndicatorPrintersMenu *self)
3297
312
{
3298
313
    return self->priv->cups_notifier;
3299
314
}
3300
315
3301
316
3302
317
void
3303
318
indicator_printers_menu_set_cups_notifier (IndicatorPrintersMenu *self,
3304
319
                                           CupsNotifier *cups_notifier)
3305
320
{
3306
321
    if (self->priv->cups_notifier) {
3307
322
        g_object_disconnect (self->priv->cups_notifier,
3308
323
                             "any-signal", update_job, self,
3309
324
                             "any-signal", on_printer_state_changed, self,
3310
325
                             NULL);
3311
326
        g_clear_object (&self->priv->cups_notifier);
3312
327
    }
3313
328
3314
329
    if (cups_notifier) {
3315
330
        self->priv->cups_notifier = g_object_ref (cups_notifier);
3316
331
        g_object_connect (self->priv->cups_notifier,
3317
332
                          "signal::job-created", update_job, self,
3318
333
                          "signal::job-state", update_job, self,
3319
334
                          "signal::job-completed", update_job, self,
3320
335
                          "signal::printer-state-changed", on_printer_state_changed, self,
3321
336
                          NULL);
3322
337
    }
3323
338
}
3324
339
3325
340
0
3326
=== removed file 'src/indicator-printers-menu.h'
3327
--- src/indicator-printers-menu.h	2012-02-12 13:20:44 +0000
3328
+++ src/indicator-printers-menu.h	1970-01-01 00:00:00 +0000
3329
@@ -1,77 +0,0 @@
3330
1
/*
3331
2
 * Copyright 2012 Canonical Ltd.
3332
3
 *
3333
4
 * Authors: Lars Uebernickel <lars.uebernickel@canonical.com>
3334
5
 *
3335
6
 * This program is free software: you can redistribute it and/or modify it
3336
7
 * under the terms of the GNU General Public License version 3, as published
3337
8
 * by the Free Software Foundation.
3338
9
 *
3339
10
 * This program is distributed in the hope that it will be useful, but
3340
11
 * WITHOUT ANY WARRANTY; without even the implied warranties of
3341
12
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
3342
13
 * PURPOSE.  See the GNU General Public License for more details.
3343
14
 *
3344
15
 * You should have received a copy of the GNU General Public License along
3345
16
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
3346
17
 */
3347
18
3348
19
#ifndef INDICATOR_PRINTERS_MENU_H
3349
20
#define INDICATOR_PRINTERS_MENU_H
3350
21
3351
22
#include <glib-object.h>
3352
23
#include <libdbusmenu-glib/dbusmenu-glib.h>
3353
24
3354
25
#include "cups-notifier.h"
3355
26
3356
27
G_BEGIN_DECLS
3357
28
3358
29
#define INDICATOR_TYPE_PRINTERS_MENU indicator_printers_menu_get_type()
3359
30
3360
31
#define INDICATOR_PRINTERS_MENU(obj) \
3361
32
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
3362
33
  INDICATOR_TYPE_PRINTERS_MENU, IndicatorPrintersMenu))
3363
34
3364
35
#define INDICATOR_PRINTERS_MENU_CLASS(klass) \
3365
36
  (G_TYPE_CHECK_CLASS_CAST ((klass), \
3366
37
  INDICATOR_TYPE_PRINTERS_MENU, IndicatorPrintersMenuClass))
3367
38
3368
39
#define INDICATOR_IS_PRINTERS_MENU(obj) \
3369
40
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
3370
41
  INDICATOR_TYPE_PRINTERS_MENU))
3371
42
3372
43
#define INDICATOR_IS_PRINTERS_MENU_CLASS(klass) \
3373
44
  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
3374
45
  INDICATOR_TYPE_PRINTERS_MENU))
3375
46
3376
47
#define INDICATOR_PRINTERS_MENU_GET_CLASS(obj) \
3377
48
  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
3378
49
  INDICATOR_TYPE_PRINTERS_MENU, IndicatorPrintersMenuClass))
3379
50
3380
51
typedef struct _IndicatorPrintersMenu IndicatorPrintersMenu;
3381
52
typedef struct _IndicatorPrintersMenuClass IndicatorPrintersMenuClass;
3382
53
typedef struct _IndicatorPrintersMenuPrivate IndicatorPrintersMenuPrivate;
3383
54
3384
55
struct _IndicatorPrintersMenu
3385
56
{
3386
57
  GObject parent;
3387
58
  IndicatorPrintersMenuPrivate *priv;
3388
59
};
3389
60
3390
61
struct _IndicatorPrintersMenuClass
3391
62
{
3392
63
  GObjectClass parent_class;
3393
64
};
3394
65
3395
66
GType indicator_printers_menu_get_type (void) G_GNUC_CONST;
3396
67
3397
68
IndicatorPrintersMenu *indicator_printers_menu_new (void);
3398
69
DbusmenuMenuitem * indicator_printers_menu_get_root (IndicatorPrintersMenu *menu);
3399
70
CupsNotifier * indicator_printers_menu_get_cups_notifier (IndicatorPrintersMenu *self);
3400
71
void indicator_printers_menu_set_cups_notifier (IndicatorPrintersMenu *self,
3401
72
                                                CupsNotifier *cups_notifier);
3402
73
3403
74
G_END_DECLS
3404
75
3405
76
#endif
3406
77
3407
78
0
3408
=== removed file 'src/indicator-printers-service.c'
3409
--- src/indicator-printers-service.c	2014-05-15 11:13:15 +0000
3410
+++ src/indicator-printers-service.c	1970-01-01 00:00:00 +0000
3411
@@ -1,206 +0,0 @@
3412
1
/*
3413
2
 * Copyright 2012 Canonical Ltd.
3414
3
 *
3415
4
 * Authors: Lars Uebernickel <lars.uebernickel@canonical.com>
3416
5
 *
3417
6
 * This program is free software: you can redistribute it and/or modify it
3418
7
 * under the terms of the GNU General Public License version 3, as published
3419
8
 * by the Free Software Foundation.
3420
9
 *
3421
10
 * This program is distributed in the hope that it will be useful, but
3422
11
 * WITHOUT ANY WARRANTY; without even the implied warranties of
3423
12
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
3424
13
 * PURPOSE.  See the GNU General Public License for more details.
3425
14
 *
3426
15
 * You should have received a copy of the GNU General Public License along
3427
16
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
3428
17
 */
3429
18
3430
19
#include <libindicator/indicator-service.h>
3431
20
#include <libdbusmenu-glib/dbusmenu-glib.h>
3432
21
#include <gtk/gtk.h>
3433
22
#include <cups/cups.h>
3434
23
#include "dbus-names.h"
3435
24
#include "config.h"
3436
25
3437
26
#include "cups-notifier.h"
3438
27
#include "indicator-printers-menu.h"
3439
28
#include "indicator-printer-state-notifier.h"
3440
29
3441
30
#define NOTIFY_LEASE_DURATION (24 * 60 * 60)
3442
31
3443
32
3444
33
static int
3445
34
create_subscription ()
3446
35
{
3447
36
    ipp_t *req;
3448
37
    ipp_t *resp;
3449
38
    ipp_attribute_t *attr;
3450
39
    int id = 0;
3451
40
3452
41
    req = ippNewRequest (IPP_CREATE_PRINTER_SUBSCRIPTION);
3453
42
    ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
3454
43
                  "printer-uri", NULL, "/");
3455
44
    ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
3456
45
                  "notify-events", NULL, "all");
3457
46
    ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
3458
47
                  "notify-recipient-uri", NULL, "dbus://");
3459
48
    ippAddInteger (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
3460
49
                   "notify-lease-duration", NOTIFY_LEASE_DURATION);
3461
50
3462
51
    resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
3463
52
    if (!resp || cupsLastError() != IPP_OK) {
3464
53
        g_warning ("Error subscribing to CUPS notifications: %s\n",
3465
54
                   cupsLastErrorString ());
3466
55
        return 0;
3467
56
    }
3468
57
3469
58
    attr = ippFindAttribute (resp, "notify-subscription-id", IPP_TAG_INTEGER);
3470
59
    if (attr)
3471
60
        id = ippGetInteger (attr, 0);
3472
61
    else
3473
62
        g_warning ("ipp-create-printer-subscription response doesn't contain "
3474
63
                   "subscription id.\n");
3475
64
3476
65
    ippDelete (resp);
3477
66
    return id;
3478
67
}
3479
68
3480
69
3481
70
static gboolean
3482
71
renew_subscription (int id)
3483
72
{
3484
73
    ipp_t *req;
3485
74
    ipp_t *resp;
3486
75
3487
76
    req = ippNewRequest (IPP_RENEW_SUBSCRIPTION);
3488
77
    ippAddInteger (req, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
3489
78
                   "notify-subscription-id", id);
3490
79
    ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
3491
80
                  "printer-uri", NULL, "/");
3492
81
    ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
3493
82
                  "notify-recipient-uri", NULL, "dbus://");
3494
83
    ippAddInteger (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
3495
84
                   "notify-lease-duration", NOTIFY_LEASE_DURATION);
3496
85
3497
86
    resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
3498
87
    if (!resp || cupsLastError() != IPP_OK) {
3499
88
        g_warning ("Error renewing CUPS subscription %d: %s\n",
3500
89
                   id, cupsLastErrorString ());
3501
90
        return FALSE;
3502
91
    }
3503
92
3504
93
    ippDelete (resp);
3505
94
    return TRUE;
3506
95
}
3507
96
3508
97
3509
98
static gboolean
3510
99
renew_subscription_timeout (gpointer userdata)
3511
100
{
3512
101
    int *subscription_id = userdata;
3513
102
3514
103
    if (*subscription_id <= 0 || !renew_subscription (*subscription_id))
3515
104
        *subscription_id = create_subscription ();
3516
105
3517
106
    return TRUE;
3518
107
}
3519
108
3520
109
3521
110
void
3522
111
cancel_subscription (int id)
3523
112
{
3524
113
    ipp_t *req;
3525
114
    ipp_t *resp;
3526
115
3527
116
    if (id <= 0)
3528
117
        return;
3529
118
3530
119
    req = ippNewRequest (IPP_CANCEL_SUBSCRIPTION);
3531
120
    ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
3532
121
                  "printer-uri", NULL, "/");
3533
122
    ippAddInteger (req, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
3534
123
                   "notify-subscription-id", id);
3535
124
3536
125
    resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
3537
126
    if (!resp || cupsLastError() != IPP_OK) {
3538
127
        g_warning ("Error subscribing to CUPS notifications: %s\n",
3539
128
                   cupsLastErrorString ());
3540
129
        return;
3541
130
    }
3542
131
3543
132
    ippDelete (resp);
3544
133
}
3545
134
3546
135
static void
3547
136
name_lost (GDBusConnection *connection,
3548
137
           const gchar     *name,
3549
138
           gpointer         user_data)
3550
139
{
3551
140
    int subscription_id = GPOINTER_TO_INT (user_data);
3552
141
3553
142
    cancel_subscription (subscription_id);
3554
143
    gtk_main_quit ();
3555
144
}
3556
145
3557
146
int main (int argc, char *argv[])
3558
147
{
3559
148
    /* Init i18n */
3560
149
    setlocale (LC_ALL, "");
3561
150
    bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
3562
151
    bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
3563
152
    textdomain (GETTEXT_PACKAGE);
3564
153
3565
154
    DbusmenuServer *menuserver;
3566
155
    CupsNotifier *cups_notifier;
3567
156
    IndicatorPrintersMenu *menu;
3568
157
    IndicatorPrinterStateNotifier *state_notifier;
3569
158
    GError *error = NULL;
3570
159
    int subscription_id;
3571
160
3572
161
    gtk_init (&argc, &argv);
3573
162
3574
163
    subscription_id = create_subscription ();
3575
164
    g_timeout_add_seconds (NOTIFY_LEASE_DURATION - 60,
3576
165
                           renew_subscription_timeout,
3577
166
                           &subscription_id);
3578
167
3579
168
    g_bus_own_name (G_BUS_TYPE_SESSION,
3580
169
                    INDICATOR_PRINTERS_DBUS_NAME,
3581
170
                    G_BUS_NAME_OWNER_FLAGS_NONE,
3582
171
                    NULL, NULL, name_lost,
3583
172
                    GINT_TO_POINTER (subscription_id), NULL);
3584
173
3585
174
    cups_notifier = cups_notifier_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
3586
175
                                                          0,
3587
176
                                                          NULL,
3588
177
                                                          CUPS_DBUS_PATH,
3589
178
                                                          NULL,
3590
179
                                                          &error);
3591
180
    if (error) {
3592
181
        g_warning ("Error creating cups notify handler: %s", error->message);
3593
182
        g_error_free (error);
3594
183
        return 1;
3595
184
    }
3596
185
3597
186
    menu = g_object_new (INDICATOR_TYPE_PRINTERS_MENU,
3598
187
                         "cups-notifier", cups_notifier,
3599
188
                         NULL);
3600
189
3601
190
    menuserver = dbusmenu_server_new (INDICATOR_PRINTERS_DBUS_OBJECT_PATH);
3602
191
    dbusmenu_server_set_root (menuserver,
3603
192
                              indicator_printers_menu_get_root (menu));
3604
193
3605
194
    state_notifier = g_object_new (INDICATOR_TYPE_PRINTER_STATE_NOTIFIER,
3606
195
                                   "cups-notifier", cups_notifier,
3607
196
                                   NULL);
3608
197
3609
198
    gtk_main ();
3610
199
3611
200
    g_object_unref (menu);
3612
201
    g_object_unref (menuserver);
3613
202
    g_object_unref (state_notifier);
3614
203
    g_object_unref (cups_notifier);
3615
204
    return 0;
3616
205
}
3617
206
3618
207
0
3619
=== removed file 'src/indicator-printers.c'
3620
--- src/indicator-printers.c	2014-02-20 22:16:42 +0000
3621
+++ src/indicator-printers.c	1970-01-01 00:00:00 +0000
3622
@@ -1,311 +0,0 @@
3623
1
/*
3624
2
 * Copyright 2012 Canonical Ltd.
3625
3
 *
3626
4
 * Authors: Lars Uebernickel <lars.uebernickel@canonical.com>
3627
5
 *
3628
6
 * This program is free software: you can redistribute it and/or modify it
3629
7
 * under the terms of the GNU General Public License version 3, as published
3630
8
 * by the Free Software Foundation.
3631
9
 *
3632
10
 * This program is distributed in the hope that it will be useful, but
3633
11
 * WITHOUT ANY WARRANTY; without even the implied warranties of
3634
12
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
3635
13
 * PURPOSE.  See the GNU General Public License for more details.
3636
14
 *
3637
15
 * You should have received a copy of the GNU General Public License along
3638
16
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
3639
17
 */
3640
18
3641
19
#include "config.h"
3642
20
3643
21
#include "indicator-printers.h"
3644
22
#include "indicator-menu-item.h"
3645
23
#include "dbus-names.h"
3646
24
3647
25
#include <glib/gi18n-lib.h>
3648
26
#include <gtk/gtk.h>
3649
27
#include <gio/gio.h>
3650
28
3651
29
#include <libindicator/indicator.h>
3652
30
#include <libindicator/indicator-image-helper.h>
3653
31
3654
32
#include <libdbusmenu-gtk/menu.h>
3655
33
#include <libdbusmenu-gtk/menuitem.h>
3656
34
3657
35
3658
36
INDICATOR_SET_VERSION
3659
37
INDICATOR_SET_TYPE(INDICATOR_PRINTERS_TYPE)
3660
38
3661
39
3662
40
G_DEFINE_TYPE (IndicatorPrinters, indicator_printers, INDICATOR_OBJECT_TYPE)
3663
41
3664
42
3665
43
struct _IndicatorPrintersPrivate
3666
44
{
3667
45
    IndicatorObjectEntry entry;
3668
46
    guint name_watch;
3669
47
};
3670
48
3671
49
3672
50
static void
3673
51
dispose (GObject *object)
3674
52
{
3675
53
    IndicatorPrinters *self = INDICATOR_PRINTERS (object);
3676
54
    if (self->priv->name_watch != 0) {
3677
55
        g_bus_unwatch_name(self->priv->name_watch);
3678
56
        self->priv->name_watch = 0;
3679
57
    }
3680
58
    g_clear_object (&self->priv->entry.menu);
3681
59
    g_clear_object (&self->priv->entry.image);
3682
60
    G_OBJECT_CLASS (indicator_printers_parent_class)->dispose (object);
3683
61
}
3684
62
3685
63
3686
64
static GList *
3687
65
get_entries (IndicatorObject *io)
3688
66
{
3689
67
    IndicatorPrinters *self = INDICATOR_PRINTERS (io);
3690
68
    return g_list_append (NULL, &self->priv->entry);
3691
69
}
3692
70
3693
71
3694
72
static void
3695
73
indicator_printers_class_init (IndicatorPrintersClass *klass)
3696
74
{
3697
75
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
3698
76
    IndicatorObjectClass *io_class = INDICATOR_OBJECT_CLASS (klass);
3699
77
3700
78
    g_type_class_add_private (klass, sizeof (IndicatorPrintersPrivate));
3701
79
3702
80
    object_class->dispose = dispose;
3703
81
3704
82
    io_class->get_entries = get_entries;
3705
83
}
3706
84
3707
85
3708
86
static void
3709
87
name_vanished (GDBusConnection * con,
3710
88
                    const gchar * name,
3711
89
                    gpointer user_data)
3712
90
{
3713
91
    IndicatorPrinters *self = INDICATOR_PRINTERS (user_data);
3714
92
3715
93
    indicator_object_set_visible (INDICATOR_OBJECT (self), FALSE);
3716
94
}
3717
95
3718
96
3719
97
static GdkPixbuf *
3720
98
gdk_pixbuf_new_from_encoded_data (guchar *data,
3721
99
                                  gsize length)
3722
100
{
3723
101
    GInputStream * input;
3724
102
    GError *err = NULL;
3725
103
    GdkPixbuf *img;
3726
104
3727
105
    input = g_memory_input_stream_new_from_data(data, length, NULL);
3728
106
    if (input == NULL)
3729
107
        return NULL;
3730
108
3731
109
    img = gdk_pixbuf_new_from_stream(input, NULL, &err);
3732
110
    if (err) {
3733
111
        g_warning("%s", err->message);
3734
112
        g_error_free(err);
3735
113
    }
3736
114
3737
115
    g_object_unref(input);
3738
116
    return img;
3739
117
}
3740
118
3741
119
3742
120
static GdkPixbuf *
3743
121
g_variant_get_image (GVariant *value)
3744
122
{
3745
123
    const gchar *strvalue = NULL;
3746
124
    gsize length = 0;
3747
125
    guchar *icondata;
3748
126
    GdkPixbuf *img;
3749
127
3750
128
    if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
3751
129
        strvalue = g_variant_get_string(value, NULL);
3752
130
3753
131
    if (!strvalue || !*strvalue) {
3754
132
        g_warning ("%s: value does not contain a base64 encoded image",
3755
133
                   __func__);
3756
134
        return NULL;
3757
135
    }
3758
136
3759
137
    icondata = g_base64_decode(strvalue, &length);
3760
138
    img = gdk_pixbuf_new_from_encoded_data (icondata, length);
3761
139
3762
140
    g_free(icondata);
3763
141
    return img;
3764
142
}
3765
143
3766
144
3767
145
static gboolean
3768
146
properties_match (const gchar *name,
3769
147
                  const gchar *prop,
3770
148
                  GVariant *value,
3771
149
                  const GVariantType *type)
3772
150
{
3773
151
    return !g_strcmp0 (name, prop) && g_variant_is_of_type (value, type);
3774
152
}
3775
153
3776
154
3777
155
static void
3778
156
indicator_prop_change_cb (DbusmenuMenuitem *mi,
3779
157
                          gchar *prop,
3780
158
                          GVariant *value,
3781
159
                          gpointer user_data)
3782
160
{
3783
161
    IndicatorMenuItem *menuitem = user_data;
3784
162
3785
163
    if (properties_match (prop, "indicator-label", value, G_VARIANT_TYPE_STRING))
3786
164
        indicator_menu_item_set_label (menuitem, g_variant_get_string (value, NULL));
3787
165
3788
166
    else if (properties_match (prop, "indicator-right", value, G_VARIANT_TYPE_STRING))
3789
167
        indicator_menu_item_set_right (menuitem, g_variant_get_string (value, NULL));
3790
168
3791
169
    else if (properties_match (prop, "indicator-icon-name", value, G_VARIANT_TYPE_STRING))
3792
170
        indicator_menu_item_set_icon_name (menuitem, g_variant_get_string (value, NULL));
3793
171
3794
172
    else if (properties_match (prop, "indicator-icon", value, G_VARIANT_TYPE_STRING)) {
3795
173
        GdkPixbuf *pb = g_variant_get_image (value);
3796
174
        indicator_menu_item_set_icon (menuitem, pb);
3797
175
        g_object_unref (pb);
3798
176
    }
3799
177
3800
178
    else if (properties_match (prop, "visible", value, G_VARIANT_TYPE_BOOLEAN))
3801
179
        gtk_widget_set_visible (GTK_WIDGET (menuitem), g_variant_get_boolean (value));
3802
180
3803
181
    else if (properties_match (prop, "indicator-right-is-lozenge", value, G_VARIANT_TYPE_BOOLEAN))
3804
182
        indicator_menu_item_set_right_is_lozenge (menuitem, g_variant_get_boolean (value));
3805
183
}
3806
184
3807
185
3808
186
static void
3809
187
root_property_changed (DbusmenuMenuitem *mi,
3810
188
                       gchar *prop,
3811
189
                       GVariant *value,
3812
190
                       gpointer user_data)
3813
191
{
3814
192
    IndicatorObject *io = user_data;
3815
193
3816
194
    if (properties_match (prop, "visible", value, G_VARIANT_TYPE_BOOLEAN))
3817
195
        indicator_object_set_visible (io, g_variant_get_boolean (value));
3818
196
}
3819
197
3820
198
3821
199
static gboolean
3822
200
new_indicator_item (DbusmenuMenuitem *newitem,
3823
201
                    DbusmenuMenuitem *parent,
3824
202
                    DbusmenuClient *client,
3825
203
                    gpointer user_data)
3826
204
{
3827
205
    GtkWidget *menuitem;
3828
206
    const gchar *icon_name, *text, *right_text;
3829
207
    GVariant *icon;
3830
208
    gboolean is_lozenge, visible;
3831
209
3832
210
    icon_name = dbusmenu_menuitem_property_get (newitem, "indicator-icon-name");
3833
211
    icon = dbusmenu_menuitem_property_get_variant (newitem, "indicator-icon");
3834
212
    text = dbusmenu_menuitem_property_get (newitem, "indicator-label");
3835
213
    right_text = dbusmenu_menuitem_property_get (newitem, "indicator-right");
3836
214
    is_lozenge = dbusmenu_menuitem_property_get_bool (newitem, "indicator-right-is-lozenge");
3837
215
    visible = dbusmenu_menuitem_property_get_bool (newitem, "visible");
3838
216
3839
217
    menuitem = g_object_new (INDICATOR_TYPE_MENU_ITEM,
3840
218
                             "icon-name", icon_name,
3841
219
                             "label", text,
3842
220
                             "right", right_text,
3843
221
                             "right-is-lozenge", is_lozenge,
3844
222
                             "visible", visible,
3845
223
                             NULL);
3846
224
    if (icon) {
3847
225
        GdkPixbuf *pb = g_variant_get_image (icon);
3848
226
        indicator_menu_item_set_icon (INDICATOR_MENU_ITEM (menuitem), pb);
3849
227
        g_object_unref (pb);
3850
228
    }
3851
229
    gtk_widget_show_all (menuitem);
3852
230
3853
231
    dbusmenu_gtkclient_newitem_base(DBUSMENU_GTKCLIENT(client),
3854
232
                                    newitem,
3855
233
                                    GTK_MENU_ITEM (menuitem),
3856
234
                                    parent);
3857
235
3858
236
    g_signal_connect(G_OBJECT(newitem),
3859
237
                     "property-changed",
3860
238
                     G_CALLBACK(indicator_prop_change_cb),
3861
239
                     menuitem);
3862
240
3863
241
    return TRUE;
3864
242
}
3865
243
3866
244
3867
245
static void
3868
246
root_changed (DbusmenuClient *client,
3869
247
              DbusmenuMenuitem *newroot,
3870
248
              gpointer user_data)
3871
249
{
3872
250
    IndicatorPrinters *indicator = user_data;
3873
251
    gboolean is_visible;
3874
252
3875
253
    if (newroot) {
3876
254
        is_visible = dbusmenu_menuitem_property_get_bool (newroot, "visible");
3877
255
        g_signal_connect (newroot, "property-changed",
3878
256
                          G_CALLBACK (root_property_changed), indicator);
3879
257
    }
3880
258
    else
3881
259
        is_visible = FALSE;
3882
260
3883
261
    indicator_object_set_visible (INDICATOR_OBJECT (indicator), is_visible);
3884
262
}
3885
263
3886
264
3887
265
static void
3888
266
indicator_printers_init (IndicatorPrinters *self)
3889
267
{
3890
268
    IndicatorPrintersPrivate *priv;
3891
269
    DbusmenuGtkMenu *menu;
3892
270
    DbusmenuClient *client;
3893
271
    GtkImage *image;
3894
272
3895
273
    priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
3896
274
                                        INDICATOR_PRINTERS_TYPE,
3897
275
                                        IndicatorPrintersPrivate);
3898
276
    self->priv = priv;
3899
277
3900
278
    priv->name_watch = g_bus_watch_name(G_BUS_TYPE_SESSION,
3901
279
                                        INDICATOR_PRINTERS_DBUS_NAME,
3902
280
                                        G_BUS_NAME_WATCHER_FLAGS_NONE,
3903
281
                                        NULL, /* appeared */
3904
282
                                        name_vanished,
3905
283
                                        self, NULL);
3906
284
3907
285
    menu = dbusmenu_gtkmenu_new(INDICATOR_PRINTERS_DBUS_NAME,
3908
286
                                INDICATOR_PRINTERS_DBUS_OBJECT_PATH);
3909
287
3910
288
    client = DBUSMENU_CLIENT (dbusmenu_gtkmenu_get_client (menu));
3911
289
    dbusmenu_client_add_type_handler(client,
3912
290
                                     "indicator-item",
3913
291
                                     new_indicator_item);
3914
292
    g_signal_connect (client, "root-changed", G_CALLBACK (root_changed), self);
3915
293
3916
294
    image = indicator_image_helper ("printer-symbolic");
3917
295
    gtk_widget_show (GTK_WIDGET (image));
3918
296
3919
297
    priv->entry.name_hint = PACKAGE_NAME;
3920
298
    priv->entry.accessible_desc = _("Printers");
3921
299
    priv->entry.menu = GTK_MENU (g_object_ref_sink (menu));
3922
300
    priv->entry.image = g_object_ref_sink (image);
3923
301
3924
302
    indicator_object_set_visible (INDICATOR_OBJECT (self), FALSE);
3925
303
}
3926
304
3927
305
3928
306
IndicatorPrinters *
3929
307
indicator_printers_new (void)
3930
308
{
3931
309
    return g_object_new (INDICATOR_PRINTERS_TYPE, NULL);
3932
310
}
3933
311
3934
312
0
3935
=== removed file 'src/indicator-printers.h'
3936
--- src/indicator-printers.h	2012-02-03 13:39:34 +0000
3937
+++ src/indicator-printers.h	1970-01-01 00:00:00 +0000
3938
@@ -1,70 +0,0 @@
3939
1
/*
3940
2
 * Copyright 2012 Canonical Ltd.
3941
3
 *
3942
4
 * Authors: Lars Uebernickel <lars.uebernickel@canonical.com>
3943
5
 *
3944
6
 * This program is free software: you can redistribute it and/or modify it
3945
7
 * under the terms of the GNU General Public License version 3, as published
3946
8
 * by the Free Software Foundation.
3947
9
 *
3948
10
 * This program is distributed in the hope that it will be useful, but
3949
11
 * WITHOUT ANY WARRANTY; without even the implied warranties of
3950
12
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
3951
13
 * PURPOSE.  See the GNU General Public License for more details.
3952
14
 *
3953
15
 * You should have received a copy of the GNU General Public License along
3954
16
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
3955
17
 */
3956
18
3957
19
#ifndef INDICATOR_PRINTERS_H
3958
20
#define INDICATOR_PRINTERS_H
3959
21
3960
22
#include <libindicator/indicator-object.h>
3961
23
3962
24
G_BEGIN_DECLS
3963
25
3964
26
#define INDICATOR_PRINTERS_TYPE indicator_printers_get_type()
3965
27
3966
28
#define INDICATOR_PRINTERS(obj) \
3967
29
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
3968
30
  INDICATOR_PRINTERS_TYPE, IndicatorPrinters))
3969
31
3970
32
#define INDICATOR_PRINTERS_CLASS(klass) \
3971
33
  (G_TYPE_CHECK_CLASS_CAST ((klass), \
3972
34
  INDICATOR_PRINTERS_TYPE, IndicatorPrintersClass))
3973
35
3974
36
#define INDICATOR_IS_PRINTERS(obj) \
3975
37
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
3976
38
  INDICATOR_PRINTERS_TYPE))
3977
39
3978
40
#define INDICATOR_IS_PRINTERS_CLASS(klass) \
3979
41
  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
3980
42
  INDICATOR_PRINTERS_TYPE))
3981
43
3982
44
#define INDICATOR_PRINTERS_GET_CLASS(obj) \
3983
45
  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
3984
46
  INDICATOR_PRINTERS_TYPE, IndicatorPrintersClass))
3985
47
3986
48
typedef struct _IndicatorPrinters IndicatorPrinters;
3987
49
typedef struct _IndicatorPrintersClass IndicatorPrintersClass;
3988
50
typedef struct _IndicatorPrintersPrivate IndicatorPrintersPrivate;
3989
51
3990
52
struct _IndicatorPrinters
3991
53
{
3992
54
  IndicatorObject parent;
3993
55
  IndicatorPrintersPrivate *priv;
3994
56
};
3995
57
3996
58
struct _IndicatorPrintersClass
3997
59
{
3998
60
  IndicatorObjectClass parent_class;
3999
61
};
4000
62
4001
63
GType indicator_printers_get_type (void) G_GNUC_CONST;
4002
64
4003
65
IndicatorPrinters *indicator_printers_new (void);
4004
66
4005
67
G_END_DECLS
4006
68
4007
69
#endif
4008
70
4009
71
0
4010
=== added file 'src/job.h'
4011
--- src/job.h	1970-01-01 00:00:00 +0000
4012
+++ src/job.h	2017-01-10 21:54:44 +0000
4013
@@ -0,0 +1,50 @@
4014
1
/*
4015
2
 * Copyright 2016-2017 Canonical Ltd.
4016
3
 *
4017
4
 * This program is free software: you can redistribute it and/or modify it
4018
5
 * under the terms of the GNU General Public License version 3, as published
4019
6
 * by the Free Software Foundation.
4020
7
 *
4021
8
 * This program is distributed in the hope that it will be useful, but
4022
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4023
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4024
11
 * PURPOSE.  See the GNU General Public License for more details.
4025
12
 *
4026
13
 * You should have received a copy of the GNU General Public License along
4027
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4028
15
 */
4029
16
4030
17
#pragma once
4031
18
4032
19
#include "printer.h"
4033
20
4034
21
#include <string>
4035
22
4036
23
namespace unity {
4037
24
namespace indicator {
4038
25
namespace printers {
4039
26
4040
27
    struct Job {
4041
28
        // State to match ipp_jstate_t from cups.h
4042
29
        typedef enum {
4043
30
            PENDING = 3,
4044
31
            HELD,
4045
32
            PROCESSING,
4046
33
            STOPPED,
4047
34
            CANCELED,
4048
35
            ABORTED,
4049
36
            COMPLETED
4050
37
        } State;
4051
38
        State state = PENDING;
4052
39
4053
40
        uint32_t id = 0;
4054
41
        std::string name;
4055
42
        std::string state_reasons;
4056
43
        uint32_t impressions_completed = 0;
4057
44
4058
45
        Printer printer;
4059
46
    };
4060
47
4061
48
} // printers
4062
49
} // indicators
4063
50
} // unity
4064
0
51
4065
=== added file 'src/main.cpp'
4066
--- src/main.cpp	1970-01-01 00:00:00 +0000
4067
+++ src/main.cpp	2017-01-10 21:54:44 +0000
4068
@@ -0,0 +1,60 @@
4069
1
/*
4070
2
 * Copyright 2016-2017 Canonical Ltd.
4071
3
 *
4072
4
 * This program is free software: you can redistribute it and/or modify it
4073
5
 * under the terms of the GNU General Public License version 3, as published
4074
6
 * by the Free Software Foundation.
4075
7
 *
4076
8
 * This program is distributed in the hope that it will be useful, but
4077
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4078
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4079
11
 * PURPOSE.  See the GNU General Public License for more details.
4080
12
 *
4081
13
 * You should have received a copy of the GNU General Public License along
4082
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4083
15
 */
4084
16
4085
17
#include "actions-live.h"
4086
18
#include "cups-client.h"
4087
19
#include "exporter.h"
4088
20
#include "utils.h"
4089
21
4090
22
#include <glib/gi18n.h>
4091
23
#include <gio/gio.h>
4092
24
4093
25
using namespace unity::indicator::printers;
4094
26
4095
27
int main() {
4096
28
    // Work around a deadlock in glib's type initialization.
4097
29
    // It can be removed when https://bugzilla.gnome.org/show_bug.cgi?id=674885 is fixed.
4098
30
    g_type_ensure(G_TYPE_DBUS_CONNECTION);
4099
31
4100
32
    // boilerplate i18n
4101
33
    setlocale(LC_ALL, "");
4102
34
4103
35
    // Need to prepend $SNAP to properly load translations
4104
36
    auto localedir = Utilities::prepend_snap_path(GETTEXT_LOCALEDIR);
4105
37
    bindtextdomain(GETTEXT_PACKAGE, localedir.c_str());
4106
38
    textdomain(GETTEXT_PACKAGE);
4107
39
4108
40
    // set up us the machine
4109
41
    auto loop = g_main_loop_new(nullptr, false);
4110
42
4111
43
    // create the menus
4112
44
    auto actions = std::make_shared<LiveActions>();
4113
45
    auto client = std::make_shared<CupsClient>();
4114
46
4115
47
    // export them & run until we lose the busname
4116
48
    Exporter exporter;
4117
49
    exporter.name_lost().connect([loop](){
4118
50
        g_message("%s exiting; failed/lost bus ownership", GETTEXT_PACKAGE);
4119
51
        g_main_loop_quit(loop);
4120
52
    });
4121
53
    exporter.publish(actions, client);
4122
54
4123
55
    g_main_loop_run(loop);
4124
56
4125
57
    // cleanup
4126
58
    g_main_loop_unref(loop);
4127
59
    return 0;
4128
60
}
4129
0
61
4130
=== added file 'src/menu.cpp'
4131
--- src/menu.cpp	1970-01-01 00:00:00 +0000
4132
+++ src/menu.cpp	2017-01-10 21:54:44 +0000
4133
@@ -0,0 +1,291 @@
4134
1
/*
4135
2
 * Copyright 2016-2017 Canonical Ltd.
4136
3
 *
4137
4
 * This program is free software: you can redistribute it and/or modify it
4138
5
 * under the terms of the GNU General Public License version 3, as published
4139
6
 * by the Free Software Foundation.
4140
7
 *
4141
8
 * This program is distributed in the hope that it will be useful, but
4142
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4143
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4144
11
 * PURPOSE.  See the GNU General Public License for more details.
4145
12
 *
4146
13
 * You should have received a copy of the GNU General Public License along
4147
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4148
15
 */
4149
16
4150
17
#include "menu.h"
4151
18
4152
19
#include <glib/gi18n.h>
4153
20
#include <gio/gio.h>
4154
21
4155
22
#include <algorithm>
4156
23
#include <iterator>
4157
24
#include <map>
4158
25
4159
26
namespace unity {
4160
27
namespace indicator {
4161
28
namespace printers {
4162
29
4163
30
4164
31
class Menu::Impl
4165
32
{
4166
33
public:
4167
34
4168
35
    static constexpr char const * ATTRIBUTE_JOB_ID {"x-canonical-job-id"};
4169
36
    static constexpr char const * ATTRIBUTE_TYPE {"x-canonical-type"};
4170
37
    static constexpr char const * TYPE_SECTION {"section"};
4171
38
4172
39
    enum Section {
4173
40
        CURRENT,
4174
41
        QUEUED,
4175
42
        PAUSED,
4176
43
        NUM_SECTIONS
4177
44
    };
4178
45
4179
46
    Impl(const std::shared_ptr<Actions>& actions,
4180
47
         const std::shared_ptr<Client>& client):
4181
48
        m_actions(actions),
4182
49
        m_client(client)
4183
50
    {
4184
51
        // initialize the menu
4185
52
        create_gmenu();
4186
53
        update_header();
4187
54
4188
55
        m_client->job_state_changed().connect([this](const Job& job) {
4189
56
                const auto printer = job.printer;
4190
57
                g_debug("State changed for job %u '%s` on printer '%s'",
4191
58
                        job.id,
4192
59
                        job.name.c_str(),
4193
60
                        printer.description.empty() ? printer.name.c_str() : printer.description.c_str());
4194
61
4195
62
                // Remove any existing menu item for the job.
4196
63
                remove(job);
4197
64
4198
65
                Section section = NUM_SECTIONS;
4199
66
                switch (job.state) {
4200
67
                case Job::State::PENDING:
4201
68
                    section = QUEUED;
4202
69
                    break;
4203
70
                case Job::State::HELD:
4204
71
                    section = PAUSED;
4205
72
                    break;
4206
73
                case Job::State::PROCESSING:
4207
74
                    section = CURRENT;
4208
75
                    break;
4209
76
                case Job::State::STOPPED:
4210
77
                case Job::State::CANCELED:
4211
78
                case Job::State::ABORTED:
4212
79
                case Job::State::COMPLETED:
4213
80
                    update_header();
4214
81
                    return;
4215
82
                }
4216
83
4217
84
                auto model = menu_model_for_section(section);
4218
85
                if (model != nullptr) {
4219
86
                    auto item = create_job_menu_item(job);
4220
87
                    g_menu_append_item(G_MENU(model), item);
4221
88
                    g_object_unref(item);
4222
89
                    m_current_jobs[job.id] = section;
4223
90
                }
4224
91
4225
92
                update_header();
4226
93
            });
4227
94
    }
4228
95
4229
96
    virtual ~Impl()
4230
97
    {
4231
98
        g_clear_object(&m_menu);
4232
99
    }
4233
100
4234
101
    void update_header()
4235
102
    {
4236
103
        auto action_group = m_actions->action_group();
4237
104
        std::string action_name{"printers"};
4238
105
        auto state = create_header_state();
4239
106
        g_action_group_change_action_state(action_group,
4240
107
                                           action_name.c_str(),
4241
108
                                           state);
4242
109
    }
4243
110
4244
111
    GVariant* get_serialized_icon(const std::string& icon_name)
4245
112
    {
4246
113
        auto icon = g_themed_icon_new_with_default_fallbacks(icon_name.c_str());
4247
114
        auto ret = g_icon_serialize(icon);
4248
115
        g_object_unref(icon);
4249
116
4250
117
        return ret;
4251
118
    }
4252
119
4253
120
    GVariant* create_header_state()
4254
121
    {
4255
122
        auto title_v = g_variant_new_string(_("Printing"));
4256
123
        const bool visible = !m_current_jobs.empty();
4257
124
        GVariantBuilder b;
4258
125
        g_variant_builder_init(&b, G_VARIANT_TYPE_VARDICT);
4259
126
        g_variant_builder_add(&b, "{sv}", "title", title_v);
4260
127
        g_variant_builder_add(&b, "{sv}", "accessible-desc", title_v);
4261
128
        g_variant_builder_add(&b, "{sv}", "icon", get_serialized_icon("printer-symbolic"));
4262
129
        g_variant_builder_add(&b, "{sv}", "visible", g_variant_new_boolean(visible));
4263
130
        return g_variant_builder_end(&b);
4264
131
    }
4265
132
4266
133
    GMenuModel* menu_model()
4267
134
    {
4268
135
        return G_MENU_MODEL(m_menu);
4269
136
    }
4270
137
4271
138
    GMenuModel* menu_model_for_section(Section section)
4272
139
    {
4273
140
        return g_menu_model_get_item_link(G_MENU_MODEL(m_submenu),
4274
141
                                          section,
4275
142
                                          G_MENU_LINK_SECTION);
4276
143
    }
4277
144
4278
145
    void remove(const Job& job)
4279
146
    {
4280
147
        Section section = NUM_SECTIONS;
4281
148
        if(get_current_section_for_job(job, section)) {
4282
149
            auto model = menu_model_for_section(section);
4283
150
            auto value = g_variant_new_uint32(job.id);
4284
151
            auto pos = find_matching_menu_item(model, ATTRIBUTE_JOB_ID, value);
4285
152
4286
153
            if (pos >= 0) {
4287
154
                g_menu_remove(G_MENU(model), pos);
4288
155
                m_current_jobs.erase(job.id);
4289
156
            }
4290
157
        }
4291
158
    }
4292
159
4293
160
private:
4294
161
    std::shared_ptr<Actions> m_actions;
4295
162
    std::shared_ptr<Client> m_client;
4296
163
    std::map<uint32_t, Section> m_current_jobs;
4297
164
4298
165
    GMenu* m_submenu = nullptr;
4299
166
    GMenu* m_menu = nullptr;
4300
167
4301
168
    static GMenuItem* create_section_menu_item(const Section& section)
4302
169
    {
4303
170
        const char* label;
4304
171
        switch (section) {
4305
172
        case CURRENT:
4306
173
            label = _("Current jobs");
4307
174
            break;
4308
175
        case QUEUED:
4309
176
            label = _("Queued jobs");
4310
177
            break;
4311
178
        case PAUSED:
4312
179
            label = _("Paused jobs");
4313
180
            break;
4314
181
        default:
4315
182
            g_warning("Request for section title of unknown section: %u",
4316
183
                      static_cast<uint32_t>(section));
4317
184
            return nullptr;
4318
185
        }
4319
186
4320
187
        // create a new item
4321
188
        auto item = g_menu_item_new(label, "indicator.section");
4322
189
        g_menu_item_set_attribute(item, ATTRIBUTE_TYPE, "s", TYPE_SECTION);
4323
190
4324
191
        return item;
4325
192
    }
4326
193
4327
194
    // Create the GMenuItem for the job.
4328
195
    static GMenuItem* create_job_menu_item(const Job& job)
4329
196
    {
4330
197
        auto menu_item = g_menu_item_new(job.name.c_str(), nullptr);
4331
198
        g_menu_item_set_attribute(menu_item, ATTRIBUTE_JOB_ID, "u", job.id);
4332
199
4333
200
        return menu_item;
4334
201
    }
4335
202
4336
203
    // find the position of the menumodel's item with the specified attribute
4337
204
    static int find_matching_menu_item(GMenuModel* mm, const char* attr,
4338
205
                                       GVariant* value)
4339
206
    {
4340
207
        g_return_val_if_fail(value != nullptr, -1);
4341
208
4342
209
        for (int i = 0, n = g_menu_model_get_n_items(mm); i < n; ++i) {
4343
210
            auto test = g_menu_model_get_item_attribute_value(mm,
4344
211
                                                              i,
4345
212
                                                              attr,
4346
213
                                                              nullptr);
4347
214
            const bool equal = g_variant_equal(value, test);
4348
215
            g_clear_pointer(&test, g_variant_unref);
4349
216
            if (equal) {
4350
217
                return i;
4351
218
            }
4352
219
        }
4353
220
4354
221
        return -1;
4355
222
    }
4356
223
4357
224
    bool get_current_section_for_job(const Job& job, Section& section) const
4358
225
    {
4359
226
        const auto it = m_current_jobs.find(job.id);
4360
227
        if (it == m_current_jobs.end()) {
4361
228
            return false;
4362
229
        }
4363
230
4364
231
        section = it->second;
4365
232
        return true;
4366
233
    }
4367
234
4368
235
    void create_gmenu()
4369
236
    {
4370
237
        g_assert(m_submenu == nullptr);
4371
238
4372
239
        // build the submenu
4373
240
        m_submenu = g_menu_new();
4374
241
        for(int i = 0; i < NUM_SECTIONS; i++) {
4375
242
            // Create the section menu
4376
243
            auto section = g_menu_new();
4377
244
            g_menu_append_section(m_submenu, nullptr, G_MENU_MODEL(section));
4378
245
4379
246
            // Add the label menuitem for the section
4380
247
            auto item = create_section_menu_item(static_cast<Section>(i));
4381
248
            if (item != nullptr) {
4382
249
                g_menu_insert_item(section, 0, item);
4383
250
                g_clear_object(&item);
4384
251
            }
4385
252
4386
253
            g_object_unref(section);
4387
254
        }
4388
255
4389
256
        // add submenu to the header
4390
257
        const std::string detailed_action{"indicator.printers"};
4391
258
        auto header = g_menu_item_new(nullptr, detailed_action.c_str());
4392
259
        g_menu_item_set_attribute(header, "x-canonical-type", "s",
4393
260
                                  "com.canonical.indicator.root");
4394
261
        g_menu_item_set_submenu(header, G_MENU_MODEL(m_submenu));
4395
262
        g_object_unref(m_submenu);
4396
263
4397
264
        // add header to the menu
4398
265
        m_menu = g_menu_new();
4399
266
        g_menu_append_item(m_menu, header);
4400
267
        g_object_unref(header);
4401
268
    }
4402
269
4403
270
4404
271
}; // class MenuImpl
4405
272
4406
273
4407
274
Menu::Menu(const std::shared_ptr<Actions>& actions,
4408
275
           const std::shared_ptr<Client>& client):
4409
276
    p(new Impl(actions, client))
4410
277
{
4411
278
}
4412
279
4413
280
Menu::~Menu()
4414
281
{
4415
282
}
4416
283
4417
284
GMenuModel* Menu::menu_model()
4418
285
{
4419
286
    return p->menu_model();
4420
287
}
4421
288
4422
289
} // namespace printers
4423
290
} // namespace indicator
4424
291
} // namespace unity
4425
0
292
4426
=== added file 'src/menu.h'
4427
--- src/menu.h	1970-01-01 00:00:00 +0000
4428
+++ src/menu.h	2017-01-10 21:54:44 +0000
4429
@@ -0,0 +1,57 @@
4430
1
/*
4431
2
 * Copyright 2016-2017 Canonical Ltd.
4432
3
 *
4433
4
 * This program is free software: you can redistribute it and/or modify it
4434
5
 * under the terms of the GNU General Public License version 3, as published
4435
6
 * by the Free Software Foundation.
4436
7
 *
4437
8
 * This program is distributed in the hope that it will be useful, but
4438
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4439
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4440
11
 * PURPOSE.  See the GNU General Public License for more details.
4441
12
 *
4442
13
 * You should have received a copy of the GNU General Public License along
4443
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4444
15
 */
4445
16
4446
17
#pragma once
4447
18
4448
19
#include "actions.h"
4449
20
#include "client.h"
4450
21
4451
22
#include <memory> // std::shared_ptr
4452
23
#include <vector>
4453
24
4454
25
#include <gio/gio.h> // GMenuModel
4455
26
4456
27
namespace unity {
4457
28
namespace indicator {
4458
29
namespace printers {
4459
30
4460
31
/**
4461
32
 * \brief A menu for a specific profile; eg, Desktop or Phone.
4462
33
 *
4463
34
 * @see MenuFactory
4464
35
 * @see Exporter
4465
36
 */
4466
37
class Menu
4467
38
{
4468
39
public:
4469
40
    Menu(const std::shared_ptr<Actions>& actions,
4470
41
         const std::shared_ptr<Client>& client);
4471
42
    virtual ~Menu();
4472
43
4473
44
    GMenuModel* menu_model();
4474
45
4475
46
private:
4476
47
    class Impl;
4477
48
    std::unique_ptr<Impl> p;
4478
49
4479
50
    // disable copying 
4480
51
    Menu(const Menu&) = delete; 
4481
52
    Menu& operator=(const Menu&) = delete; 
4482
53
};
4483
54
4484
55
} // namespace printers
4485
56
} // namespace indicator
4486
57
} // namespace unity
4487
0
58
4488
=== added file 'src/printer.h'
4489
--- src/printer.h	1970-01-01 00:00:00 +0000
4490
+++ src/printer.h	2017-01-10 21:54:44 +0000
4491
@@ -0,0 +1,44 @@
4492
1
/*
4493
2
 * Copyright 2016-2017 Canonical Ltd.
4494
3
 *
4495
4
 * This program is free software: you can redistribute it and/or modify it
4496
5
 * under the terms of the GNU General Public License version 3, as published
4497
6
 * by the Free Software Foundation.
4498
7
 *
4499
8
 * This program is distributed in the hope that it will be useful, but
4500
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4501
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4502
11
 * PURPOSE.  See the GNU General Public License for more details.
4503
12
 *
4504
13
 * You should have received a copy of the GNU General Public License along
4505
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4506
15
 */
4507
16
4508
17
#pragma once
4509
18
4510
19
#include <string>
4511
20
4512
21
namespace unity {
4513
22
namespace indicator {
4514
23
namespace printers {
4515
24
4516
25
    struct Printer {
4517
26
        // State to match ipp_jstate_t from cups.h
4518
27
        typedef enum {
4519
28
            IDLE = 3,
4520
29
            PROCESSING,
4521
30
            STOPPED
4522
31
        } State;
4523
32
        State state = IDLE;
4524
33
4525
34
        std::string name;
4526
35
        std::string description;
4527
36
        std::string text;
4528
37
        std::string uri;
4529
38
        std::string state_reasons;
4530
39
        bool accepting_jobs = false;
4531
40
    };
4532
41
4533
42
} // printers
4534
43
} // indicators
4535
44
} // unity
4536
0
45
4537
=== removed file 'src/spawn-printer-settings.c'
4538
--- src/spawn-printer-settings.c	2012-02-15 10:40:19 +0000
4539
+++ src/spawn-printer-settings.c	1970-01-01 00:00:00 +0000
4540
@@ -1,35 +0,0 @@
4541
1
4542
2
#include "spawn-printer-settings.h"
4543
3
4544
4
void
4545
5
spawn_printer_settings ()
4546
6
{
4547
7
    spawn_printer_settings_with_args (NULL);
4548
8
}
4549
9
4550
10
4551
11
void
4552
12
spawn_printer_settings_with_args (const gchar *fmt,
4553
13
                                  ...)
4554
14
{
4555
15
    GString *cmdline;
4556
16
    GError *err = NULL;
4557
17
4558
18
    cmdline = g_string_new ("system-config-printer ");
4559
19
4560
20
    if (fmt) {
4561
21
        va_list args;
4562
22
        va_start (args, fmt);
4563
23
        g_string_append_vprintf (cmdline, fmt, args);
4564
24
        va_end (args);
4565
25
    }
4566
26
4567
27
    g_spawn_command_line_async (cmdline->str, &err);
4568
28
    if (err) {
4569
29
        g_warning ("Could not spawn printer settings: %s", err->message);
4570
30
        g_error_free (err);
4571
31
    }
4572
32
4573
33
    g_string_free (cmdline, TRUE);
4574
34
}
4575
35
4576
36
0
4577
=== removed file 'src/spawn-printer-settings.h'
4578
--- src/spawn-printer-settings.h	2012-02-12 13:58:57 +0000
4579
+++ src/spawn-printer-settings.h	1970-01-01 00:00:00 +0000
4580
@@ -1,11 +0,0 @@
4581
1
4582
2
#ifndef SPAWN_PRINTER_SETTINGS_H
4583
3
#define SPAWN_PRINTER_SETTINGS_H
4584
4
4585
5
#include <glib.h>
4586
6
4587
7
void spawn_printer_settings ();
4588
8
void spawn_printer_settings_with_args (const gchar *args, ...);
4589
9
4590
10
#endif
4591
11
4592
12
0
4593
=== added file 'src/utils.cpp'
4594
--- src/utils.cpp	1970-01-01 00:00:00 +0000
4595
+++ src/utils.cpp	2017-01-10 21:54:44 +0000
4596
@@ -0,0 +1,37 @@
4597
1
/*
4598
2
 * Copyright 2016-2017 Canonical Ltd.
4599
3
 *
4600
4
 * This program is free software: you can redistribute it and/or modify it
4601
5
 * under the terms of the GNU General Public License version 3, as published
4602
6
 * by the Free Software Foundation.
4603
7
 *
4604
8
 * This program is distributed in the hope that it will be useful, but
4605
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4606
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4607
11
 * PURPOSE.  See the GNU General Public License for more details.
4608
12
 *
4609
13
 * You should have received a copy of the GNU General Public License along
4610
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4611
15
 */
4612
16
4613
17
#include "utils.h"
4614
18
4615
19
namespace unity {
4616
20
namespace indicator {
4617
21
namespace printers {
4618
22
4619
23
std::string Utilities::prepend_snap_path(const std::string& path)
4620
24
{
4621
25
    auto get_snap_path = []() {
4622
26
        const char* env_snap = getenv("SNAP");
4623
27
        if (env_snap == nullptr) {
4624
28
            return "";
4625
29
        }
4626
30
        return env_snap;
4627
31
    };
4628
32
    return get_snap_path() + path;
4629
33
}
4630
34
4631
35
} // printers
4632
36
} // indicators
4633
37
} // unity
4634
0
38
4635
=== added file 'src/utils.h'
4636
--- src/utils.h	1970-01-01 00:00:00 +0000
4637
+++ src/utils.h	2017-01-10 21:54:44 +0000
4638
@@ -0,0 +1,32 @@
4639
1
/*
4640
2
 * Copyright 2016-2017 Canonical Ltd.
4641
3
 *
4642
4
 * This program is free software: you can redistribute it and/or modify it
4643
5
 * under the terms of the GNU General Public License version 3, as published
4644
6
 * by the Free Software Foundation.
4645
7
 *
4646
8
 * This program is distributed in the hope that it will be useful, but
4647
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4648
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4649
11
 * PURPOSE.  See the GNU General Public License for more details.
4650
12
 *
4651
13
 * You should have received a copy of the GNU General Public License along
4652
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4653
15
 */
4654
16
4655
17
#pragma once
4656
18
4657
19
#include <string>
4658
20
4659
21
namespace unity {
4660
22
namespace indicator {
4661
23
namespace printers {
4662
24
4663
25
    class Utilities {
4664
26
    public:
4665
27
        static std::string prepend_snap_path(const std::string& path);
4666
28
    };
4667
29
4668
30
} // printers
4669
31
} // indicators
4670
32
} // unity
4671
0
33
4672
=== removed directory 'test'
4673
=== removed file 'test/Makefile.am'
4674
--- test/Makefile.am	2012-02-16 18:45:24 +0000
4675
+++ test/Makefile.am	1970-01-01 00:00:00 +0000
4676
@@ -1,29 +0,0 @@
4677
1
4678
2
noinst_PROGRAMS = mock-cups-notifier
4679
3
DISTCLEANFILES = mock-cups-notifier
4680
4
4681
5
cups_notifier_sources = \
4682
6
	cups-notifier.c \
4683
7
	cups-notifier.h
4684
8
4685
9
$(cups_notifier_sources): $(top_srcdir)/src/org.cups.cupsd.Notifier.xml
4686
10
	gdbus-codegen \
4687
11
	    --interface-prefix org.cups.cupsd \
4688
12
	    --c-namespace Cups \
4689
13
	    --generate-c-code cups-notifier \
4690
14
	    $^
4691
15
4692
16
mock_cups_notifier_SOURCES = \
4693
17
	mock-cups-notifier.c
4694
18
4695
19
nodist_mock_cups_notifier_SOURCES = $(cups_notifier_sources)
4696
20
4697
21
mock_cups_notifier_CPPFLAGS = \
4698
22
	$(SERVICE_CFLAGS) \
4699
23
	-I$(top_builddir)/src
4700
24
4701
25
mock_cups_notifier_LDADD = $(SERVICE_LIBS)
4702
26
4703
27
BUILT_SOURCES = $(cups_notifier_sources)
4704
28
CLEANFILES = $(BUILT_SOURCES)
4705
29
4706
30
0
4707
=== removed file 'test/mock-cups-notifier.c'
4708
--- test/mock-cups-notifier.c	2012-02-09 17:19:57 +0000
4709
+++ test/mock-cups-notifier.c	1970-01-01 00:00:00 +0000
4710
@@ -1,52 +0,0 @@
4711
1
4712
2
#include <glib.h>
4713
3
#include <cups-notifier.h>
4714
4
4715
5
4716
6
int main (int argc, char **argv)
4717
7
{
4718
8
    GMainLoop *loop;
4719
9
    CupsNotifier *notifier;
4720
10
    GDBusConnection *con;
4721
11
    GError *error = NULL;
4722
12
4723
13
    g_type_init ();
4724
14
4725
15
    loop = g_main_loop_new (NULL, FALSE);
4726
16
4727
17
    con = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
4728
18
    if (error) {
4729
19
        g_printerr ("Error getting system bus: %s\n", error->message);
4730
20
        g_error_free (error);
4731
21
        goto out;
4732
22
    }
4733
23
4734
24
    notifier = cups_notifier_skeleton_new ();
4735
25
4736
26
    g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (notifier),
4737
27
                                      con,
4738
28
                                      "/org/cups/cupsd/Notifier",
4739
29
                                      &error);
4740
30
    if (error) {
4741
31
        g_printerr ("Error exporting cups Notifier object: %s\n", error->message);
4742
32
        g_error_free (error);
4743
33
        goto out;
4744
34
    }
4745
35
4746
36
    cups_notifier_emit_printer_state_changed (notifier,
4747
37
                                              "Printer state changed!",
4748
38
                                              "file:///tmp/print",
4749
39
                                              "hp-LaserJet-1012",
4750
40
                                              5,
4751
41
                                              "toner-low",
4752
42
                                              FALSE);
4753
43
4754
44
    g_main_context_iteration (NULL, FALSE);
4755
45
4756
46
out:
4757
47
    g_clear_object (&notifier);
4758
48
    g_clear_object (&con);
4759
49
    g_main_loop_unref (loop);
4760
50
    return 0;
4761
51
}
4762
52
4763
53
0
4764
=== added directory 'tests'
4765
=== added file 'tests/CMakeLists.txt'
4766
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
4767
+++ tests/CMakeLists.txt	2017-01-10 21:54:44 +0000
4768
@@ -0,0 +1,26 @@
4769
1
find_package(GMock REQUIRED)
4770
2
4771
3
include_directories(
4772
4
  ${CMAKE_SOURCE_DIR}/src
4773
5
  ${SERVICE_DEPS_INCLUDE_DIRS}
4774
6
)
4775
7
link_directories(
4776
8
  ${SERVICE_DEPS_LIBRARY_DIRS}
4777
9
)
4778
10
4779
11
add_executable(test-libindicator-printers
4780
12
  test_exporter.cpp
4781
13
  test_menu.cpp
4782
14
  test_utils.cpp
4783
15
)
4784
16
target_link_libraries(test-libindicator-printers
4785
17
  ${SERVICE_LIB_NAME}
4786
18
  ${SERVICE_DEPS_LIBRARIES}
4787
19
  ${CUPS_LIBS}
4788
20
4789
21
  ${GTEST_LIBRARIES}
4790
22
  ${GMOCK_LIBRARIES}
4791
23
4792
24
  ${CMAKE_THREAD_LIBS_INIT}
4793
25
)
4794
26
add_test(test-libindicator-printers test-libindicator-printers)
4795
0
27
4796
=== added file 'tests/actions-mock.h'
4797
--- tests/actions-mock.h	1970-01-01 00:00:00 +0000
4798
+++ tests/actions-mock.h	2017-01-10 21:54:44 +0000
4799
@@ -0,0 +1,36 @@
4800
1
/*
4801
2
 * Copyright 2016-2017 Canonical Ltd.
4802
3
 *
4803
4
 * This program is free software: you can redistribute it and/or modify it
4804
5
 * under the terms of the GNU General Public License version 3, as published
4805
6
 * by the Free Software Foundation.
4806
7
 *
4807
8
 * This program is distributed in the hope that it will be useful, but
4808
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4809
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4810
11
 * PURPOSE.  See the GNU General Public License for more details.
4811
12
 *
4812
13
 * You should have received a copy of the GNU General Public License along
4813
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4814
15
 */
4815
16
4816
17
#pragma once
4817
18
4818
19
#include "actions.h"
4819
20
4820
21
namespace unity {
4821
22
namespace indicator {
4822
23
namespace printers {
4823
24
4824
25
    class MockActions: public Actions
4825
26
    {
4826
27
    public:
4827
28
        explicit MockActions(): Actions() {}
4828
29
        ~MockActions() = default;
4829
30
4830
31
        void open_settings_app() {}
4831
32
    };
4832
33
4833
34
} // printers
4834
35
} // indicator
4835
36
} // unity
4836
0
37
4837
=== added file 'tests/client-mock.h'
4838
--- tests/client-mock.h	1970-01-01 00:00:00 +0000
4839
+++ tests/client-mock.h	2017-01-10 21:54:44 +0000
4840
@@ -0,0 +1,54 @@
4841
1
/*
4842
2
 * Copyright 2016-2017 Canonical Ltd.
4843
3
 *
4844
4
 * This program is free software: you can redistribute it and/or modify it
4845
5
 * under the terms of the GNU General Public License version 3, as published
4846
6
 * by the Free Software Foundation.
4847
7
 *
4848
8
 * This program is distributed in the hope that it will be useful, but
4849
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4850
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4851
11
 * PURPOSE.  See the GNU General Public License for more details.
4852
12
 *
4853
13
 * You should have received a copy of the GNU General Public License along
4854
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4855
15
 */
4856
16
4857
17
#pragma once
4858
18
4859
19
#include "client.h"
4860
20
4861
21
#include <core/signal.h>
4862
22
#include <gmock/gmock.h>
4863
23
4864
24
namespace unity {
4865
25
namespace indicator {
4866
26
namespace printers {
4867
27
4868
28
    class MockClient: public Client
4869
29
    {
4870
30
    public:
4871
31
        explicit MockClient(): Client() {}
4872
32
        ~MockClient() = default;
4873
33
4874
34
        core::Signal<const Printer&>& printer_state_changed()
4875
35
        {
4876
36
            return m_printer_state_changed;
4877
37
        }
4878
38
        core::Signal<const Job&>& job_state_changed()
4879
39
        {
4880
40
            return m_job_state_changed;
4881
41
        }
4882
42
4883
43
        MOCK_METHOD0(create_subscription, void());
4884
44
        MOCK_METHOD0(renew_subscription, void());
4885
45
        MOCK_METHOD0(cancel_subscription, void());
4886
46
        MOCK_METHOD0(refresh, void());
4887
47
4888
48
        core::Signal<const Printer&> m_printer_state_changed;
4889
49
        core::Signal<const Job&> m_job_state_changed;
4890
50
    };
4891
51
4892
52
} // printers
4893
53
} // indicator
4894
54
} // unity
4895
0
55
4896
=== added file 'tests/glib-fixture.h'
4897
--- tests/glib-fixture.h	1970-01-01 00:00:00 +0000
4898
+++ tests/glib-fixture.h	2017-01-10 21:54:44 +0000
4899
@@ -0,0 +1,220 @@
4900
1
/*
4901
2
 * Copyright 2013-2016-2017 Canonical Ltd.
4902
3
 *
4903
4
 * This program is free software: you can redistribute it and/or modify it
4904
5
 * under the terms of the GNU General Public License version 3, as published
4905
6
 * by the Free Software Foundation.
4906
7
 *
4907
8
 * This program is distributed in the hope that it will be useful, but
4908
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
4909
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
4910
11
 * PURPOSE.  See the GNU General Public License for more details.
4911
12
 *
4912
13
 * You should have received a copy of the GNU General Public License along
4913
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
4914
15
 */
4915
16
4916
17
#pragma once
4917
18
4918
19
#include <chrono>
4919
20
#include <functional> // std::function
4920
21
#include <map>
4921
22
#include <memory> // std::shared_ptr
4922
23
4923
24
#include <glib.h>
4924
25
#include <glib/gstdio.h>
4925
26
#include <gio/gio.h>
4926
27
4927
28
#include <gtest/gtest.h>
4928
29
4929
30
#include <locale.h> // setlocale()
4930
31
4931
32
class GlibFixture : public ::testing::Test
4932
33
{
4933
34
  public:
4934
35
4935
36
    virtual ~GlibFixture() =default;
4936
37
4937
38
  protected:
4938
39
4939
40
    virtual void SetUp() override
4940
41
    {
4941
42
      setlocale(LC_ALL, "C.UTF-8");
4942
43
4943
44
      loop = g_main_loop_new(nullptr, false);
4944
45
4945
46
      // fail on unexpected messages from this domain
4946
47
      g_log_set_fatal_mask(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING);
4947
48
4948
49
      g_unsetenv("DISPLAY");
4949
50
4950
51
    }
4951
52
4952
53
    virtual void TearDown() override
4953
54
    {
4954
55
      g_test_assert_expected_messages ();
4955
56
4956
57
      g_clear_pointer(&loop, g_main_loop_unref);
4957
58
    }
4958
59
4959
60
    void expectLogMessage (const gchar *domain, GLogLevelFlags level, const gchar *pattern)
4960
61
    {
4961
62
      g_test_expect_message (domain, level, pattern);
4962
63
    }
4963
64
4964
65
  private:
4965
66
4966
67
    static gboolean
4967
68
    wait_for_signal__timeout(gpointer name)
4968
69
    {
4969
70
      g_error("%s: timed out waiting for signal '%s'", G_STRLOC, (char*)name);
4970
71
      return G_SOURCE_REMOVE;
4971
72
    }
4972
73
4973
74
    static gboolean
4974
75
    wait_msec__timeout(gpointer loop)
4975
76
    {
4976
77
      g_main_loop_quit(static_cast<GMainLoop*>(loop));
4977
78
      return G_SOURCE_CONTINUE;
4978
79
    }
4979
80
4980
81
  protected:
4981
82
4982
83
    /* convenience func to loop while waiting for a GObject's signal */
4983
84
    void wait_for_signal(gpointer o, const gchar * signal, const int timeout_seconds=5)
4984
85
    {
4985
86
      // wait for the signal or for timeout, whichever comes first
4986
87
      const auto handler_id = g_signal_connect_swapped(o, signal,
4987
88
                                                       G_CALLBACK(g_main_loop_quit),
4988
89
                                                       loop);
4989
90
      const auto timeout_id = g_timeout_add_seconds(timeout_seconds,
4990
91
                                                    wait_for_signal__timeout,
4991
92
                                                    loop);
4992
93
      g_main_loop_run(loop);
4993
94
      g_source_remove(timeout_id);
4994
95
      g_signal_handler_disconnect(o, handler_id);
4995
96
    }
4996
97
4997
98
    /* convenience func to loop for N msec */
4998
99
    void wait_msec(int msec=50)
4999
100
    {
5000
101
      const auto id = g_timeout_add(msec, wait_msec__timeout, loop);
Status:	Rejected
Rejected by:	dobey on 2017-01-13
Proposed branch:	lp:~dobey/indicator-printers/cpp-refactor
Merge into:	lp:indicator-printers
Diff against target:	5377 lines (+3048/-2007) 57 files modified .bzrignore (+2/-0) AUTHORS (+0/-2) CMakeLists.txt (+54/-0) COPYING (+674/-0) Makefile.am (+0/-6) Makefile.am.coverage (+0/-48) autogen.sh (+0/-9) cmake/GdbusCodegen.cmake (+36/-0) configure.ac (+0/-105) data/CMakeLists.txt (+64/-0) data/Makefile.am (+0/-55) data/com.canonical.indicator.printers (+20/-0) data/indicator-printers.desktop.in (+0/-8) data/upstart/Makefile.am (+0/-17) data/upstart/indicator-printers.desktop.in (+0/-9) debian/control (+17/-20) debian/copyright (+1/-2) debian/rules (+1/-16) debian/watch (+0/-2) m4/gcov.m4 (+0/-86) po/CMakeLists.txt (+12/-0) po/POTFILES.in (+0/-6) src/CMakeLists.txt (+62/-0) src/actions-live.cpp (+104/-0) src/actions-live.h (+54/-0) src/actions.cpp (+73/-0) src/actions.h (+57/-0) src/client.h (+56/-0) src/cups-client.cpp (+328/-0) src/cups-client.h (+65/-0) src/exporter.cpp (+158/-0) src/exporter.h (+60/-0) src/indicator-menu-item.c (+0/-404) src/indicator-menu-item.h (+0/-82) src/indicator-printers-menu.c (+0/-339) src/indicator-printers-menu.h (+0/-77) src/indicator-printers-service.c (+0/-206) src/indicator-printers.c (+0/-311) src/indicator-printers.h (+0/-70) src/job.h (+50/-0) src/main.cpp (+60/-0) src/menu.cpp (+291/-0) src/menu.h (+57/-0) src/printer.h (+44/-0) src/spawn-printer-settings.c (+0/-35) src/spawn-printer-settings.h (+0/-11) src/utils.cpp (+37/-0) src/utils.h (+32/-0) test/Makefile.am (+0/-29) test/mock-cups-notifier.c (+0/-52) tests/CMakeLists.txt (+26/-0) tests/actions-mock.h (+36/-0) tests/client-mock.h (+54/-0) tests/glib-fixture.h (+220/-0) tests/test_exporter.cpp (+110/-0) tests/test_menu.cpp (+100/-0) tests/test_utils.cpp (+33/-0)
To merge this branch:	bzr merge lp:~dobey/indicator-printers/cpp-refactor
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
unity-api-1-bot	continuous-integration		Approve on 2017-01-11
Charles Kerr (community)		2017-01-04	Approve on 2017-01-11
Review via email: mp+314115@code.launchpad.net