testgtk.c 249 KB
Newer Older
Elliot Lee's avatar
Elliot Lee committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* GTK - The GIMP Toolkit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
15
16
17
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
Elliot Lee's avatar
Elliot Lee committed
18
 */
19
20
21
22
23
24
25
26

/*
 * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
 * file for a list of people on the GTK+ Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
 */

27
28
#include "config.h"

29
#undef	G_LOG_DOMAIN
30

Elliot Lee's avatar
Elliot Lee committed
31
32
#include <stdio.h>
#include <stdlib.h>
33
#include <string.h>
34
#include <sys/stat.h>
35
#include <math.h>
36
#include <time.h>
37
#ifdef HAVE_UNISTD_H
38
#include <unistd.h>
39
40
#endif

Elliot Lee's avatar
Elliot Lee committed
41
#include "gtk.h"
42
43
#include "gdk/gdk.h"
#include "gdk/gdkkeysyms.h"
Elliot Lee's avatar
Elliot Lee committed
44

Owen Taylor's avatar
Owen Taylor committed
45
46
#include "circles.xbm"

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
typedef struct _OptionMenuItem
{
  gchar        *name;
  GtkSignalFunc func;
} OptionMenuItem;

GtkWidget *
shape_create_icon (char     *xpm_file,
		   gint      x,
		   gint      y,
		   gint      px,
		   gint      py,
		   gint      window_type);

static GtkWidget *
build_option_menu (OptionMenuItem items[],
		   gint           num_items,
		   gint           history,
		   gpointer       data);
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

/* macro, structure and variables used by tree window demos */
#define DEFAULT_NUMBER_OF_ITEM  3
#define DEFAULT_RECURSION_LEVEL 3

struct {
  GSList* selection_mode_group;
  GtkWidget* single_button;
  GtkWidget* browse_button;
  GtkWidget* multiple_button;
  GtkWidget* draw_line_button;
  GtkWidget* view_line_button;
  GtkWidget* no_root_item_button;
  GtkWidget* nb_item_spinner;
  GtkWidget* recursion_spinner;
} sTreeSampleSelection;

typedef struct sTreeButtons {
  guint nb_item_add;
  GtkWidget* add_button;
  GtkWidget* remove_button;
87
  GtkWidget* subtree_button;
88
89
90
} sTreeButtons;
/* end of tree section */

91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
static GtkWidget *
build_option_menu (OptionMenuItem items[],
		   gint           num_items,
		   gint           history,
		   gpointer       data)
{
  GtkWidget *omenu;
  GtkWidget *menu;
  GtkWidget *menu_item;
  GSList *group;
  gint i;

  omenu = gtk_option_menu_new ();
      
  menu = gtk_menu_new ();
  group = NULL;
  
  for (i = 0; i < num_items; i++)
    {
      menu_item = gtk_radio_menu_item_new_with_label (group, items[i].name);
      gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
			  (GtkSignalFunc) items[i].func, data);
      group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
      gtk_menu_append (GTK_MENU (menu), menu_item);
      if (i == history)
116
	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
117
118
119
120
121
122
123
124
125
      gtk_widget_show (menu_item);
    }

  gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
  gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history);
  
  return omenu;
}

126
static void
127
128
129
130
131
132
133
destroy_tooltips (GtkWidget *widget, GtkWindow **window)
{
  GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
  gtk_object_unref (GTK_OBJECT (tt));
  *window = NULL;
}

134
135
136
137
/*
 * GtkButton
 */

138
static void
Elliot Lee's avatar
Elliot Lee committed
139
140
141
142
143
144
145
146
147
button_window (GtkWidget *widget,
	       GtkWidget *button)
{
  if (!GTK_WIDGET_VISIBLE (button))
    gtk_widget_show (button);
  else
    gtk_widget_hide (button);
}

148
static void
149
create_buttons (void)
Elliot Lee's avatar
Elliot Lee committed
150
151
152
153
154
155
156
157
158
159
160
161
162
{
  static GtkWidget *window = NULL;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *table;
  GtkWidget *button[10];
  GtkWidget *separator;

  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
163
			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
Elliot Lee's avatar
Elliot Lee committed
164
165
			  &window);

166
      gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
167
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
Elliot Lee's avatar
Elliot Lee committed
168
169
170
171
172
173
174

      box1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), box1);

      table = gtk_table_new (3, 3, FALSE);
      gtk_table_set_row_spacings (GTK_TABLE (table), 5);
      gtk_table_set_col_spacings (GTK_TABLE (table), 5);
175
      gtk_container_set_border_width (GTK_CONTAINER (table), 10);
Elliot Lee's avatar
Elliot Lee committed
176
177
178
179
180
181
182
183
184
185
186
187
188
      gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);

      button[0] = gtk_button_new_with_label ("button1");
      button[1] = gtk_button_new_with_label ("button2");
      button[2] = gtk_button_new_with_label ("button3");
      button[3] = gtk_button_new_with_label ("button4");
      button[4] = gtk_button_new_with_label ("button5");
      button[5] = gtk_button_new_with_label ("button6");
      button[6] = gtk_button_new_with_label ("button7");
      button[7] = gtk_button_new_with_label ("button8");
      button[8] = gtk_button_new_with_label ("button9");

      gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
189
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
190
191
192
193
194
195
			  button[1]);

      gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
196
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
197
198
199
200
201
202
			  button[2]);

      gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
203
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
204
205
206
207
208
			  button[3]);
      gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
209
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
210
211
212
213
214
			  button[4]);
      gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
215
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
216
217
218
219
220
			  button[5]);
      gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
221
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
222
223
224
225
226
			  button[6]);
      gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
227
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
228
229
230
231
232
			  button[7]);
      gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
233
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
234
235
236
237
238
			  button[8]);
      gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
239
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
240
241
242
243
244
245
246
247
			  button[0]);
      gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

      separator = gtk_hseparator_new ();
      gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);

      box2 = gtk_vbox_new (FALSE, 10);
248
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
249
250
251
252
      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);

      button[9] = gtk_button_new_with_label ("close");
      gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
Elliot Lee's avatar
Elliot Lee committed
253
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
Elliot Lee's avatar
Elliot Lee committed
254
255
256
257
258
259
260
				 GTK_OBJECT (window));
      gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
      GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
      gtk_widget_grab_default (button[9]);
    }

  if (!GTK_WIDGET_VISIBLE (window))
261
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
262
263
264
265
  else
    gtk_widget_destroy (window);
}

266
267
268
269
/*
 * GtkToggleButton
 */

270
static void
271
create_toggle_buttons (void)
Elliot Lee's avatar
Elliot Lee committed
272
273
274
275
276
277
278
279
280
281
282
283
{
  static GtkWidget *window = NULL;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *button;
  GtkWidget *separator;

  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
284
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
Elliot Lee's avatar
Elliot Lee committed
285
286
			  &window);

287
      gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
288
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
Elliot Lee's avatar
Elliot Lee committed
289
290
291
292
293

      box1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), box1);

      box2 = gtk_vbox_new (FALSE, 10);
294
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
      gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);

      button = gtk_toggle_button_new_with_label ("button1");
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      button = gtk_toggle_button_new_with_label ("button2");
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      button = gtk_toggle_button_new_with_label ("button3");
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      separator = gtk_hseparator_new ();
      gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);

      box2 = gtk_vbox_new (FALSE, 10);
310
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
311
312
313
314
      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);

      button = gtk_button_new_with_label ("close");
      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
Elliot Lee's avatar
Elliot Lee committed
315
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
Elliot Lee's avatar
Elliot Lee committed
316
317
318
319
320
321
322
				 GTK_OBJECT (window));
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
      GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
      gtk_widget_grab_default (button);
    }

  if (!GTK_WIDGET_VISIBLE (window))
323
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
324
325
326
327
  else
    gtk_widget_destroy (window);
}

328
329
330
331
/*
 * GtkCheckButton
 */

332
static void
333
create_check_buttons (void)
Elliot Lee's avatar
Elliot Lee committed
334
335
336
337
338
339
340
341
342
343
344
345
{
  static GtkWidget *window = NULL;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *button;
  GtkWidget *separator;

  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
346
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
Elliot Lee's avatar
Elliot Lee committed
347
348
			  &window);

349
      gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
350
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
Elliot Lee's avatar
Elliot Lee committed
351
352
353
354
355

      box1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), box1);

      box2 = gtk_vbox_new (FALSE, 10);
356
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
      gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);

      button = gtk_check_button_new_with_label ("button1");
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      button = gtk_check_button_new_with_label ("button2");
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      button = gtk_check_button_new_with_label ("button3");
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      separator = gtk_hseparator_new ();
      gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);

      box2 = gtk_vbox_new (FALSE, 10);
372
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
373
374
375
376
      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);

      button = gtk_button_new_with_label ("close");
      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
Elliot Lee's avatar
Elliot Lee committed
377
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
Elliot Lee's avatar
Elliot Lee committed
378
379
380
381
382
383
384
				 GTK_OBJECT (window));
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
      GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
      gtk_widget_grab_default (button);
    }

  if (!GTK_WIDGET_VISIBLE (window))
385
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
386
387
388
389
  else
    gtk_widget_destroy (window);
}

390
391
392
393
/*
 * GtkRadioButton
 */

394
static void
395
create_radio_buttons (void)
Elliot Lee's avatar
Elliot Lee committed
396
397
398
399
400
401
402
403
404
405
406
407
{
  static GtkWidget *window = NULL;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *button;
  GtkWidget *separator;

  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
408
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
Elliot Lee's avatar
Elliot Lee committed
409
410
411
			  &window);

      gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
412
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
Elliot Lee's avatar
Elliot Lee committed
413
414
415
416
417

      box1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), box1);

      box2 = gtk_vbox_new (FALSE, 10);
418
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
419
420
421
422
423
424
425
426
      gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);

      button = gtk_radio_button_new_with_label (NULL, "button1");
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      button = gtk_radio_button_new_with_label (
	         gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
		 "button2");
427
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
Elliot Lee's avatar
Elliot Lee committed
428
429
430
431
432
433
434
435
436
437
438
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      button = gtk_radio_button_new_with_label (
                 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
		 "button3");
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);

      separator = gtk_hseparator_new ();
      gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);

      box2 = gtk_vbox_new (FALSE, 10);
439
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
440
441
442
443
      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);

      button = gtk_button_new_with_label ("close");
      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
Elliot Lee's avatar
Elliot Lee committed
444
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
Elliot Lee's avatar
Elliot Lee committed
445
446
447
448
449
450
451
				 GTK_OBJECT (window));
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
      GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
      gtk_widget_grab_default (button);
    }

  if (!GTK_WIDGET_VISIBLE (window))
452
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
453
454
455
456
  else
    gtk_widget_destroy (window);
}

457
458
459
/*
 * GtkButtonBox
 */
Elliot Lee's avatar
Elliot Lee committed
460

461
462
463
464
465
466
467
static GtkWidget *
create_bbox (gint  horizontal,
	     char* title, 
	     gint  spacing,
	     gint  child_w, 
	     gint  child_h, 
	     gint  layout)
Elliot Lee's avatar
Elliot Lee committed
468
{
469
470
471
  GtkWidget *frame;
  GtkWidget *bbox;
  GtkWidget *button;
Elliot Lee's avatar
Elliot Lee committed
472
	
473
  frame = gtk_frame_new (title);
Elliot Lee's avatar
Elliot Lee committed
474
475

  if (horizontal)
476
    bbox = gtk_hbutton_box_new ();
Elliot Lee's avatar
Elliot Lee committed
477
  else
478
479
    bbox = gtk_vbutton_box_new ();

480
  gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
481
482
  gtk_container_add (GTK_CONTAINER (frame), bbox);

Elliot Lee's avatar
Elliot Lee committed
483
484
485
486
487
  gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
  gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
  gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
  
  button = gtk_button_new_with_label ("OK");
488
  gtk_container_add (GTK_CONTAINER (bbox), button);
Elliot Lee's avatar
Elliot Lee committed
489
490
  
  button = gtk_button_new_with_label ("Cancel");
491
  gtk_container_add (GTK_CONTAINER (bbox), button);
Elliot Lee's avatar
Elliot Lee committed
492
493
  
  button = gtk_button_new_with_label ("Help");
494
  gtk_container_add (GTK_CONTAINER (bbox), button);
Elliot Lee's avatar
Elliot Lee committed
495

496
  return frame;
Elliot Lee's avatar
Elliot Lee committed
497
498
}

499
static void
500
create_button_box (void)
Elliot Lee's avatar
Elliot Lee committed
501
502
{
  static GtkWidget* window = NULL;
503
504
505
506
507
  GtkWidget *main_vbox;
  GtkWidget *vbox;
  GtkWidget *hbox;
  GtkWidget *frame_horz;
  GtkWidget *frame_vert;
Elliot Lee's avatar
Elliot Lee committed
508
509
510
511
	
  if (!window)
  {
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
512
    gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
Elliot Lee's avatar
Elliot Lee committed
513
514
    
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
515
516
			GTK_SIGNAL_FUNC(gtk_widget_destroyed),
			&window);
Elliot Lee's avatar
Elliot Lee committed
517
    
518
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
519
520
521

    main_vbox = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (window), main_vbox);
Elliot Lee's avatar
Elliot Lee committed
522
    
523
524
    frame_horz = gtk_frame_new ("Horizontal Button Boxes");
    gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
Elliot Lee's avatar
Elliot Lee committed
525
    
526
    vbox = gtk_vbox_new (FALSE, 0);
527
    gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
    gtk_container_add (GTK_CONTAINER (frame_horz), vbox);

    gtk_box_pack_start (GTK_BOX (vbox), 
	   create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
			TRUE, TRUE, 0);

    gtk_box_pack_start (GTK_BOX (vbox), 
	   create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
			TRUE, TRUE, 5);

    gtk_box_pack_start (GTK_BOX (vbox), 
	   create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
			TRUE, TRUE, 5);

    gtk_box_pack_start (GTK_BOX (vbox), 
	   create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
			TRUE, TRUE, 5);

    frame_vert = gtk_frame_new ("Vertical Button Boxes");
    gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
Elliot Lee's avatar
Elliot Lee committed
548
    
549
    hbox = gtk_hbox_new (FALSE, 0);
550
    gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
    gtk_container_add (GTK_CONTAINER (frame_vert), hbox);

    gtk_box_pack_start (GTK_BOX (hbox), 
	   create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
			TRUE, TRUE, 0);

    gtk_box_pack_start (GTK_BOX (hbox), 
	   create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
			TRUE, TRUE, 5);

    gtk_box_pack_start (GTK_BOX (hbox), 
	   create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
			TRUE, TRUE, 5);

    gtk_box_pack_start (GTK_BOX (hbox), 
	   create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
			TRUE, TRUE, 5);
Elliot Lee's avatar
Elliot Lee committed
568
569
570
  }

  if (!GTK_WIDGET_VISIBLE (window))
571
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
572
573
574
575
  else
    gtk_widget_destroy (window);
}

576
577
578
579
/*
 * GtkToolBar
 */

580
static GtkWidget*
581
582
583
new_pixmap (char      *filename,
	    GdkWindow *window,
	    GdkColor  *background)
584
585
586
587
588
589
590
{
  GtkWidget *wpixmap;
  GdkPixmap *pixmap;
  GdkBitmap *mask;

  pixmap = gdk_pixmap_create_from_xpm (window, &mask,
				       background,
591
				       filename);
592
593
594
595
596
  wpixmap = gtk_pixmap_new (pixmap, mask);

  return wpixmap;
}

597
static void
598
599
600
601
602
603
set_toolbar_horizontal (GtkWidget *widget,
			gpointer   data)
{
  gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
}

604
static void
605
606
607
608
609
610
set_toolbar_vertical (GtkWidget *widget,
		      gpointer   data)
{
  gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
}

611
static void
612
613
614
615
616
617
set_toolbar_icons (GtkWidget *widget,
		   gpointer   data)
{
  gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
}

618
static void
619
620
621
622
623
624
set_toolbar_text (GtkWidget *widget,
	          gpointer   data)
{
  gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
}

625
static void
626
627
628
629
630
631
set_toolbar_both (GtkWidget *widget,
		  gpointer   data)
{
  gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
}

632
633
634
635
636
637
638
static void
set_toolbar_both_horiz (GtkWidget *widget,
			gpointer   data)
{
  gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
}

639
static void
640
641
642
643
644
645
set_toolbar_small_space (GtkWidget *widget,
			 gpointer   data)
{
  gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
}

646
static void
647
648
649
650
651
652
set_toolbar_big_space (GtkWidget *widget,
		       gpointer   data)
{
  gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
}

653
static void
654
655
656
657
658
659
set_toolbar_enable (GtkWidget *widget,
		    gpointer   data)
{
  gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
}

660
static void
661
662
663
664
665
666
set_toolbar_disable (GtkWidget *widget,
		     gpointer   data)
{
  gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
}

667
668
669
670
671
672
673
674
675
676
677
678
679
680
static void
set_toolbar_borders (GtkWidget *widget,
		     gpointer   data)
{
  gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL);
}

static void
set_toolbar_borderless (GtkWidget *widget,
			gpointer   data)
{
  gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
}

681
682
683
684
685
686
687
688
689
690
691
692
693
694
static void
set_toolbar_space_style_empty (GtkWidget *widget,
			       gpointer   data)
{
  gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_EMPTY);
}

static void
set_toolbar_space_style_line (GtkWidget *widget,
			      gpointer   data)
{
  gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_LINE);
}

695
static void
696
697
698
699
create_toolbar (void)
{
  static GtkWidget *window = NULL;
  GtkWidget *toolbar;
700
  GtkWidget *entry;
701
702
703
704
705

  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
706
      gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
707
708

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
709
			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
710
711
			  &window);

712
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
713
714
715
      gtk_widget_realize (window);

      toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
716
      gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
717
718

      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
719
			       "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
720
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
721
722
			       (GtkSignalFunc) set_toolbar_horizontal, toolbar);
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
723
			       "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
724
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
725
726
727
728
729
			       (GtkSignalFunc) set_toolbar_vertical, toolbar);

      gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));

      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
730
			       "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
731
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
732
733
			       (GtkSignalFunc) set_toolbar_icons, toolbar);
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
734
			       "Text", "Only show toolbar text", "Toolbar/TextOnly",
735
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
736
737
			       (GtkSignalFunc) set_toolbar_text, toolbar);
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
738
			       "Both", "Show toolbar icons and text", "Toolbar/Both",
739
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
740
			       (GtkSignalFunc) set_toolbar_both, toolbar);
741
742
743
744
745
746
747
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			       "Both (horizontal)",
			       "Show toolbar icons and text in a horizontal fashion",
			       "Toolbar/BothHoriz",
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
			       (GtkSignalFunc) set_toolbar_both_horiz, toolbar);
			       
748
749
      gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

750
      entry = gtk_entry_new ();
751

752
      gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
753
754
755

      gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

756
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
757
			       "Small", "Use small spaces", "Toolbar/Small",
758
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
759
			       (GtkSignalFunc) set_toolbar_small_space, toolbar);
760
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
761
			       "Big", "Use big spaces", "Toolbar/Big",
762
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
763
764
			       (GtkSignalFunc) set_toolbar_big_space, toolbar);

765
      gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
766

767
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
768
			       "Enable", "Enable tooltips", NULL,
769
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
770
			       (GtkSignalFunc) set_toolbar_enable, toolbar);
771
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
772
			       "Disable", "Disable tooltips", NULL,
773
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
774
			       (GtkSignalFunc) set_toolbar_disable, toolbar);
775

776
777
778
779
780
781
782
783
784
785
786
      gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			       "Borders", "Show Borders", NULL,
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
			       (GtkSignalFunc) set_toolbar_borders, toolbar);
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			       "Borderless", "Hide Borders", NULL,
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
			       (GtkSignalFunc) set_toolbar_borderless, toolbar);

787
788
789
790
791
792
793
794
795
796
797
      gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
      
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			       "Empty", "Empty spaces", NULL,
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
			       (GtkSignalFunc) set_toolbar_space_style_empty, toolbar);
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			       "Lines", "Lines in spaces", NULL,
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
			       (GtkSignalFunc) set_toolbar_space_style_line, toolbar);

798
799
800
801
      gtk_container_add (GTK_CONTAINER (window), toolbar);
    }

  if (!GTK_WIDGET_VISIBLE (window))
802
    gtk_widget_show_all (window);
803
804
805
806
  else
    gtk_widget_destroy (window);
}

807
static GtkWidget*
808
809
810
811
812
813
814
815
make_toolbar (GtkWidget *window)
{
  GtkWidget *toolbar;

  if (!GTK_WIDGET_REALIZED (window))
    gtk_widget_realize (window);

  toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
816
  gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
817
818

  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
819
			   "Horizontal", "Horizontal toolbar layout", NULL,
820
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
821
822
			   (GtkSignalFunc) set_toolbar_horizontal, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
823
			   "Vertical", "Vertical toolbar layout", NULL,
824
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
825
826
827
828
829
			   (GtkSignalFunc) set_toolbar_vertical, toolbar);

  gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));

  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
830
			   "Icons", "Only show toolbar icons", NULL,
831
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
832
833
			   (GtkSignalFunc) set_toolbar_icons, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
834
			   "Text", "Only show toolbar text", NULL,
835
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
836
837
			   (GtkSignalFunc) set_toolbar_text, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
838
			   "Both", "Show toolbar icons and text", NULL,
839
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
840
841
842
843
844
			   (GtkSignalFunc) set_toolbar_both, toolbar);

  gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
845
			   "Small", "Use small spaces", NULL,
846
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
847
848
			   (GtkSignalFunc) set_toolbar_small_space, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
849
			   "Big", "Use big spaces", "Toolbar/Big",
850
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
851
852
853
854
855
			   (GtkSignalFunc) set_toolbar_big_space, toolbar);

  gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
856
			   "Enable", "Enable tooltips", NULL,
857
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
858
859
			   (GtkSignalFunc) set_toolbar_enable, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
860
			   "Disable", "Disable tooltips", NULL,
861
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
862
863
			   (GtkSignalFunc) set_toolbar_disable, toolbar);

864
865
866
867
868
869
870
871
872
873
874
  gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
  
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			   "Borders", "Show Borders", NULL,
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
			   (GtkSignalFunc) set_toolbar_borders, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			   "Borderless", "Hide Borders", NULL,
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
			   (GtkSignalFunc) set_toolbar_borderless, toolbar);

875
876
877
  return toolbar;
}

878
879
880
881
/*
 * GtkStatusBar
 */

882
883
884
885
886
887
888
889
890
891
static guint statusbar_counter = 1;

static void
statusbar_push (GtkWidget *button,
		GtkStatusbar *statusbar)
{
  gchar text[1024];

  sprintf (text, "something %d", statusbar_counter++);

892
  gtk_statusbar_push (statusbar, 1, text);
893
894
895
896
897
898
}

static void
statusbar_pop (GtkWidget *button,
	       GtkStatusbar *statusbar)
{
899
  gtk_statusbar_pop (statusbar, 1);
900
901
902
903
904
905
}

static void
statusbar_steal (GtkWidget *button,
	         GtkStatusbar *statusbar)
{
906
  gtk_statusbar_remove (statusbar, 1, 4);
907
908
909
910
}

static void
statusbar_popped (GtkStatusbar  *statusbar,
911
		  guint          context_id,
912
913
914
915
916
917
		  const gchar	*text)
{
  if (!statusbar->messages)
    statusbar_counter = 1;
}

918
static void
919
statusbar_contexts (GtkStatusbar *statusbar)
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
{
  gchar *string;

  string = "any context";
  g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
	   string,
	   gtk_statusbar_get_context_id (statusbar, string));
  
  string = "idle messages";
  g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
	   string,
	   gtk_statusbar_get_context_id (statusbar, string));
  
  string = "some text";
  g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
	   string,
	   gtk_statusbar_get_context_id (statusbar, string));

  string = "hit the mouse";
  g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
	   string,
	   gtk_statusbar_get_context_id (statusbar, string));

  string = "hit the mouse2";
  g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
	   string,
	   gtk_statusbar_get_context_id (statusbar, string));
}

949
static void
950
statusbar_dump_stack (GtkStatusbar *statusbar)
951
{
952
  GSList *list;
953
954
955
956
957
958

  for (list = statusbar->messages; list; list = list->next)
    {
      GtkStatusbarMsg *msg;

      msg = list->data;
959
960
961
962
      g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
               msg->context_id,
               msg->message_id,
               msg->text);
963
964
965
966
    }
}

static void
967
create_statusbar (void)
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
{
  static GtkWidget *window = NULL;
  GtkWidget *box1;
  GtkWidget *box2;
  GtkWidget *button;
  GtkWidget *separator;
  GtkWidget *statusbar;

  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      gtk_signal_connect (GTK_OBJECT (window), "destroy",
			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
			  &window);

      gtk_window_set_title (GTK_WINDOW (window), "statusbar");
985
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
986
987
988
989
990

      box1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (window), box1);

      box2 = gtk_vbox_new (FALSE, 10);
991
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
992
993
994
995
996
997
998
999
1000
1001
      gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);

      statusbar = gtk_statusbar_new ();
      gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
      gtk_signal_connect (GTK_OBJECT (statusbar),
			  "text_popped",
			  GTK_SIGNAL_FUNC (statusbar_popped),
			  NULL);

      button = gtk_widget_new (gtk_button_get_type (),
1002
1003
1004
1005
			       "label", "push something",
			       "visible", TRUE,
			       "parent", box2,
			       "signal::clicked", statusbar_push, statusbar,
1006
1007
1008
			       NULL);

      button = gtk_widget_new (gtk_button_get_type (),
1009
1010
1011
1012
			       "label", "pop",
			       "visible", TRUE,
			       "parent", box2,
			       "signal_after::clicked", statusbar_pop, statusbar,
1013
1014
1015
			       NULL);

      button = gtk_widget_new (gtk_button_get_type (),
1016
1017
1018
1019
			       "label", "steal #4",
			       "visible", TRUE,
			       "parent", box2,
			       "signal_after::clicked", statusbar_steal, statusbar,
1020
1021
1022
			       NULL);

      button = gtk_widget_new (gtk_button_get_type (),
1023
1024
1025
1026
			       "label", "dump stack",
			       "visible", TRUE,
			       "parent", box2,
			       "object_signal::clicked", statusbar_dump_stack, statusbar,
1027
1028
			       NULL);

1029
      button = gtk_widget_new (gtk_button_get_type (),
1030
1031
1032
1033
			       "label", "test contexts",
			       "visible", TRUE,
			       "parent", box2,
			       "object_signal_after::clicked", statusbar_contexts, statusbar,
1034
1035
			       NULL);

1036
1037
1038
1039
      separator = gtk_hseparator_new ();
      gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);

      box2 = gtk_vbox_new (FALSE, 10);
1040
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);

      button = gtk_button_new_with_label ("close");
      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
				 GTK_OBJECT (window));
      gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
      GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
      gtk_widget_grab_default (button);
    }

  if (!GTK_WIDGET_VISIBLE (window))
1053
    gtk_widget_show_all (window);
1054
1055
1056
1057
  else
    gtk_widget_destroy (window);
}

1058
1059
1060
/*
 * GtkTree
 */
1061

1062
1063
1064
1065
1066
1067
static void
cb_tree_destroy_event(GtkWidget* w)
{
  sTreeButtons* tree_buttons;

  /* free buttons structure associate at this tree */
1068
1069
  tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
  g_free (tree_buttons);
1070
}
1071

1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
static void
cb_add_new_item(GtkWidget* w, GtkTree* tree)
{
  sTreeButtons* tree_buttons;
  GList* selected_list;
  GtkWidget* selected_item;
  GtkWidget* subtree;
  GtkWidget* item_new;
  char buffer[255];

  tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));

  selected_list = GTK_TREE_SELECTION(tree);

  if(selected_list == NULL)
    {
      /* there is no item in tree */
      subtree = GTK_WIDGET(tree);
    }
  else
    {
      /* list can have only one element */
      selected_item = GTK_WIDGET(selected_list->data);
      
      subtree = GTK_TREE_ITEM_SUBTREE(selected_item);

      if(subtree == NULL)
	{
	  /* current selected item have not subtree ... create it */
	  subtree = gtk_tree_new();
	  gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item), 
				    subtree);
	}
    }

  /* at this point, we know which subtree will be used to add new item */
  /* create a new item */
  sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
  item_new = gtk_tree_item_new_with_label(buffer);
  gtk_tree_append(GTK_TREE(subtree), item_new);
  gtk_widget_show(item_new);

  tree_buttons->nb_item_add++;
}

static void
cb_remove_item(GtkWidget*w, GtkTree* tree)
{
  GList* selected_list;
  GList* clear_list;
  
  selected_list = GTK_TREE_SELECTION(tree);

  clear_list = NULL;
    
  while (selected_list) 
    {
      clear_list = g_list_prepend (clear_list, selected_list->data);
      selected_list = selected_list->next;
    }
  
  clear_list = g_list_reverse (clear_list);
  gtk_tree_remove_items(tree, clear_list);

  g_list_free (clear_list);
}

1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
static void
cb_remove_subtree(GtkWidget*w, GtkTree* tree)
{
  GList* selected_list;
  GtkTreeItem *item;
  
  selected_list = GTK_TREE_SELECTION(tree);

  if (selected_list)
    {
      item = GTK_TREE_ITEM (selected_list->data);
      if (item->subtree)
	gtk_tree_item_remove_subtree (item);
    }
}

1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
static void
cb_tree_changed(GtkTree* tree)
{
  sTreeButtons* tree_buttons;
  GList* selected_list;
  guint nb_selected;

  tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));

  selected_list = GTK_TREE_SELECTION(tree);
  nb_selected = g_list_length(selected_list);

  if(nb_selected == 0) 
    {
      if(tree->children == NULL)
	gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
      else
	gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
      gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1174
      gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1175
1176
1177
1178
1179
    } 
  else 
    {
      gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
      gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1180
      gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
    }  
}

static void 
create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
{
  GtkWidget* item_subtree;
  GtkWidget* item_new;
  guint nb_item;
  char buffer[255];
  int no_root_item;

  if(level == recursion_level_max) return;

  if(level == -1)
    {
      /* query with no root item */
      level = 0;
      item_subtree = item;
      no_root_item = 1;
    }
  else
    {
      /* query with no root item */
      /* create subtree and associate it with current item */
      item_subtree = gtk_tree_new();
      no_root_item = 0;
    }
  
  for(nb_item = 0; nb_item < nb_item_max; nb_item++)
    {
      sprintf(buffer, "item %d-%d", level, nb_item);
      item_new = gtk_tree_item_new_with_label(buffer);
      gtk_tree_append(GTK_TREE(item_subtree), item_new);
      create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
      gtk_widget_show(item_new);
    }

  if(!no_root_item)
    gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
}

static void
create_tree_sample(guint selection_mode, 
		   guint draw_line, guint view_line, guint no_root_item,
		   guint nb_item_max, guint recursion_level_max) 
{
  GtkWidget* window;
  GtkWidget* box1;
  GtkWidget* box2;
  GtkWidget* separator;
  GtkWidget* button;
  GtkWidget* scrolled_win;
  GtkWidget* root_tree;
  GtkWidget* root_item;
  sTreeButtons* tree_buttons;

  /* create tree buttons struct */
1239
  if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
    {
      g_error("can't allocate memory for tree structure !\n");
      return;
    }
  tree_buttons->nb_item_add = 0;

  /* create top level window */
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
  gtk_signal_connect(GTK_OBJECT(window), "destroy",
		     (GtkSignalFunc) cb_tree_destroy_event, NULL);
  gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);

  box1 = gtk_vbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER(window), box1);
  gtk_widget_show(box1);

  /* create tree box */
  box2 = gtk_vbox_new(FALSE, 0);
  gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1260
  gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
  gtk_widget_show(box2);

  /* create scrolled window */
  scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
				  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
  gtk_widget_set_usize (scrolled_win, 200, 200);
  gtk_widget_show (scrolled_win);
  
  /* create root tree widget */
  root_tree = gtk_tree_new();
  gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
		     (GtkSignalFunc)cb_tree_changed,
		     (gpointer)NULL);
  gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1277
  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
  gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
  gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
  gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
  gtk_widget_show(root_tree);

  if ( no_root_item )
    {
      /* set root tree to subtree function with root item variable */
      root_item = GTK_WIDGET(root_tree);
    }
  else
    {
      /* create root tree item widget */
      root_item = gtk_tree_item_new_with_label("root item");
      gtk_tree_append(GTK_TREE(root_tree), root_item);
      gtk_widget_show(root_item);
     }
  create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);

  box2 = gtk_vbox_new(FALSE, 0);
  gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1299
  gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
  gtk_widget_show(box2);

  button = gtk_button_new_with_label("Add Item");
  gtk_widget_set_sensitive(button, FALSE);
  gtk_signal_connect(GTK_OBJECT (button), "clicked",
		     (GtkSignalFunc) cb_add_new_item, 
		     (gpointer)root_tree);
  gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
  gtk_widget_show(button);
  tree_buttons->add_button = button;

  button = gtk_button_new_with_label("Remove Item(s)");
  gtk_widget_set_sensitive(button, FALSE);
  gtk_signal_connect(GTK_OBJECT (button), "clicked",
		     (GtkSignalFunc) cb_remove_item, 
		     (gpointer)root_tree);
  gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
  gtk_widget_show(button);
  tree_buttons->remove_button = button;

1320
1321
1322
1323
1324
1325
1326
1327
1328
  button = gtk_button_new_with_label("Remove Subtree");
  gtk_widget_set_sensitive(button, FALSE);
  gtk_signal_connect(GTK_OBJECT (button), "clicked",
		     (GtkSignalFunc) cb_remove_subtree, 
		     (gpointer)root_tree);
  gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
  gtk_widget_show(button);
  tree_buttons->subtree_button = button;

1329
1330
1331
1332
1333
1334
1335
1336
  /* create separator */
  separator = gtk_hseparator_new();
  gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
  gtk_widget_show(separator);

  /* create button box */
  box2 = gtk_vbox_new(FALSE, 0);
  gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1337
  gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
  gtk_widget_show(box2);

  button = gtk_button_new_with_label("Close");
  gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
  gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
			    (GtkSignalFunc) gtk_widget_destroy, 
			    GTK_OBJECT(window));
  gtk_widget_show(button);

  gtk_widget_show(window);
}

static void
cb_create_tree(GtkWidget* w)
{
1353
  guint selection_mode = GTK_SELECTION_SINGLE;
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
  guint view_line;
  guint draw_line;
  guint no_root_item;
  guint nb_item;
  guint recursion_level;

  /* get selection mode choice */
  if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
    selection_mode = GTK_SELECTION_SINGLE;
  else
    if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
      selection_mode = GTK_SELECTION_BROWSE;
    else
1367
      selection_mode = GTK_SELECTION_MULTIPLE;
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377

  /* get options choice */
  draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
  view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
  no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
    
  /* get levels */
  nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
  recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));

1378
1379
1380
1381
1382
1383
1384
  if (pow (nb_item, recursion_level) > 10000)
    {
      g_print ("%g total items? That will take a very long time. Try less\n",
	       pow (nb_item, recursion_level));
      return;
    }

1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
  create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
}

void 
create_tree_mode_window(void)
{
  static GtkWidget* window;
  GtkWidget* box1;
  GtkWidget* box2;
  GtkWidget* box3;
  GtkWidget* box4;
  GtkWidget* box5;
  GtkWidget* button;
  GtkWidget* frame;
  GtkWidget* separator;
  GtkWidget* label;
  GtkWidget* spinner;
  GtkAdjustment *adj;

  if (!window)
    {
      /* create toplevel window  */
      window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1408
      gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
1409
      gtk_signal_connect (GTK_OBJECT (window), "destroy",
1410
1411
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
			  &window);
1412
1413
1414
      box1 = gtk_vbox_new(FALSE, 0);
      gtk_container_add(GTK_CONTAINER(window), box1);

1415
      /* create upper box - selection box */
1416
1417
      box2 = gtk_vbox_new(FALSE, 5);
      gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);