(U-0002011D): Use `ideographic-radical@{ucs|cns}' and
[chise/xemacs-chise.git.1] / src / ui-byhand.c
1 /* I really wish this entire file could go away, but there is
2    currently no way to do the following in the Foreign Function
3    Interface:
4
5    1) Deal with return values in the parameter list (ie: int *foo)
6
7    So we have to code a few functions by hand.  Ick.
8
9    William M. Perry 5/8/00
10 */
11
12 #include "gui.h"
13
14 DEFUN ("gtk-box-query-child-packing", Fgtk_box_query_child_packing, 2, 2,0, /*
15 Returns information about how CHILD is packed into BOX.
16 Return value is a list of (EXPAND FILL PADDING PACK_TYPE).
17 */
18        (box, child))
19 {
20   gboolean expand, fill;
21   guint padding;
22   GtkPackType pack_type;
23   Lisp_Object result = Qnil;
24   
25   CHECK_GTK_OBJECT (box);
26   CHECK_GTK_OBJECT (child);
27
28   if (!GTK_IS_BOX (XGTK_OBJECT (box)->object))
29     {
30       signal_simple_error ("Object is not a GtkBox", box);
31     }
32
33   if (!GTK_IS_WIDGET (XGTK_OBJECT (child)->object))
34     {
35       signal_simple_error ("Child is not a GtkWidget", child);
36     }
37
38   gtk_box_query_child_packing (GTK_BOX (XGTK_OBJECT (box)->object),
39                                GTK_WIDGET (XGTK_OBJECT (child)->object),
40                                &expand, &fill, &padding, &pack_type);
41
42   result = Fcons (make_int (pack_type), result);
43   result = Fcons (make_int (padding), result);
44   result = Fcons (fill ? Qt : Qnil, result);
45   result = Fcons (expand ? Qt : Qnil, result);
46
47   return (result);
48 }
49
50 /* void gtk_button_box_get_child_size_default (gint *min_width, gint *min_height); */
51 DEFUN ("gtk-button-box-get-child-size-default",
52        Fgtk_button_box_get_child_size_default, 0, 0, 0, /*
53 Return a cons cell (WIDTH . HEIGHT) of the default button box child size.
54 */
55        ())
56 {
57   gint width, height;
58
59   gtk_button_box_get_child_size_default (&width, &height);
60
61   return (Fcons (make_int (width), make_int (height)));
62 }
63
64 /* void gtk_button_box_get_child_ipadding_default (gint *ipad_x, gint *ipad_y);  */
65 DEFUN ("gtk-button-box-get-child-ipadding-default",
66        Fgtk_button_box_get_child_ipadding_default, 0, 0, 0, /*
67 Return a cons cell (X . Y) of the default button box ipadding.
68 */
69        ())
70 {
71   gint x, y;
72
73   gtk_button_box_get_child_ipadding_default (&x, &y);
74
75   return (Fcons (make_int (x), make_int (y)));
76 }
77
78 /* void gtk_button_box_get_child_size (GtkButtonBox *widget,
79    gint *min_width, gint *min_height); */
80 DEFUN ("gtk-button-box-get-child-size", Fgtk_button_box_get_child_size, 1, 1, 0, /*
81 Get the current size of a child in the buttonbox BOX.
82 */
83        (box))
84 {
85   gint width, height;
86
87   CHECK_GTK_OBJECT (box);
88
89   if (!GTK_IS_BUTTON_BOX (XGTK_OBJECT (box)->object))
90     {
91       signal_simple_error ("Not a GtkBox object", box);
92     }
93
94   gtk_button_box_get_child_size (GTK_BUTTON_BOX (XGTK_OBJECT (box)->object),
95                                  &width, &height);
96
97   return (Fcons (make_int (width), make_int (height)));
98 }
99
100 /* void gtk_button_box_get_child_ipadding (GtkButtonBox *widget, gint *ipad_x, gint *ipad_y); */
101 DEFUN ("gtk-button-box-get-child-ipadding",
102        Fgtk_button_box_get_child_ipadding, 1, 1, 0, /*
103 Return a cons cell (X . Y) of the current buttonbox BOX ipadding.
104 */
105        (box))
106 {
107   gint x, y;
108
109   CHECK_GTK_OBJECT (box);
110
111   if (!GTK_IS_BUTTON_BOX (XGTK_OBJECT (box)->object))
112     {
113       signal_simple_error ("Not a GtkBox object", box);
114     }
115
116   gtk_button_box_get_child_ipadding (GTK_BUTTON_BOX (XGTK_OBJECT (box)->object),
117                                      &x, &y);
118
119   return (Fcons (make_int (x), make_int (y)));
120 }
121
122 /*void     gtk_calendar_get_date        (GtkCalendar *calendar, 
123                                          guint       *year,
124                                          guint       *month,
125                                          guint       *day);
126 */
127 DEFUN ("gtk-calendar-get-date", Fgtk_calendar_get_date, 1, 1, 0, /*
128 Return a list of (YEAR MONTH DAY) from the CALENDAR object.
129 */
130        (calendar))
131 {
132   guint year, month, day;
133
134   CHECK_GTK_OBJECT (calendar);
135
136   if (!GTK_IS_CALENDAR (XGTK_OBJECT (calendar)->object))
137     {
138       signal_simple_error ("Not a GtkCalendar object", calendar);
139     }
140
141   gtk_calendar_get_date (GTK_CALENDAR (XGTK_OBJECT (calendar)->object),
142                          &year, &month, &day);
143
144   return (list3 (make_int (year), make_int (month), make_int (day)));
145 }
146
147 /* gint gtk_clist_get_text (GtkCList  *clist,
148                          gint       row,
149                          gint       column,
150                          gchar    **text);
151 */
152 DEFUN ("gtk-clist-get-text", Fgtk_clist_get_text, 3, 3, 0, /*
153 Returns the text from GtkCList OBJ cell at coordinates ROW, COLUMN.
154 */
155        (obj, row, column))
156 {
157   gchar *text = NULL;
158   Lisp_Object rval = Qnil;
159
160   CHECK_GTK_OBJECT (obj);
161   CHECK_INT (row);
162   CHECK_INT (column);
163
164   if (!GTK_IS_CLIST (XGTK_OBJECT (obj)->object))
165     {
166       signal_simple_error ("Object is not a GtkCList", obj);
167     }
168
169   gtk_clist_get_text (GTK_CLIST (XGTK_OBJECT (obj)->object), XINT (row), XINT (column), &text);
170
171   if (text)
172     {
173       rval = build_string (text);
174       /* NOTE: This is NOT a memory leak.  GtkCList returns a pointer
175          to internally used memory, not a copy of it.
176          g_free (text);
177       */
178     }
179
180   return (rval);
181 }
182
183 /* gint gtk_clist_get_selection_info (GtkCList *clist,
184                                    gint      x,
185                                    gint      y,
186                                    gint     *row,
187                                    gint *column); */
188 DEFUN ("gtk-clist-get-selection-info", Fgtk_clist_get_selection, 3, 3, 0, /*
189 Returns a cons cell of (ROW . COLUMN) of the GtkCList OBJ at coordinates X, Y.
190 */
191        (obj, x, y))
192 {
193   gint row, column;
194
195   CHECK_GTK_OBJECT (obj);
196   CHECK_INT (x);
197   CHECK_INT (y);
198
199   if (!GTK_IS_CLIST (XGTK_OBJECT (obj)->object))
200     {
201       signal_simple_error ("Object is not a GtkCList", obj);
202     }
203
204   gtk_clist_get_selection_info (GTK_CLIST (XGTK_OBJECT (obj)->object),
205                                 XINT (x), XINT (y), &row, &column);
206
207   return (Fcons (make_int (row), make_int (column)));
208 }
209
210 DEFUN ("gtk-clist-get-pixmap", Fgtk_clist_get_pixmap, 3, 3, 0, /*
211 Return a cons of (pixmap . mask) at ROW,COLUMN in CLIST.
212 */
213        (clist, row, column))
214 {
215   GdkPixmap *pixmap = NULL;
216   GdkBitmap *mask = NULL;
217
218   CHECK_GTK_OBJECT (clist);
219   CHECK_INT (row);
220   CHECK_INT (column);
221
222   if (!GTK_IS_CLIST (XGTK_OBJECT (clist)->object))
223     {
224       signal_simple_error ("Object is not a GtkCList", clist);
225     }
226
227   gtk_clist_get_pixmap (GTK_CLIST (XGTK_OBJECT (clist)->object),
228                         XINT (row), XINT (column),
229                         &pixmap, &mask);
230
231   return (Fcons (pixmap ? build_gtk_boxed (pixmap, GTK_TYPE_GDK_WINDOW) : Qnil,
232                  mask ? build_gtk_boxed (mask, GTK_TYPE_GDK_WINDOW) : Qnil));
233 }
234
235 DEFUN ("gtk-clist-get-pixtext", Fgtk_clist_get_pixtext, 3, 3, 0, /*
236 Return a list of (pixmap mask text) at ROW,COLUMN in CLIST.
237 */
238        (clist, row, column))
239 {
240   GdkPixmap *pixmap = NULL;
241   GdkBitmap *mask = NULL;
242   char *text = NULL;
243   guint8 spacing;
244
245   CHECK_GTK_OBJECT (clist);
246   CHECK_INT (row);
247   CHECK_INT (column);
248
249   if (!GTK_IS_CLIST (XGTK_OBJECT (clist)->object))
250     {
251       signal_simple_error ("Object is not a GtkCList", clist);
252     }
253
254   gtk_clist_get_pixtext (GTK_CLIST (XGTK_OBJECT (clist)->object),
255                          XINT (row), XINT (column), &text, &spacing,
256                          &pixmap, &mask);
257
258   return (list3 (pixmap ? build_gtk_boxed (pixmap, GTK_TYPE_GDK_WINDOW) : Qnil,
259                  mask ? build_gtk_boxed (mask, GTK_TYPE_GDK_WINDOW) : Qnil,
260                  (text && text[0]) ? build_string (text) : Qnil));
261 }
262
263 /* void gtk_color_selection_get_color(GtkColorSelection *colorsel, gdouble *color); */
264 DEFUN ("gtk-color-selection-get-color", Fgtk_color_selection_get_color, 1, 1, 0, /*
265 Return a list of (RED GREEN BLUE ALPHA) from the GtkColorSelection OBJECT.
266 */
267        (object))
268 {
269   gdouble rgba[4];
270
271   CHECK_GTK_OBJECT (object);
272
273   if (!GTK_IS_COLOR_SELECTION (XGTK_OBJECT (object)->object))
274     {
275       signal_simple_error ("Object is not a GtkColorSelection", object);
276     }
277
278   gtk_color_selection_get_color (GTK_COLOR_SELECTION (XGTK_OBJECT (object)), rgba);
279
280   return (list4 (make_float (rgba[0]),
281                  make_float (rgba[1]),
282                  make_float (rgba[2]),
283                  make_float (rgba[3])));
284 }
285
286 /* (gtk-import-function nil "gtk_editable_insert_text" 'GtkEditable 'GtkString 'gint 'pointer-to-gint) */
287 DEFUN ("gtk-editable-insert-text", Fgtk_editable_insert_text, 3, 3, 0, /*
288 Insert text STRINT at POS in GtkEditable widget OBJ.
289 Returns the new position of the cursor in the widget.
290 */
291        (obj, string, pos))
292 {
293   gint the_pos;
294
295   CHECK_GTK_OBJECT (obj);
296   CHECK_STRING (string);
297   CHECK_INT (pos);
298
299   the_pos = XINT (pos);
300
301   if (!GTK_IS_EDITABLE (XGTK_OBJECT (obj)->object))
302     {
303       signal_simple_error ("Object is not a GtkEditable", obj);
304     }
305
306   gtk_editable_insert_text (GTK_EDITABLE (XGTK_OBJECT (obj)->object),
307                             (char *) XSTRING_DATA (string),
308                             XSTRING_LENGTH (string),
309                             &the_pos);
310
311   return (make_int (the_pos));
312 }
313
314 DEFUN ("gtk-pixmap-get", Fgtk_pixmap_get, 1, 1, 0, /*
315 Return a cons cell of (PIXMAP . MASK) from GtkPixmap OBJECT.
316 */
317          (object))
318 {
319   GdkPixmap *pixmap, *mask;
320
321   CHECK_GTK_OBJECT (object);
322
323   if (!GTK_IS_PIXMAP (XGTK_OBJECT (object)->object))
324     {
325       signal_simple_error ("Object is not a GtkPixmap", object);
326     }
327
328   gtk_pixmap_get (GTK_PIXMAP (XGTK_OBJECT (object)->object), &pixmap, &mask);
329
330   return (Fcons (pixmap ? build_gtk_object (GTK_OBJECT (pixmap)) : Qnil,
331                  mask ? build_gtk_object (GTK_OBJECT (mask)) : Qnil));
332 }
333
334 DEFUN ("gtk-curve-get-vector", Fgtk_curve_get_vector, 2, 2, 0, /*
335 Returns a vector of LENGTH points representing the curve of CURVE.
336 */
337        (curve, length))
338 {
339   gfloat *vector = NULL;
340   Lisp_Object lisp_vector = Qnil;
341   int i;
342
343   CHECK_GTK_OBJECT (curve);
344   CHECK_INT (length);
345
346   if (!GTK_IS_CURVE (XGTK_OBJECT (curve)->object))
347     {
348       signal_simple_error ("Object is not a GtkCurve", curve);
349     }
350
351   vector = (gfloat *) alloca (sizeof (gfloat) * XINT (length));
352
353   gtk_curve_get_vector (GTK_CURVE (XGTK_OBJECT (curve)->object), XINT (length), vector);
354   lisp_vector = make_vector (XINT (length), Qnil);
355
356   for (i = 0; i < XINT (length); i++)
357     {
358       XVECTOR_DATA (lisp_vector)[i] = make_float (vector[i]);
359     }
360
361   return (lisp_vector);
362 }
363
364 DEFUN ("gtk-curve-set-vector", Fgtk_curve_set_vector, 2, 2, 0, /*
365 Set the vector of points on CURVE to VECTOR.
366 */
367        (curve, vector))
368 {
369   gfloat *c_vector = NULL;
370   int vec_length = 0;
371   int i;
372
373   CHECK_GTK_OBJECT (curve);
374   CHECK_VECTOR (vector);
375
376   vec_length = XVECTOR_LENGTH (vector);
377
378   if (!GTK_IS_CURVE (XGTK_OBJECT (curve)->object))
379     {
380       signal_simple_error ("Object is not a GtkCurve", curve);
381     }
382
383   c_vector = (gfloat *) alloca (sizeof (gfloat) * vec_length);
384
385   for (i = 0; i < vec_length; i++)
386     {
387       CHECK_FLOAT (XVECTOR_DATA (vector)[i]);
388       c_vector[i] = extract_float (XVECTOR_DATA (vector)[i]);
389     }
390
391   gtk_curve_set_vector (GTK_CURVE (XGTK_OBJECT (curve)->object), vec_length, c_vector);
392   return (Qt);
393 }
394
395 DEFUN ("gtk-label-get", Fgtk_label_get, 1, 1, 0, /*
396 Return the text of LABEL.
397 */
398        (label))
399 {
400   gchar *string;
401
402   CHECK_GTK_OBJECT (label);
403
404   if (!GTK_IS_LABEL (XGTK_OBJECT (label)->object))
405     {
406       signal_simple_error ("Object is not a GtkLabel", label);
407     }
408
409   gtk_label_get (GTK_LABEL (XGTK_OBJECT (label)->object), &string);
410
411   return (build_string (string));
412 }
413
414 DEFUN ("gtk-notebook-query-tab-label-packing", Fgtk_notebook_query_tab_label_packing, 2, 2, 0, /*
415 Return a list of packing information (EXPAND FILL PACK_TYPE) for CHILD in NOTEBOOK.
416 */
417        (notebook, child))
418 {
419   gboolean expand, fill;
420   GtkPackType pack_type;
421
422   CHECK_GTK_OBJECT (notebook);
423   CHECK_GTK_OBJECT (child);
424
425   if (!GTK_IS_NOTEBOOK (XGTK_OBJECT (notebook)->object))
426     {
427       signal_simple_error ("Object is not a GtkLabel", notebook);
428     }
429
430   if (!GTK_IS_WIDGET (XGTK_OBJECT (child)->object))
431     {
432       signal_simple_error ("Object is not a GtkWidget", child);
433     }
434
435   gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (XGTK_OBJECT (notebook)->object),
436                                         GTK_WIDGET (XGTK_OBJECT (child)->object),
437                                         &expand, &fill, &pack_type);
438
439   return (list3 (expand ? Qt : Qnil, fill ? Qt : Qnil, make_int (pack_type)));
440 }
441
442 DEFUN ("gtk-widget-get-pointer", Fgtk_widget_get_pointer, 1, 1, 0, /*
443 Return the pointer position relative to WIDGET as a cons of (X . Y).
444 */
445        (widget))
446 {
447   gint x,y;
448   CHECK_GTK_OBJECT (widget);
449
450   if (!GTK_IS_WIDGET (XGTK_OBJECT (widget)->object))
451     {
452       signal_simple_error ("Object is not a GtkWidget", widget);
453     }
454
455   gtk_widget_get_pointer (GTK_WIDGET (XGTK_OBJECT (widget)->object), &x, &y);
456
457   return (Fcons (make_int (x), make_int (y)));
458 }
459
460 /* This is called whenever an item with a GUI_ID associated with it is
461    destroyed.  This allows us to remove the references in gui-gtk.c
462    that made sure callbacks and such were GCPRO-ed
463 */
464 static void
465 __remove_gcpro_by_id (gpointer user_data)
466 {
467   ungcpro_popup_callbacks ((GUI_ID) user_data);
468 }
469
470 static void
471 __generic_toolbar_callback (GtkWidget *item, gpointer user_data)
472 {
473   Lisp_Object callback;
474   Lisp_Object lisp_user_data;
475
476   VOID_TO_LISP (callback, user_data);
477
478   lisp_user_data = XCAR (callback);
479   callback = XCDR (callback);
480
481   signal_special_gtk_user_event (Qnil, callback, lisp_user_data);
482 }
483
484 static Lisp_Object
485 generic_toolbar_insert_item (Lisp_Object toolbar,
486                              Lisp_Object text,
487                              Lisp_Object tooltip_text,
488                              Lisp_Object tooltip_private_text,
489                              Lisp_Object icon,
490                              Lisp_Object callback,
491                              Lisp_Object data,
492                              Lisp_Object prepend_p,
493                              Lisp_Object position)
494 {
495   GUI_ID id;
496   GtkWidget *w = NULL;
497
498   CHECK_GTK_OBJECT (toolbar);
499   CHECK_GTK_OBJECT (icon);
500   CHECK_STRING (text);
501   CHECK_STRING (tooltip_text);
502   CHECK_STRING (tooltip_private_text);
503
504   if (!SYMBOLP (callback) && !LISTP (callback))
505     {
506       signal_simple_error ("Callback must be symbol or eval-able form", callback);
507     }
508
509   if (!GTK_IS_TOOLBAR (XGTK_OBJECT (toolbar)->object))
510     {
511       signal_simple_error ("Object is not a GtkToolbar", toolbar);
512     }
513
514   if (!GTK_IS_WIDGET (XGTK_OBJECT (icon)->object))
515     {
516       signal_simple_error ("Object is not a GtkWidget", icon);
517     }
518
519   callback = Fcons (data, callback);
520
521   id = new_gui_id ();
522   gcpro_popup_callbacks (id, callback);
523   gtk_object_weakref (XGTK_OBJECT (toolbar)->object, __remove_gcpro_by_id,
524                       (gpointer) id);
525
526   if (NILP (position))
527     {
528       w = (NILP (prepend_p) ? gtk_toolbar_append_item : gtk_toolbar_prepend_item)
529         (GTK_TOOLBAR (XGTK_OBJECT (toolbar)->object),
530          XSTRING_DATA (text),
531          XSTRING_DATA (tooltip_text),
532          XSTRING_DATA (tooltip_private_text),
533          GTK_WIDGET (XGTK_OBJECT (icon)->object),
534          GTK_SIGNAL_FUNC (__generic_toolbar_callback),
535          LISP_TO_VOID (callback));
536     }
537   else
538     {
539       w = gtk_toolbar_insert_item (GTK_TOOLBAR (XGTK_OBJECT (toolbar)->object),
540                                    XSTRING_DATA (text),
541                                    XSTRING_DATA (tooltip_text),
542                                    XSTRING_DATA (tooltip_private_text),
543                                    GTK_WIDGET (XGTK_OBJECT (icon)->object),
544                                    GTK_SIGNAL_FUNC (__generic_toolbar_callback),
545                                    LISP_TO_VOID (callback),
546                                    XINT (position));
547     }
548
549
550   return (w ? build_gtk_object (GTK_OBJECT (w)) : Qnil);
551 }
552
553 DEFUN ("gtk-toolbar-append-item", Fgtk_toolbar_append_item, 6, 7, 0, /*
554 Appends a new button to the given toolbar.
555 */
556            (toolbar, text, tooltip_text, tooltip_private_text, icon, callback, data))
557 {
558   return (generic_toolbar_insert_item (toolbar,text,tooltip_text,tooltip_private_text,icon,callback,data,Qnil,Qnil));
559 }
560
561 DEFUN ("gtk-toolbar-prepend-item", Fgtk_toolbar_prepend_item, 6, 7, 0, /*
562 Adds a new button to the beginning (left or top edges) of the given toolbar.
563 */
564            (toolbar, text, tooltip_text, tooltip_private_text, icon, callback, data))
565 {
566   return (generic_toolbar_insert_item (toolbar,text,tooltip_text,tooltip_private_text,icon,callback,data,Qt,Qnil));
567 }
568
569 DEFUN ("gtk-toolbar-insert-item", Fgtk_toolbar_insert_item, 7, 8, 0, /*
570 Adds a new button to the beginning (left or top edges) of the given toolbar.
571 */
572            (toolbar, text, tooltip_text, tooltip_private_text, icon, callback, position, data))
573 {
574   CHECK_INT (position);
575
576   return (generic_toolbar_insert_item (toolbar,text,tooltip_text,tooltip_private_text,icon,callback,data,Qnil,position));
577 }
578
579 /* GtkCTree is an abomination in the eyes of the object system. */
580 static void
581 __emacs_gtk_ctree_recurse_internal (GtkCTree *ctree, GtkCTreeNode *node, gpointer user_data)
582 {
583   Lisp_Object closure;
584
585   VOID_TO_LISP (closure, user_data);
586
587   call3 (XCAR (closure),
588          build_gtk_object (GTK_OBJECT (ctree)),
589          build_gtk_boxed (node, GTK_TYPE_CTREE_NODE),
590          XCDR (closure));
591 }
592
593 DEFUN ("gtk-ctree-recurse", Fgtk_ctree_recurse, 3, 6, 0, /*
594 Recursively apply FUNC to all nodes of CTREE at or below NODE.
595 FUNC is called with three arguments: CTREE, a GtkCTreeNode, and DATA.
596 The return value of FUNC is ignored.
597
598 If optional 5th argument CHILDFIRSTP is non-nil, then
599 the function is called for each node after it has been
600 called for that node's children.
601
602 Optional 6th argument DEPTH limits how deeply to recurse.
603
604 This function encompasses all the following Gtk functions:
605
606 void gtk_ctree_post_recursive                    (GtkCTree     *ctree, 
607                                                   GtkCTreeNode *node,
608                                                   GtkCTreeFunc  func,
609                                                   gpointer      data);
610 void gtk_ctree_post_recursive_to_depth           (GtkCTree     *ctree, 
611                                                   GtkCTreeNode *node,
612                                                   gint          depth,
613                                                   GtkCTreeFunc  func,
614                                                   gpointer      data);
615 void gtk_ctree_pre_recursive                     (GtkCTree     *ctree, 
616                                                   GtkCTreeNode *node,
617                                                   GtkCTreeFunc  func,
618                                                   gpointer      data);
619 void gtk_ctree_pre_recursive_to_depth            (GtkCTree     *ctree, 
620                                                   GtkCTreeNode *node,
621                                                   gint          depth,
622                                                   GtkCTreeFunc  func,
623                                                   gpointer      data);
624 */
625        (ctree, node, func, data, childfirstp, depth))
626 {
627   struct gcpro gcpro1, gcpro2, gcpro3;
628   Lisp_Object closure = Qnil;
629
630   CHECK_GTK_OBJECT (ctree);
631
632   if (!NILP (node))
633     {
634       CHECK_GTK_BOXED (node);
635     }
636
637   if (!NILP (depth))
638     {
639       CHECK_INT (depth);
640     }
641
642   closure = Fcons (func, data);
643
644   GCPRO3 (ctree, node, closure);
645
646   if (NILP (depth))
647     {
648       (NILP (childfirstp) ? gtk_ctree_post_recursive : gtk_ctree_pre_recursive)
649         (GTK_CTREE (XGTK_OBJECT (ctree)->object),
650          NILP (node) ? NULL : (GtkCTreeNode *) XGTK_BOXED (node)->object,
651          __emacs_gtk_ctree_recurse_internal,
652          LISP_TO_VOID (closure));
653     }
654   else
655     {
656       (NILP (childfirstp) ? gtk_ctree_post_recursive_to_depth : gtk_ctree_pre_recursive_to_depth)
657         (GTK_CTREE (XGTK_OBJECT (ctree)->object),
658          NILP (node) ? NULL : (GtkCTreeNode *) XGTK_BOXED (node)->object,
659          XINT (depth),
660          __emacs_gtk_ctree_recurse_internal,
661          LISP_TO_VOID (closure));
662     }
663
664   UNGCPRO;
665   return (Qnil);
666 }
667
668 void syms_of_ui_byhand (void)
669 {
670   DEFSUBR (Fgtk_toolbar_append_item);
671   DEFSUBR (Fgtk_toolbar_insert_item);
672   DEFSUBR (Fgtk_toolbar_prepend_item);
673   DEFSUBR (Fgtk_box_query_child_packing);
674   DEFSUBR (Fgtk_button_box_get_child_size_default);
675   DEFSUBR (Fgtk_button_box_get_child_ipadding_default);
676   DEFSUBR (Fgtk_button_box_get_child_size);
677   DEFSUBR (Fgtk_button_box_get_child_ipadding);
678   DEFSUBR (Fgtk_calendar_get_date);
679   DEFSUBR (Fgtk_clist_get_text);
680   DEFSUBR (Fgtk_clist_get_selection);
681   DEFSUBR (Fgtk_clist_get_pixmap);
682   DEFSUBR (Fgtk_clist_get_pixtext);
683   DEFSUBR (Fgtk_color_selection_get_color);
684   DEFSUBR (Fgtk_editable_insert_text);
685   DEFSUBR (Fgtk_pixmap_get);
686   DEFSUBR (Fgtk_curve_get_vector);
687   DEFSUBR (Fgtk_curve_set_vector);
688   DEFSUBR (Fgtk_label_get);
689   DEFSUBR (Fgtk_notebook_query_tab_label_packing);
690   DEFSUBR (Fgtk_widget_get_pointer);
691   DEFSUBR (Fgtk_ctree_recurse);
692 }