← Back to branch summary

~muktupavels/metacity/adwaita-icon-theme-lp-1414613

« back to all changes in this revision

Viewing changes to src/tools/metacity-window-demo.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2005-10-03 22:44:28 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20051003224428-ft31gkmz12qpzohj
Tags: 1:2.12.1-0ubuntu1
* New upstream release:
  - Thanks to Ray Strode, Havoc Pennington, and Elijah Newren for
    improvements in this release.
  - Truncate ridiculously long titles to avoid crashing or letting the
    pager crash (Ray, Havoc, Elijah) [#315070] (Ubuntu: #15995)
  - Get the tabbing window outline to work with gtk+ 2.8.4 again
    (Elijah) [#317528] (Ubuntu: #16589)
  - Translations: Mahay Alam Khan (bn), Francisco Javier F. Serrador (es), 
    Ivar Smolin (et), I\uffffaki Larra\uffffaga Murgoitio (eu), Luca 
    Ferretti (it), Christian Rose (sv), Clytie Siddall (vi), Funda 
    Wang (zh_CN)
* debian/control.in:
  - Bumped Standards-Version.
* debian/patches/003_bordersdrawingfix.patch:
  - dropped, fixed upstream.

Show diffs side-by-side

added added

removed removed

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