1 #ifdef HAVE_CONFIG_H
2 #include "config.h"
3 #endif
4
5 #include <string>
6 #include <list>
7 #include <map>
8 #include <deque>
9
10 #include <stdlib.h>
11 #include <gio/gio.h>
12
13 #include "dbus/DBusBindingGio.hh"
14 #include "dbus/DBusException.hh"
15 #include "DBusGUI.hh"
16
17 using namespace std;
18 using namespace workrave::dbus;
19
20 class DBusGUI_Marshall : public DBusMarshallGio
21 {
22 public:
23 void get_operation_mode(GVariant *variant, OperationMode *result);
24 GVariant *put_operation_mode(const OperationMode *result);
25
26 void get_TimerData(GVariant *variant, GenericDBusApplet::TimerData *result);
27 GVariant *put_TimerData(const GenericDBusApplet::TimerData *result);
28 void get_MenuItem(GVariant *variant, GenericDBusApplet::MenuItem *result);
29 GVariant *put_MenuItem(const GenericDBusApplet::MenuItem *result);
30
31 void get_MenuItems(GVariant *variant, GenericDBusApplet::MenuItems *result);
32 GVariant *put_MenuItems(const GenericDBusApplet::MenuItems *result);
33
34 };
35
36
37 void
get_operation_mode(GVariant * variant,OperationMode * result)38 DBusGUI_Marshall::get_operation_mode(GVariant *variant, OperationMode *result)
39 {
40 std::string value;
41 get_string(variant, &value);
42
43 if("normal" == value)
44 {
45 *result = OPERATION_MODE_NORMAL;
46 }
47 else if("suspended" == value)
48 {
49 *result = OPERATION_MODE_SUSPENDED;
50 }
51 else if("quiet" == value)
52 {
53 *result = OPERATION_MODE_QUIET;
54 }
55 else
56 {
57 throw DBusRemoteException()
58 << message_info("Type error in enum")
59 << error_code_info(DBUS_ERROR_INVALID_ARGS)
60 << actual_type_info("operation_mode");
61 }
62 }
63
64 GVariant *
put_operation_mode(const OperationMode * result)65 DBusGUI_Marshall::put_operation_mode(const OperationMode *result)
66 {
67 string value;
68 switch (*result)
69 {
70 case OPERATION_MODE_NORMAL:
71 value = "normal";
72 break;
73 case OPERATION_MODE_SUSPENDED:
74 value = "suspended";
75 break;
76 case OPERATION_MODE_QUIET:
77 value = "quiet";
78 break;
79 default:
80 throw DBusRemoteException()
81 << message_info("Type error in enum")
82 << error_code_info(DBUS_ERROR_INVALID_ARGS)
83 << actual_type_info("operation_mode");
84 }
85
86 return put_string(&value);
87 }
88
89
90
91 void
get_TimerData(GVariant * variant,GenericDBusApplet::TimerData * result)92 DBusGUI_Marshall::get_TimerData(GVariant *variant, GenericDBusApplet::TimerData *result)
93 {
94
95 gsize num_fields = g_variant_n_children(variant);
96 if (num_fields != 8)
97 {
98 throw DBusRemoteException()
99 << message_info("Incorrect number of member in struct")
100 << error_code_info(DBUS_ERROR_INVALID_ARGS)
101 << actual_type_info("TimerData");
102 }
103
104 GVariant *v_bar_text = g_variant_get_child_value(variant, 0);
105 get_string(v_bar_text, &result->bar_text);
106 GVariant *v_slot = g_variant_get_child_value(variant, 1);
107 get_int(v_slot, &result->slot);
108 GVariant *v_bar_secondary_color = g_variant_get_child_value(variant, 2);
109 get_uint32(v_bar_secondary_color, &result->bar_secondary_color);
110 GVariant *v_bar_secondary_val = g_variant_get_child_value(variant, 3);
111 get_uint32(v_bar_secondary_val, &result->bar_secondary_val);
112 GVariant *v_bar_secondary_max = g_variant_get_child_value(variant, 4);
113 get_uint32(v_bar_secondary_max, &result->bar_secondary_max);
114 GVariant *v_bar_primary_color = g_variant_get_child_value(variant, 5);
115 get_uint32(v_bar_primary_color, &result->bar_primary_color);
116 GVariant *v_bar_primary_val = g_variant_get_child_value(variant, 6);
117 get_uint32(v_bar_primary_val, &result->bar_primary_val);
118 GVariant *v_bar_primary_max = g_variant_get_child_value(variant, 7);
119 get_uint32(v_bar_primary_max, &result->bar_primary_max);
120
121 g_variant_unref(v_bar_text);
122 g_variant_unref(v_slot);
123 g_variant_unref(v_bar_secondary_color);
124 g_variant_unref(v_bar_secondary_val);
125 g_variant_unref(v_bar_secondary_max);
126 g_variant_unref(v_bar_primary_color);
127 g_variant_unref(v_bar_primary_val);
128 g_variant_unref(v_bar_primary_max);
129 }
130
131 GVariant *
put_TimerData(const GenericDBusApplet::TimerData * result)132 DBusGUI_Marshall::put_TimerData(const GenericDBusApplet::TimerData *result)
133 {
134 GVariantBuilder builder;
135 g_variant_builder_init(&builder, (GVariantType *)"(siuuuuuu)");
136
137 GVariant *v;
138 v = put_string(&(result->bar_text));
139 g_variant_builder_add_value(&builder, v);
140 v = put_int(&(result->slot));
141 g_variant_builder_add_value(&builder, v);
142 v = put_uint32(&(result->bar_secondary_color));
143 g_variant_builder_add_value(&builder, v);
144 v = put_uint32(&(result->bar_secondary_val));
145 g_variant_builder_add_value(&builder, v);
146 v = put_uint32(&(result->bar_secondary_max));
147 g_variant_builder_add_value(&builder, v);
148 v = put_uint32(&(result->bar_primary_color));
149 g_variant_builder_add_value(&builder, v);
150 v = put_uint32(&(result->bar_primary_val));
151 g_variant_builder_add_value(&builder, v);
152 v = put_uint32(&(result->bar_primary_max));
153 g_variant_builder_add_value(&builder, v);
154
155 return g_variant_builder_end(&builder);
156 }
157
158
159 void
get_MenuItem(GVariant * variant,GenericDBusApplet::MenuItem * result)160 DBusGUI_Marshall::get_MenuItem(GVariant *variant, GenericDBusApplet::MenuItem *result)
161 {
162
163 gsize num_fields = g_variant_n_children(variant);
164 if (num_fields != 3)
165 {
166 throw DBusRemoteException()
167 << message_info("Incorrect number of member in struct")
168 << error_code_info(DBUS_ERROR_INVALID_ARGS)
169 << actual_type_info("MenuItem");
170 }
171
172 GVariant *v_text = g_variant_get_child_value(variant, 0);
173 get_string(v_text, &result->text);
174 GVariant *v_command = g_variant_get_child_value(variant, 1);
175 get_int32(v_command, &result->command);
176 GVariant *v_flags = g_variant_get_child_value(variant, 2);
177 get_int32(v_flags, &result->flags);
178
179 g_variant_unref(v_text);
180 g_variant_unref(v_command);
181 g_variant_unref(v_flags);
182 }
183
184 GVariant *
put_MenuItem(const GenericDBusApplet::MenuItem * result)185 DBusGUI_Marshall::put_MenuItem(const GenericDBusApplet::MenuItem *result)
186 {
187 GVariantBuilder builder;
188 g_variant_builder_init(&builder, (GVariantType *)"(sii)");
189
190 GVariant *v;
191 v = put_string(&(result->text));
192 g_variant_builder_add_value(&builder, v);
193 v = put_int32(&(result->command));
194 g_variant_builder_add_value(&builder, v);
195 v = put_int32(&(result->flags));
196 g_variant_builder_add_value(&builder, v);
197
198 return g_variant_builder_end(&builder);
199 }
200
201
202
203 void
get_MenuItems(GVariant * variant,GenericDBusApplet::MenuItems * result)204 DBusGUI_Marshall::get_MenuItems(GVariant *variant, GenericDBusApplet::MenuItems *result)
205 {
206 GVariantIter iter;
207 g_variant_iter_init(&iter, variant);
208
209 GVariant *child;
210 while ((child = g_variant_iter_next_value(&iter)))
211 {
212 GenericDBusApplet::MenuItem tmp;
213 get_MenuItem(child, &tmp);
214 result->push_back(tmp);
215
216 g_variant_unref (child);
217 }
218 }
219
220 GVariant *
put_MenuItems(const GenericDBusApplet::MenuItems * result)221 DBusGUI_Marshall::put_MenuItems(const GenericDBusApplet::MenuItems *result)
222 {
223 GVariantBuilder builder;
224 g_variant_builder_init(&builder, (GVariantType *)"a(sii)");
225
226 GenericDBusApplet::MenuItems::const_iterator it;
227
228 for (it = result->begin(); it != result->end(); it++)
229 {
230 GVariant *v = put_MenuItem(&(*it));
231 g_variant_builder_add_value(&builder, v);
232 }
233
234 return g_variant_builder_end(&builder);
235 }
236
237
238
239
240
241 class org_workrave_ControlInterface_Stub : public DBusBindingGio, public org_workrave_ControlInterface, DBusGUI_Marshall
242 {
243 private:
244 typedef void (org_workrave_ControlInterface_Stub::*DBusMethodPointer)(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
245
246 struct DBusMethod
247 {
248 const string name;
249 DBusMethodPointer fn;
250 };
251
252 virtual void call(const std::string &method_name, void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
253
get_interface_introspect()254 virtual const char *get_interface_introspect()
255 {
256 return interface_introspect;
257 }
258
259 public:
260 org_workrave_ControlInterface_Stub(IDBus::Ptr dbus);
261 ~org_workrave_ControlInterface_Stub();
262
263
264 private:
265 void OpenMain(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
266 void Preferences(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
267 void SetOperationMode(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
268 void NetworkConnect(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
269 void NetworkLog(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
270 void NetworkReconnect(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
271 void NetworkDisconnect(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
272 void ReadingMode(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
273 void Statistics(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
274 void Exercises(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
275 void RestBreak(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
276 void Quit(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
277 void About(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
278
279 static const DBusMethod method_table[];
280 static const char *interface_introspect;
281 };
282
283
instance(const::workrave::dbus::IDBus::Ptr dbus)284 org_workrave_ControlInterface *org_workrave_ControlInterface::instance(const ::workrave::dbus::IDBus::Ptr dbus)
285 {
286 org_workrave_ControlInterface_Stub *iface = NULL;
287 DBusBinding *binding = dbus->find_binding("org.workrave.ControlInterface");
288
289 if (binding != NULL)
290 {
291 iface = dynamic_cast<org_workrave_ControlInterface_Stub *>(binding);
292 }
293
294 return iface;
295 }
296
org_workrave_ControlInterface_Stub(IDBus::Ptr dbus)297 org_workrave_ControlInterface_Stub::org_workrave_ControlInterface_Stub(IDBus::Ptr dbus)
298 : DBusBindingGio(dbus)
299 {
300 }
301
~org_workrave_ControlInterface_Stub()302 org_workrave_ControlInterface_Stub::~org_workrave_ControlInterface_Stub()
303 {
304 }
305
306 void
call(const std::string & method_name,void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)307 org_workrave_ControlInterface_Stub::call(const std::string &method_name, void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
308 {
309 const DBusMethod *table = method_table;
310 while (table->fn != NULL)
311 {
312 if (method_name == table->name)
313 {
314 DBusMethodPointer ptr = table->fn;
315 if (ptr != NULL)
316 {
317 (this->*ptr)(object, invocation, sender, inargs);
318 }
319 return;
320 }
321 table++;
322 }
323
324 throw DBusRemoteException()
325 << message_info("Unknown method")
326 << error_code_info(DBUS_ERROR_UNKNOWN_METHOD)
327 << method_info(method_name)
328 << interface_info("org.workrave.ControlInterface");
329 }
330
331
332 void
OpenMain(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)333 org_workrave_ControlInterface_Stub::OpenMain(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
334 {
335 (void) sender;
336
337 try
338 {
339 Menus *dbus_object = (Menus *) object;
340
341
342 gsize num_in_args = g_variant_n_children(inargs);
343 if (num_in_args != 0)
344 {
345 throw DBusRemoteException()
346 << message_info("Incorrecy number of in-paraeters")
347 << error_code_info(DBUS_ERROR_INVALID_ARGS)
348 << method_info("OpenMain")
349 << interface_info("org.workrave.ControlInterface");
350 }
351
352
353 dbus_object->on_menu_open_main_window(
354
355 );
356
357 GVariant *out = NULL;
358
359 g_dbus_method_invocation_return_value(invocation, out);
360 }
361 catch (const DBusRemoteException &e)
362 {
363 e << method_info("OpenMain")
364 << interface_info("org.workrave.ControlInterface");
365 throw;
366 }
367
368 }
369
370 void
Preferences(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)371 org_workrave_ControlInterface_Stub::Preferences(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
372 {
373 (void) sender;
374
375 try
376 {
377 Menus *dbus_object = (Menus *) object;
378
379
380 gsize num_in_args = g_variant_n_children(inargs);
381 if (num_in_args != 0)
382 {
383 throw DBusRemoteException()
384 << message_info("Incorrecy number of in-paraeters")
385 << error_code_info(DBUS_ERROR_INVALID_ARGS)
386 << method_info("Preferences")
387 << interface_info("org.workrave.ControlInterface");
388 }
389
390
391 dbus_object->on_menu_preferences(
392
393 );
394
395 GVariant *out = NULL;
396
397 g_dbus_method_invocation_return_value(invocation, out);
398 }
399 catch (const DBusRemoteException &e)
400 {
401 e << method_info("Preferences")
402 << interface_info("org.workrave.ControlInterface");
403 throw;
404 }
405
406 }
407
408 void
SetOperationMode(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)409 org_workrave_ControlInterface_Stub::SetOperationMode(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
410 {
411 (void) sender;
412
413 try
414 {
415 Menus *dbus_object = (Menus *) object;
416
417 OperationMode p_mode
418 ;
419
420 gsize num_in_args = g_variant_n_children(inargs);
421 if (num_in_args != 1)
422 {
423 throw DBusRemoteException()
424 << message_info("Incorrecy number of in-paraeters")
425 << error_code_info(DBUS_ERROR_INVALID_ARGS)
426 << method_info("SetOperationMode")
427 << interface_info("org.workrave.ControlInterface");
428 }
429
430 GVariant *v_mode = g_variant_get_child_value(inargs, 0 );
431 get_operation_mode(v_mode, &p_mode);
432
433 dbus_object->on_set_operation_mode(
434
435 p_mode
436 );
437
438 GVariant *out = NULL;
439
440 g_dbus_method_invocation_return_value(invocation, out);
441 }
442 catch (const DBusRemoteException &e)
443 {
444 e << method_info("SetOperationMode")
445 << interface_info("org.workrave.ControlInterface");
446 throw;
447 }
448
449 }
450
451 void
NetworkConnect(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)452 org_workrave_ControlInterface_Stub::NetworkConnect(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
453 {
454 (void) sender;
455
456 try
457 {
458 Menus *dbus_object = (Menus *) object;
459
460
461 gsize num_in_args = g_variant_n_children(inargs);
462 if (num_in_args != 0)
463 {
464 throw DBusRemoteException()
465 << message_info("Incorrecy number of in-paraeters")
466 << error_code_info(DBUS_ERROR_INVALID_ARGS)
467 << method_info("NetworkConnect")
468 << interface_info("org.workrave.ControlInterface");
469 }
470
471
472 dbus_object->on_menu_network_join(
473
474 );
475
476 GVariant *out = NULL;
477
478 g_dbus_method_invocation_return_value(invocation, out);
479 }
480 catch (const DBusRemoteException &e)
481 {
482 e << method_info("NetworkConnect")
483 << interface_info("org.workrave.ControlInterface");
484 throw;
485 }
486
487 }
488
489 void
NetworkLog(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)490 org_workrave_ControlInterface_Stub::NetworkLog(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
491 {
492 (void) sender;
493
494 try
495 {
496 Menus *dbus_object = (Menus *) object;
497
498 bool p_show
499 ;
500
501 gsize num_in_args = g_variant_n_children(inargs);
502 if (num_in_args != 1)
503 {
504 throw DBusRemoteException()
505 << message_info("Incorrecy number of in-paraeters")
506 << error_code_info(DBUS_ERROR_INVALID_ARGS)
507 << method_info("NetworkLog")
508 << interface_info("org.workrave.ControlInterface");
509 }
510
511 GVariant *v_show = g_variant_get_child_value(inargs, 0 );
512 get_bool(v_show, &p_show);
513
514 dbus_object->on_menu_network_log(
515
516 p_show
517 );
518
519 GVariant *out = NULL;
520
521 g_dbus_method_invocation_return_value(invocation, out);
522 }
523 catch (const DBusRemoteException &e)
524 {
525 e << method_info("NetworkLog")
526 << interface_info("org.workrave.ControlInterface");
527 throw;
528 }
529
530 }
531
532 void
NetworkReconnect(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)533 org_workrave_ControlInterface_Stub::NetworkReconnect(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
534 {
535 (void) sender;
536
537 try
538 {
539 Menus *dbus_object = (Menus *) object;
540
541
542 gsize num_in_args = g_variant_n_children(inargs);
543 if (num_in_args != 0)
544 {
545 throw DBusRemoteException()
546 << message_info("Incorrecy number of in-paraeters")
547 << error_code_info(DBUS_ERROR_INVALID_ARGS)
548 << method_info("NetworkReconnect")
549 << interface_info("org.workrave.ControlInterface");
550 }
551
552
553 dbus_object->on_menu_network_reconnect(
554
555 );
556
557 GVariant *out = NULL;
558
559 g_dbus_method_invocation_return_value(invocation, out);
560 }
561 catch (const DBusRemoteException &e)
562 {
563 e << method_info("NetworkReconnect")
564 << interface_info("org.workrave.ControlInterface");
565 throw;
566 }
567
568 }
569
570 void
NetworkDisconnect(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)571 org_workrave_ControlInterface_Stub::NetworkDisconnect(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
572 {
573 (void) sender;
574
575 try
576 {
577 Menus *dbus_object = (Menus *) object;
578
579
580 gsize num_in_args = g_variant_n_children(inargs);
581 if (num_in_args != 0)
582 {
583 throw DBusRemoteException()
584 << message_info("Incorrecy number of in-paraeters")
585 << error_code_info(DBUS_ERROR_INVALID_ARGS)
586 << method_info("NetworkDisconnect")
587 << interface_info("org.workrave.ControlInterface");
588 }
589
590
591 dbus_object->on_menu_network_leave(
592
593 );
594
595 GVariant *out = NULL;
596
597 g_dbus_method_invocation_return_value(invocation, out);
598 }
599 catch (const DBusRemoteException &e)
600 {
601 e << method_info("NetworkDisconnect")
602 << interface_info("org.workrave.ControlInterface");
603 throw;
604 }
605
606 }
607
608 void
ReadingMode(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)609 org_workrave_ControlInterface_Stub::ReadingMode(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
610 {
611 (void) sender;
612
613 try
614 {
615 Menus *dbus_object = (Menus *) object;
616
617 bool p_show
618 ;
619
620 gsize num_in_args = g_variant_n_children(inargs);
621 if (num_in_args != 1)
622 {
623 throw DBusRemoteException()
624 << message_info("Incorrecy number of in-paraeters")
625 << error_code_info(DBUS_ERROR_INVALID_ARGS)
626 << method_info("ReadingMode")
627 << interface_info("org.workrave.ControlInterface");
628 }
629
630 GVariant *v_show = g_variant_get_child_value(inargs, 0 );
631 get_bool(v_show, &p_show);
632
633 dbus_object->on_menu_reading(
634
635 p_show
636 );
637
638 GVariant *out = NULL;
639
640 g_dbus_method_invocation_return_value(invocation, out);
641 }
642 catch (const DBusRemoteException &e)
643 {
644 e << method_info("ReadingMode")
645 << interface_info("org.workrave.ControlInterface");
646 throw;
647 }
648
649 }
650
651 void
Statistics(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)652 org_workrave_ControlInterface_Stub::Statistics(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
653 {
654 (void) sender;
655
656 try
657 {
658 Menus *dbus_object = (Menus *) object;
659
660
661 gsize num_in_args = g_variant_n_children(inargs);
662 if (num_in_args != 0)
663 {
664 throw DBusRemoteException()
665 << message_info("Incorrecy number of in-paraeters")
666 << error_code_info(DBUS_ERROR_INVALID_ARGS)
667 << method_info("Statistics")
668 << interface_info("org.workrave.ControlInterface");
669 }
670
671
672 dbus_object->on_menu_statistics(
673
674 );
675
676 GVariant *out = NULL;
677
678 g_dbus_method_invocation_return_value(invocation, out);
679 }
680 catch (const DBusRemoteException &e)
681 {
682 e << method_info("Statistics")
683 << interface_info("org.workrave.ControlInterface");
684 throw;
685 }
686
687 }
688
689 void
Exercises(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)690 org_workrave_ControlInterface_Stub::Exercises(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
691 {
692 #if defined(HAVE_EXERCISES)
693 (void) sender;
694
695 try
696 {
697 Menus *dbus_object = (Menus *) object;
698
699
700 gsize num_in_args = g_variant_n_children(inargs);
701 if (num_in_args != 0)
702 {
703 throw DBusRemoteException()
704 << message_info("Incorrecy number of in-paraeters")
705 << error_code_info(DBUS_ERROR_INVALID_ARGS)
706 << method_info("Exercises")
707 << interface_info("org.workrave.ControlInterface");
708 }
709
710
711 dbus_object->on_menu_exercises(
712
713 );
714
715 GVariant *out = NULL;
716
717 g_dbus_method_invocation_return_value(invocation, out);
718 }
719 catch (const DBusRemoteException &e)
720 {
721 e << method_info("Exercises")
722 << interface_info("org.workrave.ControlInterface");
723 throw;
724 }
725
726 #else
727 (void) object;
728
729 g_dbus_method_invocation_return_dbus_error (invocation,
730 "org.workrave.NotImplemented",
731 "This method is unavailable in current configuration");
732 #endif
733 }
734
735 void
RestBreak(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)736 org_workrave_ControlInterface_Stub::RestBreak(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
737 {
738 (void) sender;
739
740 try
741 {
742 Menus *dbus_object = (Menus *) object;
743
744
745 gsize num_in_args = g_variant_n_children(inargs);
746 if (num_in_args != 0)
747 {
748 throw DBusRemoteException()
749 << message_info("Incorrecy number of in-paraeters")
750 << error_code_info(DBUS_ERROR_INVALID_ARGS)
751 << method_info("RestBreak")
752 << interface_info("org.workrave.ControlInterface");
753 }
754
755
756 dbus_object->on_menu_restbreak_now(
757
758 );
759
760 GVariant *out = NULL;
761
762 g_dbus_method_invocation_return_value(invocation, out);
763 }
764 catch (const DBusRemoteException &e)
765 {
766 e << method_info("RestBreak")
767 << interface_info("org.workrave.ControlInterface");
768 throw;
769 }
770
771 }
772
773 void
Quit(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)774 org_workrave_ControlInterface_Stub::Quit(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
775 {
776 (void) sender;
777
778 try
779 {
780 Menus *dbus_object = (Menus *) object;
781
782
783 gsize num_in_args = g_variant_n_children(inargs);
784 if (num_in_args != 0)
785 {
786 throw DBusRemoteException()
787 << message_info("Incorrecy number of in-paraeters")
788 << error_code_info(DBUS_ERROR_INVALID_ARGS)
789 << method_info("Quit")
790 << interface_info("org.workrave.ControlInterface");
791 }
792
793
794 dbus_object->on_menu_quit(
795
796 );
797
798 GVariant *out = NULL;
799
800 g_dbus_method_invocation_return_value(invocation, out);
801 }
802 catch (const DBusRemoteException &e)
803 {
804 e << method_info("Quit")
805 << interface_info("org.workrave.ControlInterface");
806 throw;
807 }
808
809 }
810
811 void
About(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)812 org_workrave_ControlInterface_Stub::About(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
813 {
814 (void) sender;
815
816 try
817 {
818 Menus *dbus_object = (Menus *) object;
819
820
821 gsize num_in_args = g_variant_n_children(inargs);
822 if (num_in_args != 0)
823 {
824 throw DBusRemoteException()
825 << message_info("Incorrecy number of in-paraeters")
826 << error_code_info(DBUS_ERROR_INVALID_ARGS)
827 << method_info("About")
828 << interface_info("org.workrave.ControlInterface");
829 }
830
831
832 dbus_object->on_menu_about(
833
834 );
835
836 GVariant *out = NULL;
837
838 g_dbus_method_invocation_return_value(invocation, out);
839 }
840 catch (const DBusRemoteException &e)
841 {
842 e << method_info("About")
843 << interface_info("org.workrave.ControlInterface");
844 throw;
845 }
846
847 }
848
849
850 const org_workrave_ControlInterface_Stub::DBusMethod org_workrave_ControlInterface_Stub::method_table[] = {
851 { "OpenMain", &org_workrave_ControlInterface_Stub::OpenMain },
852 { "Preferences", &org_workrave_ControlInterface_Stub::Preferences },
853 { "SetOperationMode", &org_workrave_ControlInterface_Stub::SetOperationMode },
854 { "NetworkConnect", &org_workrave_ControlInterface_Stub::NetworkConnect },
855 { "NetworkLog", &org_workrave_ControlInterface_Stub::NetworkLog },
856 { "NetworkReconnect", &org_workrave_ControlInterface_Stub::NetworkReconnect },
857 { "NetworkDisconnect", &org_workrave_ControlInterface_Stub::NetworkDisconnect },
858 { "ReadingMode", &org_workrave_ControlInterface_Stub::ReadingMode },
859 { "Statistics", &org_workrave_ControlInterface_Stub::Statistics },
860 { "Exercises", &org_workrave_ControlInterface_Stub::Exercises },
861 { "RestBreak", &org_workrave_ControlInterface_Stub::RestBreak },
862 { "Quit", &org_workrave_ControlInterface_Stub::Quit },
863 { "About", &org_workrave_ControlInterface_Stub::About },
864 { "", NULL }
865 };
866
867 const char *
868 org_workrave_ControlInterface_Stub::interface_introspect =
869 " <interface name=\"org.workrave.ControlInterface\">\n"
870 " <method name=\"OpenMain\">\n"
871 " </method>\n"
872 " <method name=\"Preferences\">\n"
873 " </method>\n"
874 " <method name=\"SetOperationMode\">\n"
875 " <arg type=\"s\" name=\"mode\" direction=\"in\" />\n"
876 " </method>\n"
877 " <method name=\"NetworkConnect\">\n"
878 " </method>\n"
879 " <method name=\"NetworkLog\">\n"
880 " <arg type=\"b\" name=\"show\" direction=\"in\" />\n"
881 " </method>\n"
882 " <method name=\"NetworkReconnect\">\n"
883 " </method>\n"
884 " <method name=\"NetworkDisconnect\">\n"
885 " </method>\n"
886 " <method name=\"ReadingMode\">\n"
887 " <arg type=\"b\" name=\"show\" direction=\"in\" />\n"
888 " </method>\n"
889 " <method name=\"Statistics\">\n"
890 " </method>\n"
891 " <method name=\"Exercises\">\n"
892 " </method>\n"
893 " <method name=\"RestBreak\">\n"
894 " </method>\n"
895 " <method name=\"Quit\">\n"
896 " </method>\n"
897 " <method name=\"About\">\n"
898 " </method>\n"
899 " </interface>\n";
900
901
902
903
904
905 class org_workrave_AppletInterface_Stub : public DBusBindingGio, public org_workrave_AppletInterface, DBusGUI_Marshall
906 {
907 private:
908 typedef void (org_workrave_AppletInterface_Stub::*DBusMethodPointer)(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
909
910 struct DBusMethod
911 {
912 const string name;
913 DBusMethodPointer fn;
914 };
915
916 virtual void call(const std::string &method_name, void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
917
get_interface_introspect()918 virtual const char *get_interface_introspect()
919 {
920 return interface_introspect;
921 }
922
923 public:
924 org_workrave_AppletInterface_Stub(IDBus::Ptr dbus);
925 ~org_workrave_AppletInterface_Stub();
926
927 void TimersUpdated(const string &path
928 , GenericDBusApplet::TimerData µ
929 , GenericDBusApplet::TimerData &rest
930 , GenericDBusApplet::TimerData &daily
931 );
932 void MenuUpdated(const string &path
933 , GenericDBusApplet::MenuItems &menuitems
934 );
935 void TrayIconUpdated(const string &path
936 , bool enabled
937 );
938
939 private:
940 void Embed(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
941 void Command(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
942 void ButtonClicked(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
943 void GetMenu(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
944 void GetTrayIconEnabled(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs);
945
946 static const DBusMethod method_table[];
947 static const char *interface_introspect;
948 };
949
950
instance(const::workrave::dbus::IDBus::Ptr dbus)951 org_workrave_AppletInterface *org_workrave_AppletInterface::instance(const ::workrave::dbus::IDBus::Ptr dbus)
952 {
953 org_workrave_AppletInterface_Stub *iface = NULL;
954 DBusBinding *binding = dbus->find_binding("org.workrave.AppletInterface");
955
956 if (binding != NULL)
957 {
958 iface = dynamic_cast<org_workrave_AppletInterface_Stub *>(binding);
959 }
960
961 return iface;
962 }
963
org_workrave_AppletInterface_Stub(IDBus::Ptr dbus)964 org_workrave_AppletInterface_Stub::org_workrave_AppletInterface_Stub(IDBus::Ptr dbus)
965 : DBusBindingGio(dbus)
966 {
967 }
968
~org_workrave_AppletInterface_Stub()969 org_workrave_AppletInterface_Stub::~org_workrave_AppletInterface_Stub()
970 {
971 }
972
973 void
call(const std::string & method_name,void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)974 org_workrave_AppletInterface_Stub::call(const std::string &method_name, void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
975 {
976 const DBusMethod *table = method_table;
977 while (table->fn != NULL)
978 {
979 if (method_name == table->name)
980 {
981 DBusMethodPointer ptr = table->fn;
982 if (ptr != NULL)
983 {
984 (this->*ptr)(object, invocation, sender, inargs);
985 }
986 return;
987 }
988 table++;
989 }
990
991 throw DBusRemoteException()
992 << message_info("Unknown method")
993 << error_code_info(DBUS_ERROR_UNKNOWN_METHOD)
994 << method_info(method_name)
995 << interface_info("org.workrave.AppletInterface");
996 }
997
998
999 void
Embed(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)1000 org_workrave_AppletInterface_Stub::Embed(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
1001 {
1002 (void) sender;
1003
1004 try
1005 {
1006 GenericDBusApplet *dbus_object = (GenericDBusApplet *) object;
1007
1008 bool p_enabled
1009 ;
1010 std::string p_sender
1011 ;
1012
1013 gsize num_in_args = g_variant_n_children(inargs);
1014 if (num_in_args != 2)
1015 {
1016 throw DBusRemoteException()
1017 << message_info("Incorrecy number of in-paraeters")
1018 << error_code_info(DBUS_ERROR_INVALID_ARGS)
1019 << method_info("Embed")
1020 << interface_info("org.workrave.AppletInterface");
1021 }
1022
1023 GVariant *v_enabled = g_variant_get_child_value(inargs, 0 );
1024 get_bool(v_enabled, &p_enabled);
1025 GVariant *v_sender = g_variant_get_child_value(inargs, 1 );
1026 get_string(v_sender, &p_sender);
1027
1028 dbus_object->applet_embed(
1029
1030 p_enabled
1031 , p_sender
1032 );
1033
1034 GVariant *out = NULL;
1035
1036 g_dbus_method_invocation_return_value(invocation, out);
1037 }
1038 catch (const DBusRemoteException &e)
1039 {
1040 e << method_info("Embed")
1041 << interface_info("org.workrave.AppletInterface");
1042 throw;
1043 }
1044
1045 }
1046
1047 void
Command(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)1048 org_workrave_AppletInterface_Stub::Command(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
1049 {
1050 (void) sender;
1051
1052 try
1053 {
1054 GenericDBusApplet *dbus_object = (GenericDBusApplet *) object;
1055
1056 int32_t p_command
1057 ;
1058
1059 gsize num_in_args = g_variant_n_children(inargs);
1060 if (num_in_args != 1)
1061 {
1062 throw DBusRemoteException()
1063 << message_info("Incorrecy number of in-paraeters")
1064 << error_code_info(DBUS_ERROR_INVALID_ARGS)
1065 << method_info("Command")
1066 << interface_info("org.workrave.AppletInterface");
1067 }
1068
1069 GVariant *v_command = g_variant_get_child_value(inargs, 0 );
1070 get_int32(v_command, &p_command);
1071
1072 dbus_object->applet_command(
1073
1074 p_command
1075 );
1076
1077 GVariant *out = NULL;
1078
1079 g_dbus_method_invocation_return_value(invocation, out);
1080 }
1081 catch (const DBusRemoteException &e)
1082 {
1083 e << method_info("Command")
1084 << interface_info("org.workrave.AppletInterface");
1085 throw;
1086 }
1087
1088 }
1089
1090 void
ButtonClicked(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)1091 org_workrave_AppletInterface_Stub::ButtonClicked(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
1092 {
1093 (void) sender;
1094
1095 try
1096 {
1097 GenericDBusApplet *dbus_object = (GenericDBusApplet *) object;
1098
1099 uint32_t p_button
1100 ;
1101
1102 gsize num_in_args = g_variant_n_children(inargs);
1103 if (num_in_args != 1)
1104 {
1105 throw DBusRemoteException()
1106 << message_info("Incorrecy number of in-paraeters")
1107 << error_code_info(DBUS_ERROR_INVALID_ARGS)
1108 << method_info("ButtonClicked")
1109 << interface_info("org.workrave.AppletInterface");
1110 }
1111
1112 GVariant *v_button = g_variant_get_child_value(inargs, 0 );
1113 get_uint32(v_button, &p_button);
1114
1115 dbus_object->button_clicked(
1116
1117 p_button
1118 );
1119
1120 GVariant *out = NULL;
1121
1122 g_dbus_method_invocation_return_value(invocation, out);
1123 }
1124 catch (const DBusRemoteException &e)
1125 {
1126 e << method_info("ButtonClicked")
1127 << interface_info("org.workrave.AppletInterface");
1128 throw;
1129 }
1130
1131 }
1132
1133 void
GetMenu(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)1134 org_workrave_AppletInterface_Stub::GetMenu(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
1135 {
1136 (void) sender;
1137
1138 try
1139 {
1140 GenericDBusApplet *dbus_object = (GenericDBusApplet *) object;
1141
1142 GenericDBusApplet::MenuItems p_menuitems
1143 ;
1144
1145 gsize num_in_args = g_variant_n_children(inargs);
1146 if (num_in_args != 0)
1147 {
1148 throw DBusRemoteException()
1149 << message_info("Incorrecy number of in-paraeters")
1150 << error_code_info(DBUS_ERROR_INVALID_ARGS)
1151 << method_info("GetMenu")
1152 << interface_info("org.workrave.AppletInterface");
1153 }
1154
1155
1156 dbus_object->get_menu(
1157
1158 p_menuitems
1159 );
1160
1161 GVariantBuilder builder;
1162 g_variant_builder_init(&builder, (GVariantType*)"(a(sii))");
1163
1164 GVariant *v_menuitems = put_MenuItems(&p_menuitems);
1165 g_variant_builder_add_value(&builder, v_menuitems);
1166
1167 GVariant *out = g_variant_builder_end(&builder);
1168
1169 g_dbus_method_invocation_return_value(invocation, out);
1170 }
1171 catch (const DBusRemoteException &e)
1172 {
1173 e << method_info("GetMenu")
1174 << interface_info("org.workrave.AppletInterface");
1175 throw;
1176 }
1177
1178 }
1179
1180 void
GetTrayIconEnabled(void * object,GDBusMethodInvocation * invocation,const std::string & sender,GVariant * inargs)1181 org_workrave_AppletInterface_Stub::GetTrayIconEnabled(void *object, GDBusMethodInvocation *invocation, const std::string &sender, GVariant *inargs)
1182 {
1183 (void) sender;
1184
1185 try
1186 {
1187 GenericDBusApplet *dbus_object = (GenericDBusApplet *) object;
1188
1189 bool p_enabled
1190 ;
1191
1192 gsize num_in_args = g_variant_n_children(inargs);
1193 if (num_in_args != 0)
1194 {
1195 throw DBusRemoteException()
1196 << message_info("Incorrecy number of in-paraeters")
1197 << error_code_info(DBUS_ERROR_INVALID_ARGS)
1198 << method_info("GetTrayIconEnabled")
1199 << interface_info("org.workrave.AppletInterface");
1200 }
1201
1202
1203 dbus_object->get_tray_icon_enabled(
1204
1205 p_enabled
1206 );
1207
1208 GVariantBuilder builder;
1209 g_variant_builder_init(&builder, (GVariantType*)"(b)");
1210
1211 GVariant *v_enabled = put_bool(&p_enabled);
1212 g_variant_builder_add_value(&builder, v_enabled);
1213
1214 GVariant *out = g_variant_builder_end(&builder);
1215
1216 g_dbus_method_invocation_return_value(invocation, out);
1217 }
1218 catch (const DBusRemoteException &e)
1219 {
1220 e << method_info("GetTrayIconEnabled")
1221 << interface_info("org.workrave.AppletInterface");
1222 throw;
1223 }
1224
1225 }
1226
TimersUpdated(const string & path,GenericDBusApplet::TimerData & micro,GenericDBusApplet::TimerData & rest,GenericDBusApplet::TimerData & daily)1227 void org_workrave_AppletInterface_Stub::TimersUpdated(const string &path
1228 , GenericDBusApplet::TimerData µ
1229 , GenericDBusApplet::TimerData &rest
1230 , GenericDBusApplet::TimerData &daily
1231 )
1232 {
1233 IDBusPrivateGio::Ptr p = std::dynamic_pointer_cast<IDBusPrivateGio>(dbus);
1234
1235 GDBusConnection *connection = p->get_connection();
1236 if (connection == NULL)
1237 {
1238 return;
1239 }
1240
1241 GVariantBuilder builder;
1242 g_variant_builder_init(&builder, (GVariantType*)"((siuuuuuu)(siuuuuuu)(siuuuuuu))");
1243
1244 GVariant *v_micro = put_TimerData(µ);
1245 g_variant_builder_add_value(&builder, v_micro);
1246 GVariant *v_rest = put_TimerData(&rest);
1247 g_variant_builder_add_value(&builder, v_rest);
1248 GVariant *v_daily = put_TimerData(&daily);
1249 g_variant_builder_add_value(&builder, v_daily);
1250
1251 GVariant *out = g_variant_builder_end(&builder);
1252
1253 GError *error = NULL;
1254 g_dbus_connection_emit_signal(connection,
1255 NULL,
1256 path.c_str(),
1257 "org.workrave.AppletInterface",
1258 "TimersUpdated",
1259 out,
1260 &error);
1261
1262 if (error != NULL)
1263 {
1264 g_error_free(error);
1265 }
1266 }
MenuUpdated(const string & path,GenericDBusApplet::MenuItems & menuitems)1267 void org_workrave_AppletInterface_Stub::MenuUpdated(const string &path
1268 , GenericDBusApplet::MenuItems &menuitems
1269 )
1270 {
1271 IDBusPrivateGio::Ptr p = std::dynamic_pointer_cast<IDBusPrivateGio>(dbus);
1272
1273 GDBusConnection *connection = p->get_connection();
1274 if (connection == NULL)
1275 {
1276 return;
1277 }
1278
1279 GVariantBuilder builder;
1280 g_variant_builder_init(&builder, (GVariantType*)"(a(sii))");
1281
1282 GVariant *v_menuitems = put_MenuItems(&menuitems);
1283 g_variant_builder_add_value(&builder, v_menuitems);
1284
1285 GVariant *out = g_variant_builder_end(&builder);
1286
1287 GError *error = NULL;
1288 g_dbus_connection_emit_signal(connection,
1289 NULL,
1290 path.c_str(),
1291 "org.workrave.AppletInterface",
1292 "MenuUpdated",
1293 out,
1294 &error);
1295
1296 if (error != NULL)
1297 {
1298 g_error_free(error);
1299 }
1300 }
TrayIconUpdated(const string & path,bool enabled)1301 void org_workrave_AppletInterface_Stub::TrayIconUpdated(const string &path
1302 , bool enabled
1303 )
1304 {
1305 IDBusPrivateGio::Ptr p = std::dynamic_pointer_cast<IDBusPrivateGio>(dbus);
1306
1307 GDBusConnection *connection = p->get_connection();
1308 if (connection == NULL)
1309 {
1310 return;
1311 }
1312
1313 GVariantBuilder builder;
1314 g_variant_builder_init(&builder, (GVariantType*)"(b)");
1315
1316 GVariant *v_enabled = put_bool(&enabled);
1317 g_variant_builder_add_value(&builder, v_enabled);
1318
1319 GVariant *out = g_variant_builder_end(&builder);
1320
1321 GError *error = NULL;
1322 g_dbus_connection_emit_signal(connection,
1323 NULL,
1324 path.c_str(),
1325 "org.workrave.AppletInterface",
1326 "TrayIconUpdated",
1327 out,
1328 &error);
1329
1330 if (error != NULL)
1331 {
1332 g_error_free(error);
1333 }
1334 }
1335
1336 const org_workrave_AppletInterface_Stub::DBusMethod org_workrave_AppletInterface_Stub::method_table[] = {
1337 { "Embed", &org_workrave_AppletInterface_Stub::Embed },
1338 { "Command", &org_workrave_AppletInterface_Stub::Command },
1339 { "ButtonClicked", &org_workrave_AppletInterface_Stub::ButtonClicked },
1340 { "GetMenu", &org_workrave_AppletInterface_Stub::GetMenu },
1341 { "GetTrayIconEnabled", &org_workrave_AppletInterface_Stub::GetTrayIconEnabled },
1342 { "", NULL }
1343 };
1344
1345 const char *
1346 org_workrave_AppletInterface_Stub::interface_introspect =
1347 " <interface name=\"org.workrave.AppletInterface\">\n"
1348 " <method name=\"Embed\">\n"
1349 " <arg type=\"b\" name=\"enabled\" direction=\"in\" />\n"
1350 " <arg type=\"s\" name=\"sender\" direction=\"in\" />\n"
1351 " </method>\n"
1352 " <method name=\"Command\">\n"
1353 " <arg type=\"i\" name=\"command\" direction=\"in\" />\n"
1354 " </method>\n"
1355 " <method name=\"ButtonClicked\">\n"
1356 " <arg type=\"u\" name=\"button\" direction=\"in\" />\n"
1357 " </method>\n"
1358 " <method name=\"GetMenu\">\n"
1359 " <arg type=\"a(sii)\" name=\"menuitems\" direction=\"out\" />\n"
1360 " </method>\n"
1361 " <method name=\"GetTrayIconEnabled\">\n"
1362 " <arg type=\"b\" name=\"enabled\" direction=\"out\" />\n"
1363 " </method>\n"
1364 " <signal name=\"TimersUpdated\">\n"
1365 " <arg type=\"(siuuuuuu)\" name=\"micro\" />\n"
1366 " <arg type=\"(siuuuuuu)\" name=\"rest\" />\n"
1367 " <arg type=\"(siuuuuuu)\" name=\"daily\" />\n"
1368 " </signal>\n"
1369 " <signal name=\"MenuUpdated\">\n"
1370 " <arg type=\"a(sii)\" name=\"menuitems\" />\n"
1371 " </signal>\n"
1372 " <signal name=\"TrayIconUpdated\">\n"
1373 " <arg type=\"b\" name=\"enabled\" />\n"
1374 " </signal>\n"
1375 " </interface>\n";
1376
1377
1378
1379
init_DBusGUI(IDBus::Ptr dbus)1380 void init_DBusGUI(IDBus::Ptr dbus)
1381 {
1382 dbus->register_binding("org.workrave.ControlInterface", new org_workrave_ControlInterface_Stub(dbus));
1383 dbus->register_binding("org.workrave.AppletInterface", new org_workrave_AppletInterface_Stub(dbus));
1384 }