← Back to branch summary

~ubuntu-branches/ubuntu/wily/mutter/wily

« back to all changes in this revision

Viewing changes to .pc/18_gtk3_gdk_macros.patch/src/tools/mutter-window-demo.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Terry
  • Date: 2010-12-09 10:55:23 UTC
  • Revision ID: james.westby@ubuntu.com-20101209105523-a0fhznet2ssp9whv
Tags: 2.91.3-0ubuntu2
* Rebuild for libgirepository rename
* debian/patches/18_gtk3_gdk_macros.patch,
  debian/patches/19_gtk3_theme_states.patch,
  debian/patches/20_gtk3_testgradient.patch:
  - A collection of patches from upstream git to fix building against
    gtk3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/18_gtk3_gdk_macros.patch/src/tools/mutter-window-demo.c
 
1
/* Mutter window types/properties demo app */
 
2
 
 
3
/* 
 
4
 * Copyright (C) 2002 Havoc Pennington
 
5
 * 
 
6
 * This program is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU General Public License as
 
8
 * published by the Free Software Foundation; either version 2 of the
 
9
 * License, or (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful, but
 
12
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 * 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, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 
19
 * 02111-1307, USA.
 
20
 */
 
21
 
 
22
#include <gtk/gtk.h>
 
23
#include <gdk/gdkx.h>
 
24
#include <X11/Xatom.h>
 
25
#include <unistd.h>
 
26
 
 
27
static GtkWidget* do_appwindow (void);
 
28
 
 
29
static gboolean aspect_on;
 
30
 
 
31
static void
 
32
set_gdk_window_struts (GdkWindow *window,
 
33
                       int        left,
 
34
                       int        right,
 
35
                       int        top,
 
36
                       int        bottom)
 
37
{
 
38
  long vals[12];
 
39
  
 
40
  vals[0] = left;
 
41
  vals[1] = right;
 
42
  vals[2] = top;
 
43
  vals[3] = bottom;
 
44
  vals[4] = 000;
 
45
  vals[5] = 400;
 
46
  vals[6] = 200;
 
47
  vals[7] = 600;
 
48
  vals[8] = 76;
 
49
  vals[9] = 676;
 
50
  vals[10] = 200;
 
51
  vals[11] = 800;
 
52
 
 
53
  XChangeProperty (GDK_WINDOW_XDISPLAY (window),
 
54
                   GDK_WINDOW_XWINDOW (window),
 
55
                   XInternAtom (GDK_WINDOW_XDISPLAY (window),
 
56
                                "_NET_WM_STRUT_PARTIAL", False),
 
57
                   XA_CARDINAL, 32, PropModeReplace,
 
58
                   (guchar *)vals, 12);
 
59
}
 
60
 
 
61
static void
 
62
on_realize_set_struts (GtkWindow *window,
 
63
                       gpointer   data)
 
64
{
 
65
  GtkWidget *widget;
 
66
  int left;
 
67
  int right;
 
68
  int top;
 
69
  int bottom;
 
70
 
 
71
  widget = GTK_WIDGET (window);
 
72
 
 
73
  g_return_if_fail (gtk_widget_get_realized (widget));
 
74
 
 
75
  left = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "meta-strut-left"));
 
76
  right = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "meta-strut-right"));
 
77
  top = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "meta-strut-top"));
 
78
  bottom = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "meta-strut-bottom"));
 
79
  
 
80
  set_gdk_window_struts (gtk_widget_get_window (widget),
 
81
                         left, right, top, bottom);
 
82
}
 
83
 
 
84
static void
 
85
set_gtk_window_struts (GtkWidget  *window,
 
86
                       int         left,
 
87
                       int         right,
 
88
                       int         top,
 
89
                       int         bottom)
 
90
{
 
91
  GtkWidget *widget;
 
92
 
 
93
  widget = GTK_WIDGET (window);
 
94
 
 
95
  g_object_set_data (G_OBJECT (window), "meta-strut-left",
 
96
                     GINT_TO_POINTER (left));
 
97
  g_object_set_data (G_OBJECT (window), "meta-strut-right",
 
98
                     GINT_TO_POINTER (right));
 
99
  g_object_set_data (G_OBJECT (window), "meta-strut-top",
 
100
                     GINT_TO_POINTER (top));
 
101
  g_object_set_data (G_OBJECT (window), "meta-strut-bottom",
 
102
                     GINT_TO_POINTER (bottom));
 
103
 
 
104
  g_signal_handlers_disconnect_by_func (G_OBJECT (window),
 
105
                                        on_realize_set_struts,
 
106
                                        NULL);
 
107
 
 
108
  g_signal_connect_after (G_OBJECT (window),
 
109
                          "realize",
 
110
                          G_CALLBACK (on_realize_set_struts),
 
111
                          NULL);
 
112
 
 
113
  if (gtk_widget_get_realized (widget))
 
114
    set_gdk_window_struts (gtk_widget_get_window (widget),
 
115
                           left, right, top, bottom);
 
116
}
 
117
 
 
118
static void
 
119
set_gdk_window_type (GdkWindow  *window,
 
120
                     const char *type)
 
121
{
 
122
  Atom atoms[2] = { None, None };
 
123
  
 
124
  atoms[0] = XInternAtom (GDK_WINDOW_XDISPLAY (window),
 
125
                          type, False);
 
126
  
 
127
  XChangeProperty (GDK_WINDOW_XDISPLAY (window),
 
128
                   GDK_WINDOW_XWINDOW (window),
 
129
                   XInternAtom (GDK_WINDOW_XDISPLAY (window), "_NET_WM_WINDOW_TYPE", False),
 
130
                   XA_ATOM, 32, PropModeReplace,
 
131
                   (guchar *)atoms, 
 
132
                   1);
 
133
}
 
134
 
 
135
static void
 
136
on_realize_set_type (GtkWindow *window,
 
137
                     gpointer   data)
 
138
{
 
139
  GtkWidget *widget;
 
140
  const char *type;
 
141
 
 
142
  widget =  GTK_WIDGET (window);
 
143
 
 
144
  g_return_if_fail (gtk_widget_get_realized (widget));
 
145
 
 
146
  type = g_object_get_data (G_OBJECT (window), "meta-window-type");
 
147
 
 
148
  g_return_if_fail (type != NULL);
 
149
  
 
150
  set_gdk_window_type (gtk_widget_get_window (widget),
 
151
                       type);
 
152
}
 
153
 
 
154
static void
 
155
set_gtk_window_type (GtkWindow  *window,
 
156
                     const char *type)
 
157
{
 
158
  GtkWidget *widget;
 
159
 
 
160
  widget = GTK_WIDGET (window);
 
161
 
 
162
  g_object_set_data (G_OBJECT (window), "meta-window-type", (char*) type);
 
163
 
 
164
  g_signal_handlers_disconnect_by_func (G_OBJECT (window),
 
165
                                        on_realize_set_type,
 
166
                                        NULL);
 
167
                                
 
168
  g_signal_connect_after (G_OBJECT (window),
 
169
                          "realize",
 
170
                          G_CALLBACK (on_realize_set_type),
 
171
                          NULL);
 
172
 
 
173
  if (gtk_widget_get_realized (widget))
 
174
    set_gdk_window_type (gtk_widget_get_window (widget),
 
175
                         type);
 
176
}
 
177
 
 
178
static void
 
179
set_gdk_window_border_only (GdkWindow *window)
 
180
{
 
181
  gdk_window_set_decorations (window, GDK_DECOR_BORDER);
 
182
}
 
183
 
 
184
static void
 
185
on_realize_set_border_only (GtkWindow *window,
 
186
                            gpointer   data)
 
187
{
 
188
  GtkWidget *widget;
 
189
 
 
190
  widget = GTK_WIDGET (window);
 
191
 
 
192
  g_return_if_fail (gtk_widget_get_realized (widget));
 
193
  
 
194
  set_gdk_window_border_only (gtk_widget_get_window (widget));
 
195
}
 
196
 
 
197
static void
 
198
set_gtk_window_border_only (GtkWindow  *window)
 
199
{
 
200
  GtkWidget *widget;
 
201
 
 
202
  widget = GTK_WIDGET (window);
 
203
 
 
204
  g_signal_handlers_disconnect_by_func (G_OBJECT (window),
 
205
                                        on_realize_set_border_only,
 
206
                                        NULL);
 
207
                                
 
208
  g_signal_connect_after (G_OBJECT (window),
 
209
                          "realize",
 
210
                          G_CALLBACK (on_realize_set_border_only),
 
211
                          NULL);
 
212
 
 
213
  if (gtk_widget_get_realized (widget))
 
214
    set_gdk_window_border_only (gtk_widget_get_window (widget));
 
215
}
 
216
 
 
217
int
 
218
main (int argc, char **argv)
 
219
{
 
220
  GList *list;
 
221
  GdkPixbuf *pixbuf;
 
222
  GError *err;
 
223
  
 
224
  gtk_init (&argc, &argv);
 
225
 
 
226
  err = NULL;
 
227
  pixbuf = gdk_pixbuf_new_from_file (MUTTER_ICON_DIR"/mutter-window-demo.png",
 
228
                                     &err);
 
229
  if (pixbuf)
 
230
    {
 
231
      list = g_list_prepend (NULL, pixbuf);
 
232
      
 
233
      gtk_window_set_default_icon_list (list);
 
234
      g_list_free (list);
 
235
      g_object_unref (G_OBJECT (pixbuf));
 
236
    }
 
237
  else
 
238
    {
 
239
      g_printerr ("Could not load icon: %s\n", err->message);
 
240
      g_error_free (err);
 
241
    }
 
242
  
 
243
  do_appwindow ();
 
244
 
 
245
  gtk_main ();
 
246
  
 
247
  return 0;
 
248
}
 
249
 
 
250
static void
 
251
response_cb (GtkDialog *dialog,
 
252
             int        response_id,
 
253
             void      *data);
 
254
 
 
255
static void
 
256
make_dialog (GtkWidget *parent,
 
257
             int        depth)
 
258
{
 
259
  GtkWidget *dialog;
 
260
  char *str;
 
261
  
 
262
  dialog = gtk_message_dialog_new (parent ? GTK_WINDOW (parent) : NULL,
 
263
                                   GTK_DIALOG_DESTROY_WITH_PARENT,
 
264
                                   GTK_MESSAGE_INFO,
 
265
                                   GTK_BUTTONS_CLOSE,
 
266
                                   parent ? "Here is a dialog %d" :
 
267
                                   "Here is a dialog %d with no transient parent",
 
268
                                   depth);
 
269
 
 
270
  str = g_strdup_printf ("%d dialog", depth);
 
271
  gtk_window_set_title (GTK_WINDOW (dialog), str);
 
272
  g_free (str);
 
273
  
 
274
  gtk_dialog_add_button (GTK_DIALOG (dialog),
 
275
                         "Open child dialog",
 
276
                         GTK_RESPONSE_ACCEPT);
 
277
  
 
278
  /* Close dialog on user response */
 
279
  g_signal_connect (G_OBJECT (dialog),
 
280
                    "response",
 
281
                    G_CALLBACK (response_cb),
 
282
                    NULL);
 
283
 
 
284
  g_object_set_data (G_OBJECT (dialog), "depth",
 
285
                     GINT_TO_POINTER (depth));
 
286
  
 
287
  gtk_widget_show (dialog);
 
288
}
 
289
 
 
290
static void
 
291
response_cb (GtkDialog *dialog,
 
292
             int        response_id,
 
293
             void      *data)
 
294
{
 
295
  switch (response_id)
 
296
    {
 
297
    case GTK_RESPONSE_ACCEPT:
 
298
      make_dialog (GTK_WIDGET (dialog),
 
299
                   GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog),
 
300
                                                       "depth")) + 1);
 
301
      break;
 
302
 
 
303
    default:
 
304
      gtk_widget_destroy (GTK_WIDGET (dialog));
 
305
      break;
 
306
    }
 
307
}
 
308
 
 
309
static void
 
310
dialog_cb (GtkAction           *action,
 
311
           gpointer             callback_data)
 
312
{
 
313
  make_dialog (GTK_WIDGET (callback_data), 1);
 
314
}
 
315
 
 
316
static void
 
317
modal_dialog_cb (GtkAction           *action,
 
318
                 gpointer             callback_data)
 
319
{
 
320
  GtkWidget *dialog;
 
321
  
 
322
  dialog = gtk_message_dialog_new (GTK_WINDOW (callback_data),
 
323
                                   GTK_DIALOG_DESTROY_WITH_PARENT,
 
324
                                   GTK_MESSAGE_INFO,
 
325
                                   GTK_BUTTONS_CLOSE,
 
326
                                   "Here is a MODAL dialog");
 
327
 
 
328
  set_gtk_window_type (GTK_WINDOW (dialog), "_NET_WM_WINDOW_TYPE_MODAL_DIALOG");
 
329
  
 
330
  gtk_dialog_run (GTK_DIALOG (dialog));
 
331
 
 
332
  gtk_widget_destroy (dialog);
 
333
}
 
334
 
 
335
static void
 
336
no_parent_dialog_cb (GtkAction           *action,
 
337
                     gpointer             callback_data)
 
338
{
 
339
  make_dialog (NULL, 1);
 
340
}
 
341
 
 
342
static void
 
343
utility_cb (GtkAction           *action,
 
344
            gpointer             callback_data)
 
345
{
 
346
  GtkWidget *window;
 
347
  GtkWidget *vbox;
 
348
  GtkWidget *button;
 
349
  
 
350
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
351
  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_UTILITY");
 
352
  gtk_window_set_title (GTK_WINDOW (window), "Utility");
 
353
  
 
354
  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));
 
355
  
 
356
  vbox = gtk_vbox_new (FALSE, 0);
 
357
 
 
358
  gtk_container_add (GTK_CONTAINER (window), vbox);
 
359
 
 
360
  button = gtk_button_new_with_mnemonic ("_A button");
 
361
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
362
 
 
363
  button = gtk_button_new_with_mnemonic ("_B button");
 
364
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
365
 
 
366
  button = gtk_button_new_with_mnemonic ("_C button");
 
367
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
368
 
 
369
  button = gtk_button_new_with_mnemonic ("_D button");
 
370
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
371
  
 
372
  gtk_widget_show_all (window);
 
373
}
 
374
 
 
375
static void
 
376
toolbar_cb (GtkAction           *action,
 
377
            gpointer             callback_data)
 
378
{
 
379
  GtkWidget *window;
 
380
  GtkWidget *vbox;
 
381
  GtkWidget *label;
 
382
  
 
383
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
384
  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_TOOLBAR");
 
385
  gtk_window_set_title (GTK_WINDOW (window), "Toolbar");
 
386
  
 
387
  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));
 
388
  
 
389
  vbox = gtk_vbox_new (FALSE, 0);
 
390
 
 
391
  gtk_container_add (GTK_CONTAINER (window), vbox);
 
392
 
 
393
  label = gtk_label_new ("FIXME this needs a resize grip, etc.");
 
394
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
395
  
 
396
  gtk_widget_show_all (window);
 
397
}
 
398
 
 
399
static void
 
400
menu_cb (GtkAction           *action,
 
401
         gpointer             callback_data)
 
402
{
 
403
  GtkWidget *window;
 
404
  GtkWidget *vbox;
 
405
  GtkWidget *label;
 
406
  
 
407
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
408
  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_MENU");
 
409
  gtk_window_set_title (GTK_WINDOW (window), "Menu");
 
410
  
 
411
  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));
 
412
  
 
413
  vbox = gtk_vbox_new (FALSE, 0);
 
414
 
 
415
  gtk_container_add (GTK_CONTAINER (window), vbox);
 
416
 
 
417
  label = gtk_label_new ("FIXME this isn't a menu.");
 
418
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
419
  
 
420
  gtk_widget_show_all (window);
 
421
}
 
422
 
 
423
static void
 
424
override_redirect_cb (GtkAction           *action,
 
425
                      gpointer             callback_data)
 
426
{
 
427
  GtkWidget *window;
 
428
  GtkWidget *vbox;
 
429
  GtkWidget *label;
 
430
  
 
431
  window = gtk_window_new (GTK_WINDOW_POPUP);
 
432
  gtk_window_set_title (GTK_WINDOW (window), "Override Redirect");
 
433
  
 
434
  vbox = gtk_vbox_new (FALSE, 0);
 
435
 
 
436
  gtk_container_add (GTK_CONTAINER (window), vbox);
 
437
 
 
438
  label = gtk_label_new ("This is an override\nredirect window\nand should not be managed");
 
439
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
440
  
 
441
  gtk_widget_show_all (window);
 
442
}
 
443
 
 
444
static void
 
445
border_only_cb (GtkAction           *action,
 
446
                gpointer             callback_data)
 
447
{
 
448
  GtkWidget *window;
 
449
  GtkWidget *vbox;
 
450
  GtkWidget *label;
 
451
  
 
452
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
453
  set_gtk_window_border_only (GTK_WINDOW (window));
 
454
  gtk_window_set_title (GTK_WINDOW (window), "Border only");
 
455
  
 
456
  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (callback_data));
 
457
  
 
458
  vbox = gtk_vbox_new (FALSE, 0);
 
459
 
 
460
  gtk_container_add (GTK_CONTAINER (window), vbox);
 
461
 
 
462
  label = gtk_label_new ("This window is supposed to have a border but no titlebar.");
 
463
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
464
  
 
465
  gtk_widget_show_all (window);
 
466
}
 
467
 
 
468
#if 0
 
469
static void
 
470
changing_icon_cb (GtkAction           *action,
 
471
                  gpointer             callback_data)
 
472
{
 
473
  GtkWidget *window;
 
474
  GtkWidget *vbox;
 
475
  GtkWidget *label;
 
476
  
 
477
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
478
  gtk_window_set_title (GTK_WINDOW (window), "Changing Icon");
 
479
  
 
480
  vbox = gtk_vbox_new (FALSE, 0);
 
481
 
 
482
  gtk_container_add (GTK_CONTAINER (window), vbox);
 
483
 
 
484
  label = gtk_label_new ("This window has an icon that changes over time");
 
485
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
486
  
 
487
  gtk_widget_show_all (window);
 
488
}
 
489
#endif
 
490
 
 
491
static gboolean
 
492
focus_in_event_cb (GtkWidget *window,
 
493
                   GdkEvent  *event,
 
494
                   gpointer   data)
 
495
{
 
496
  GtkWidget *widget;
 
497
 
 
498
  widget = GTK_WIDGET (data);
 
499
 
 
500
  gtk_label_set_text (GTK_LABEL (widget), "Has focus");
 
501
 
 
502
  return TRUE;
 
503
}
 
504
 
 
505
 
 
506
static gboolean
 
507
focus_out_event_cb (GtkWidget *window,
 
508
                    GdkEvent  *event,
 
509
                    gpointer   data)
 
510
{
 
511
  GtkWidget *widget;
 
512
 
 
513
  widget = GTK_WIDGET (data);
 
514
 
 
515
  gtk_label_set_text (GTK_LABEL (widget), "Not focused");
 
516
  
 
517
  return TRUE;
 
518
}
 
519
 
 
520
static GtkWidget*
 
521
focus_label (GtkWidget *window)
 
522
{
 
523
  GtkWidget *label;
 
524
  
 
525
  label = gtk_label_new ("Not focused");
 
526
 
 
527
  g_signal_connect (G_OBJECT (window), "focus_in_event",
 
528
                    G_CALLBACK (focus_in_event_cb), label);
 
529
 
 
530
  g_signal_connect (G_OBJECT (window), "focus_out_event",
 
531
                    G_CALLBACK (focus_out_event_cb), label);
 
532
  
 
533
  return label;
 
534
}
 
535
 
 
536
static void
 
537
splashscreen_cb (GtkAction           *action,
 
538
                 gpointer             callback_data)
 
539
{
 
540
  GtkWidget *window;
 
541
  GtkWidget *image;
 
542
  GtkWidget *vbox;
 
543
  
 
544
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
545
  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_SPLASHSCREEN");
 
546
  gtk_window_set_title (GTK_WINDOW (window), "Splashscreen");
 
547
  
 
548
  vbox = gtk_vbox_new (FALSE, 0);
 
549
  
 
550
  image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
 
551
  gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
 
552
 
 
553
  gtk_box_pack_start (GTK_BOX (vbox), focus_label (window), FALSE, FALSE, 0);  
 
554
  
 
555
  gtk_container_add (GTK_CONTAINER (window), vbox);
 
556
  
 
557
  gtk_widget_show_all (window);
 
558
}
 
559
 
 
560
enum
 
561
{
 
562
  DOCK_TOP = 1,
 
563
  DOCK_BOTTOM = 2,
 
564
  DOCK_LEFT = 3,
 
565
  DOCK_RIGHT = 4,
 
566
  DOCK_ALL = 5
 
567
};
 
568
 
 
569
static void
 
570
make_dock (int type)
 
571
{
 
572
  GtkWidget *window;
 
573
  GtkWidget *image;
 
574
  GtkWidget *box;
 
575
  GtkWidget *button;
 
576
 
 
577
  g_return_if_fail (type != DOCK_ALL);
 
578
 
 
579
  box = NULL;
 
580
  switch (type)
 
581
    {
 
582
    case DOCK_LEFT:
 
583
    case DOCK_RIGHT:      
 
584
      box = gtk_vbox_new (FALSE, 0);
 
585
      break;
 
586
    case DOCK_TOP:
 
587
    case DOCK_BOTTOM:
 
588
      box = gtk_hbox_new (FALSE, 0);
 
589
      break;
 
590
    case DOCK_ALL:
 
591
      break;
 
592
    }
 
593
 
 
594
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
595
  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_DOCK");
 
596
  
 
597
  image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
 
598
  gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 0);  
 
599
  
 
600
  gtk_box_pack_start (GTK_BOX (box), focus_label (window), FALSE, FALSE, 0);  
 
601
 
 
602
  button = gtk_button_new_with_label ("Close");
 
603
  gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
 
604
 
 
605
  g_signal_connect_swapped (G_OBJECT (button), "clicked",
 
606
                            G_CALLBACK (gtk_widget_destroy), window);
 
607
  
 
608
  gtk_container_add (GTK_CONTAINER (window), box);
 
609
 
 
610
#define DOCK_SIZE 48
 
611
  switch (type)
 
612
    {
 
613
    case DOCK_LEFT:
 
614
      gtk_widget_set_size_request (window, DOCK_SIZE, 400);
 
615
      gtk_window_move (GTK_WINDOW (window), 0, 000);
 
616
      set_gtk_window_struts (window, DOCK_SIZE, 0, 0, 0);
 
617
      gtk_window_set_title (GTK_WINDOW (window), "LeftDock");
 
618
      break;
 
619
    case DOCK_RIGHT:      
 
620
      gtk_widget_set_size_request (window, DOCK_SIZE, 400);
 
621
      gtk_window_move (GTK_WINDOW (window), gdk_screen_width () - DOCK_SIZE, 200);
 
622
      set_gtk_window_struts (window, 0, DOCK_SIZE, 0, 0);
 
623
      gtk_window_set_title (GTK_WINDOW (window), "RightDock");
 
624
      break;
 
625
    case DOCK_TOP:
 
626
      gtk_widget_set_size_request (window, 600, DOCK_SIZE);
 
627
      gtk_window_move (GTK_WINDOW (window), 76, 0);
 
628
      set_gtk_window_struts (window, 0, 0, DOCK_SIZE, 0);
 
629
      gtk_window_set_title (GTK_WINDOW (window), "TopDock");
 
630
      break;
 
631
    case DOCK_BOTTOM:
 
632
      gtk_widget_set_size_request (window, 600, DOCK_SIZE);
 
633
      gtk_window_move (GTK_WINDOW (window), 200, gdk_screen_height () - DOCK_SIZE);
 
634
      set_gtk_window_struts (window, 0, 0, 0, DOCK_SIZE);
 
635
      gtk_window_set_title (GTK_WINDOW (window), "BottomDock");
 
636
      break;
 
637
    case DOCK_ALL:
 
638
      break;
 
639
    }
 
640
  
 
641
  gtk_widget_show_all (window);
 
642
}
 
643
 
 
644
static void
 
645
dock_cb (GtkAction           *action,
 
646
         gpointer             callback_data)
 
647
{
 
648
  guint callback_action;
 
649
  const gchar *name;
 
650
 
 
651
  name = gtk_action_get_name (action);
 
652
 
 
653
  if (!g_strcmp0 (name, "Top dock"))
 
654
    callback_action = DOCK_TOP;
 
655
  else if (!g_strcmp0 (name, "Bottom dock"))
 
656
    callback_action = DOCK_BOTTOM;
 
657
  else if (!g_strcmp0 (name, "Left dock"))
 
658
    callback_action = DOCK_LEFT;
 
659
  else if (!g_strcmp0 (name, "Right dock"))
 
660
    callback_action = DOCK_RIGHT;
 
661
  else if (!g_strcmp0 (name, "All docks"))
 
662
    callback_action = DOCK_ALL;
 
663
  else
 
664
    return;
 
665
 
 
666
  if (callback_action == DOCK_ALL)
 
667
    {
 
668
      make_dock (DOCK_TOP);
 
669
      make_dock (DOCK_BOTTOM);
 
670
      make_dock (DOCK_LEFT);
 
671
      make_dock (DOCK_RIGHT);
 
672
    }
 
673
  else
 
674
    {
 
675
      make_dock (callback_action);
 
676
    }
 
677
}
 
678
 
 
679
static void
 
680
desktop_cb (GtkAction           *action,
 
681
            gpointer             callback_data)
 
682
{
 
683
  GtkWidget *window;
 
684
  GtkWidget *label;
 
685
  GdkColor desktop_color;
 
686
  
 
687
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
688
  set_gtk_window_type (GTK_WINDOW (window), "_NET_WM_WINDOW_TYPE_DESKTOP");
 
689
  gtk_window_set_title (GTK_WINDOW (window), "Desktop");
 
690
  gtk_widget_set_size_request (window,
 
691
                               gdk_screen_width (), gdk_screen_height ());
 
692
  gtk_window_move (GTK_WINDOW (window), 0, 0);
 
693
  
 
694
  desktop_color.red = 0x5144;
 
695
  desktop_color.green = 0x75D6;
 
696
  desktop_color.blue = 0xA699;
 
697
 
 
698
  gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &desktop_color);
 
699
  
 
700
  label = focus_label (window);
 
701
  
 
702
  gtk_container_add (GTK_CONTAINER (window), label);
 
703
  
 
704
  gtk_widget_show_all (window);
 
705
}
 
706
 
 
707
static void
 
708
sleep_cb (GtkAction *action,
 
709
          gpointer   data)
 
710
{
 
711
  sleep (1000);
 
712
}
 
713
 
 
714
static void
 
715
toggle_aspect_ratio (GtkAction *action,
 
716
                     gpointer   data)
 
717
{
 
718
  GtkWidget *window;
 
719
  GdkGeometry geom;
 
720
  GtkWidget *widget = GTK_WIDGET (data);
 
721
 
 
722
  if (aspect_on)
 
723
    {
 
724
      geom.min_aspect = 0;
 
725
      geom.max_aspect = 65535;
 
726
    }
 
727
  else
 
728
    {
 
729
      geom.min_aspect = 1.777778;
 
730
      geom.max_aspect = 1.777778;
 
731
    }
 
732
 
 
733
  aspect_on = !aspect_on;
 
734
 
 
735
  window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
 
736
  if (window)
 
737
    gtk_window_set_geometry_hints (GTK_WINDOW (window),
 
738
                                   widget,
 
739
                                   &geom,
 
740
                                   GDK_HINT_ASPECT);
 
741
                                   
 
742
}
 
743
 
 
744
static void
 
745
toggle_decorated_cb (GtkWidget *button,
 
746
                     gpointer   data)
 
747
{
 
748
  GtkWidget *window;
 
749
  window = gtk_widget_get_ancestor (data, GTK_TYPE_WINDOW);
 
750
  if (window)
 
751
    gtk_window_set_decorated (GTK_WINDOW (window),
 
752
                              !gtk_window_get_decorated (GTK_WINDOW (window)));
 
753
}
 
754
 
 
755
static void
 
756
clicked_toolbar_cb (GtkWidget *button,
 
757
                    gpointer   data)
 
758
{
 
759
  GtkWidget *dialog;
 
760
  
 
761
  dialog = gtk_message_dialog_new (GTK_WINDOW (data),
 
762
                                   GTK_DIALOG_DESTROY_WITH_PARENT,
 
763
                                   GTK_MESSAGE_INFO,
 
764
                                   GTK_BUTTONS_CLOSE,
 
765
                                   "Clicking the toolbar buttons doesn't do anything");
 
766
 
 
767
  /* Close dialog on user response */
 
768
  g_signal_connect (G_OBJECT (dialog),
 
769
                    "response",
 
770
                    G_CALLBACK (gtk_widget_destroy),
 
771
                    NULL);
 
772
  
 
773
  gtk_widget_show (dialog);
 
774
}
 
775
 
 
776
static void
 
777
update_statusbar (GtkTextBuffer *buffer,
 
778
                  GtkStatusbar  *statusbar)
 
779
{
 
780
  gchar *msg;
 
781
  gint row, col;
 
782
  gint count;
 
783
  GtkTextIter iter;
 
784
  
 
785
  gtk_statusbar_pop (statusbar, 0); /* clear any previous message, underflow is allowed */
 
786
 
 
787
  count = gtk_text_buffer_get_char_count (buffer);
 
788
 
 
789
  gtk_text_buffer_get_iter_at_mark (buffer,
 
790
                                    &iter,
 
791
                                    gtk_text_buffer_get_insert (buffer));
 
792
 
 
793
  row = gtk_text_iter_get_line (&iter);
 
794
  col = gtk_text_iter_get_line_offset (&iter);
 
795
 
 
796
  msg = g_strdup_printf ("Cursor at row %d column %d - %d chars in document",
 
797
                         row, col, count);
 
798
 
 
799
  gtk_statusbar_push (statusbar, 0, msg);
 
800
 
 
801
  g_free (msg);
 
802
}
 
803
 
 
804
static void
 
805
mark_set_callback (GtkTextBuffer     *buffer,
 
806
                   const GtkTextIter *new_location,
 
807
                   GtkTextMark       *mark,
 
808
                   gpointer           data)
 
809
{
 
810
  update_statusbar (buffer, GTK_STATUSBAR (data));
 
811
}
 
812
 
 
813
static int window_count = 0;
 
814
 
 
815
static void
 
816
destroy_cb (GtkWidget *w, gpointer data)
 
817
{
 
818
  --window_count;
 
819
  if (window_count == 0)
 
820
    gtk_main_quit ();
 
821
}
 
822
 
 
823
static const gchar *menu_item_string =
 
824
  "<ui>\n"
 
825
    "<menubar>\n"
 
826
      "<menu name='Windows' action='Windows'>\n"
 
827
        "<menuitem name='Dialog' action='Dialog'/>\n"
 
828
        "<menuitem name='Modal dialog' action='Modal dialog'/>\n"
 
829
        "<menuitem name='Parentless dialog' action='Parentless dialog'/>\n"
 
830
        "<menuitem name='Utility' action='Utility'/>\n"
 
831
        "<menuitem name='Splashscreen' action='Splashscreen'/>\n"
 
832
        "<menuitem name='Top dock' action='Top dock'/>\n"
 
833
        "<menuitem name='Bottom dock' action='Bottom dock'/>\n"
 
834
        "<menuitem name='Left dock' action='Left dock'/>\n"
 
835
        "<menuitem name='Right dock' action='Right dock'/>\n"
 
836
        "<menuitem name='All docks' action='All docks'/>\n"
 
837
        "<menuitem name='Desktop' action='Desktop'/>\n"
 
838
        "<menuitem name='Menu' action='Menu'/>\n"
 
839
        "<menuitem name='Toolbar' action='Toolbar'/>\n"
 
840
        "<menuitem name='Override Redirect' action='Override Redirect'/>\n"
 
841
        "<menuitem name='Border Only' action='Border Only'/>\n"
 
842
      "</menu>\n"
 
843
    "</menubar>\n"
 
844
    "<toolbar>\n"
 
845
      "<toolitem name='New' action='New'/>\n"
 
846
      "<toolitem name='Lock' action='Lock'/>\n"
 
847
      "<toolitem name='Decorations' action='Decorations'/>\n"
 
848
      "<toolitem name='Ratio' action='Ratio'/>\n"
 
849
      "<toolitem name='Quit' action='Quit'/>\n"
 
850
    "</toolbar>\n"
 
851
  "</ui>\n";
 
852
 
 
853
static const GtkActionEntry menu_items[] =
 
854
{
 
855
  { "Windows",                  NULL,   "_Windows",             NULL,
 
856
    NULL,       NULL },
 
857
  { "Dialog",                   NULL,   "_Dialog",              "<control>d",
 
858
    NULL,       G_CALLBACK (dialog_cb) },
 
859
  { "Modal dialog",             NULL,   "_Modal dialog",        NULL,
 
860
    NULL,       G_CALLBACK (modal_dialog_cb) },
 
861
  { "Parentless dialog",        NULL,   "_Parentless dialog",   NULL,
 
862
    NULL,       G_CALLBACK (no_parent_dialog_cb) },
 
863
  { "Utility",                  NULL,   "_Utility",             "<control>u",
 
864
    NULL,       G_CALLBACK (utility_cb) },
 
865
  { "Splashscreen",             NULL,   "_Splashscreen",        "<control>s",
 
866
    NULL,       G_CALLBACK (splashscreen_cb) },
 
867
  { "Top dock",                 NULL,   "_Top dock",            NULL,
 
868
    NULL,       G_CALLBACK (dock_cb) },
 
869
  { "Bottom dock",              NULL,   "_Bottom dock",         NULL,
 
870
    NULL,       G_CALLBACK (dock_cb) },
 
871
  { "Left dock",                NULL,   "_Left dock",           NULL,
 
872
    NULL,       G_CALLBACK (dock_cb) },
 
873
  { "Right dock",               NULL,   "_Right dock",          NULL,
 
874
    NULL,       G_CALLBACK (dock_cb) },
 
875
  { "All docks",                NULL,   "_All docks",           NULL,
 
876
    NULL,       G_CALLBACK (dock_cb) },
 
877
  { "Desktop",                  NULL,   "Des_ktop",             NULL,
 
878
    NULL,       G_CALLBACK (desktop_cb) },
 
879
  { "Menu",                     NULL,   "Me_nu",                NULL,
 
880
    NULL,       G_CALLBACK (menu_cb) },
 
881
  { "Toolbar",                  NULL,   "Tool_bar",             NULL,
 
882
    NULL,       G_CALLBACK (toolbar_cb) },
 
883
  { "Override Redirect",        NULL,   "Override Redirect",    NULL,
 
884
    NULL,       G_CALLBACK (override_redirect_cb) },
 
885
  { "Border Only",              NULL,   "Border Only",          NULL,
 
886
    NULL,       G_CALLBACK (border_only_cb) }
 
887
};
 
888
 
 
889
static const GtkActionEntry tool_items[] =
 
890
{
 
891
  { "New",              GTK_STOCK_NEW,  NULL,   NULL,
 
892
    "Open another one of these windows", G_CALLBACK (do_appwindow) },
 
893
  { "Lock",             GTK_STOCK_OPEN, NULL,   NULL,
 
894
    "This is a demo button that"
 
895
    " locks up the demo",                G_CALLBACK (sleep_cb) },
 
896
  { "Decorations",      GTK_STOCK_OPEN, NULL,   NULL,
 
897
    "This is a demo button that "
 
898
    "toggles window decorations",        G_CALLBACK (toggle_decorated_cb) },
 
899
  { "Quit",             GTK_STOCK_QUIT, NULL,   NULL,
 
900
    "This is a demo button with "
 
901
    " a 'quit' icon",                    G_CALLBACK (clicked_toolbar_cb) },
 
902
  { "Ratio",            GTK_STOCK_OPEN, NULL,   NULL,
 
903
    "This is a demo button that locks the aspect ratio "
 
904
    "using a hint",                     G_CALLBACK (toggle_aspect_ratio) }
 
905
};
 
906
 
 
907
static GtkWidget *
 
908
do_appwindow (void)
 
909
{
 
910
  GtkWidget *window;
 
911
  GtkWidget *table;
 
912
  GtkWidget *handlebox;
 
913
  GtkWidget *statusbar;
 
914
  GtkWidget *contents;
 
915
  GtkWidget *sw;
 
916
  GtkTextBuffer *buffer;
 
917
  GtkActionGroup *action_group;
 
918
  GtkUIManager *ui_manager;
 
919
      
 
920
  /* Create the toplevel window
 
921
   */
 
922
 
 
923
  ++window_count;
 
924
 
 
925
  aspect_on = FALSE;
 
926
 
 
927
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
928
  gtk_window_set_title (GTK_WINDOW (window), "Application Window");
 
929
  
 
930
  g_signal_connect (G_OBJECT (window), "destroy",
 
931
                    G_CALLBACK (destroy_cb), NULL);
 
932
      
 
933
  table = gtk_table_new (1, 4, FALSE);
 
934
      
 
935
  gtk_container_add (GTK_CONTAINER (window), table);
 
936
      
 
937
  /* Create the menubar
 
938
   */
 
939
      
 
940
  contents = gtk_text_view_new ();
 
941
 
 
942
  action_group = gtk_action_group_new ("mainmenu");
 
943
  gtk_action_group_add_actions (action_group,
 
944
                                menu_items,
 
945
                                G_N_ELEMENTS (menu_items),
 
946
                                window);
 
947
  gtk_action_group_add_actions (action_group,
 
948
                                tool_items,
 
949
                                G_N_ELEMENTS (tool_items),
 
950
                                window);
 
951
 
 
952
  ui_manager = gtk_ui_manager_new ();
 
953
 
 
954
  gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
 
955
 
 
956
  /* create menu items */
 
957
 
 
958
  gtk_ui_manager_add_ui_from_string (ui_manager, menu_item_string, -1, NULL);
 
959
 
 
960
  gtk_table_attach (GTK_TABLE (table),
 
961
                    gtk_ui_manager_get_widget (ui_manager, "/ui/menubar"),
 
962
                    /* X direction */          /* Y direction */
 
963
                    0, 1,                      0, 1,
 
964
                    GTK_EXPAND | GTK_FILL,     0,
 
965
                    0,                         0);
 
966
 
 
967
  /* Create document
 
968
   */
 
969
 
 
970
  sw = gtk_scrolled_window_new (NULL, NULL);
 
971
 
 
972
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 
973
                                  GTK_POLICY_AUTOMATIC,
 
974
                                  GTK_POLICY_AUTOMATIC);
 
975
 
 
976
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
 
977
                                       GTK_SHADOW_IN);
 
978
      
 
979
  gtk_table_attach (GTK_TABLE (table),
 
980
                    sw,
 
981
                    /* X direction */       /* Y direction */
 
982
                    0, 1,                   2, 3,
 
983
                    GTK_EXPAND | GTK_FILL,  GTK_EXPAND | GTK_FILL,
 
984
                    0,                      0);
 
985
 
 
986
  gtk_window_set_default_size (GTK_WINDOW (window),
 
987
                               200, 200);
 
988
      
 
989
  gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),
 
990
                               PANGO_WRAP_WORD);
 
991
      
 
992
  gtk_container_add (GTK_CONTAINER (sw),
 
993
                     contents);
 
994
 
 
995
  /* Create the toolbar
 
996
   */
 
997
 
 
998
  handlebox = gtk_handle_box_new ();
 
999
 
 
1000
  gtk_container_add (GTK_CONTAINER (handlebox),
 
1001
                     gtk_ui_manager_get_widget (ui_manager, "/ui/toolbar"));
 
1002
      
 
1003
  gtk_table_attach (GTK_TABLE (table),
 
1004
                    handlebox,
 
1005
                    /* X direction */       /* Y direction */
 
1006
                    0, 1,                   1, 2,
 
1007
                    GTK_EXPAND | GTK_FILL,  0,
 
1008
                    0,                      0);
 
1009
 
 
1010
  /* Create statusbar */
 
1011
 
 
1012
  statusbar = gtk_statusbar_new ();
 
1013
  gtk_table_attach (GTK_TABLE (table),
 
1014
                    statusbar,
 
1015
                    /* X direction */       /* Y direction */
 
1016
                    0, 1,                   3, 4,
 
1017
                    GTK_EXPAND | GTK_FILL,  0,
 
1018
                    0,                      0);
 
1019
 
 
1020
  /* Show text widget info in the statusbar */
 
1021
  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
 
1022
 
 
1023
  gtk_text_buffer_set_text (buffer,
 
1024
                            "This demo demonstrates various kinds of windows that "
 
1025
                            "window managers and window manager themes should handle. "
 
1026
                            "Be sure to tear off the menu and toolbar, those are also "
 
1027
                            "a special kind of window.",
 
1028
                            -1);
 
1029
      
 
1030
  g_signal_connect_object (buffer,
 
1031
                           "changed",
 
1032
                           G_CALLBACK (update_statusbar),
 
1033
                           statusbar,
 
1034
                           0);
 
1035
 
 
1036
  g_signal_connect_object (buffer,
 
1037
                           "mark_set", /* cursor moved */
 
1038
                           G_CALLBACK (mark_set_callback),
 
1039
                           statusbar,
 
1040
                           0);
 
1041
      
 
1042
  update_statusbar (buffer, GTK_STATUSBAR (statusbar));
 
1043
 
 
1044
  gtk_widget_show_all (window);
 
1045
 
 
1046
  g_object_unref (ui_manager);
 
1047
 
 
1048
  return window;
 
1049
}
 
1050
 
 
1051