← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ekiga/vivid-proposed

« back to all changes in this revision

Viewing changes to lib/gui/gmwindow.c

  • Committer: Bazaar Package Importer
  • Author(s): Kilian Krause
  • Date: 2011-07-17 00:24:50 UTC
  • mfrom: (5.1.5 upstream) (7.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20110717002450-ytg3wsrc1ptd3153
Tags: 3.3.1-1
* New upstream release.
 - Required libpt-dev 2.10 and libopal-dev 3.10
* Fix debian/watch to catch new version
* Remove libnotify0.7.patch - included upstream
* Add libboost-dev and libboost-signals-dev to Build-Depends
* debian/rules: Don't install *.la files for new internal shared libs
* Fix Vcs URIs to point to correct desktop/experimental/ekiga tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/gui/gmwindow.c
1
1
 
2
2
/* Ekiga -- A VoIP and Video-Conferencing application
3
 
 * Copyright (C) 2000-2006 Damien Sandras
 
3
 * Copyright (C) 2000-2009 Damien Sandras <dsandras@seconix.com>
4
4
 *
5
5
 * This program is free software; you can redistribute it and/or modify
6
6
 * it under the terms of the GNU General Public License as published by
36
36
 *
37
37
 */
38
38
 
 
39
#include "config.h"
 
40
 
39
41
#include "gmwindow.h"
40
42
 
41
43
#include "gmconf.h"
44
46
#include <string.h>
45
47
#include <stdlib.h>
46
48
 
 
49
#ifndef WIN32
 
50
#include <gdk/gdkx.h>
 
51
#include <X11/Xlib.h>
 
52
#endif
 
53
 
 
54
#define USER_INTERFACE_KEY "/apps/" PACKAGE_NAME "/general/user_interface/"
47
55
 
48
56
/*
49
57
 * The GmWindow
53
61
  GtkAccelGroup *accel;
54
62
  gboolean hide_on_esc;
55
63
  gboolean hide_on_delete;
56
 
  const gchar *key;
 
64
  gchar *key;
57
65
  int x;
58
66
  int y;
59
67
  int width;
66
74
  GM_HIDE_ON_DELETE = 3
67
75
};
68
76
 
69
 
static GObjectClass *parent_class = NULL;
 
77
G_DEFINE_TYPE (GmWindow, gm_window, GTK_TYPE_WINDOW);
70
78
 
71
79
static gboolean
72
80
gm_window_delete_event (GtkWidget *w,
73
81
                        gpointer data);
74
82
 
75
83
static void
76
 
gm_window_show (GtkWidget *w,
77
 
                gpointer data);
 
84
window_show_cb (GtkWidget *w,
 
85
                gpointer data);
78
86
 
79
87
static void
80
 
gm_window_hide (GtkWidget *w,
81
 
                gpointer data);
 
88
window_hide_cb (GtkWidget *w,
 
89
                gpointer data);
82
90
 
83
91
static gboolean 
84
92
gm_window_configure_event (GtkWidget *widget,
88
96
/* 
89
97
 * GObject stuff
90
98
 */
91
 
static void
92
 
gm_window_dispose (GObject *obj)
93
 
{
94
 
  GmWindow *window = NULL;
95
 
 
96
 
  window = GM_WINDOW (obj);
97
 
 
98
 
  parent_class->dispose (obj);
99
 
}
100
 
 
101
99
 
102
100
static void
103
101
gm_window_finalize (GObject *obj)
106
104
 
107
105
  window = GM_WINDOW (obj);
108
106
 
109
 
  g_free ((gchar *) window->priv->key);
 
107
  g_free (window->priv->key);
 
108
  window->priv->key = NULL;
110
109
 
111
 
  parent_class->finalize (obj);
 
110
  G_OBJECT_CLASS (gm_window_parent_class)->finalize (obj);
112
111
}
113
112
 
114
113
 
121
120
  GmWindow *self = NULL;
122
121
 
123
122
  self = GM_WINDOW (obj);
124
 
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_WINDOW_TYPE, GmWindowPrivate);
 
123
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_TYPE_WINDOW, GmWindowPrivate);
125
124
 
126
125
  switch (prop_id) {
127
126
 
154
153
  const gchar *str = NULL;
155
154
 
156
155
  self = GM_WINDOW (obj);
157
 
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_WINDOW_TYPE, GmWindowPrivate);
 
156
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_TYPE_WINDOW, GmWindowPrivate);
158
157
 
159
158
  switch (prop_id) {
160
159
 
161
160
  case GM_WINDOW_KEY:
162
 
    g_free ((gchar *) self->priv->key);
 
161
    if (self->priv->key)
 
162
      g_free (self->priv->key);
163
163
    str = g_value_get_string (value);
164
164
    self->priv->key = g_strdup (str ? str : "");
165
165
    break;
185
185
 
186
186
 
187
187
static void
188
 
gm_window_class_init (gpointer g_class,
189
 
                      G_GNUC_UNUSED gpointer class_data)
 
188
gm_window_class_init (GmWindowClass* klass)
190
189
{
191
 
  GObjectClass *gobject_class = NULL;
 
190
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
192
191
  GParamSpec *spec = NULL;
193
192
 
194
 
  parent_class = (GObjectClass *) g_type_class_peek_parent (g_class);
195
 
  g_type_class_add_private (g_class, sizeof (GmWindowPrivate));
 
193
  g_type_class_add_private (klass, sizeof (GmWindowPrivate));
196
194
 
197
 
  gobject_class = (GObjectClass *) g_class;
198
 
  gobject_class->dispose = gm_window_dispose;
199
195
  gobject_class->finalize = gm_window_finalize;
200
196
  gobject_class->get_property = gm_window_get_property;
201
197
  gobject_class->set_property = gm_window_set_property;
215
211
 
216
212
 
217
213
static void
218
 
gm_window_init (GTypeInstance *instance,
219
 
                gpointer g_class)
 
214
gm_window_init (GmWindow* self)
220
215
{
221
 
  GmWindow *self = NULL;
222
 
 
223
 
  (void) g_class; /* -Wextra */
224
 
 
225
 
  self = GM_WINDOW (instance);
226
 
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_WINDOW_TYPE, GmWindowPrivate);
 
216
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_TYPE_WINDOW, GmWindowPrivate);
227
217
  self->priv->key = g_strdup ("");
228
218
  self->priv->hide_on_esc = TRUE;
229
219
  self->priv->hide_on_delete = TRUE;
233
223
  gtk_accel_group_connect (self->priv->accel, GDK_Escape, (GdkModifierType) 0, GTK_ACCEL_LOCKED,
234
224
                           g_cclosure_new_swap (G_CALLBACK (gtk_widget_hide), (gpointer) self, NULL));
235
225
 
236
 
  g_signal_connect (G_OBJECT (self), "delete_event",
 
226
  g_signal_connect (self, "delete_event",
237
227
                    G_CALLBACK (gm_window_delete_event), NULL);
238
228
 
239
 
  g_signal_connect (G_OBJECT (self), "show",
240
 
                    G_CALLBACK (gm_window_show), self);
241
 
 
242
 
  g_signal_connect (G_OBJECT (self), "hide",
243
 
                    G_CALLBACK (gm_window_hide), self);
244
 
 
245
 
  g_signal_connect (G_OBJECT (self), "configure-event",
 
229
  g_signal_connect (self, "show",
 
230
                    G_CALLBACK (window_show_cb), self);
 
231
 
 
232
  g_signal_connect (self, "hide",
 
233
                    G_CALLBACK (window_hide_cb), self);
 
234
 
 
235
  g_signal_connect (self, "configure-event",
246
236
                    G_CALLBACK (gm_window_configure_event), self);
247
237
}
248
238
 
249
 
 
250
 
GType
251
 
gm_window_get_type ()
252
 
{
253
 
  static GType result = 0;
254
 
 
255
 
  if (result == 0) {
256
 
 
257
 
    static const GTypeInfo info = {
258
 
      sizeof (GmWindowClass),
259
 
      NULL,
260
 
      NULL,
261
 
      gm_window_class_init,
262
 
      NULL,
263
 
      NULL,
264
 
      sizeof (GmWindow),
265
 
      0,
266
 
      gm_window_init,
267
 
      NULL
268
 
    };
269
 
 
270
 
    result = g_type_register_static (GTK_TYPE_WINDOW,
271
 
                                     "GmWindowType",
272
 
                                     &info, (GTypeFlags) 0);
273
 
  }
274
 
 
275
 
  return result;
276
 
}
277
 
 
278
 
 
279
239
/* 
280
240
 * Our own stuff
281
241
 */
282
242
 
283
243
static gboolean
 
244
delete_event_cb (GtkWidget* window,
 
245
                 G_GNUC_UNUSED gpointer data)
 
246
{
 
247
  gm_window_hide (window);
 
248
 
 
249
  return TRUE;
 
250
}
 
251
 
 
252
static gboolean
284
253
gm_window_delete_event (GtkWidget *w,
285
254
                        G_GNUC_UNUSED gpointer data)
286
255
{
296
265
  }
297
266
}
298
267
 
299
 
 
300
268
static void
301
 
gm_window_show (GtkWidget *w,
 
269
window_show_cb (GtkWidget *w,
302
270
                G_GNUC_UNUSED gpointer data)
303
271
{
304
272
  int x = 0;
311
279
  gchar *size = NULL;
312
280
  gchar *position = NULL;
313
281
  gchar **couple = NULL;
314
 
 
315
 
  g_return_if_fail (w != NULL);
316
282
  
317
283
  self = GM_WINDOW (w);
318
284
 
366
332
 
367
333
 
368
334
static void
369
 
gm_window_hide (GtkWidget *w,
 
335
window_hide_cb (GtkWidget *w,
370
336
                G_GNUC_UNUSED gpointer data)
371
337
{
372
338
  GmWindow *self = NULL;
404
370
 
405
371
 
406
372
static gboolean 
407
 
gm_window_configure_event (GtkWidget *widget,
 
373
gm_window_configure_event (GtkWidget *self,
408
374
                           GdkEventConfigure *event)
409
375
{
410
 
  GM_WINDOW (widget)->priv->x = event->x;
411
 
  GM_WINDOW (widget)->priv->y = event->y;
 
376
  gtk_window_get_position (GTK_WINDOW (self), &GM_WINDOW (self)->priv->x, &GM_WINDOW (self)->priv->y);
412
377
 
413
 
  GM_WINDOW (widget)->priv->width = event->width;
414
 
  GM_WINDOW (widget)->priv->height = event->height;
 
378
  GM_WINDOW (self)->priv->width = event->width;
 
379
  GM_WINDOW (self)->priv->height = event->height;
415
380
 
416
381
  return FALSE;
417
382
}
423
388
GtkWidget *
424
389
gm_window_new ()
425
390
{
426
 
  return GTK_WIDGET (g_object_new (GM_WINDOW_TYPE, NULL));
 
391
  return GTK_WIDGET (g_object_new (GM_TYPE_WINDOW, NULL));
427
392
}
428
393
 
429
394
 
430
395
GtkWidget *
431
396
gm_window_new_with_key (const char *key)
432
397
{
433
 
  GtkWidget *window = NULL;
434
 
 
435
398
  g_return_val_if_fail (key != NULL, NULL);
436
399
 
437
 
  window = gm_window_new ();
438
 
  gm_window_set_key (GM_WINDOW (window), key);
439
 
 
440
 
  return window;
 
400
  return GTK_WIDGET (g_object_new (GM_TYPE_WINDOW, "key", key, NULL));
441
401
}
442
402
 
443
403
 
445
405
gm_window_set_key (GmWindow *window,
446
406
                   const char *key)
447
407
{
448
 
  g_return_if_fail (window != NULL);
 
408
  g_return_if_fail (GM_IS_WINDOW (window));
449
409
  g_return_if_fail (key != NULL);
450
410
 
451
 
  g_object_set (GM_WINDOW (window), "key", key, NULL);
 
411
  g_object_set (window, "key", key, NULL);
452
412
}
453
413
 
454
414
 
461
421
  gchar *size = NULL;
462
422
  gchar **couple = NULL;
463
423
 
464
 
  g_return_if_fail (self != NULL);
 
424
  g_return_if_fail (GM_IS_WINDOW (self) && x != NULL && y != NULL);
465
425
 
466
426
  conf_key_size = g_strdup_printf ("%s/size", self->priv->key);
467
427
  size = gm_conf_get_string (conf_key_size);
482
442
gm_window_set_hide_on_delete (GmWindow *window,
483
443
                              gboolean hide_on_delete)
484
444
{
485
 
  g_return_if_fail (window != NULL);
486
 
  g_return_if_fail (IS_GM_WINDOW (window));
 
445
  g_return_if_fail (GM_IS_WINDOW (window));
487
446
 
488
 
  g_object_set (GM_WINDOW (window), "hide_on_delete", hide_on_delete, NULL);
 
447
  g_object_set (window, "hide_on_delete", hide_on_delete, NULL);
489
448
}
490
449
 
491
450
gboolean
492
451
gm_window_get_hide_on_delete (GmWindow *window)
493
452
{
494
 
  g_return_val_if_fail (window != NULL, FALSE);
495
 
  g_return_val_if_fail (IS_GM_WINDOW (window), FALSE);
 
453
  g_return_val_if_fail (GM_IS_WINDOW (window), FALSE);
496
454
 
497
455
  return window->priv->hide_on_delete;
498
456
}
499
457
 
 
458
#ifndef WIN32
 
459
// helper copied from gdk
 
460
static void
 
461
gdk_wmspec_change_state (gboolean add,
 
462
                         GdkWindow *window,
 
463
                         GdkAtom state1,
 
464
                         GdkAtom state2);
 
465
#endif
 
466
 
 
467
void
 
468
gm_window_set_always_on_top (GdkWindow *window,
 
469
                             gboolean enable)
 
470
{
 
471
#ifndef WIN32
 
472
  gdk_wmspec_change_state (enable, window,
 
473
                           gdk_atom_intern ("_NET_WM_STATE_ABOVE", FALSE), 0);
 
474
#endif
 
475
}
 
476
 
 
477
 
 
478
gboolean
 
479
gm_window_is_visible (GtkWidget* w)
 
480
{
 
481
  return (gtk_widget_get_visible (w) && !(gdk_window_get_state (gtk_widget_get_window (w)) & GDK_WINDOW_STATE_ICONIFIED));
 
482
}
 
483
 
 
484
 
 
485
void
 
486
gm_window_show (GtkWidget* w)
 
487
{
 
488
  int x = 0;
 
489
  int y = 0;
 
490
 
 
491
  gchar* window_name = NULL;
 
492
  gchar* conf_key_size = NULL;
 
493
  gchar* conf_key_position = NULL;
 
494
  gchar* size = NULL;
 
495
  gchar* position = NULL;
 
496
  gchar** couple = NULL;
 
497
 
 
498
  g_return_if_fail (GTK_IS_WINDOW (w));
 
499
 
 
500
  if (gm_window_is_visible (w)) {
 
501
 
 
502
    gtk_window_present (GTK_WINDOW (w));
 
503
    return;
 
504
  } // else we do the show :
 
505
 
 
506
  window_name = (char *) g_object_get_data (G_OBJECT (w), "window_name");
 
507
 
 
508
  if (window_name) {
 
509
 
 
510
    conf_key_position = g_strdup_printf ("%s%s/position", USER_INTERFACE_KEY, window_name);
 
511
    conf_key_size = g_strdup_printf ("%s%s/size", USER_INTERFACE_KEY, window_name);
 
512
 
 
513
    if (!gm_window_is_visible (w)) {
 
514
 
 
515
      position = gm_conf_get_string (conf_key_position);
 
516
      if (position)
 
517
        couple = g_strsplit (position, ",", 0);
 
518
 
 
519
      if (couple && couple [0])
 
520
        x = atoi (couple [0]);
 
521
      if (couple && couple [1])
 
522
        y = atoi (couple [1]);
 
523
 
 
524
 
 
525
      if (x != 0 && y != 0)
 
526
        gtk_window_move (GTK_WINDOW (w), x, y);
 
527
 
 
528
      g_strfreev (couple);
 
529
      couple = NULL;
 
530
      g_free (position);
 
531
 
 
532
      if (gtk_window_get_resizable (GTK_WINDOW (w))) {
 
533
 
 
534
        size = gm_conf_get_string (conf_key_size);
 
535
        if (size)
 
536
          couple = g_strsplit (size, ",", 0);
 
537
 
 
538
        if (couple && couple [0])
 
539
          x = atoi (couple [0]);
 
540
        if (couple && couple [1])
 
541
          y = atoi (couple [1]);
 
542
 
 
543
        if (x > 0 && y > 0)
 
544
          gtk_window_resize (GTK_WINDOW (w), x, y);
 
545
 
 
546
        g_strfreev (couple);
 
547
        g_free (size);
 
548
      }
 
549
    }
 
550
 
 
551
    gtk_window_present (GTK_WINDOW (w));
 
552
    gtk_widget_show_all (w);
 
553
  }
 
554
 
 
555
  g_free (conf_key_position);
 
556
  g_free (conf_key_size);
 
557
}
 
558
 
 
559
 
 
560
void
 
561
gm_window_hide (GtkWidget* w)
 
562
{
 
563
  int x = 0;
 
564
  int y = 0;
 
565
 
 
566
  gchar* window_name = NULL;
 
567
  gchar* conf_key_size = NULL;
 
568
  gchar* conf_key_position = NULL;
 
569
  gchar* size = NULL;
 
570
  gchar* position = NULL;
 
571
 
 
572
  g_return_if_fail (GTK_IS_WINDOW (w));
 
573
 
 
574
  window_name = (char *) g_object_get_data (G_OBJECT (w), "window_name");
 
575
 
 
576
  g_return_if_fail (window_name != NULL);
 
577
 
 
578
  conf_key_position =
 
579
    g_strdup_printf ("%s%s/position", USER_INTERFACE_KEY, window_name);
 
580
  conf_key_size =
 
581
    g_strdup_printf ("%s%s/size", USER_INTERFACE_KEY, window_name);
 
582
 
 
583
 
 
584
  /* If the window is visible, save its position and hide the window */
 
585
  if (gm_window_is_visible (w)) {
 
586
 
 
587
    gtk_window_get_position (GTK_WINDOW (w), &x, &y);
 
588
    position = g_strdup_printf ("%d,%d", x, y);
 
589
    gm_conf_set_string (conf_key_position, position);
 
590
    g_free (position);
 
591
 
 
592
    if (gtk_window_get_resizable (GTK_WINDOW (w))) {
 
593
 
 
594
      gtk_window_get_size (GTK_WINDOW (w), &x, &y);
 
595
      size = g_strdup_printf ("%d,%d", x, y);
 
596
      gm_conf_set_string (conf_key_size, size);
 
597
      g_free (size);
 
598
    }
 
599
 
 
600
    gtk_widget_hide (w);
 
601
  }
 
602
 
 
603
  g_free (conf_key_position);
 
604
  g_free (conf_key_size);
 
605
}
 
606
 
 
607
void
 
608
gm_window_hide_on_delete (GtkWidget* window)
 
609
{
 
610
  g_return_if_fail (GTK_IS_WIDGET (window));
 
611
 
 
612
  g_signal_connect (window, "delete-event",
 
613
                    G_CALLBACK (delete_event_cb), NULL);
 
614
}
 
615
 
 
616
/* Stolen from GDK */
 
617
#ifndef WIN32
 
618
static void
 
619
gdk_wmspec_change_state (gboolean add,
 
620
                         GdkWindow *window,
 
621
                         GdkAtom state1,
 
622
                         GdkAtom state2)
 
623
{
 
624
  GdkDisplay *display = 
 
625
    gdk_screen_get_display (gdk_drawable_get_screen (GDK_DRAWABLE (window)));
 
626
  XEvent xev;
 
627
  
 
628
#define _NET_WM_STATE_REMOVE        0    /* remove/unset property */
 
629
#define _NET_WM_STATE_ADD           1    /* add/set property */
 
630
#define _NET_WM_STATE_TOGGLE        2    /* toggle property  */  
 
631
  
 
632
  xev.xclient.type = ClientMessage;
 
633
  xev.xclient.serial = 0;
 
634
  xev.xclient.send_event = True;
 
635
  xev.xclient.window = GDK_WINDOW_XID (window);
 
636
  xev.xclient.message_type = 
 
637
    gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE");
 
638
  xev.xclient.format = 32;
 
639
  xev.xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
 
640
  xev.xclient.data.l[1] = gdk_x11_atom_to_xatom_for_display (display, state1);
 
641
  xev.xclient.data.l[2] = gdk_x11_atom_to_xatom_for_display (display, state2);
 
642
  
 
643
  XSendEvent (GDK_WINDOW_XDISPLAY (window),
 
644
              GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (gdk_drawable_get_screen (GDK_DRAWABLE (window)))),
 
645
              False, SubstructureRedirectMask | SubstructureNotifyMask,
 
646
              &xev);
 
647
}
 
648
#endif