← Back to branch summary

~ubuntu-branches/ubuntu/raring/workrave/raring

« back to all changes in this revision

Viewing changes to frontend/gtkmm/src/gnome_applet3/WorkraveApplet.c

  • Committer: Package Import Robot
  • Author(s): Francois Marier, Francois Marier, Jordi Mallach
  • Date: 2012-05-28 11:29:40 UTC
  • mfrom: (1.2.9)
  • Revision ID: package-import@ubuntu.com-20120528112940-bbbsjkk30fom9s8x
Tags: 1.9.909+abc941eb70-1
http://bugs.debian.org/642514
http://bugs.debian.org/666100
[ Francois Marier ]
* New upstream snapshot
  - Drop leak-fix patch (applied upstream)
  - Document how the tarball is built in README.source
* Build GNOME applets and use gsettings
* Massive update of Build-Depends as per configure.ac

* Update README.source with snapshot instructions
* Switch to machine-readable copyright file
* Update alioth git repo links
* Bump debhelper version to 9
* Bump Standards-Version to 3.9.3

[ Jordi Mallach ]
* Avoid references to GNU/Linux in manpage.
* Drop build dependency on libgnet-dev, it's obsolete and unneeded.
* Add myself to Uploaders.
* Rewrite d/rules into dh style.
  - Move all install tweaks to .install files.
  - Install manpages using dh_installman.
* As a side effect, the package installs arch-dependant data in the
  arch triplet directory; add the required Pre-Depends for m-a-support.
* Bring back GNOME Panel applet (for GNOME 3 fallback mode) and ship the
  new GNOME Shell extension (closes: #642514, #666100).
* Add private_dirs.patch: move libworkrave-private and GObject
  Introspection files to a private dir, so they are really out of the
  way, but disable it for now as it breaks the Shell extension.
* Move typelib out of the triplet dir as gobject-introspection is not
  M-A ready yet.
* Enable dh_autoreconf for the above patches.
* Add lintian overrides.
* Add necessary Breaks/Replaces as the xpm icon has moved to workrave-data.
* Prefix all debhelper files with package name.
* Suggest gnome-shell and gnome-panel.

Show diffs side-by-side

added added

removed removed

Lines of Context:
frontend/gtkmm/src/gnome_applet3/WorkraveApplet.c
1
 
// WorkraveApplet.cc
2
 
//
3
 
// Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Rob Caelers & Raymond Penners
4
 
// All rights reserved.
5
 
//
6
 
// This program is free software: you can redistribute it and/or modify
7
 
// it under the terms of the GNU General Public License as published by
8
 
// the Free Software Foundation, either version 3 of the License, or
9
 
// (at your option) any later version.
10
 
//
11
 
// This program is distributed in the hope that it will be useful,
12
 
// but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
// GNU General Public License for more details.
15
 
//
16
 
// You should have received a copy of the GNU General Public License
17
 
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
 
//
19
 
 
20
 
#ifdef HAVE_CONFIG_H
21
 
#include "config.h"
22
 
#endif
23
 
 
24
 
#include "credits.h"
25
 
 
26
 
#include <panel-applet.h>
27
 
 
28
 
#include <gtk/gtk.h>
29
 
#include <gdk/gdkx.h>
30
 
 
31
 
#define DBUS_API_SUBJECT_TO_CHANGE
32
 
#include <dbus/dbus.h>
33
 
#include <dbus/dbus-glib-bindings.h>
34
 
#include <dbus/dbus-glib-lowlevel.h>
35
 
 
36
 
#include "WorkraveApplet.h"
37
 
#include "applet-server-bindings.h"
38
 
#include "gui-client-bindings.h"
39
 
 
40
 
#include "nls.h"
41
 
 
42
 
G_DEFINE_TYPE (WorkraveApplet, workrave_applet, G_TYPE_OBJECT);
43
 
 
44
 
static WorkraveApplet *g_applet = NULL;
45
 
static DBusGConnection *g_connection = NULL;
46
 
 
47
 
static void workrave_applet_set_all_visible(gboolean visible);
48
 
static void workrave_applet_set_visible(gchar *name, gboolean visible);
49
 
 
50
 
static
51
 
void workrave_applet_destroy(GtkObject *object);
52
 
 
53
 
/************************************************************************/
54
 
/* DBUS                                                                 */
55
 
/************************************************************************/
56
 
 
57
 
static WorkraveApplet*
58
 
workrave_applet_new()
59
 
{
60
 
  return (WorkraveApplet *)g_object_new(WORKRAVE_APPLET_TYPE, NULL);
61
 
}
62
 
 
63
 
static void
64
 
workrave_applet_class_init(WorkraveAppletClass *klass)
65
 
{
66
 
}
67
 
 
68
 
 
69
 
static void
70
 
workrave_applet_init(WorkraveApplet *applet)
71
 
{
72
 
  applet->image = NULL;
73
 
  applet->socket = NULL;
74
 
  applet->size = 48;
75
 
  applet->socket_id = 0;
76
 
  applet->orientation = 0;
77
 
  applet->last_showlog_state = FALSE;
78
 
  applet->last_reading_mode_state = FALSE;
79
 
  applet->last_mode = 0; 
80
 
  applet->applet = NULL;
81
 
  
82
 
  applet->support = NULL;
83
 
  applet->ui = NULL;
84
 
  applet->core = NULL;
85
 
}
86
 
 
87
 
 
88
 
static void
89
 
workrave_dbus_server_init()
90
 
{
91
 
  DBusGProxy *driver_proxy;
92
 
  GError *err = NULL;
93
 
  guint request_name_result;
94
 
 
95
 
  g_return_if_fail(g_connection == NULL);
96
 
  g_return_if_fail(g_applet != NULL);
97
 
 
98
 
  g_connection = dbus_g_bus_get(DBUS_BUS_SESSION, &err);
99
 
  if (g_connection == NULL)
100
 
    {
101
 
      g_warning("DBUS Service registration failed: %s", err ? err->message : "");
102
 
      g_error_free(err);
103
 
      return;
104
 
    }
105
 
 
106
 
  dbus_connection_set_exit_on_disconnect(dbus_g_connection_get_connection(g_connection),
107
 
                                         FALSE);
108
 
 
109
 
  driver_proxy = dbus_g_proxy_new_for_name(g_connection,
110
 
                                           DBUS_SERVICE_DBUS,
111
 
                                           DBUS_PATH_DBUS,
112
 
                                           DBUS_INTERFACE_DBUS);
113
 
 
114
 
  if (!org_freedesktop_DBus_request_name(driver_proxy,
115
 
                                         DBUS_SERVICE_APPLET,
116
 
                                         0,
117
 
                                         &request_name_result,
118
 
                                         &err))
119
 
    {
120
 
      g_warning("DBUS Service name request failed.");
121
 
      g_clear_error(&err);
122
 
    }
123
 
 
124
 
  if (request_name_result == DBUS_REQUEST_NAME_REPLY_EXISTS)
125
 
    {
126
 
      g_warning("DBUS Service already started elsewhere");
127
 
      return;
128
 
    }
129
 
 
130
 
  dbus_g_object_type_install_info(WORKRAVE_APPLET_TYPE,
131
 
                                  &dbus_glib_workrave_object_info);
132
 
 
133
 
  dbus_g_connection_register_g_object(g_connection,
134
 
                                      "/org/workrave/Workrave/GnomeApplet",
135
 
                                      G_OBJECT(g_applet));
136
 
 
137
 
  g_applet->support = dbus_g_proxy_new_for_name(g_connection,
138
 
                                                "org.workrave.Workrave.Activator",
139
 
                                                "/org/workrave/Workrave/UI",
140
 
                                                "org.workrave.GnomeAppletSupportInterface");
141
 
 
142
 
  g_applet->ui = dbus_g_proxy_new_for_name(g_connection,
143
 
                                           "org.workrave.Workrave.Activator",
144
 
                                           "/org/workrave/Workrave/UI",
145
 
                                           "org.workrave.ControlInterface");
146
 
 
147
 
  g_applet->core = dbus_g_proxy_new_for_name(g_connection,
148
 
                                             "org.workrave.Workrave.Activator",
149
 
                                             "/org/workrave/Workrave/Core",
150
 
                                             "org.workrave.CoreInterface");
151
 
}
152
 
 
153
 
 
154
 
static void
155
 
workrave_dbus_server_cleanup()
156
 
{
157
 
  DBusGProxy *driver_proxy;
158
 
  GError *err = NULL;
159
 
  guint release_name_result;
160
 
 
161
 
  driver_proxy = dbus_g_proxy_new_for_name(g_connection,
162
 
                                           DBUS_SERVICE_DBUS,
163
 
                                           DBUS_PATH_DBUS,
164
 
                                           DBUS_INTERFACE_DBUS);
165
 
 
166
 
  if (!org_freedesktop_DBus_release_name(driver_proxy,
167
 
                                         DBUS_SERVICE_APPLET,
168
 
                                         &release_name_result,
169
 
                                         &err))
170
 
    {
171
 
      g_warning("DBUS Service name release failed.");
172
 
      g_clear_error(&err);
173
 
    }
174
 
 
175
 
  if (g_connection != NULL)
176
 
    {
177
 
      dbus_g_connection_unref(g_connection);
178
 
      g_connection = NULL;
179
 
    }
180
 
}
181
 
 
182
 
 
183
 
static gboolean
184
 
workrave_is_running(void)
185
 
{
186
 
        DBusGProxy *dbus = NULL;
187
 
        GError *error = NULL;
188
 
        gboolean running = FALSE;
189
 
 
190
 
  if (g_connection != NULL)
191
 
    {
192
 
      dbus = dbus_g_proxy_new_for_name(g_connection,
193
 
                                       "org.freedesktop.DBus",
194
 
                                       "/org/freedesktop/DBus",
195
 
                                       "org.freedesktop.DBus");
196
 
    }
197
 
 
198
 
  if (dbus != NULL)
199
 
    {
200
 
      dbus_g_proxy_call(dbus, "NameHasOwner", &error,
201
 
                        G_TYPE_STRING, "org.workrave.Workrave",
202
 
                        G_TYPE_INVALID,
203
 
                        G_TYPE_BOOLEAN, &running,
204
 
                        G_TYPE_INVALID);
205
 
    }
206
 
 
207
 
        return running;
208
 
}
209
 
 
210
 
 
211
 
gboolean
212
 
workrave_applet_get_socket_id(WorkraveApplet *applet, guint *id, GError **err)
213
 
{
214
 
  *id = applet->socket_id;
215
 
 
216
 
  return TRUE;
217
 
}
218
 
 
219
 
 
220
 
gboolean
221
 
workrave_applet_get_size(WorkraveApplet *applet, guint *size, GError **err)
222
 
{
223
 
  *size = applet->size;
224
 
 
225
 
  return TRUE;
226
 
}
227
 
 
228
 
 
229
 
gboolean
230
 
workrave_applet_get_orientation(WorkraveApplet *applet, guint *orientation, GError **err)
231
 
{
232
 
  *orientation = applet->orientation;
233
 
 
234
 
  return TRUE;
235
 
}
236
 
 
237
 
 
238
 
gboolean
239
 
workrave_applet_set_menu_status(WorkraveApplet *applet, const char *name, gboolean status, GError **err)
240
 
{
241
 
  if (g_str_has_prefix(name, "/commands/"))
242
 
    {
243
 
      name += 10; // Skip gnome2 prefix for compatibility
244
 
    }
245
 
 
246
 
  GtkAction *action = gtk_action_group_get_action(g_applet->action_group, name);
247
 
  if (GTK_IS_TOGGLE_ACTION(action))
248
 
    {
249
 
      GtkToggleAction *toggle = GTK_TOGGLE_ACTION(action);
250
 
      gtk_toggle_action_set_active(toggle, status);
251
 
 
252
 
      return TRUE;
253
 
    }
254
 
 
255
 
  return FALSE;
256
 
}
257
 
 
258
 
 
259
 
gboolean
260
 
workrave_applet_get_menu_status(WorkraveApplet *applet, const char *name,  gboolean *status, GError **err)
261
 
{
262
 
  if (g_str_has_prefix(name, "/commands/"))
263
 
    {
264
 
      name += 10; // Skip gnome2 prefix for compatibility
265
 
    }
266
 
 
267
 
  GtkAction *action = gtk_action_group_get_action(g_applet->action_group, name);
268
 
  if (GTK_IS_TOGGLE_ACTION(action))
269
 
    {
270
 
      GtkToggleAction *toggle = GTK_TOGGLE_ACTION(action);
271
 
      *status = gtk_toggle_action_get_active(toggle);
272
 
 
273
 
      return TRUE;
274
 
    }
275
 
  return FALSE;
276
 
}
277
 
 
278
 
 
279
 
gboolean
280
 
workrave_applet_set_menu_active(WorkraveApplet *applet, const char *name, gboolean status, GError **err)
281
 
{
282
 
  GtkAction *action = gtk_action_group_get_action(g_applet->action_group, name);
283
 
  gtk_action_set_visible(action, status);
284
 
 
285
 
  return TRUE;
286
 
}
287
 
 
288
 
 
289
 
gboolean
290
 
workrave_applet_get_menu_active(WorkraveApplet *applet, const char *name, gboolean *active, GError **err)
291
 
{
292
 
  GtkAction *action = gtk_action_group_get_action(g_applet->action_group, name);
293
 
  *active = gtk_action_get_visible(action);
294
 
    
295
 
  return TRUE;
296
 
}
297
 
 
298
 
 
299
 
 
300
 
/************************************************************************/
301
 
/* GNOME::Applet                                                        */
302
 
/************************************************************************/
303
 
 
304
 
static void
305
 
dbus_callback(DBusGProxy *proxy,
306
 
              DBusGProxyCall *call,
307
 
              void *user_data)
308
 
{
309
 
  GError *error = NULL;
310
 
 
311
 
  dbus_g_proxy_end_call(proxy, call, &error, G_TYPE_INVALID);
312
 
 
313
 
  if (error != NULL)
314
 
    {
315
 
      g_warning("DBUS Failed: %s", error ? error->message : "");
316
 
      g_error_free(error);
317
 
    }
318
 
}
319
 
 
320
 
 
321
 
static void
322
 
on_menu_about(GtkAction *action, WorkraveApplet *a)
323
 
{
324
 
  GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(WORKRAVE_PKGDATADIR "/images/workrave.png", NULL);
325
 
  GtkAboutDialog *about = GTK_ABOUT_DIALOG(gtk_about_dialog_new());
326
 
 
327
 
  gtk_container_set_border_width(GTK_CONTAINER(about), 5);
328
 
 
329
 
  gtk_show_about_dialog(NULL,
330
 
                        "name", "Workrave",
331
 
#ifdef GIT_VERSION                        
332
 
                        "version", PACKAGE_VERSION "\n(" GIT_VERSION ")",
333
 
#else                        
334
 
                        "version", PACKAGE_VERSION,
335
 
#endif                        
336
 
                        "copyright", workrave_copyright,
337
 
                        "website", "http://www.workrave.org",
338
 
                        "website_label", "www.workrave.org",
339
 
                        "comments", _("This program assists in the prevention and recovery"
340
 
                                      " of Repetitive Strain Injury (RSI)."),
341
 
                        "translator-credits", workrave_translators,
342
 
                        "authors", workrave_authors,
343
 
                        "logo", pixbuf,
344
 
                         NULL);
345
 
  g_object_unref(pixbuf);
346
 
}
347
 
 
348
 
 
349
 
static void
350
 
on_menu_open(GtkAction *action, WorkraveApplet *a)
351
 
{
352
 
  if (g_applet->ui != NULL)
353
 
    {
354
 
      dbus_g_proxy_begin_call(g_applet->ui, "OpenMain", dbus_callback, NULL, NULL,
355
 
                              G_TYPE_INVALID);
356
 
    }
357
 
}
358
 
 
359
 
 
360
 
static void
361
 
on_menu_preferences(GtkAction *action, WorkraveApplet *a)
362
 
{
363
 
  if (!workrave_is_running())
364
 
    {
365
 
      return;
366
 
    }
367
 
  
368
 
  if (g_applet->ui != NULL)
369
 
    {
370
 
      dbus_g_proxy_begin_call(g_applet->ui, "Preferences", dbus_callback, NULL, NULL,
371
 
                             G_TYPE_INVALID);
372
 
    }
373
 
}
374
 
 
375
 
 
376
 
static void
377
 
on_menu_exercises(GtkAction *action, WorkraveApplet *a)
378
 
{
379
 
  if (!workrave_is_running())
380
 
    {
381
 
      return;
382
 
    }
383
 
  
384
 
  if (g_applet->ui != NULL)
385
 
    {
386
 
      dbus_g_proxy_begin_call(g_applet->ui, "Exercises", dbus_callback, NULL, NULL,
387
 
                              G_TYPE_INVALID);
388
 
    }
389
 
}
390
 
 
391
 
static void
392
 
on_menu_statistics(GtkAction *action, WorkraveApplet *a)
393
 
{
394
 
  if (!workrave_is_running())
395
 
    {
396
 
      return;
397
 
    }
398
 
  
399
 
  if (g_applet->ui != NULL)
400
 
    { 
401
 
      dbus_g_proxy_begin_call(g_applet->ui, "Statistics", dbus_callback, NULL, NULL,
402
 
                             G_TYPE_INVALID);
403
 
    }
404
 
}
405
 
 
406
 
static void
407
 
on_menu_restbreak(GtkAction *action, WorkraveApplet *a)
408
 
{
409
 
  if (!workrave_is_running())
410
 
    {
411
 
      return;
412
 
    }
413
 
  
414
 
  if (g_applet->ui != NULL)
415
 
    {
416
 
      dbus_g_proxy_begin_call(g_applet->ui, "RestBreak", dbus_callback, NULL, NULL,
417
 
                             G_TYPE_INVALID);
418
 
    }
419
 
}
420
 
 
421
 
 
422
 
 
423
 
static void
424
 
on_menu_connect(GtkAction *action, WorkraveApplet *a)
425
 
{
426
 
  if (!workrave_is_running())
427
 
    {
428
 
      return;
429
 
    }
430
 
  
431
 
  if (g_applet->ui != NULL)
432
 
    {
433
 
      dbus_g_proxy_begin_call(g_applet->ui, "NetworkConnect", dbus_callback, NULL, NULL,
434
 
                             G_TYPE_INVALID);
435
 
 
436
 
    }
437
 
}
438
 
 
439
 
 
440
 
static void
441
 
on_menu_disconnect(GtkAction *action, WorkraveApplet *a)
442
 
{
443
 
  if (!workrave_is_running())
444
 
    {
445
 
      return;
446
 
    }
447
 
  
448
 
  if (g_applet->ui != NULL)
449
 
    {
450
 
      dbus_g_proxy_begin_call(g_applet->ui, "NetworkDisconnect", dbus_callback, NULL, NULL,
451
 
                             G_TYPE_INVALID);
452
 
    }
453
 
}
454
 
 
455
 
static void
456
 
on_menu_reconnect(GtkAction *action, WorkraveApplet *a)
457
 
{
458
 
  if (!workrave_is_running())
459
 
    {
460
 
      return;
461
 
    }
462
 
  
463
 
  if (g_applet->ui != NULL)
464
 
    {
465
 
      dbus_g_proxy_begin_call(g_applet->ui, "NetworkReconnect", dbus_callback, NULL, NULL,
466
 
                             G_TYPE_INVALID);
467
 
    }
468
 
}
469
 
 
470
 
 
471
 
 
472
 
static void
473
 
on_menu_quit(GtkAction *action, WorkraveApplet *a)
474
 
{
475
 
  if (!workrave_is_running())
476
 
    {
477
 
      return;
478
 
    }
479
 
  
480
 
  if (g_applet->ui != NULL)
481
 
    {
482
 
      dbus_g_proxy_begin_call(g_applet->ui, "Quit", dbus_callback, NULL, NULL,
483
 
                             G_TYPE_INVALID);
484
 
    }
485
 
}
486
 
 
487
 
static void
488
 
change_orient(PanelApplet *applet, PanelAppletOrient o, gpointer data)
489
 
{
490
 
  switch (o)
491
 
    {
492
 
    case PANEL_APPLET_ORIENT_UP:
493
 
      g_applet->orientation = 0;
494
 
      break;
495
 
    case PANEL_APPLET_ORIENT_RIGHT:
496
 
      g_applet->orientation = 1;
497
 
      break;
498
 
    case PANEL_APPLET_ORIENT_DOWN:
499
 
      g_applet->orientation = 2;
500
 
      break;
501
 
    case PANEL_APPLET_ORIENT_LEFT:
502
 
      g_applet->orientation = 3;
503
 
      break;
504
 
    }
505
 
 
506
 
  if (g_applet->support != NULL && workrave_is_running())
507
 
    {
508
 
      dbus_g_proxy_begin_call(g_applet->support, "SetOrientation", dbus_callback, NULL, NULL,
509
 
                             G_TYPE_UINT, g_applet->orientation, G_TYPE_INVALID);
510
 
 
511
 
 
512
 
    }
513
 
}
514
 
 
515
 
static void
516
 
change_background(PanelApplet * widget,
517
 
                  PanelAppletBackgroundType type,
518
 
                  GdkColor * color,
519
 
                  GdkPixmap * pixmap,
520
 
                  void *data)
521
 
{
522
 
  static GdkPixmap *keep = NULL;
523
 
  long xid = 0;
524
 
  GValueArray *val = g_value_array_new(4);
525
 
 
526
 
  if (type == PANEL_NO_BACKGROUND)
527
 
    {
528
 
      GtkStyle *style = gtk_widget_get_style(GTK_WIDGET(widget));
529
 
 
530
 
      if (style->bg_pixmap[GTK_STATE_NORMAL])
531
 
        {
532
 
          pixmap = style->bg_pixmap[GTK_STATE_NORMAL];
533
 
          type = PANEL_PIXMAP_BACKGROUND;
534
 
        }
535
 
      else
536
 
        {
537
 
          color = &style->bg[GTK_STATE_NORMAL];
538
 
          if (color != NULL)
539
 
            {
540
 
              type = PANEL_COLOR_BACKGROUND;
541
 
            }
542
 
        }
543
 
    }
544
 
  
545
 
  if (type == PANEL_COLOR_BACKGROUND && color != NULL)
546
 
    {
547
 
      g_value_array_append(val, NULL);
548
 
      g_value_init(g_value_array_get_nth(val, 0), G_TYPE_UINT);
549
 
      g_value_set_uint(g_value_array_get_nth(val, 0), color->pixel);
550
 
 
551
 
      g_value_array_append(val, NULL);
552
 
      g_value_init(g_value_array_get_nth(val, 1), G_TYPE_UINT);
553
 
      g_value_set_uint(g_value_array_get_nth(val, 1), color->red);
554
 
      
555
 
      g_value_array_append(val, NULL);
556
 
      g_value_init(g_value_array_get_nth(val, 2), G_TYPE_UINT);
557
 
      g_value_set_uint(g_value_array_get_nth(val, 2), color->green);
558
 
 
559
 
      g_value_array_append(val, NULL);
560
 
      g_value_init(g_value_array_get_nth(val, 3), G_TYPE_UINT);
561
 
      g_value_set_uint(g_value_array_get_nth(val, 3), color->blue);
562
 
    }
563
 
  else
564
 
    {
565
 
      int i;
566
 
      for (i = 0; i < 4; i++)
567
 
        {
568
 
          g_value_array_prepend(val, NULL);
569
 
          g_value_init(g_value_array_get_nth(val, 0), G_TYPE_UINT);
570
 
          g_value_set_uint(g_value_array_get_nth(val, 0), 0);
571
 
        }
572
 
    }
573
 
  
574
 
  if (type == PANEL_PIXMAP_BACKGROUND)
575
 
    {
576
 
      if (keep != NULL)
577
 
        {
578
 
          gdk_pixmap_unref(keep);
579
 
          keep = pixmap;
580
 
        }
581
 
      if (pixmap != NULL)
582
 
        {
583
 
          gdk_pixmap_ref(pixmap);
584
 
        }
585
 
 
586
 
      xid = GDK_PIXMAP_XID(pixmap);
587
 
    }
588
 
 
589
 
  if (g_applet->support != NULL && workrave_is_running())
590
 
    {
591
 
      dbus_g_proxy_begin_call(g_applet->support, "SetBackground", dbus_callback, NULL, NULL,
592
 
                              G_TYPE_UINT, type,
593
 
                              G_TYPE_VALUE_ARRAY, val,
594
 
                              G_TYPE_UINT, xid,
595
 
                              G_TYPE_INVALID);
596
 
      
597
 
 
598
 
    }
599
 
 
600
 
  g_value_array_free(val);
601
 
}
602
 
 
603
 
 
604
 
static gboolean
605
 
plug_removed(GtkSocket *socket, void *manager)
606
 
{
607
 
  gtk_widget_show(GTK_WIDGET(g_applet->image));
608
 
  gtk_widget_hide(GTK_WIDGET(g_applet->socket));
609
 
  workrave_applet_set_all_visible(FALSE);
610
 
  return TRUE;
611
 
}
612
 
 
613
 
 
614
 
static gboolean
615
 
plug_added(GtkSocket *socket, void *manager)
616
 
{
617
 
  gtk_widget_hide(GTK_WIDGET(g_applet->image));
618
 
  gtk_widget_show(GTK_WIDGET(g_applet->socket));
619
 
  workrave_applet_set_all_visible(TRUE);
620
 
  return TRUE;
621
 
}
622
 
 
623
 
 
624
 
static gboolean
625
 
button_pressed(GtkWidget *widget, GdkEventButton *event, gpointer data)
626
 
{
627
 
  gboolean ret = FALSE;
628
 
  
629
 
  if (event->button == 1)
630
 
    {
631
 
      if (g_applet->support != NULL && workrave_is_running())
632
 
        {
633
 
          dbus_g_proxy_begin_call(g_applet->support, "ButtonClicked", dbus_callback, NULL, NULL,
634
 
                                  G_TYPE_UINT, event->button, G_TYPE_INVALID);
635
 
 
636
 
          ret = TRUE;
637
 
        }
638
 
    }
639
 
 
640
 
  return ret;
641
 
}
642
 
 
643
 
static void
644
 
showlog_callback(GtkAction *action, WorkraveApplet *a)
645
 
{
646
 
  gboolean new_state = FALSE;
647
 
 
648
 
  if (GTK_IS_TOGGLE_ACTION(action))
649
 
    {
650
 
      GtkToggleAction *toggle = GTK_TOGGLE_ACTION(action);
651
 
      new_state = gtk_toggle_action_get_active(toggle);
652
 
    }
653
 
 
654
 
  g_applet->last_showlog_state = new_state;
655
 
 
656
 
  if (g_applet->ui != NULL && workrave_is_running())
657
 
    {
658
 
      dbus_g_proxy_begin_call(g_applet->ui, "NetworkLog", dbus_callback, NULL, NULL,
659
 
                              G_TYPE_BOOLEAN, new_state, G_TYPE_INVALID);
660
 
    }
661
 
}
662
 
 
663
 
static void
664
 
reading_mode_callback(GtkAction *action, WorkraveApplet *a)
665
 
{
666
 
  gboolean new_state = FALSE;
667
 
 
668
 
  if (GTK_IS_TOGGLE_ACTION(action))
669
 
    {
670
 
      GtkToggleAction *toggle = GTK_TOGGLE_ACTION(action);
671
 
      new_state = gtk_toggle_action_get_active(toggle);
672
 
    }
673
 
 
674
 
  g_applet->last_reading_mode_state = new_state;
675
 
  
676
 
  if (g_applet->ui != NULL && workrave_is_running())
677
 
    {
678
 
      dbus_g_proxy_begin_call(g_applet->ui, "ReadingMode", dbus_callback, NULL, NULL,
679
 
                              G_TYPE_BOOLEAN, new_state, G_TYPE_INVALID);
680
 
    }
681
 
}
682
 
 
683
 
static void
684
 
mode_callback(GtkAction *action, WorkraveApplet *a)
685
 
{
686
 
  const char *modes[] = { "normal", "suspended", "quiet" };
687
 
  int mode = 0;
688
 
 
689
 
  if (GTK_IS_RADIO_ACTION(action))
690
 
    {
691
 
      GtkRadioAction *toggle = GTK_RADIO_ACTION(action);
692
 
      mode = gtk_radio_action_get_current_value(toggle);
693
 
    }
694
 
 
695
 
  if (mode >= 0 && mode < G_N_ELEMENTS(modes))
696
 
    {
697
 
      g_applet->last_mode = mode;
698
 
          
699
 
      if (g_applet->ui != NULL && workrave_is_running())
700
 
        {
701
 
          dbus_g_proxy_begin_call(g_applet->core, "SetOperationMode", dbus_callback, NULL, NULL,
702
 
                                  G_TYPE_STRING, modes[mode], G_TYPE_INVALID);
703
 
        }
704
 
    }
705
 
}
706
 
 
707
 
 
708
 
static void
709
 
workrave_applet_set_visible(gchar *name, gboolean visible)
710
 
{
711
 
  GtkAction *action;
712
 
 
713
 
  action = gtk_action_group_get_action(g_applet->action_group, name);
714
 
  gtk_action_set_visible(action, visible);
715
 
}
716
 
 
717
 
 
718
 
static void
719
 
workrave_applet_set_all_visible(gboolean visible)
720
 
{
721
 
  workrave_applet_set_visible("Preferences", visible);
722
 
  workrave_applet_set_visible("Restbreak", visible);
723
 
  workrave_applet_set_visible("Network", visible);
724
 
  workrave_applet_set_visible("Normal", visible);
725
 
  workrave_applet_set_visible("Suspended", visible);
726
 
  workrave_applet_set_visible("Quiet", visible);
727
 
  workrave_applet_set_visible("Mode", visible);
728
 
  workrave_applet_set_visible("Statistics", visible);
729
 
  workrave_applet_set_visible("Exercises", visible);
730
 
  workrave_applet_set_visible("ReadingMode", visible);
731
 
  workrave_applet_set_visible("Quit", visible);
732
 
}
733
 
 
734
 
 
735
 
/* stolen from clock applet :) */
736
 
static inline void
737
 
force_no_focus_padding(GtkWidget *widget)
738
 
{
739
 
  static gboolean first = TRUE;
740
 
 
741
 
  if (first)
742
 
    {
743
 
      gtk_rc_parse_string ("\n"
744
 
                           "   style \"hdate-applet-button-style\"\n"
745
 
                           "   {\n"
746
 
                           "      GtkWidget::focus-line-width=0\n"
747
 
                           "      GtkWidget::focus-padding=0\n"
748
 
                           "   }\n"
749
 
                           "\n"
750
 
                           "    widget \"*.hdate-applet-button\" style \"hdate-applet-button-style\"\n"
751
 
                           "\n");
752
 
      first = FALSE;
753
 
    }
754
 
 
755
 
  gtk_widget_set_name(widget, "hdate-applet-button");
756
 
}
757
 
 
758
 
void size_allocate(GtkWidget     *widget,
759
 
                   GtkAllocation *allocation,
760
 
                   gpointer       user_data)
761
 
{
762
 
  static int prev_width = -1;
763
 
  static int prev_height = -1;
764
 
 
765
 
  if (prev_height == -1 || prev_width == -1 ||
766
 
      allocation->width != prev_width ||
767
 
      allocation->height != prev_height)
768
 
    {
769
 
      prev_height = allocation->height;
770
 
      prev_width = allocation->width;
771
 
 
772
 
      if (g_applet->orientation == 1 ||
773
 
          g_applet->orientation == 3)
774
 
        {
775
 
          g_applet->size = allocation->width;
776
 
        }
777
 
      else
778
 
        {
779
 
          g_applet->size = allocation->height;
780
 
        }
781
 
 
782
 
      if (g_applet->support != NULL && workrave_is_running())
783
 
        {
784
 
          dbus_g_proxy_begin_call(g_applet->support, "SetSize", dbus_callback, NULL, NULL,
785
 
                                  G_TYPE_UINT, g_applet->size,
786
 
                                  G_TYPE_INVALID);
787
 
      
788
 
        }
789
 
    }
790
 
}
791
 
      
792
 
 
793
 
static
794
 
void workrave_applet_destroy(GtkObject *object)
795
 
{
796
 
  workrave_dbus_server_cleanup();
797
 
}
798
 
 
799
 
 
800
 
static void
801
 
workrave_applet_realize(GtkWidget *widget, void *data)
802
 
{
803
 
}
804
 
 
805
 
 
806
 
static void
807
 
workrave_applet_unrealize(GtkWidget *widget, void *data)
808
 
{
809
 
  if (g_applet != NULL)
810
 
    {
811
 
      g_object_unref(g_applet);
812
 
      g_applet = NULL;
813
 
    }
814
 
 
815
 
  workrave_dbus_server_cleanup();
816
 
}
817
 
 
818
 
static const GtkActionEntry menu_actions [] = {
819
 
  { "Open", GTK_STOCK_OPEN, N_("_Open"),
820
 
    NULL, NULL,
821
 
    G_CALLBACK(on_menu_open) },
822
 
 
823
 
  { "Statistics", NULL, N_("_Statistics"),
824
 
    NULL, NULL,
825
 
    G_CALLBACK(on_menu_statistics) },
826
 
 
827
 
  { "Preferences", GTK_STOCK_PREFERENCES, N_("_Preferences"),
828
 
    NULL, NULL,
829
 
    G_CALLBACK(on_menu_preferences) },
830
 
  
831
 
  { "Exercises", NULL, N_("_Exercises"),
832
 
    NULL, NULL,
833
 
    G_CALLBACK(on_menu_exercises) },
834
 
 
835
 
  { "Restbreak", NULL, N_("_Restbreak"),
836
 
    NULL, NULL,
837
 
    G_CALLBACK(on_menu_restbreak) },
838
 
 
839
 
  { "Mode", NULL, N_("_Mode"),
840
 
    NULL, NULL,
841
 
    NULL },
842
 
 
843
 
  { "Network", NULL, N_("_Network"),
844
 
    NULL, NULL,
845
 
    NULL },
846
 
 
847
 
  { "Join", NULL, N_("_Join"),
848
 
    NULL, NULL,
849
 
    G_CALLBACK(on_menu_connect) },
850
 
 
851
 
  { "Disconnect", NULL, N_("_Disconnect"),
852
 
    NULL, NULL,
853
 
    G_CALLBACK(on_menu_disconnect) },
854
 
 
855
 
  { "Reconnect", NULL, N_("_Reconnect"),
856
 
    NULL, NULL,
857
 
    G_CALLBACK(on_menu_reconnect) },
858
 
 
859
 
  { "About", GTK_STOCK_ABOUT, N_("_About"),
860
 
    NULL, NULL,
861
 
    G_CALLBACK(on_menu_about) },
862
 
 
863
 
  { "Quit", GTK_STOCK_QUIT, N_("_Quit"),
864
 
    NULL, NULL,
865
 
    G_CALLBACK(on_menu_quit) },
866
 
};
867
 
 
868
 
 
869
 
static const GtkToggleActionEntry toggle_actions[] = {
870
 
    { "ShowLog", NULL, N_("Show log"),
871
 
      NULL, NULL,
872
 
      G_CALLBACK(showlog_callback), FALSE },
873
 
 
874
 
    { "ReadingMode", NULL, N_("Reading mode"),
875
 
      NULL, NULL,
876
 
      G_CALLBACK(reading_mode_callback), FALSE },
877
 
};
878
 
 
879
 
static const GtkRadioActionEntry mode_actions[] = {
880
 
    { "Normal", NULL, N_("Normal"),
881
 
      NULL, NULL,
882
 
      0 },
883
 
 
884
 
    { "Suspended", NULL, N_("Suspended"),
885
 
      NULL, NULL,
886
 
      1 },
887
 
 
888
 
    { "Quiet", NULL, N_("Quiet"),
889
 
      NULL, NULL,
890
 
      2 },
891
 
};
892
 
 
893
 
 
894
 
static gboolean
895
 
workrave_applet_fill(PanelApplet *applet)
896
 
{
897
 
  GdkPixbuf *pixbuf = NULL;
898
 
  GtkWidget *hbox = NULL;
899
 
  PanelAppletOrient orient;
900
 
 
901
 
  g_applet->action_group = gtk_action_group_new("WorkraveAppletActions");
902
 
  gtk_action_group_set_translation_domain(g_applet->action_group, GETTEXT_PACKAGE);
903
 
  gtk_action_group_add_actions(g_applet->action_group,
904
 
                               menu_actions,
905
 
                               G_N_ELEMENTS (menu_actions),
906
 
                               applet);
907
 
  gtk_action_group_add_toggle_actions(g_applet->action_group,
908
 
                                      toggle_actions,
909
 
                                      G_N_ELEMENTS (toggle_actions),
910
 
                                      applet);
911
 
  gtk_action_group_add_radio_actions (g_applet->action_group,
912
 
                                      mode_actions,
913
 
                                      G_N_ELEMENTS(mode_actions),
914
 
                                      0,
915
 
                                      G_CALLBACK(mode_callback),
916
 
                                      NULL);
917
 
 
918
 
 gchar *ui_path = g_build_filename(WORKRAVE_UIDATADIR, "workrave-applet-menu.xml", NULL);
919
 
  panel_applet_setup_menu_from_file(applet, ui_path, g_applet->action_group);
920
 
  g_free(ui_path);
921
 
  //g_object_unref(action_group);
922
 
  
923
 
  panel_applet_set_flags(PANEL_APPLET(applet),
924
 
                         PANEL_APPLET_EXPAND_MINOR);
925
 
 
926
 
  gtk_container_set_border_width(GTK_CONTAINER(applet), 0);
927
 
  panel_applet_set_background_widget(applet, GTK_WIDGET(applet));
928
 
  gtk_widget_set_events(GTK_WIDGET(applet),
929
 
                        gtk_widget_get_events(GTK_WIDGET(applet)) | GDK_BUTTON_PRESS_MASK);
930
 
 
931
 
 
932
 
  g_signal_connect(G_OBJECT(applet), "button_press_event", G_CALLBACK(button_pressed),
933
 
                   g_applet);
934
 
 
935
 
  // Socket.
936
 
  g_applet->socket = gtk_socket_new();
937
 
  gtk_container_set_border_width(GTK_CONTAINER(g_applet->socket), 0);
938
 
 
939
 
  // Image
940
 
  pixbuf = gdk_pixbuf_new_from_file(WORKRAVE_PKGDATADIR "/images/workrave-icon-medium.png", NULL);
941
 
  g_applet->image = gtk_image_new_from_pixbuf(pixbuf);
942
 
 
943
 
  // Signals.
944
 
  g_signal_connect(g_applet->socket, "plug_removed", G_CALLBACK(plug_removed), NULL);
945
 
  g_signal_connect(g_applet->socket, "plug_added", G_CALLBACK(plug_added), NULL);
946
 
  g_signal_connect(G_OBJECT(applet), "change_orient", G_CALLBACK(change_orient), NULL);
947
 
 
948
 
  // Container.
949
 
  hbox = gtk_vbox_new(FALSE, 0);
950
 
  gtk_container_add(GTK_CONTAINER(applet), hbox);
951
 
  gtk_box_pack_end(GTK_BOX(hbox), g_applet->socket, TRUE, TRUE, 0);
952
 
  gtk_box_pack_end(GTK_BOX(hbox), g_applet->image, TRUE, TRUE, 0);
953
 
 
954
 
  gtk_container_set_border_width(GTK_CONTAINER(hbox), 0);
955
 
 
956
 
  g_applet->socket_id = gtk_socket_get_id(GTK_SOCKET(g_applet->socket));
957
 
  g_applet->size = panel_applet_get_size(applet);
958
 
 
959
 
  orient = panel_applet_get_orient(applet);
960
 
 
961
 
  switch (orient)
962
 
    {
963
 
    case PANEL_APPLET_ORIENT_UP:
964
 
      g_applet->orientation = 0;
965
 
      break;
966
 
    case PANEL_APPLET_ORIENT_RIGHT:
967
 
      g_applet->orientation = 1;
968
 
      break;
969
 
    case PANEL_APPLET_ORIENT_DOWN:
970
 
      g_applet->orientation = 2;
971
 
      break;
972
 
    case PANEL_APPLET_ORIENT_LEFT:
973
 
      g_applet->orientation = 3;
974
 
      break;
975
 
    }
976
 
 
977
 
  force_no_focus_padding(GTK_WIDGET(applet));
978
 
  force_no_focus_padding(GTK_WIDGET(g_applet->socket));
979
 
  force_no_focus_padding(GTK_WIDGET(g_applet->image));
980
 
  force_no_focus_padding(GTK_WIDGET(hbox));
981
 
 
982
 
  g_signal_connect(G_OBJECT(applet), "destroy", G_CALLBACK(workrave_applet_destroy), NULL);
983
 
        g_signal_connect(G_OBJECT(hbox), "realize",   G_CALLBACK(workrave_applet_realize), NULL);
984
 
        g_signal_connect(G_OBJECT(hbox), "unrealize", G_CALLBACK(workrave_applet_unrealize), NULL);
985
 
  
986
 
  gtk_widget_show(GTK_WIDGET(g_applet->image));
987
 
  gtk_widget_show(GTK_WIDGET(g_applet->socket));
988
 
  gtk_widget_show(GTK_WIDGET(hbox));
989
 
  gtk_widget_show(GTK_WIDGET(applet));
990
 
 
991
 
  g_signal_connect(G_OBJECT(applet), "size-allocate", G_CALLBACK(size_allocate), NULL);
992
 
  g_signal_connect(G_OBJECT(applet), "change_background", G_CALLBACK(change_background), NULL);
993
 
 
994
 
  return TRUE;
995
 
}
996
 
 
997
 
 
998
 
static gboolean
999
 
workrave_applet_factory(PanelApplet *applet, const gchar *iid, gpointer data)
1000
 
{
1001
 
  gboolean retval = FALSE;
1002
 
 
1003
 
  if (!g_ascii_strcasecmp(iid, "WorkraveApplet"))
1004
 
    {
1005
 
      g_applet = workrave_applet_new();
1006
 
      g_applet->applet = applet;
1007
 
      
1008
 
      workrave_dbus_server_init();
1009
 
      retval = workrave_applet_fill(applet);
1010
 
 
1011
 
      if (g_applet->support != NULL)
1012
 
        {
1013
 
          dbus_g_proxy_begin_call(g_applet->support, "EmbedRequest", dbus_callback, NULL, NULL,
1014
 
                                  G_TYPE_INVALID);
1015
 
        }
1016
 
    }
1017
 
 
1018
 
  return retval;
1019
 
}
1020
 
 
1021
 
PANEL_APPLET_OUT_PROCESS_FACTORY("WorkraveAppletFactory",
1022
 
                                 PANEL_TYPE_APPLET,
1023
 
                                 "Workrave Applet",
1024
 
                                 workrave_applet_factory,
1025
 
                                 NULL)