git.chise.org Git - chise/xemacs-chise.git.1/blob - 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 }