testgtk.c 248 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
#undef	G_LOG_DOMAIN
28

Elliot Lee's avatar
Elliot Lee committed
29
30
#include <stdio.h>
#include <stdlib.h>
31
#include <string.h>
32
#include <sys/stat.h>
33
#include <math.h>
34
#include <time.h>
35
#include <unistd.h>
Elliot Lee's avatar
Elliot Lee committed
36
#include "gtk.h"
37
38
#include "gdk/gdk.h"
#include "gdk/gdkkeysyms.h"
Elliot Lee's avatar
Elliot Lee committed
39

Owen Taylor's avatar
Owen Taylor committed
40
41
#include "circles.xbm"

42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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);
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

/* 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;
82
  GtkWidget* subtree_button;
83
84
85
} sTreeButtons;
/* end of tree section */

86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
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)
111
	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
112
113
114
115
116
117
118
119
120
      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;
}

121
static void
122
123
124
125
126
127
128
destroy_tooltips (GtkWidget *widget, GtkWindow **window)
{
  GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
  gtk_object_unref (GTK_OBJECT (tt));
  *window = NULL;
}

129
130
131
132
/*
 * GtkButton
 */

133
static void
Elliot Lee's avatar
Elliot Lee committed
134
135
136
137
138
139
140
141
142
button_window (GtkWidget *widget,
	       GtkWidget *button)
{
  if (!GTK_WIDGET_VISIBLE (button))
    gtk_widget_show (button);
  else
    gtk_widget_hide (button);
}

143
static void
144
create_buttons (void)
Elliot Lee's avatar
Elliot Lee committed
145
146
147
148
149
150
151
152
153
154
155
156
157
{
  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",
158
			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
Elliot Lee's avatar
Elliot Lee committed
159
160
			  &window);

161
      gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
162
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
Elliot Lee's avatar
Elliot Lee committed
163
164
165
166
167
168
169

      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);
170
      gtk_container_set_border_width (GTK_CONTAINER (table), 10);
Elliot Lee's avatar
Elliot Lee committed
171
172
173
174
175
176
177
178
179
180
181
182
183
      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
184
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
185
186
187
188
189
190
			  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
191
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
192
193
194
195
196
197
			  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
198
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
199
200
201
202
203
			  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
204
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
205
206
207
208
209
			  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
210
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
211
212
213
214
215
			  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
216
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
217
218
219
220
221
			  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
222
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
223
224
225
226
227
			  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
228
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
229
230
231
232
233
			  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
234
			  GTK_SIGNAL_FUNC(button_window),
Elliot Lee's avatar
Elliot Lee committed
235
236
237
238
239
240
241
242
			  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);
243
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
244
245
246
247
      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
248
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
Elliot Lee's avatar
Elliot Lee committed
249
250
251
252
253
254
255
				 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))
256
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
257
258
259
260
  else
    gtk_widget_destroy (window);
}

261
262
263
264
/*
 * GtkToggleButton
 */

265
static void
266
create_toggle_buttons (void)
Elliot Lee's avatar
Elliot Lee committed
267
268
269
270
271
272
273
274
275
276
277
278
{
  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",
279
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
Elliot Lee's avatar
Elliot Lee committed
280
281
			  &window);

282
      gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
283
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
Elliot Lee's avatar
Elliot Lee committed
284
285
286
287
288

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

      box2 = gtk_vbox_new (FALSE, 10);
289
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
      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);
305
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
306
307
308
309
      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
310
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
Elliot Lee's avatar
Elliot Lee committed
311
312
313
314
315
316
317
				 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))
318
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
319
320
321
322
  else
    gtk_widget_destroy (window);
}

323
324
325
326
/*
 * GtkCheckButton
 */

327
static void
328
create_check_buttons (void)
Elliot Lee's avatar
Elliot Lee committed
329
330
331
332
333
334
335
336
337
338
339
340
{
  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",
341
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
Elliot Lee's avatar
Elliot Lee committed
342
343
			  &window);

344
      gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
345
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
Elliot Lee's avatar
Elliot Lee committed
346
347
348
349
350

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

      box2 = gtk_vbox_new (FALSE, 10);
351
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
      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);
367
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
368
369
370
371
      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
372
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
Elliot Lee's avatar
Elliot Lee committed
373
374
375
376
377
378
379
				 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))
380
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
381
382
383
384
  else
    gtk_widget_destroy (window);
}

385
386
387
388
/*
 * GtkRadioButton
 */

389
static void
390
create_radio_buttons (void)
Elliot Lee's avatar
Elliot Lee committed
391
392
393
394
395
396
397
398
399
400
401
402
{
  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",
403
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
Elliot Lee's avatar
Elliot Lee committed
404
405
406
			  &window);

      gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
407
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
Elliot Lee's avatar
Elliot Lee committed
408
409
410
411
412

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

      box2 = gtk_vbox_new (FALSE, 10);
413
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
414
415
416
417
418
419
420
421
      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");
422
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
Elliot Lee's avatar
Elliot Lee committed
423
424
425
426
427
428
429
430
431
432
433
      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);
434
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
Elliot Lee's avatar
Elliot Lee committed
435
436
437
438
      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
439
				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
Elliot Lee's avatar
Elliot Lee committed
440
441
442
443
444
445
446
				 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))
447
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
448
449
450
451
  else
    gtk_widget_destroy (window);
}

452
453
454
/*
 * GtkButtonBox
 */
Elliot Lee's avatar
Elliot Lee committed
455

456
457
458
459
460
461
462
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
463
{
464
465
466
  GtkWidget *frame;
  GtkWidget *bbox;
  GtkWidget *button;
Elliot Lee's avatar
Elliot Lee committed
467
	
468
  frame = gtk_frame_new (title);
Elliot Lee's avatar
Elliot Lee committed
469
470

  if (horizontal)
471
    bbox = gtk_hbutton_box_new ();
Elliot Lee's avatar
Elliot Lee committed
472
  else
473
474
    bbox = gtk_vbutton_box_new ();

475
  gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
476
477
  gtk_container_add (GTK_CONTAINER (frame), bbox);

Elliot Lee's avatar
Elliot Lee committed
478
479
480
481
482
  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");
483
  gtk_container_add (GTK_CONTAINER (bbox), button);
Elliot Lee's avatar
Elliot Lee committed
484
485
  
  button = gtk_button_new_with_label ("Cancel");
486
  gtk_container_add (GTK_CONTAINER (bbox), button);
Elliot Lee's avatar
Elliot Lee committed
487
488
  
  button = gtk_button_new_with_label ("Help");
489
  gtk_container_add (GTK_CONTAINER (bbox), button);
Elliot Lee's avatar
Elliot Lee committed
490

491
  return frame;
Elliot Lee's avatar
Elliot Lee committed
492
493
}

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

    main_vbox = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (window), main_vbox);
Elliot Lee's avatar
Elliot Lee committed
517
    
518
519
    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
520
    
521
    vbox = gtk_vbox_new (FALSE, 0);
522
    gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
    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
543
    
544
    hbox = gtk_hbox_new (FALSE, 0);
545
    gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
    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
563
564
565
  }

  if (!GTK_WIDGET_VISIBLE (window))
566
    gtk_widget_show_all (window);
Elliot Lee's avatar
Elliot Lee committed
567
568
569
570
  else
    gtk_widget_destroy (window);
}

571
572
573
574
/*
 * GtkToolBar
 */

575
static GtkWidget*
576
577
578
new_pixmap (char      *filename,
	    GdkWindow *window,
	    GdkColor  *background)
579
580
581
582
583
584
585
{
  GtkWidget *wpixmap;
  GdkPixmap *pixmap;
  GdkBitmap *mask;

  pixmap = gdk_pixmap_create_from_xpm (window, &mask,
				       background,
586
				       filename);
587
588
589
590
591
  wpixmap = gtk_pixmap_new (pixmap, mask);

  return wpixmap;
}

592
static void
593
594
595
596
597
598
set_toolbar_horizontal (GtkWidget *widget,
			gpointer   data)
{
  gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
}

599
static void
600
601
602
603
604
605
set_toolbar_vertical (GtkWidget *widget,
		      gpointer   data)
{
  gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
}

606
static void
607
608
609
610
611
612
set_toolbar_icons (GtkWidget *widget,
		   gpointer   data)
{
  gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
}

613
static void
614
615
616
617
618
619
set_toolbar_text (GtkWidget *widget,
	          gpointer   data)
{
  gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
}

620
static void
621
622
623
624
625
626
set_toolbar_both (GtkWidget *widget,
		  gpointer   data)
{
  gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
}

627
628
629
630
631
632
633
static void
set_toolbar_both_horiz (GtkWidget *widget,
			gpointer   data)
{
  gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
}

634
static void
635
636
637
638
639
640
set_toolbar_small_space (GtkWidget *widget,
			 gpointer   data)
{
  gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
}

641
static void
642
643
644
645
646
647
set_toolbar_big_space (GtkWidget *widget,
		       gpointer   data)
{
  gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
}

648
static void
649
650
651
652
653
654
set_toolbar_enable (GtkWidget *widget,
		    gpointer   data)
{
  gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
}

655
static void
656
657
658
659
660
661
set_toolbar_disable (GtkWidget *widget,
		     gpointer   data)
{
  gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
}

662
663
664
665
666
667
668
669
670
671
672
673
674
675
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);
}

676
677
678
679
680
681
682
683
684
685
686
687
688
689
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);
}

690
static void
691
692
693
694
create_toolbar (void)
{
  static GtkWidget *window = NULL;
  GtkWidget *toolbar;
695
  GtkWidget *entry;
696
697
698
699
700

  if (!window)
    {
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
701
      gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
702
703

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

707
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
708
709
710
      gtk_widget_realize (window);

      toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
711
      gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
712
713

      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
714
			       "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
715
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
716
717
			       (GtkSignalFunc) set_toolbar_horizontal, toolbar);
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
718
			       "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
719
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
720
721
722
723
724
			       (GtkSignalFunc) set_toolbar_vertical, toolbar);

      gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));

      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
725
			       "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
726
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
727
728
			       (GtkSignalFunc) set_toolbar_icons, toolbar);
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
729
			       "Text", "Only show toolbar text", "Toolbar/TextOnly",
730
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
731
732
			       (GtkSignalFunc) set_toolbar_text, toolbar);
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
733
			       "Both", "Show toolbar icons and text", "Toolbar/Both",
734
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
735
			       (GtkSignalFunc) set_toolbar_both, toolbar);
736
737
738
739
740
741
742
      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);
			       
743
744
      gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

745
      entry = gtk_entry_new ();
746

747
      gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
748
749
750

      gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

751
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
752
			       "Small", "Use small spaces", "Toolbar/Small",
753
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
754
			       (GtkSignalFunc) set_toolbar_small_space, toolbar);
755
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
756
			       "Big", "Use big spaces", "Toolbar/Big",
757
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
758
759
			       (GtkSignalFunc) set_toolbar_big_space, toolbar);

760
      gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
761

762
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
763
			       "Enable", "Enable tooltips", NULL,
764
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
765
			       (GtkSignalFunc) set_toolbar_enable, toolbar);
766
      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
767
			       "Disable", "Disable tooltips", NULL,
768
			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
769
			       (GtkSignalFunc) set_toolbar_disable, toolbar);
770

771
772
773
774
775
776
777
778
779
780
781
      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);

782
783
784
785
786
787
788
789
790
791
792
      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);

793
794
795
796
      gtk_container_add (GTK_CONTAINER (window), toolbar);
    }

  if (!GTK_WIDGET_VISIBLE (window))
797
    gtk_widget_show_all (window);
798
799
800
801
  else
    gtk_widget_destroy (window);
}

802
static GtkWidget*
803
804
805
806
807
808
809
810
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);
811
  gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
812
813

  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
814
			   "Horizontal", "Horizontal toolbar layout", NULL,
815
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
816
817
			   (GtkSignalFunc) set_toolbar_horizontal, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
818
			   "Vertical", "Vertical toolbar layout", NULL,
819
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
820
821
822
823
824
			   (GtkSignalFunc) set_toolbar_vertical, toolbar);

  gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));

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

  gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
840
			   "Small", "Use small spaces", NULL,
841
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
842
843
			   (GtkSignalFunc) set_toolbar_small_space, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
844
			   "Big", "Use big spaces", "Toolbar/Big",
845
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
846
847
848
849
850
			   (GtkSignalFunc) set_toolbar_big_space, toolbar);

  gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
851
			   "Enable", "Enable tooltips", NULL,
852
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
853
854
			   (GtkSignalFunc) set_toolbar_enable, toolbar);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
855
			   "Disable", "Disable tooltips", NULL,
856
			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
857
858
			   (GtkSignalFunc) set_toolbar_disable, toolbar);

859
860
861
862
863
864
865
866
867
868
869
  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);

870
871
872
  return toolbar;
}

873
874
875
876
/*
 * GtkStatusBar
 */

877
878
879
880
881
882
883
884
885
886
static guint statusbar_counter = 1;

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

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

887
  gtk_statusbar_push (statusbar, 1, text);
888
889
890
891
892
893
}

static void
statusbar_pop (GtkWidget *button,
	       GtkStatusbar *statusbar)
{
894
  gtk_statusbar_pop (statusbar, 1);
895
896
897
898
899
900
}

static void
statusbar_steal (GtkWidget *button,
	         GtkStatusbar *statusbar)
{
901
  gtk_statusbar_remove (statusbar, 1, 4);
902
903
904
905
}

static void
statusbar_popped (GtkStatusbar  *statusbar,
906
		  guint          context_id,
907
908
909
910
911
912
		  const gchar	*text)
{
  if (!statusbar->messages)
    statusbar_counter = 1;
}

913
static void
914
statusbar_contexts (GtkStatusbar *statusbar)
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
{
  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));
}

944
static void
945
statusbar_dump_stack (GtkStatusbar *statusbar)
946
{
947
  GSList *list;
948
949
950
951
952
953

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

      msg = list->data;
954
955
956
957
      g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
               msg->context_id,
               msg->message_id,
               msg->text);
958
959
960
961
    }
}

static void
962
create_statusbar (void)
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
{
  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");
980
      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
981
982
983
984
985

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

      box2 = gtk_vbox_new (FALSE, 10);
986
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
987
988
989
990
991
992
993
994
995
996
      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 (),
997
998
999
1000
			       "label", "push something",
			       "visible", TRUE,
			       "parent", box2,
			       "signal::clicked", statusbar_push, statusbar,
1001
1002
1003
			       NULL);

      button = gtk_widget_new (gtk_button_get_type (),
1004
1005
1006
1007
			       "label", "pop",
			       "visible", TRUE,
			       "parent", box2,
			       "signal_after::clicked", statusbar_pop, statusbar,
1008
1009
1010
			       NULL);

      button = gtk_widget_new (gtk_button_get_type (),
1011
1012
1013
1014
			       "label", "steal #4",
			       "visible", TRUE,
			       "parent", box2,
			       "signal_after::clicked", statusbar_steal, statusbar,
1015
1016
1017
			       NULL);

      button = gtk_widget_new (gtk_button_get_type (),
1018
1019
1020
1021
			       "label", "dump stack",
			       "visible", TRUE,
			       "parent", box2,
			       "object_signal::clicked", statusbar_dump_stack, statusbar,
1022
1023
			       NULL);

1024
      button = gtk_widget_new (gtk_button_get_type (),
1025
1026
1027
1028
			       "label", "test contexts",
			       "visible", TRUE,
			       "parent", box2,
			       "object_signal_after::clicked", statusbar_contexts, statusbar,
1029
1030
			       NULL);

1031
1032
1033
1034
      separator = gtk_hseparator_new ();
      gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);

      box2 = gtk_vbox_new (FALSE, 10);
1035
      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
      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))
1048
    gtk_widget_show_all (window);
1049
1050
1051
1052
  else
    gtk_widget_destroy (window);
}

1053
1054
1055
/*
 * GtkTree
 */
1056

1057
1058
1059
1060
1061
1062
static void
cb_tree_destroy_event(GtkWidget* w)
{
  sTreeButtons* tree_buttons;

  /* free buttons structure associate at this tree */
1063
1064
  tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
  g_free (tree_buttons);
1065
}
1066

1067
1068
1069
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
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);
}

1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
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);
    }
}

1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
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);
1169
      gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1170
1171
1172
1173
1174
    } 
  else 
    {
      gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
      gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1175
      gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1176
1177
1178
1179
1180
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
    }  
}

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 */
1234
  if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
    {
      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);
1255
  gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
  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);
1272
  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
  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);
1294
  gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
  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;

1315
1316
1317
1318
1319
1320
1321
1322
1323
  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;

1324
1325
1326
1327
1328
1329
1330
1331
  /* 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);
1332
  gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
  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)
{
1348
  guint selection_mode = GTK_SELECTION_SINGLE;
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
  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
1362
      selection_mode = GTK_SELECTION_MULTIPLE;
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372

  /* 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));

1373
1374
1375
1376
1377
1378
1379
  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;
    }

1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
  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);
1403
      gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
1404
      gtk_signal_connect (GTK_OBJECT (window), "destroy",
1405
1406
			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
			  &window);
1407
1408
1409
      box1 = gtk_vbox_new(FALSE, 0);
      gtk_container_add(GTK_CONTAINER(window), box1);

1410
      /* create upper box - selection box */
1411
1412
      box2 = gtk_vbox_new(FALSE, 5);
      gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1413
      gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423

      box3 = gtk_hbox_new(FALSE, 5);
      gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);

      /* create selection mode frame */
      frame = gtk_frame_new("Selection Mode");
      gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);

      box4 = gtk_vbox_new(FALSE, 0);
      gtk_container_add(GTK_CONTAINER(frame), box4);