← 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: Bazaar Package Importer
  • Author(s): Francois Marier
  • Date: 2011-03-25 17:17:18 UTC
  • mfrom: (1.2.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20110325171718-3znn7qnfgmx20iyw
Tags: 1.9.4-1
* New upstream release
  - drop all Debian patches (applied upstream)

* Update location of .xpm menu icon
* Remove empty /usr/include directory after building
* Remove obsolete breaks/replaces from debian/control

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)