src/gtk1/wx_gtk_vmsjackets.c

   1 /* Jackets for VMS only */
   2
   3 #include <stdarg.h>
   4
   5 #include <glib.h>
   6 #include <gdk/gdk.h>
   7 #include <gdk/gdkprivate.h>
   8 #include <gdk/gdkx.h>
   9 #include <gtk/gtk.h>
  10
  11 void GDK_BEEP (void)
  12 {
  13    gdk_beep();
  14 }
  15
  16 GdkBitmap* GDK_BITMAP_CREATE_FROM_DATA  (GdkWindow   *window,
  17                                          const gchar *data,
  18                                          gint         width,
  19                                          gint         height)
  20 {
  21    return gdk_bitmap_create_from_data   (window,
  22                                          data,
  23                                          width,
  24                                          height);
  25 }
  26
  27 void       GDK_BITMAP_UNREF             (GdkBitmap  *pixmap)
  28 {
  29    gdk_bitmap_unref             (pixmap);
  30 }
  31
  32 gint     GDK_CHAR_HEIGHT    (GdkFont        *font,
  33                              gchar           character)
  34 {
  35    return gdk_char_height    (font,
  36                              character);
  37 }
  38
  39 GdkColormap* GDK_COLORMAP_GET_SYSTEM      (void)
  40 {
  41    return gdk_colormap_get_system();
  42 }
  43
  44 GdkVisual*   GDK_COLORMAP_GET_VISUAL      (GdkColormap    *colormap)
  45 {
  46    return gdk_colormap_get_visual      (colormap);
  47 }
  48
  49 GdkColormap* GDK_COLORMAP_NEW             (GdkVisual      *visual,
  50                                            gboolean        allocate)
  51 {
  52    return gdk_colormap_new                (visual,
  53                                            allocate);
  54 }
  55
  56 void         GDK_COLORMAP_UNREF           (GdkColormap    *cmap)
  57 {
  58    gdk_colormap_unref             (cmap);
  59 }
  60
  61 gboolean GDK_COLOR_ALLOC  (GdkColormap  *colormap,
  62                            GdkColor     *color)
  63 {
  64    return gdk_color_alloc  (colormap,
  65                            color);
  66 }
  67
  68 gboolean     GDK_COLOR_PARSE              (const gchar    *spec,
  69                                            GdkColor       *color)
  70 {
  71    return gdk_color_parse                 (spec,
  72                                            color);
  73 }
  74
  75 void       GDK_CURSOR_DESTROY            (GdkCursor      *cursor)
  76 {
  77    gdk_cursor_destroy            (cursor);
  78 }
  79
  80 GdkCursor* GDK_CURSOR_NEW                (GdkCursorType   cursor_type)
  81 {
  82    return gdk_cursor_new                 (cursor_type);
  83 }
  84
  85 void GDK_DRAW_ARC        (GdkDrawable  *drawable,
  86                           GdkGC        *gc,
  87                           gint          filled,
  88                           gint          x,
  89                           gint          y,
  90                           gint          width,
  91                           gint          height,
  92                           gint          angle1,
  93                           gint          angle2)
  94 {
  95    gdk_draw_arc  (drawable,
  96                 gc,
  97                 filled,
  98                 x,
  99                 y,
 100                 width,
 101                 height,
 102                 angle1,
 103                 angle2);
 104 }
 105
 106 void GDK_DRAW_IMAGE      (GdkDrawable  *drawable,
 107                           GdkGC        *gc,
 108                           GdkImage     *image,
 109                           gint          xsrc,
 110                           gint          ysrc,
 111                           gint          xdest,
 112                           gint          ydest,
 113                           gint          width,
 114                           gint          height)
 115 {
 116    gdk_draw_image        (drawable,
 117                           gc,
 118                           image,
 119                           xsrc,
 120                           ysrc,
 121                           xdest,
 122                           ydest,
 123                           width,
 124                           height);
 125 }
 126
 127 void GDK_DRAW_LINE       (GdkDrawable  *drawable,
 128                           GdkGC        *gc,
 129                           gint          x1,
 130                           gint          y1,
 131                           gint          x2,
 132                           gint          y2)
 133 {
 134    gdk_draw_line         (drawable,
 135                           gc,
 136                           x1,
 137                           y1,
 138                           x2,
 139                           y2);
 140 }
 141
 142 void GDK_DRAW_PIXMAP     (GdkDrawable  *drawable,
 143                           GdkGC        *gc,
 144                           GdkDrawable  *src,
 145                           gint          xsrc,
 146                           gint          ysrc,
 147                           gint          xdest,
 148                           gint          ydest,
 149                           gint          width,
 150                           gint          height)
 151 {
 152    gdk_draw_pixmap       (drawable,
 153                           gc,
 154                           src,
 155                           xsrc,
 156                           ysrc,
 157                           xdest,
 158                           ydest,
 159                           width,
 160                           height);
 161 }
 162
 163 void GDK_DRAW_POINT      (GdkDrawable  *drawable,
 164                           GdkGC        *gc,
 165                           gint          x,
 166                           gint          y)
 167 {
 168    gdk_draw_point        (drawable,
 169                           gc,
 170                           x,
 171                           y);
 172 }
 173
 174 void GDK_DRAW_POLYGON    (GdkDrawable  *drawable,
 175                           GdkGC        *gc,
 176                           gint          filled,
 177                           GdkPoint     *points,
 178                           gint          npoints)
 179 {
 180    gdk_draw_polygon      (drawable,
 181                           gc,
 182                           filled,
 183                           points,
 184                           npoints);
 185 }
 186
 187 void GDK_DRAW_RECTANGLE  (GdkDrawable  *drawable,
 188                           GdkGC        *gc,
 189                           gint          filled,
 190                           gint          x,
 191                           gint          y,
 192                           gint          width,
 193                           gint          height)
 194 {
 195    gdk_draw_rectangle    (drawable,
 196                           gc,
 197                           filled,
 198                           x,
 199                           y,
 200                           width,
 201                           height);
 202 }
 203
 204 void GDK_DRAW_STRING     (GdkDrawable  *drawable,
 205                           GdkFont      *font,
 206                           GdkGC        *gc,
 207                           gint          x,
 208                           gint          y,
 209                           const gchar  *string)
 210 {
 211    gdk_draw_string       (drawable,
 212                           font,
 213                           gc,
 214                           x,
 215                           y,
 216                           string);
 217 }
 218
 219 void GDK_FLUSH (void)
 220 {
 221    gdk_flush ();
 222 }
 223
 224 GdkFont* GDK_FONT_LOAD      (const gchar    *font_name)
 225 {
 226    return gdk_font_load     (font_name);
 227 }
 228
 229 GdkFont* GDK_FONT_REF       (GdkFont        *font)
 230 {
 231    return gdk_font_ref      (font);
 232 }
 233
 234 void     GDK_FONT_UNREF     (GdkFont        *font)
 235 {
 236    gdk_font_unref           (font);
 237 }
 238
 239 void   GDK_GC_DESTROY             (GdkGC            *gc)
 240 {
 241    gdk_gc_destroy                 (gc);
 242 }
 243
 244 GdkGC* GDK_GC_NEW                 (GdkWindow        *window)
 245 {
 246    return gdk_gc_new              (window);
 247 }
 248
 249 void   GDK_GC_SET_BACKGROUND      (GdkGC            *gc,
 250                                    GdkColor         *color)
 251 {
 252    gdk_gc_set_background          (gc,
 253                                    color);
 254 }
 255
 256 void   GDK_GC_SET_CLIP_MASK       (GdkGC            *gc,
 257                                    GdkBitmap        *mask)
 258 {
 259    gdk_gc_set_clip_mask   (gc,
 260                         mask);
 261 }
 262
 263 void   GDK_GC_SET_CLIP_ORIGIN     (GdkGC            *gc,
 264                                    gint              x,
 265                                    gint              y)
 266 {
 267    gdk_gc_set_clip_origin         (gc,
 268                                    x,
 269                                    y);
 270 }
 271
 272 void   GDK_GC_SET_CLIP_RECTANGLE  (GdkGC            *gc,
 273                                    GdkRectangle     *rectangle)
 274 {
 275    gdk_gc_set_clip_rectangle  (gc,
 276                         rectangle);
 277 }
 278
 279 void   GDK_GC_SET_CLIP_REGION     (GdkGC            *gc,
 280                                    GdkRegion        *region)
 281 {
 282    gdk_gc_set_clip_region         (gc,
 283                                    region);
 284 }
 285
 286 void   GDK_GC_SET_DASHES          (GdkGC            *gc,
 287                                    gint              dash_offset,
 288                                    gint8             dash_list[],
 289                                    gint              n)
 290 {
 291    gdk_gc_set_dashes          (gc,
 292                         dash_offset,
 293                         dash_list,
 294                         n);
 295 }
 296
 297 void   GDK_GC_SET_EXPOSURES       (GdkGC            *gc,
 298                                    gboolean          exposures)
 299 {
 300    gdk_gc_set_exposures   (gc,
 301                         exposures);
 302 }
 303
 304 void   GDK_GC_SET_FILL            (GdkGC            *gc,
 305                                    GdkFill           fill)
 306 {
 307    gdk_gc_set_fill                (gc,
 308                                    fill);
 309 }
 310
 311 void   GDK_GC_SET_FOREGROUND      (GdkGC            *gc,
 312                                    GdkColor         *color)
 313 {
 314    gdk_gc_set_foreground          (gc,
 315                                    color);
 316 }
 317
 318 void   GDK_GC_SET_FUNCTION        (GdkGC            *gc,
 319                                    GdkFunction       function)
 320 {
 321    gdk_gc_set_function    (gc,
 322                         function);
 323 }
 324
 325 void   GDK_GC_SET_LINE_ATTRIBUTES (GdkGC            *gc,
 326                                    gint              line_width,
 327                                    GdkLineStyle      line_style,
 328                                    GdkCapStyle       cap_style,
 329                                    GdkJoinStyle      join_style)
 330 {
 331    gdk_gc_set_line_attributes (gc,
 332                         line_width,
 333                         line_style,
 334                         cap_style,
 335                         join_style);
 336 }
 337
 338 void   GDK_GC_SET_STIPPLE         (GdkGC            *gc,
 339                                    GdkPixmap        *stipple)
 340 {
 341    gdk_gc_set_stipple     (gc,
 342                         stipple);
 343 }
 344
 345 void   GDK_GC_SET_SUBWINDOW       (GdkGC            *gc,
 346                                    GdkSubwindowMode  mode)
 347 {
 348    gdk_gc_set_subwindow   (gc,
 349                         mode);
 350 }
 351
 352 void   GDK_GC_SET_TILE            (GdkGC            *gc,
 353                                    GdkPixmap        *tile)
 354 {
 355    gdk_gc_set_tile                (gc,
 356                                    tile);
 357 }
 358
 359 void   GDK_GC_SET_TS_ORIGIN       (GdkGC            *gc,
 360                                    gint              x,
 361                                    gint              y)
 362 {
 363    gdk_gc_set_ts_origin   (gc,
 364                         x,
 365                         y);
 366 }
 367
 368 void   GDK_GC_UNREF               (GdkGC            *gc)
 369 {
 370    gdk_gc_unref           (gc);
 371 }
 372
 373 void       GDK_IMAGE_DESTROY   (GdkImage     *image)
 374 {
 375    gdk_image_destroy   (image);
 376 }
 377
 378 GdkImage*  GDK_IMAGE_GET       (GdkWindow    *window,
 379                                 gint          x,
 380                                 gint          y,
 381                                 gint          width,
 382                                 gint          height)
 383 {
 384    return gdk_image_get       (window,
 385                         x,
 386                         y,
 387                         width,
 388                         height);
 389 }
 390
 391 guint32    GDK_IMAGE_GET_PIXEL (GdkImage     *image,
 392                                 gint          x,
 393                                 gint          y)
 394 {
 395    return gdk_image_get_pixel (image,
 396                         x,
 397                         y);
 398 }
 399
 400 GdkImage*  GDK_IMAGE_NEW       (GdkImageType  type,
 401                                 GdkVisual    *visual,
 402                                 gint          width,
 403                                 gint          height)
 404 {
 405    return gdk_image_new       (type,
 406                         visual,
 407                         width,
 408                         height);
 409 }
 410
 411 GdkImage* GDK_IMAGE_NEW_BITMAP(GdkVisual     *visual,
 412                                 gpointer      data,
 413                                 gint          width,
 414                                 gint          height)
 415 {
 416    return gdk_image_new_bitmap(visual,
 417                         data,
 418                         width,
 419                         height);
 420 }
 421
 422 void       GDK_IMAGE_PUT_PIXEL (GdkImage     *image,
 423                                 gint          x,
 424                                 gint          y,
 425                                 guint32       pixel)
 426 {
 427    gdk_image_put_pixel (image,
 428                         x,
 429                         y,
 430                         pixel);
 431
 432 }
 433
 434 gint GDK_INPUT_ADD_FULL   (gint              source,
 435                            GdkInputCondition condition,
 436                            GdkInputFunction  function,
 437                            gpointer          data,
 438                            GdkDestroyNotify  destroy)
 439 {
 440    return gdk_input_add_full      (source,
 441                            condition,
 442                            function,
 443                            data,
 444                            destroy);
 445 }
 446
 447 void GDK_INPUT_REMOVE     (gint              tag)
 448 {
 449    gdk_input_remove       (tag);
 450 }
 451
 452 guint    GDK_KEYVAL_TO_UPPER              (guint        keyval)
 453 {
 454    return gdk_keyval_to_upper             (keyval);
 455 }
 456
 457 GdkPixmap* GDK_PIXMAP_CREATE_FROM_XPM   (GdkWindow  *window,
 458                                          GdkBitmap **mask,
 459                                          GdkColor   *transparent_color,
 460                                          const gchar *filename)
 461 {
 462    return gdk_pixmap_create_from_xpm    (window,
 463                                          mask,
 464                                          transparent_color,
 465                                          filename);
 466 }
 467
 468 GdkPixmap* GDK_PIXMAP_CREATE_FROM_XPM_D (GdkWindow  *window,
 469                                          GdkBitmap **mask,
 470                                          GdkColor   *transparent_color,
 471                                          gchar     **data)
 472 {
 473    return gdk_pixmap_create_from_xpm_d (window,
 474                                         mask,
 475                                         transparent_color,
 476                                         data);
 477 }
 478
 479 GdkPixmap* GDK_PIXMAP_NEW               (GdkWindow  *window,
 480                                          gint        width,
 481                                          gint        height,
 482                                          gint        depth)
 483 {
 484    return gdk_pixmap_new                (window,
 485                                          width,
 486                                          height,
 487                                          depth);
 488 }
 489
 490 void       GDK_PIXMAP_UNREF             (GdkPixmap  *pixmap)
 491 {
 492    gdk_pixmap_unref             (pixmap);
 493 }
 494
 495 gint     GDK_POINTER_GRAB       (GdkWindow    *window,
 496                                  gint          owner_events,
 497                                  GdkEventMask  event_mask,
 498                                  GdkWindow    *confine_to,
 499                                  GdkCursor    *cursor,
 500                                  guint32       time)
 501 {
 502    return gdk_pointer_grab       (window,
 503                                  owner_events,
 504                                  event_mask,
 505                                  confine_to,
 506                                  cursor,
 507                                  time);
 508 }
 509
 510 void     GDK_POINTER_UNGRAB     (guint32       time)
 511 {
 512    gdk_pointer_ungrab     (time);
 513 }
 514
 515 GdkRegion*    GDK_REGIONS_INTERSECT       (GdkRegion      *source1,
 516                                            GdkRegion      *source2)
 517 {
 518    return gdk_regions_intersect   (source1,
 519                                 source2);
 520
 521 }
 522
 523 GdkRegion*    GDK_REGIONS_SUBTRACT        (GdkRegion      *source1,
 524                                            GdkRegion      *source2)
 525 {
 526    return gdk_regions_subtract    (source1,
 527                                 source2);
 528 }
 529
 530 GdkRegion*    GDK_REGIONS_UNION           (GdkRegion      *source1,
 531                                            GdkRegion      *source2)
 532 {
 533    return gdk_regions_union               (source1,
 534                                            source2);
 535 }
 536
 537 GdkRegion*    GDK_REGIONS_XOR             (GdkRegion      *source1,
 538                                            GdkRegion      *source2)
 539 {
 540    return gdk_regions_xor                 (source1,
 541                                            source2);
 542 }
 543
 544 void           GDK_REGION_DESTROY   (GdkRegion     *region)
 545 {
 546    gdk_region_destroy   (region);
 547 }
 548
 549 gboolean       GDK_REGION_EMPTY     (GdkRegion     *region)
 550 {
 551    return gdk_region_empty          (region);
 552 }
 553
 554 void           GDK_REGION_GET_CLIPBOX(GdkRegion    *region,
 555                                       GdkRectangle *rectangle)
 556 {
 557    gdk_region_get_clipbox(region,
 558                         rectangle);
 559 }
 560
 561 GdkRegion*     GDK_REGION_NEW       (void)
 562 {
 563    return gdk_region_new            ();
 564 }
 565
 566 gboolean       GDK_REGION_POINT_IN  (GdkRegion     *region,
 567                                      int                   x,
 568                                      int                   y)
 569 {
 570    return gdk_region_point_in  (region,
 571                                 x,
 572                                 y);
 573 }
 574
 575 GdkOverlapType GDK_REGION_RECT_IN   (GdkRegion     *region,
 576                                      GdkRectangle  *rect)
 577 {
 578    return gdk_region_rect_in   (region,
 579                                 rect);
 580 }
 581
 582 GdkRegion*    GDK_REGION_UNION_WITH_RECT  (GdkRegion      *region,
 583                                            GdkRectangle   *rect)
 584 {
 585    return gdk_region_union_with_rect  (region,
 586                                 rect);
 587 }
 588
 589 gint GDK_SCREEN_HEIGHT (void)
 590 {
 591    return gdk_screen_height ();
 592 }
 593
 594 gint GDK_SCREEN_WIDTH  (void)
 595 {
 596    return gdk_screen_width  ();
 597 }
 598
 599 gint     GDK_STRING_WIDTH   (GdkFont        *font,
 600                              const gchar    *string)
 601 {
 602    return gdk_string_width   (font,
 603                              string);
 604 }
 605
 606 void     gdk_threads_enter1                (void)
 607 {
 608    gdk_threads_enter                ();
 609 }
 610
 611 void     gdk_threads_leave1                (void)
 612 {
 613    gdk_threads_leave                ();
 614 }
 615
 616 GdkVisual*    GDK_VISUAL_GET_BEST            (void)
 617 {
 618    return gdk_visual_get_best        ();
 619 }
 620
 621 GdkVisual*    GDK_VISUAL_GET_SYSTEM          (void)
 622 {
 623    return gdk_visual_get_system      ();
 624 }
 625
 626 void          GDK_WINDOW_ADD_FILTER     (GdkWindow     *window,
 627                                          GdkFilterFunc  function,
 628                                          gpointer       data)
 629 {
 630    gdk_window_add_filter        (window,
 631                                 function,
 632                                 data);
 633 }
 634
 635 void          GDK_WINDOW_CLEAR       (GdkWindow    *window)
 636 {
 637    gdk_window_clear          (window);
 638 }
 639
 640 void          GDK_WINDOW_CLEAR_AREA  (GdkWindow    *window,
 641                                       gint          x,
 642                                       gint          y,
 643                                       gint          width,
 644                                       gint          height)
 645 {
 646    gdk_window_clear_area  (window,
 647                         x,
 648                         y,
 649                         width,
 650                         height);
 651 }
 652
 653 void          GDK_WINDOW_COPY_AREA   (GdkWindow    *window,
 654                                       GdkGC        *gc,
 655                                       gint          x,
 656                                       gint          y,
 657                                       GdkWindow    *source_window,
 658                                       gint          source_x,
 659                                       gint          source_y,
 660                                       gint          width,
 661                                       gint          height)
 662 {
 663    gdk_window_copy_area   (window,
 664                         gc,
 665                         x,
 666                         y,
 667                         source_window,
 668                         source_x,
 669                         source_y,
 670                         width,
 671                         height);
 672 }
 673
 674 void          GDK_WINDOW_DESTROY     (GdkWindow     *window)
 675 {
 676    gdk_window_destroy     (window);
 677 }
 678
 679 GdkColormap*  GDK_WINDOW_GET_COLORMAP    (GdkWindow       *window)
 680 {
 681    return gdk_window_get_colormap        (window);
 682 }
 683
 684 gint          GDK_WINDOW_GET_ORIGIN      (GdkWindow       *window,
 685                                           gint            *x,
 686                                           gint            *y)
 687 {
 688    return gdk_window_get_origin  (window,
 689                                 x,
 690                                 y);
 691 }
 692
 693 GdkWindow*    GDK_WINDOW_GET_POINTER     (GdkWindow       *window,
 694                                           gint            *x,
 695                                           gint            *y,
 696                                           GdkModifierType *mask)
 697 {
 698    return gdk_window_get_pointer         (window,
 699                                           x,
 700                                           y,
 701                                           mask);
 702 }
 703
 704 void          GDK_WINDOW_GET_ROOT_ORIGIN (GdkWindow       *window,
 705                                           gint            *x,
 706                                           gint            *y)
 707 {
 708    gdk_window_get_root_origin (window,
 709                         x,
 710                         y);
 711 }
 712
 713 void          GDK_WINDOW_GET_SIZE        (GdkWindow       *window,
 714                                           gint            *width,
 715                                           gint            *height)
 716 {
 717    gdk_window_get_size   (window,
 718                         width,
 719                         height);
 720 }
 721
 722 void          GDK_WINDOW_GET_USER_DATA   (GdkWindow       *window,
 723                                           gpointer        *data)
 724 {
 725    gdk_window_get_user_data      (window,
 726                                 data);
 727 }
 728
 729 GdkVisual*    GDK_WINDOW_GET_VISUAL      (GdkWindow       *window)
 730 {
 731    return gdk_window_get_visual  (window);
 732 }
 733
 734 void          GDK_WINDOW_LOWER       (GdkWindow    *window)
 735 {
 736    gdk_window_lower          (window);
 737 }
 738
 739 void          GDK_WINDOW_MOVE        (GdkWindow    *window,
 740                                       gint          x,
 741                                       gint          y)
 742 {
 743    gdk_window_move           (window,
 744                         x,
 745                         y);
 746 }
 747
 748 void          GDK_WINDOW_MOVE_RESIZE (GdkWindow    *window,
 749                                       gint          x,
 750                                       gint          y,
 751                                       gint          width,
 752                                       gint          height)
 753 {
 754    gdk_window_move_resize (window,
 755                         x,
 756                         y,
 757                         width,
 758                         height);
 759 }
 760
 761 GdkWindow*    GDK_WINDOW_NEW         (GdkWindow     *parent,
 762                                       GdkWindowAttr *attributes,
 763                                       gint           attributes_mask)
 764 {
 765    return gdk_window_new             (parent,
 766                                       attributes,
 767                                       attributes_mask);
 768 }
 769
 770 void          GDK_WINDOW_RAISE       (GdkWindow    *window)
 771 {
 772    gdk_window_raise          (window);
 773 }
 774
 775 GdkWindow*    GDK_WINDOW_REF         (GdkWindow     *window)
 776 {
 777    return gdk_window_ref             (window);
 778 }
 779
 780 void          GDK_WINDOW_RESIZE      (GdkWindow    *window,
 781                                       gint          width,
 782                                       gint          height)
 783 {
 784    gdk_window_resize         (window,
 785                         width,
 786                         height);
 787 }
 788
 789 void          GDK_WINDOW_SET_BACKGROUND  (GdkWindow       *window,
 790                                           GdkColor        *color)
 791 {
 792    gdk_window_set_background     (window,
 793                                 color);
 794 }
 795
 796 void          GDK_WINDOW_SET_CURSOR      (GdkWindow       *window,
 797                                           GdkCursor       *cursor)
 798 {
 799    gdk_window_set_cursor         (window,
 800                                 cursor);
 801 }
 802
 803 void          GDK_WINDOW_SET_DECORATIONS (GdkWindow       *window,
 804                                           GdkWMDecoration  decorations)
 805 {
 806    gdk_window_set_decorations (window,
 807                         decorations);
 808 }
 809
 810 void          GDK_WINDOW_SET_FUNCTIONS   (GdkWindow       *window,
 811                                           GdkWMFunction    functions)
 812 {
 813    gdk_window_set_functions      (window,
 814                                 functions);
 815 }
 816
 817 void          GDK_WINDOW_SET_HINTS       (GdkWindow       *window,
 818                                           gint             x,
 819                                           gint             y,
 820                                           gint             min_width,
 821                                           gint             min_height,
 822                                           gint             max_width,
 823                                           gint             max_height,
 824                                           gint             flags)
 825 {
 826    gdk_window_set_hints  (window,
 827                         x,
 828                         y,
 829                         min_width,
 830                         min_height,
 831                         max_width,
 832                         max_height,
 833                         flags);
 834 }
 835
 836 void          GDK_WINDOW_SET_ICON        (GdkWindow       *window,
 837                                           GdkWindow       *icon_window,
 838                                           GdkPixmap       *pixmap,
 839                                           GdkBitmap       *mask)
 840 {
 841    gdk_window_set_icon   (window,
 842                         icon_window,
 843                         pixmap,
 844                         mask);
 845 }
 846
 847 gboolean GDK_WINDOW_SET_STATIC_GRAVITIES (GdkWindow *window,
 848                                           gboolean   use_static)
 849 {
 850    return gdk_window_set_static_gravities (window,
 851                                           use_static);
 852 }
 853
 854 void          GDK_WINDOW_SET_USER_DATA   (GdkWindow       *window,
 855                                           gpointer         user_data)
 856 {
 857    gdk_window_set_user_data      (window,
 858                                 user_data);
 859 }
 860
 861 void          GDK_WINDOW_SHOW        (GdkWindow    *window)
 862 {
 863    gdk_window_show           (window);
 864 }
 865
 866 void          GDK_WINDOW_UNREF       (GdkWindow     *window)
 867 {
 868    gdk_window_unref          (window);
 869 }
 870
 871 void
 872 GDK_DRAW_RGB_IMAGE (GdkDrawable *drawable,
 873                     GdkGC *gc,
 874                     gint x,
 875                     gint y,
 876                     gint width,
 877                     gint height,
 878                     GdkRgbDither dith,
 879                     guchar *rgb_buf,
 880                     gint rowstride)
 881 {
 882 gdk_draw_rgb_image (drawable,
 883                     gc,
 884                     x,
 885                     y,
 886                     width,
 887                     height,
 888                     dith,
 889                     rgb_buf,
 890                     rowstride);
 891 }
 892
 893 void
 894 GDK_RGB_INIT (void)
 895 {
 896 gdk_rgb_init ();
 897 }
 898
 899 gpointer GDK_XID_TABLE_LOOKUP (XID       xid)
 900 {
 901    return gdk_xid_table_lookup (xid);
 902 }
 903
 904
 905 Display* GDK_DISPLAY0( void )
 906 {
 907    return gdk_display;
 908 }
 909
 910 gint GDK_INPUT_ADD        (gint              source,
 911                            GdkInputCondition condition,
 912                            GdkInputFunction  function,
 913                            gpointer          data)
 914 {
 915    return gdk_input_add   (source,
 916                            condition,
 917                            function,
 918                            data);
 919 }
 920
 921 GdkWindow* GDK_ROOT_PARENT0( void )
 922 {
 923    return ((GdkWindow *)&gdk_root_parent);
 924 }
 925
 926 void            GTK_ACCEL_GROUP_ATTACH          (GtkAccelGroup  *accel_group,
 927                                                  GtkObject      *object)
 928 {
 929    gtk_accel_group_attach               (accel_group,
 930                                         object);
 931 }
 932
 933 void            GTK_ACCEL_GROUP_DETACH          (GtkAccelGroup  *accel_group,
 934                                                  GtkObject      *object)
 935 {
 936    gtk_accel_group_detach               (accel_group,
 937                                         object);
 938 }
 939
 940 GtkAccelGroup*  GTK_ACCEL_GROUP_NEW             (void)
 941 {
 942    return gtk_accel_group_new           ();
 943 }
 944
 945 GtkType    GTK_ACCEL_LABEL_GET_TYPE          (void)
 946 {
 947    return gtk_accel_label_get_type           ();
 948 }
 949
 950 gboolean   GTK_ACCEL_LABEL_REFETCH           (GtkAccelLabel *accel_label)
 951 {
 952    return gtk_accel_label_refetch           (accel_label);
 953 }
 954
 955 GtkType    GTK_ADJUSTMENT_GET_TYPE              (void)
 956 {
 957    return gtk_adjustment_get_type               ();
 958 }
 959
 960 GtkType  GTK_BIN_GET_TYPE   (void)
 961 {
 962    return gtk_bin_get_type   ();
 963 }
 964
 965 GtkType    GTK_BOX_GET_TYPE            (void)
 966 {
 967    return gtk_box_get_type             ();
 968 }
 969
 970 void       GTK_BOX_PACK_START          (GtkBox       *box,
 971                                         GtkWidget    *child,
 972                                         gboolean      expand,
 973                                         gboolean      fill,
 974                                         guint         padding)
 975 {
 976    gtk_box_pack_start          (box,
 977                                 child,
 978                                 expand,
 979                                 fill,
 980                                 padding);
 981 }
 982
 983 GtkType        GTK_BUTTON_GET_TYPE       (void)
 984 {
 985    return gtk_button_get_type       ();
 986 }
 987
 988 GtkWidget*     GTK_BUTTON_NEW            (void)
 989 {
 990    return gtk_button_new            ();
 991 }
 992
 993 GtkWidget*     GTK_BUTTON_NEW_WITH_LABEL (const gchar *label)
 994 {
 995    return gtk_button_new_with_label (label);
 996 }
 997
 998 void           GTK_BUTTON_SET_RELIEF     (GtkButton *button,
 999                                           GtkReliefStyle newstyle)
1000 {
1001    gtk_button_set_relief     (button,
1002                         newstyle);
1003 }
1004
1005 GtkWidget* GTK_CHECK_BUTTON_NEW            (void)
1006 {
1007    return gtk_check_button_new            ();
1008 }
1009
1010 GtkWidget* GTK_CHECK_BUTTON_NEW_WITH_LABEL (const gchar *label)
1011 {
1012    return gtk_check_button_new_with_label (label);
1013 }
1014
1015 void       GTK_CHECK_MENU_ITEM_SET_ACTIVE      (GtkCheckMenuItem *check_menu_item,
1016                                                 gboolean          is_active)
1017 {
1018    gtk_check_menu_item_set_active      (check_menu_item,
1019                                         is_active);
1020 }
1021
1022 guint      GTK_COMBO_GET_TYPE              (void)
1023 {
1024    return gtk_combo_get_type              ();
1025 }
1026
1027 GtkWidget *GTK_COMBO_NEW                   (void)
1028 {
1029    return gtk_combo_new                   ();
1030 }
1031
1032 void       GTK_COMBO_SET_USE_ARROWS_ALWAYS (GtkCombo*    combo,
1033                                             gint         val)
1034 {
1035    gtk_combo_set_use_arrows_always (combo,
1036                                     val);
1037 }
1038
1039 void    GTK_CONTAINER_ADD                (GtkContainer     *container,
1040                                           GtkWidget        *widget)
1041 {
1042    gtk_container_add             (container,
1043                                 widget);
1044 }
1045
1046 gint   GTK_CONTAINER_FOCUS                 (GtkContainer     *container,
1047                                             GtkDirectionType  direction)
1048 {
1049    return gtk_container_focus              (container,
1050                                             direction);
1051 }
1052
1053 void    GTK_CONTAINER_FORALL                 (GtkContainer *container,
1054                                               GtkCallback   callback,
1055                                               gpointer      callback_data)
1056 {
1057    gtk_container_forall              (container,
1058                                 callback,
1059                                 callback_data);
1060 }
1061
1062 GtkType GTK_CONTAINER_GET_TYPE           (void)
1063 {
1064    return gtk_container_get_type                 ();
1065 }
1066
1067 void    GTK_CONTAINER_REMOVE             (GtkContainer     *container,
1068                                           GtkWidget        *widget)
1069 {
1070    gtk_container_remove          (container,
1071                                 widget);
1072 }
1073
1074 void   GTK_CONTAINER_SET_FOCUS_VADJUST (GtkContainer     *container,
1075                                             GtkAdjustment    *adjustment)
1076 {
1077    gtk_container_set_focus_vadjustment (container,
1078                                         adjustment);
1079 }
1080
1081 void GTK_DRAW_SHADOW  (GtkStyle      *style,
1082                        GdkWindow     *window,
1083                        GtkStateType   state_type,
1084                        GtkShadowType  shadow_type,
1085                        gint           x,
1086                        gint           y,
1087                        gint           width,
1088                        gint           height)
1089 {
1090    gtk_draw_shadow  (style,
1091                      window,
1092                      state_type,
1093                      shadow_type,
1094                      x,
1095                      y,
1096                      width,
1097                      height);
1098 }
1099
1100 void       GTK_EDITABLE_COPY_CLIPBOARD (GtkEditable      *editable)
1101 {
1102    gtk_editable_copy_clipboard (editable);
1103 }
1104
1105 void       GTK_EDITABLE_CUT_CLIPBOARD  (GtkEditable      *editable)
1106 {
1107    gtk_editable_cut_clipboard  (editable);
1108 }
1109
1110 void       GTK_EDITABLE_DELETE_TEXT    (GtkEditable      *editable,
1111                                         gint              start_pos,
1112                                         gint              end_pos)
1113 {
1114    gtk_editable_delete_text    (editable,
1115                                 start_pos,
1116                                 end_pos);
1117 }
1118
1119 gchar*     GTK_EDITABLE_GET_CHARS      (GtkEditable      *editable,
1120                                         gint              start_pos,
1121                                         gint              end_pos)
1122 {
1123    return gtk_editable_get_chars      (editable,
1124                                 start_pos,
1125                                 end_pos);
1126 }
1127
1128 GtkType    GTK_EDITABLE_GET_TYPE       (void)
1129 {
1130    return gtk_editable_get_type       ();
1131 }
1132
1133 void       GTK_EDITABLE_INSERT_TEXT   (GtkEditable       *editable,
1134                                         const gchar      *new_text,
1135                                         gint              new_text_length,
1136                                         gint             *position)
1137 {
1138    gtk_editable_insert_text   (editable,
1139                         new_text,
1140                         new_text_length,
1141                         position);
1142 }
1143
1144 void       GTK_EDITABLE_PASTE_CLIPBOARD (GtkEditable     *editable)
1145 {
1146    gtk_editable_paste_clipboard (editable);
1147 }
1148
1149 void       GTK_EDITABLE_SELECT_REGION  (GtkEditable      *editable,
1150                                         gint              start,
1151                                         gint              end)
1152 {
1153    gtk_editable_select_region  (editable,
1154                                 start,
1155                                 end);
1156 }
1157
1158 void       GTK_ENTRY_APPEND_TEXT                (GtkEntry      *entry,
1159                                                  const gchar   *text)
1160 {
1161    gtk_entry_append_text                (entry,
1162                                         text);
1163 }
1164
1165 gchar*     GTK_ENTRY_GET_TEXT                   (GtkEntry      *entry)
1166 {
1167    return gtk_entry_get_text                    (entry);
1168 }
1169
1170 GtkType    GTK_ENTRY_GET_TYPE                   (void)
1171 {
1172    return gtk_entry_get_type                    ();
1173 }
1174
1175 GtkWidget* GTK_ENTRY_NEW                        (void)
1176 {
1177    return gtk_entry_new                         ();
1178 }
1179
1180 void       GTK_ENTRY_SET_EDITABLE               (GtkEntry      *entry,
1181                                                  gboolean       editable)
1182 {
1183    gtk_entry_set_editable               (entry,
1184                                         editable);
1185 }
1186
1187 void       GTK_ENTRY_SET_POSITION               (GtkEntry      *entry,
1188                                                  gint           position)
1189 {
1190    gtk_entry_set_position               (entry,
1191                                         position);
1192 }
1193
1194 void       GTK_ENTRY_SET_TEXT                   (GtkEntry      *entry,
1195                                                  const gchar   *text)
1196 {
1197    gtk_entry_set_text                   (entry,
1198                                         text);
1199 }
1200
1201 void       GTK_ENTRY_SET_VISIBILITY             (GtkEntry      *entry,
1202                                                  gboolean       visible)
1203 {
1204    gtk_entry_set_visibility             (entry,
1205                                         visible);
1206 }
1207
1208 gint       GTK_EVENTS_PENDING    (void)
1209 {
1210    return gtk_events_pending     ();
1211 }
1212
1213 gchar*     GTK_FILE_SELECTION_GET_FILENAME        (GtkFileSelection *filesel)
1214 {
1215    return gtk_file_selection_get_filename        (filesel);
1216 }
1217
1218 GtkType    GTK_FILE_SELECTION_GET_TYPE            (void)
1219 {
1220    return gtk_file_selection_get_type            ();
1221 }
1222
1223 void       GTK_FILE_SELECTION_HIDE_FILEOP_ (GtkFileSelection *filesel)
1224 {
1225    gtk_file_selection_hide_fileop_buttons (filesel);
1226 }
1227
1228 GtkWidget* GTK_FILE_SELECTION_NEW                 (const gchar      *title)
1229 {
1230    return gtk_file_selection_new                 (title);
1231 }
1232
1233 void       GTK_FILE_SELECTION_SET_FILENAME        (GtkFileSelection *filesel,
1234                                                    const gchar      *filename)
1235 {
1236    gtk_file_selection_set_filename        (filesel,
1237                                         filename);
1238 }
1239
1240 gchar*   GTK_FONT_SELECTION_DIALOG_GETNF    (GtkFontSelectionDialog *fsd)
1241 {
1242    return gtk_font_selection_dialog_get_font_name    (fsd);
1243 }
1244
1245 GdkFont* GTK_FONT_SELECTION_DIALOG_GET_F            (GtkFontSelectionDialog *fsd)
1246 {
1247    return gtk_font_selection_dialog_get_font        (fsd);
1248 }
1249
1250 GtkType    GTK_FONT_SELECTION_DIALOG_GET_T      (void)
1251 {
1252    return gtk_font_selection_dialog_get_type    ();
1253 }
1254
1255 GtkWidget* GTK_FONT_SELECTION_DIALOG_NEW        (const gchar      *title)
1256 {
1257    return gtk_font_selection_dialog_new (title);
1258 }
1259
1260 GtkType    GTK_FRAME_GET_TYPE        (void)
1261 {
1262    return gtk_frame_get_type        ();
1263 }
1264
1265 GtkWidget* GTK_FRAME_NEW             (const gchar   *label)
1266 {
1267    return gtk_frame_new             (label);
1268 }
1269
1270 void       GTK_FRAME_SET_LABEL       (GtkFrame      *frame,
1271                                       const gchar   *label)
1272 {
1273    gtk_frame_set_label       (frame,
1274                         label);
1275 }
1276
1277 void       GTK_GRAB_ADD            (GtkWidget          *widget)
1278 {
1279    gtk_grab_add            (widget);
1280 }
1281
1282 void       GTK_GRAB_REMOVE         (GtkWidget          *widget)
1283 {
1284    gtk_grab_remove         (widget);
1285 }
1286
1287 GtkType     GTK_HANDLE_BOX_GET_TYPE             (void)
1288 {
1289    return gtk_handle_box_get_type             ();
1290 }
1291
1292 GtkWidget*  GTK_HANDLE_BOX_NEW                  (void)
1293 {
1294    return gtk_handle_box_new                  ();
1295 }
1296
1297 void        GTK_HANDLE_BOX_SET_SHADOW_TYPE      (GtkHandleBox    *handle_box,
1298                                                  GtkShadowType    type)
1299 {
1300    gtk_handle_box_set_shadow_type      (handle_box,
1301                                         type);
1302 }
1303
1304 GtkWidget* GTK_HBOX_NEW      (gboolean homogeneous,
1305                               gint spacing)
1306 {
1307    return gtk_hbox_new       (homogeneous,
1308                               spacing);
1309 }
1310
1311 GtkWidget* GTK_HSCALE_NEW      (GtkAdjustment *adjustment)
1312 {
1313    return gtk_hscale_new      (adjustment);
1314 }
1315
1316 GtkWidget* GTK_HSCROLLBAR_NEW      (GtkAdjustment *adjustment)
1317 {
1318    return gtk_hscrollbar_new      (adjustment);
1319 }
1320
1321 GtkWidget* GTK_HSEPARATOR_NEW      (void)
1322 {
1323    return gtk_hseparator_new      ();
1324 }
1325
1326 guint      GTK_IDLE_ADD            (GtkFunction        function,
1327                                     gpointer           data)
1328 {
1329    return gtk_idle_add             (function,
1330                                     data);
1331 }
1332
1333 void       GTK_IDLE_REMOVE         (guint              idle_handler_id)
1334 {
1335    gtk_idle_remove         (idle_handler_id);
1336 }
1337
1338 void       GTK_INIT              (int          *argc,
1339                                   char       ***argv)
1340 {
1341    gtk_init              (argc,
1342                         argv);
1343 }
1344
1345 void    GTK_ITEM_FACTORY_CREATE_ITEM    (GtkItemFactory         *ifactory,
1346                                          GtkItemFactoryEntry    *entry,
1347                                          gpointer                callback_data,
1348                                          guint                   callback_type)
1349 {
1350    gtk_item_factory_create_item (ifactory,
1351                                 entry,
1352                                 callback_data,
1353                                 callback_type);
1354 }
1355
1356 GtkWidget*      GTK_ITEM_FACTORY_GET_ITEM             (GtkItemFactory *ifactory,
1357                                                        const gchar    *path)
1358 {
1359    return gtk_item_factory_get_item           (ifactory,
1360                                         path);
1361 }
1362
1363 GtkWidget*      GTK_ITEM_FACTORY_GET_WIDGET           (GtkItemFactory *ifactory,
1364                                                        const gchar    *path)
1365 {
1366    return gtk_item_factory_get_widget         (ifactory,
1367                                         path);
1368 }
1369
1370 GtkItemFactory* GTK_ITEM_FACTORY_NEW       (GtkType              container_type,
1371                                             const gchar         *path,
1372                                             GtkAccelGroup       *accel_group)
1373 {
1374    return gtk_item_factory_new     (container_type,
1375                                 path,
1376                                 accel_group);
1377 }
1378
1379 void       GTK_LABEL_GET           (GtkLabel          *label,
1380                                     gchar            **str)
1381 {
1382    gtk_label_get           (label,
1383                             str);
1384 }
1385
1386 GtkType    GTK_LABEL_GET_TYPE      (void)
1387 {
1388    return gtk_label_get_type      ();
1389 }
1390
1391 GtkWidget* GTK_LABEL_NEW           (const gchar       *str)
1392 {
1393    return gtk_label_new           (str);
1394 }
1395
1396 guint      GTK_LABEL_PARSE_ULINE    (GtkLabel         *label,
1397                                      const gchar      *string)
1398 {
1399    return gtk_label_parse_uline    (label,
1400                                     string);
1401 }
1402
1403 void       GTK_LABEL_SET_JUSTIFY   (GtkLabel          *label,
1404                                     GtkJustification   jtype)
1405 {
1406    gtk_label_set_justify   (label,
1407                             jtype);
1408 }
1409
1410 void       GTK_LABEL_SET_LINE_WRAP (GtkLabel          *label,
1411                                     gboolean           wrap)
1412 {
1413    gtk_label_set_line_wrap (label,
1414                         wrap);
1415 }
1416
1417 void       GTK_LABEL_SET_TEXT      (GtkLabel          *label,
1418                                     const gchar       *str)
1419 {
1420    gtk_label_set_text      (label,
1421                             str);
1422 }
1423
1424 void       GTK_LIST_APPEND_ITEMS          (GtkList          *list,
1425                                            GList            *items)
1426 {
1427    gtk_list_append_items          (list,
1428                                 items);
1429 }
1430
1431 void       GTK_LIST_CLEAR_ITEMS           (GtkList          *list,
1432                                            gint              start,
1433                                            gint              end)
1434 {
1435    gtk_list_clear_items           (list,
1436                                 start,
1437                                 end);
1438 }
1439
1440 GtkType    GTK_LIST_GET_TYPE              (void)
1441 {
1442    return gtk_list_get_type               ();
1443 }
1444
1445 void       GTK_LIST_INSERT_ITEMS          (GtkList          *list,
1446                                            GList            *items,
1447                                            gint              position)
1448 {
1449    gtk_list_insert_items          (list,
1450                                 items,
1451                                 position);
1452 }
1453
1454 GtkWidget* GTK_LIST_ITEM_NEW_WITH_LABEL (const gchar      *label)
1455 {
1456    return gtk_list_item_new_with_label (label);
1457 }
1458
1459 GtkWidget* GTK_LIST_NEW                   (void)
1460 {
1461    return gtk_list_new                    ();
1462 }
1463
1464 void       GTK_LIST_REMOVE_ITEMS          (GtkList          *list,
1465                                            GList            *items)
1466 {
1467    gtk_list_remove_items          (list,
1468                                 items);
1469 }
1470
1471 void       GTK_LIST_SELECT_ITEM           (GtkList          *list,
1472                                            gint              item)
1473 {
1474    gtk_list_select_item           (list,
1475                                 item);
1476 }
1477
1478 void       GTK_LIST_SET_SELECTION_MODE    (GtkList          *list,
1479                                            GtkSelectionMode  mode)
1480 {
1481    gtk_list_set_selection_mode    (list,
1482                                 mode);
1483 }
1484
1485 void       GTK_LIST_UNSELECT_ITEM         (GtkList          *list,
1486                                            gint              item)
1487 {
1488    gtk_list_unselect_item         (list,
1489                                 item);
1490 }
1491
1492 void       GTK_MAIN              (void)
1493 {
1494    gtk_main              ();
1495 }
1496
1497 gint       GTK_MAIN_ITERATION    (void)
1498 {
1499    return gtk_main_iteration     ();
1500 }
1501
1502 guint      GTK_MAIN_LEVEL        (void)
1503 {
1504    return gtk_main_level         ();
1505 }
1506
1507 void       GTK_MAIN_QUIT         (void)
1508 {
1509    gtk_main_quit         ();
1510 }
1511
1512 GdkEventMask  GDK_WINDOW_GET_EVENTS      (GdkWindow       *window)
1513 {
1514    return gdk_window_get_events  (window);
1515 }
1516
1517 void          GDK_WINDOW_SET_EVENTS      (GdkWindow       *window,
1518                                           GdkEventMask     event_mask)
1519 {
1520    gdk_window_set_events         (window,
1521                                 event_mask);
1522 }
1523
1524 guint      GTK_IDLE_ADD_PRIORITY   (gint               priority,
1525                                     GtkFunction        function,
1526                                     gpointer           data)
1527 {
1528    return gtk_idle_add_priority   (priority,
1529                                    function,
1530                                    data);
1531 }
1532
1533 guint VMS_GTK_MAJOR_VERSION( void )
1534 {
1535    return gtk_major_version;
1536 }
1537
1538 guint VMS_GTK_MINOR_VERSION( void )
1539 {
1540    return gtk_minor_version;
1541 }
1542
1543 guint VMS_GTK_MICRO_VERSION( void )
1544 {
1545    return gtk_micro_version;
1546 }
1547
1548 GtkWidget*
1549 gtk_item_factory_get_item (GtkItemFactory *ifactory,
1550                            const gchar    *path)
1551 {
1552   GtkWidget *widget;
1553
1554   g_return_val_if_fail (GTK_IS_ITEM_FACTORY (ifactory), NULL);
1555   g_return_val_if_fail (path != NULL, NULL);
1556
1557   widget = gtk_item_factory_get_widget (ifactory, path);
1558
1559   if (GTK_IS_MENU (widget))
1560     widget = gtk_menu_get_attach_widget (GTK_MENU (widget));
1561
1562   return GTK_IS_ITEM (widget) ? widget : NULL;
1563 }
1564
1565 void GTK_MARSHAL_NONE__POINTER_POINT (GtkObject * object,
1566                                           GtkSignalFunc func,
1567                                           gpointer func_data, GtkArg * args)
1568 {
1569    gtk_marshal_NONE__POINTER_POINTER (object,
1570                                 func,
1571                                 func_data, args);
1572 }
1573
1574 void       GTK_MENU_APPEND                (GtkMenu             *menu,
1575                                            GtkWidget           *child)
1576 {
1577    gtk_menu_append                (menu,
1578                                 child);
1579 }
1580
1581 GtkType    GTK_MENU_BAR_GET_TYPE        (void)
1582 {
1583    return gtk_menu_bar_get_type        ();
1584 }
1585
1586 GtkType    GTK_MENU_GET_TYPE              (void)
1587 {
1588    return gtk_menu_get_type               ();
1589 }
1590
1591 void       GTK_MENU_INSERT                (GtkMenu             *menu,
1592                                            GtkWidget           *child,
1593                                            gint                 position)
1594 {
1595    gtk_menu_insert                (menu,
1596                                            child,
1597                                            position);
1598 }
1599
1600 GtkType    GTK_MENU_ITEM_GET_TYPE         (void)
1601 {
1602    return gtk_menu_item_get_type          ();
1603 }
1604
1605 GtkWidget* GTK_MENU_ITEM_NEW_WITH_LABEL   (const gchar         *label)
1606 {
1607    return gtk_menu_item_new_with_label    (label);
1608 }
1609
1610 void       GTK_MENU_ITEM_SET_SUBMENU      (GtkMenuItem         *menu_item,
1611                                            GtkWidget           *submenu)
1612 {
1613    gtk_menu_item_set_submenu      (menu_item,
1614                                 submenu);
1615 }
1616
1617 GtkWidget* GTK_MENU_NEW                   (void)
1618 {
1619    return gtk_menu_new                    ();
1620 }
1621
1622 void       GTK_MENU_POPUP                 (GtkMenu             *menu,
1623                                            GtkWidget           *parent_menu_shell,
1624                                            GtkWidget           *parent_menu_item,
1625                                            GtkMenuPositionFunc  func,
1626                                            gpointer             data,
1627                                            guint                button,
1628                                            guint32              activate_time)
1629 {
1630    gtk_menu_popup                 (menu,
1631                                 parent_menu_shell,
1632                                 parent_menu_item,
1633                                 func,
1634                                 data,
1635                                 button,
1636                                 activate_time);
1637 }
1638
1639 GtkType GTK_MENU_SHELL_GET_TYPE   (void)
1640 {
1641    return gtk_menu_shell_get_type         ();
1642 }
1643
1644 GtkType GTK_MISC_GET_TYPE      (void)
1645 {
1646    return gtk_misc_get_type      ();
1647 }
1648
1649 void    GTK_MISC_SET_ALIGNMENT (GtkMisc *misc,
1650                                 gfloat   xalign,
1651                                 gfloat   yalign)
1652 {
1653    gtk_misc_set_alignment (misc,
1654                         xalign,
1655                         yalign);
1656 }
1657
1658 void GTK_OBJECT_UNREF     (GtkObject        *object)
1659 {
1660    gtk_object_unref       (object);
1661 }
1662
1663 GtkWidget* GTK_OPTION_MENU_GET_MENU    (GtkOptionMenu *option_menu)
1664 {
1665    return gtk_option_menu_get_menu    (option_menu);
1666 }
1667
1668 GtkType    GTK_OPTION_MENU_GET_TYPE    (void)
1669 {
1670    return gtk_option_menu_get_type    ();
1671 }
1672
1673 GtkWidget* GTK_OPTION_MENU_NEW         (void)
1674 {
1675    return gtk_option_menu_new         ();
1676 }
1677
1678 void       GTK_OPTION_MENU_REMOVE_MENU (GtkOptionMenu *option_menu)
1679 {
1680    gtk_option_menu_remove_menu (option_menu);
1681 }
1682
1683 void       GTK_OPTION_MENU_SET_HISTORY (GtkOptionMenu *option_menu,
1684                                         guint          index)
1685 {
1686    gtk_option_menu_set_history (option_menu,
1687                                 index);
1688 }
1689
1690 void       GTK_OPTION_MENU_SET_MENU    (GtkOptionMenu *option_menu,
1691                                         GtkWidget     *menu)
1692 {
1693    gtk_option_menu_set_menu    (option_menu,
1694                                 menu);
1695 }
1696
1697 GtkType    GTK_PIXMAP_GET_TYPE   (void)
1698 {
1699    return gtk_pixmap_get_type    ();
1700 }
1701
1702 GtkWidget* GTK_PIXMAP_NEW        (GdkPixmap  *pixmap,
1703                                   GdkBitmap  *mask)
1704 {
1705    return gtk_pixmap_new         (pixmap,
1706                                   mask);
1707 }
1708
1709 void       GTK_PIXMAP_SET        (GtkPixmap  *pixmap,
1710                                   GdkPixmap  *val,
1711                                   GdkBitmap  *mask)
1712 {
1713    gtk_pixmap_set        (pixmap,
1714                         val,
1715                         mask);
1716 }
1717
1718 void       GTK_PIXMAP_SET_BUILD_INSENSITIV (GtkPixmap *pixmap,
1719                                              guint build)
1720 {
1721    gtk_pixmap_set_build_insensitive (pixmap,
1722                                      build);
1723 }
1724
1725 GtkType    GTK_PROGRESS_BAR_GET_TYPE             (void)
1726 {
1727    return gtk_progress_bar_get_type             ();
1728 }
1729
1730 GtkWidget* GTK_PROGRESS_BAR_NEW                  (void)
1731 {
1732    return gtk_progress_bar_new                  ();
1733 }
1734
1735 void       GTK_PROGRESS_BAR_UPDATE               (GtkProgressBar *pbar,
1736                                                   gfloat          percentage)
1737 {
1738    gtk_progress_bar_update               (pbar,
1739                                         percentage);
1740 }
1741
1742 GtkType     GTK_RADIO_BUTTON_GET_TYPE        (void)
1743 {
1744    return gtk_radio_button_get_type          ();
1745 }
1746
1747 GSList*     GTK_RADIO_BUTTON_GROUP           (GtkRadioButton *radio_button)
1748 {
1749    return gtk_radio_button_group             (radio_button);
1750 }
1751
1752 GtkWidget*  GTK_RADIO_BUTTON_NEW_WITH_LABEL  (GSList         *group,
1753                                               const gchar    *label)
1754 {
1755    return gtk_radio_button_new_with_label  (group,
1756                                             label);
1757 }
1758
1759 GtkAdjustment* GTK_RANGE_GET_ADJUSTMENT         (GtkRange      *range)
1760 {
1761    return gtk_range_get_adjustment         (range);
1762 }
1763
1764 GtkType        GTK_RANGE_GET_TYPE               (void)
1765 {
1766    return gtk_range_get_type               ();
1767 }
1768
1769 GtkStyle* GTK_RC_GET_STYLE              (GtkWidget   *widget)
1770 {
1771    return gtk_rc_get_style              (widget);
1772 }
1773
1774 GtkType GTK_SCALE_GET_TYPE        (void)
1775 {
1776    return gtk_scale_get_type        ();
1777 }
1778
1779 void    GTK_SCALE_SET_DIGITS      (GtkScale        *scale,
1780                                    gint             digits)
1781 {
1782    gtk_scale_set_digits      (scale,
1783                                    digits);
1784 }
1785
1786 void    GTK_SCALE_SET_DRAW_VALUE  (GtkScale        *scale,
1787                                    gboolean         draw_value)
1788 {
1789    gtk_scale_set_draw_value  (scale,
1790                         draw_value);
1791 }
1792
1793 void           GTK_SCROLLED_WINDOW_ADD_WITH_VI (GtkScrolledWindow *scrolled_window,
1794                                                       GtkWidget         *child)
1795 {
1796    gtk_scrolled_window_add_with_viewport (scrolled_window,
1797                                         child);
1798 }
1799
1800 GtkType        GTK_SCROLLED_WINDOW_GET_TYPE          (void)
1801 {
1802    return gtk_scrolled_window_get_type          ();
1803 }
1804
1805 GtkAdjustment* GTK_SCROLLED_WINDOW_GET_VADJUST   (GtkScrolledWindow *scrolled_window)
1806 {
1807    return gtk_scrolled_window_get_vadjustment   (scrolled_window);
1808 }
1809
1810 GtkWidget*     GTK_SCROLLED_WINDOW_NEW               (GtkAdjustment     *hadjustment,
1811                                                       GtkAdjustment     *vadjustment)
1812 {
1813    return gtk_scrolled_window_new               (hadjustment,
1814                                                  vadjustment);
1815 }
1816
1817 void           GTK_SCROLLED_WINDOW_SET_POLICY        (GtkScrolledWindow *scrolled_window,
1818                                                       GtkPolicyType      hscrollbar_policy,
1819                                                       GtkPolicyType      vscrollbar_policy)
1820 {
1821    gtk_scrolled_window_set_policy        (scrolled_window,
1822                                         hscrollbar_policy,
1823                                         vscrollbar_policy);
1824 }
1825
1826 gchar*     GTK_SET_LOCALE        (void)
1827 {
1828    return gtk_set_locale         ();
1829 }
1830
1831 guint  GTK_SIGNAL_CONNECT                 (GtkObject           *object,
1832                                            const gchar         *name,
1833                                            GtkSignalFunc        func,
1834                                            gpointer             func_data)
1835 {
1836    return gtk_signal_connect              (object,
1837                                            name,
1838                                            func,
1839                                            func_data);
1840 }
1841
1842 guint  GTK_SIGNAL_CONNECT_AFTER           (GtkObject           *object,
1843                                            const gchar         *name,
1844                                            GtkSignalFunc        func,
1845                                            gpointer             func_data)
1846 {
1847    return gtk_signal_connect_after                (object,
1848                                            name,
1849                                            func,
1850                                            func_data);
1851 }
1852
1853 void   GTK_SIGNAL_DISCONNECT_BY_FUNC      (GtkObject           *object,
1854                                            GtkSignalFunc        func,
1855                                            gpointer             data)
1856 {
1857    gtk_signal_disconnect_by_func          (object,
1858                                            func,
1859                                            data);
1860 }
1861
1862 void   GTK_SIGNAL_EMIT_BY_NAME            (GtkObject           *object,
1863                                            const gchar         *name
1864                                            )
1865 {
1866    gtk_signal_emit_by_name                (object,
1867                                            name
1868                                           );
1869
1870 }
1871
1872 void   GTK_SIGNAL_EMIT_STOP_BY_NAME       (GtkObject           *object,
1873                                            const gchar         *name)
1874 {
1875    gtk_signal_emit_stop_by_name   (object,
1876                                 name);
1877 }
1878
1879 #define MAX_SIGNAL_PARAMS               (31)
1880
1881 guint  GTK_SIGNAL_NEW                     (const gchar         *name,
1882                                            GtkSignalRunType     signal_flags,
1883                                            GtkType              object_type,
1884                                            guint                function_offset,
1885                                            GtkSignalMarshaller  marshaller,
1886                                            GtkType              return_val,
1887                                            guint                nparams,
1888                                            ...)
1889 {
1890   GtkType *params;
1891   guint i;
1892   va_list args;
1893   guint signal_id;
1894
1895   g_return_val_if_fail (nparams < MAX_SIGNAL_PARAMS, 0);
1896
1897   if (nparams > 0)
1898     {
1899       params = g_new (GtkType, nparams);
1900
1901       va_start (args, nparams);
1902
1903       for (i = 0; i < nparams; i++)
1904         params[i] = va_arg (args, GtkType);
1905
1906       va_end (args);
1907     }
1908   else
1909     params = NULL;
1910
1911   signal_id = gtk_signal_newv (name,
1912                                signal_flags,
1913                                object_type,
1914                                function_offset,
1915                                marshaller,
1916                                return_val,
1917                                nparams,
1918                                params);
1919
1920   g_free (params);
1921
1922   return signal_id;
1923 }
1924
1925 GtkStyle* GTK_STYLE_ATTACH                   (GtkStyle      *style,
1926                                               GdkWindow     *window)
1927 {
1928    return gtk_style_attach                   (style,
1929                                               window);
1930 }
1931
1932 GtkStyle* GTK_STYLE_COPY                     (GtkStyle      *style)
1933 {
1934    return gtk_style_copy                     (style);
1935 }
1936
1937 void      GTK_STYLE_SET_BACKGROUND           (GtkStyle     *style,
1938                                               GdkWindow    *window,
1939                                               GtkStateType  state_type)
1940 {
1941    gtk_style_set_background          (style,
1942                                 window,
1943                                 state_type);
1944 }
1945
1946 void      GTK_STYLE_UNREF                    (GtkStyle     *style)
1947 {
1948    gtk_style_unref                   (style);
1949 }
1950
1951 void       GTK_TABLE_ATTACH           (GtkTable        *table,
1952                                        GtkWidget       *child,
1953                                        guint            left_attach,
1954                                        guint            right_attach,
1955                                        guint            top_attach,
1956                                        guint            bottom_attach,
1957                                        GtkAttachOptions xoptions,
1958                                        GtkAttachOptions yoptions,
1959                                        guint            xpadding,
1960                                        guint            ypadding)
1961 {
1962    gtk_table_attach           (table,
1963                         child,
1964                         left_attach,
1965                         right_attach,
1966                         top_attach,
1967                         bottom_attach,
1968                         xoptions,
1969                         yoptions,
1970                         xpadding,
1971                         ypadding);
1972 }
1973
1974 GtkType    GTK_TABLE_GET_TYPE         (void)
1975 {
1976    return gtk_table_get_type          ();
1977 }
1978
1979 GtkWidget* GTK_TABLE_NEW              (guint            rows,
1980                                        guint            columns,
1981                                        gboolean         homogeneous)
1982 {
1983    return gtk_table_new       (rows,
1984                         columns,
1985                         homogeneous);
1986 }
1987
1988 guint      GTK_TEXT_GET_LENGTH      (GtkText       *text)
1989 {
1990    return gtk_text_get_length      (text);
1991 }
1992
1993 guint      GTK_TEXT_GET_POINT       (GtkText       *text)
1994 {
1995    return gtk_text_get_point       (text);
1996 }
1997
1998 GtkType    GTK_TEXT_GET_TYPE        (void)
1999 {
2000    return gtk_text_get_type        ();
2001 }
2002
2003 void       GTK_TEXT_INSERT          (GtkText       *text,
2004                                      GdkFont       *font,
2005                                      GdkColor      *fore,
2006                                      GdkColor      *back,
2007                                      const char    *chars,
2008                                      gint           length)
2009 {
2010    gtk_text_insert          (text,
2011                         font,
2012                         fore,
2013                         back,
2014                         chars,
2015                         length);
2016 }
2017
2018 GtkWidget* GTK_TEXT_NEW             (GtkAdjustment *hadj,
2019                                      GtkAdjustment *vadj)
2020 {
2021    return gtk_text_new             (hadj,
2022                                     vadj);
2023 }
2024
2025 void       GTK_TEXT_SET_EDITABLE    (GtkText       *text,
2026                                      gboolean       editable)
2027 {
2028    gtk_text_set_editable    (text,
2029                         editable);
2030 }
2031
2032 void       GTK_TEXT_SET_WORD_WRAP   (GtkText       *text,
2033                                      gint           word_wrap)
2034 {
2035    gtk_text_set_word_wrap   (text,
2036                         word_wrap);
2037 }
2038
2039 guint      GTK_TIMEOUT_ADD         (guint32            interval,
2040                                     GtkFunction        function,
2041                                     gpointer           data)
2042 {
2043    return gtk_timeout_add          (interval,
2044                                     function,
2045                                     data);
2046 }
2047
2048 void       GTK_TIMEOUT_REMOVE      (guint              timeout_handler_id)
2049 {
2050    gtk_timeout_remove      (timeout_handler_id);
2051 }
2052
2053 GtkType    GTK_TOGGLE_BUTTON_GET_TYPE       (void)
2054 {
2055    return gtk_toggle_button_get_type       ();
2056 }
2057
2058 void       GTK_TOGGLE_BUTTON_SET_ACTIVE     (GtkToggleButton *toggle_button,
2059                                              gboolean         is_active)
2060 {
2061    gtk_toggle_button_set_active     (toggle_button,
2062                                 is_active);
2063 }
2064
2065 void       GTK_TOOLBAR_APPEND_SPACE    (GtkToolbar      *toolbar)
2066 {
2067    gtk_toolbar_append_space    (toolbar);
2068 }
2069
2070 GtkType    GTK_TOOLBAR_GET_TYPE        (void)
2071 {
2072    return gtk_toolbar_get_type        ();
2073 }
2074
2075 GtkWidget* GTK_TOOLBAR_INSERT_ELEMENT  (GtkToolbar      *toolbar,
2076                                         GtkToolbarChildType type,
2077                                         GtkWidget       *widget,
2078                                         const char      *text,
2079                                         const char      *tooltip_text,
2080                                         const char      *tooltip_private_text,
2081                                         GtkWidget       *icon,
2082                                         GtkSignalFunc    callback,
2083                                         gpointer         user_data,
2084                                         gint             position)
2085 {
2086    return gtk_toolbar_insert_element  (toolbar,
2087                                 type,
2088                                 widget,
2089                                 text,
2090                                 tooltip_text,
2091                                 tooltip_private_text,
2092                                 icon,
2093                                 callback,
2094                                 user_data,
2095                                 position);
2096 }
2097
2098 void       GTK_TOOLBAR_INSERT_WIDGET   (GtkToolbar      *toolbar,
2099                                         GtkWidget       *widget,
2100                                         const char      *tooltip_text,
2101                                         const char      *tooltip_private_text,
2102                                         gint             position)
2103 {
2104    gtk_toolbar_insert_widget   (toolbar,
2105                                 widget,
2106                                 tooltip_text,
2107                                 tooltip_private_text,
2108                                 position);
2109
2110
2111 }
2112
2113 GtkWidget* GTK_TOOLBAR_NEW             (GtkOrientation   orientation,
2114                                         GtkToolbarStyle  style)
2115 {
2116    return gtk_toolbar_new             (orientation,
2117                                 style);
2118 }
2119
2120 void       GTK_TOOLBAR_SET_BUTTON_RELIEF     (GtkToolbar           *toolbar,
2121                                               GtkReliefStyle        relief)
2122 {
2123    gtk_toolbar_set_button_relief     (toolbar,
2124                                 relief);
2125 }
2126
2127 void       GTK_TOOLBAR_SET_SPACE_SIZE        (GtkToolbar           *toolbar,
2128                                               gint                  space_size)
2129 {
2130    gtk_toolbar_set_space_size        (toolbar,
2131                                 space_size);
2132 }
2133
2134 void       GTK_TOOLBAR_SET_TOOLTIPS          (GtkToolbar           *toolbar,
2135                                               gint                  enable)
2136 {
2137    gtk_toolbar_set_tooltips          (toolbar,
2138                                 enable);
2139 }
2140
2141 void             GTK_TOOLTIPS_FORCE_WINDOW (GtkTooltips   *tooltips)
2142 {
2143    gtk_tooltips_force_window (tooltips);
2144 }
2145
2146 GtkTypeClass*   GTK_TYPE_CHECK_CLASS_CAST       (GtkTypeClass   *klass,
2147                                                  GtkType         cast_type)
2148 {
2149    return gtk_type_check_class_cast     (klass,
2150                                         cast_type);
2151 }
2152
2153 GtkTypeObject*  GTK_TYPE_CHECK_OBJECT_CAST      (GtkTypeObject  *type_object,
2154                                                  GtkType         cast_type)
2155 {
2156    return gtk_type_check_object_cast    (type_object,
2157                                         cast_type);
2158 }
2159
2160 gpointer        GTK_TYPE_CLASS                  (GtkType         type)
2161 {
2162    return gtk_type_class                        (type);
2163 }
2164
2165 gboolean        GTK_TYPE_IS_A                   (GtkType         type,
2166                                                  GtkType         is_a_type)
2167 {
2168    return gtk_type_is_a                 (type,
2169                                         is_a_type);
2170 }
2171
2172 gpointer        GTK_TYPE_NEW                    (GtkType         type)
2173 {
2174    return gtk_type_new                  (type);
2175 }
2176
2177 GtkType         GTK_TYPE_UNIQUE                 (GtkType           parent_type,
2178                                                  const GtkTypeInfo *type_info)
2179 {
2180    return gtk_type_unique                       (parent_type,
2181                                                  type_info);
2182 }
2183
2184 GtkWidget* GTK_VSCALE_NEW      (GtkAdjustment *adjustment)
2185 {
2186    return gtk_vscale_new      (adjustment);
2187 }
2188
2189 GtkWidget* GTK_VSCROLLBAR_NEW      (GtkAdjustment *adjustment)
2190 {
2191    return gtk_vscrollbar_new      (adjustment);
2192 }
2193
2194 GtkWidget* GTK_VSEPARATOR_NEW      (void)
2195 {
2196    return gtk_vseparator_new      ();
2197 }
2198
2199 gboolean   GTK_WIDGET_ACTIVATE               (GtkWidget        *widget)
2200 {
2201    return gtk_widget_activate                (widget);
2202 }
2203
2204 void       GTK_WIDGET_DESTROY             (GtkWidget           *widget)
2205 {
2206    gtk_widget_destroy             (widget);
2207 }
2208
2209 void       GTK_WIDGET_DRAW                (GtkWidget           *widget,
2210                                            GdkRectangle        *area)
2211 {
2212    gtk_widget_draw                (widget,
2213                                 area);
2214 }
2215
2216 gint       GTK_WIDGET_EVENT               (GtkWidget           *widget,
2217                                            GdkEvent            *event)
2218 {
2219    return gtk_widget_event                (widget,
2220                                            event);
2221 }
2222
2223 void       GTK_WIDGET_GET_CHILD_REQUISITIO (GtkWidget          *widget,
2224                                              GtkRequisition    *requisition)
2225 {
2226    gtk_widget_get_child_requisition (widget,
2227                                 requisition);
2228 }
2229
2230 GdkColormap* GTK_WIDGET_GET_COLORMAP    (GtkWidget      *widget)
2231 {
2232    return gtk_widget_get_colormap       (widget);
2233 }
2234
2235 GdkColormap* GTK_WIDGET_GET_DEFAULT_COLORMAP (void)
2236 {
2237    return gtk_widget_get_default_colormap ();
2238 }
2239
2240 GtkStyle*    GTK_WIDGET_GET_DEFAULT_STYLE    (void)
2241 {
2242    return gtk_widget_get_default_style    ();
2243 }
2244
2245 gint         GTK_WIDGET_GET_EVENTS      (GtkWidget      *widget)
2246 {
2247    return gtk_widget_get_events (widget);
2248 }
2249
2250 GdkWindow *GTK_WIDGET_GET_PARENT_WINDOW   (GtkWidget           *widget)
2251 {
2252    return gtk_widget_get_parent_window    (widget);
2253 }
2254
2255 GtkStyle*  GTK_WIDGET_GET_STYLE         (GtkWidget      *widget)
2256 {
2257    return gtk_widget_get_style          (widget);
2258 }
2259
2260 GtkType    GTK_WIDGET_GET_TYPE            (void)
2261 {
2262    return gtk_widget_get_type             ();
2263 }
2264
2265 GdkVisual*   GTK_WIDGET_GET_VISUAL      (GtkWidget      *widget)
2266 {
2267    return gtk_widget_get_visual (widget);
2268 }
2269
2270 void       GTK_WIDGET_GRAB_DEFAULT        (GtkWidget           *widget)
2271 {
2272    gtk_widget_grab_default        (widget);
2273 }
2274
2275 void       GTK_WIDGET_GRAB_FOCUS          (GtkWidget           *widget)
2276 {
2277    gtk_widget_grab_focus          (widget);
2278 }
2279
2280 void       GTK_WIDGET_HIDE                (GtkWidget           *widget)
2281 {
2282    gtk_widget_hide                (widget);
2283 }
2284
2285 gint       GTK_WIDGET_INTERSECT           (GtkWidget           *widget,
2286                                            GdkRectangle        *area,
2287                                            GdkRectangle        *intersection)
2288 {
2289    return gtk_widget_intersect            (widget,
2290                                            area,
2291                                            intersection);
2292 }
2293
2294 void       GTK_WIDGET_MAP                 (GtkWidget           *widget)
2295 {
2296    gtk_widget_map                 (widget);
2297 }
2298
2299 void       GTK_WIDGET_QUEUE_DRAW          (GtkWidget           *widget)
2300 {
2301    gtk_widget_queue_draw          (widget);
2302 }
2303
2304 void       GTK_WIDGET_QUEUE_RESIZE        (GtkWidget           *widget)
2305 {
2306    gtk_widget_queue_resize        (widget);
2307 }
2308
2309 void       GTK_WIDGET_REALIZE             (GtkWidget           *widget)
2310 {
2311    gtk_widget_realize             (widget);
2312 }
2313
2314 void       GTK_WIDGET_REF                 (GtkWidget           *widget)
2315 {
2316    gtk_widget_ref                 (widget);
2317 }
2318
2319 void       GTK_WIDGET_REPARENT            (GtkWidget           *widget,
2320                                            GtkWidget           *new_parent)
2321 {
2322    gtk_widget_reparent            (widget,
2323                                 new_parent);
2324 }
2325
2326 void         GTK_WIDGET_SET_DEFAULT_COLORMAP (GdkColormap *colormap)
2327 {
2328    gtk_widget_set_default_colormap (colormap);
2329 }
2330
2331 void         GTK_WIDGET_SET_DEFAULT_VISUAL   (GdkVisual   *visual)
2332 {
2333    gtk_widget_set_default_visual   (visual);
2334 }
2335
2336 void       GTK_WIDGET_SET_PARENT          (GtkWidget           *widget,
2337                                            GtkWidget           *parent)
2338 {
2339    gtk_widget_set_parent          (widget,
2340                                 parent);
2341 }
2342
2343 void       GTK_WIDGET_SET_PARENT_WINDOW   (GtkWidget           *widget,
2344                                            GdkWindow           *parent_window)
2345 {
2346    gtk_widget_set_parent_window   (widget,
2347                                 parent_window);
2348 }
2349
2350 void       GTK_WIDGET_SET_SENSITIVE       (GtkWidget           *widget,
2351                                            gboolean             sensitive)
2352 {
2353    gtk_widget_set_sensitive       (widget,
2354                                 sensitive);
2355 }
2356
2357 void       GTK_WIDGET_SET_STYLE         (GtkWidget      *widget,
2358                                          GtkStyle       *style)
2359 {
2360    gtk_widget_set_style         (widget,
2361                                 style);
2362 }
2363
2364 void       GTK_WIDGET_SET_UPOSITION       (GtkWidget           *widget,
2365                                            gint                 x,
2366                                            gint                 y)
2367 {
2368    gtk_widget_set_uposition       (widget,
2369                                 x,
2370                                 y);
2371 }
2372
2373 void       GTK_WIDGET_SET_USIZE           (GtkWidget           *widget,
2374                                            gint                 width,
2375                                            gint                 height)
2376 {
2377    gtk_widget_set_usize           (widget,
2378                                 width,
2379                                 height);
2380 }
2381
2382 void       GTK_WIDGET_SHOW                (GtkWidget           *widget)
2383 {
2384    gtk_widget_show                (widget);
2385 }
2386
2387 void       GTK_WIDGET_SIZE_ALLOCATE       (GtkWidget           *widget,
2388                                            GtkAllocation       *allocation)
2389 {
2390    gtk_widget_size_allocate       (widget,
2391                                 allocation);
2392 }
2393
2394 void       GTK_WIDGET_SIZE_REQUEST        (GtkWidget           *widget,
2395                                            GtkRequisition      *requisition)
2396 {
2397    gtk_widget_size_request        (widget,
2398                                 requisition);
2399 }
2400
2401 void       GTK_WIDGET_UNMAP               (GtkWidget           *widget)
2402 {
2403    gtk_widget_unmap               (widget);
2404 }
2405
2406 void       GTK_WIDGET_UNPARENT            (GtkWidget           *widget)
2407 {
2408    gtk_widget_unparent            (widget);
2409 }
2410
2411 void       GTK_WIDGET_UNREF               (GtkWidget           *widget)
2412 {
2413    gtk_widget_unref               (widget);
2414 }
2415
2416 GtkType    GTK_WINDOW_GET_TYPE                 (void)
2417 {
2418    return gtk_window_get_type                 ();
2419 }
2420
2421 GtkWidget* GTK_WINDOW_NEW                      (GtkWindowType        type)
2422 {
2423    return gtk_window_new                      (type);
2424 }
2425
2426 void       GTK_WINDOW_SET_POLICY               (GtkWindow           *window,
2427                                                 gint                 allow_shrink,
2428                                                 gint                 allow_grow,
2429                                                 gint                 auto_shrink)
2430 {
2431    gtk_window_set_policy               (window,
2432                                         allow_shrink,
2433                                         allow_grow,
2434                                         auto_shrink);
2435 }
2436
2437 void       GTK_WINDOW_SET_TITLE                (GtkWindow           *window,
2438                                                 const gchar         *title)
2439 {
2440    gtk_window_set_title                (window,
2441                                         title);
2442 }
2443
2444 void       GTK_WINDOW_SET_TRANSIENT_FOR        (GtkWindow           *window,
2445                                                 GtkWindow           *parent)
2446 {
2447    gtk_window_set_transient_for        (window,
2448                                         parent);
2449 }
2450
2451 void       GTK_WINDOW_SET_WMCLASS              (GtkWindow           *window,
2452                                                 const gchar         *wmclass_name,
2453                                                 const gchar         *wmclass_class)
2454 {
2455    gtk_window_set_wmclass              (window,
2456                                         wmclass_name,
2457                                         wmclass_class);
2458 }
2459
2460 void     G_FREE        (gpointer  mem)
2461 {
2462    g_free              (mem);
2463 }
2464
2465 GList* G_LIST_ALLOC             (void)
2466 {
2467    return g_list_alloc          ();
2468 }
2469
2470 GList* G_LIST_APPEND            (GList          *list,
2471                                  gpointer        data)
2472 {
2473    return g_list_append         (list,
2474                                  data);
2475 }
2476
2477 void   G_LIST_FREE              (GList          *list)
2478 {
2479    g_list_free          (list);
2480 }
2481
2482 GList* G_LIST_INSERT            (GList          *list,
2483                                  gpointer        data,
2484                                  gint            position)
2485 {
2486    return g_list_insert         (list,
2487                                  data,
2488                                  position);
2489 }
2490
2491 GList* G_LIST_LAST              (GList          *list)
2492 {
2493    return g_list_last           (list);
2494 }
2495
2496 guint  G_LIST_LENGTH            (GList          *list)
2497 {
2498    return g_list_length         (list);
2499 }
2500
2501 GList* G_LIST_NTH               (GList          *list,
2502                                  guint           n)
2503 {
2504    return g_list_nth            (list,
2505                                  n);
2506 }
2507
2508 GList* G_LIST_REMOVE            (GList          *list,
2509                                  gpointer        data)
2510 {
2511    return g_list_remove         (list,
2512                                  data);
2513 }
2514
2515 GList* G_LIST_REMOVE_LINK       (GList          *list,
2516                                  GList          *llink)
2517 {
2518    return g_list_remove_link    (list,
2519                                  llink);
2520 }
2521
2522 void            G_LOG                   (const gchar    *log_domain,
2523                                          GLogLevelFlags  log_level,
2524                                          const gchar    *format,
2525                                          ...)
2526 {
2527   va_list args;
2528
2529   va_start (args, format);
2530   g_logv (log_domain, log_level, format, args);
2531   va_end (args);
2532 }
2533
2534 void            G_LOGV                  (const gchar    *log_domain,
2535                                          GLogLevelFlags  log_level,
2536                                          const gchar    *format,
2537                                          va_list         args)
2538 {
2539    g_logv                       (log_domain,
2540                                 log_level,
2541                                 format,
2542                                 args);
2543 }
2544
2545 gpointer G_MALLOC      (gulong    size)
2546 {
2547    return g_malloc      (size);
2548 }
2549
2550 GSList* G_SLIST_FIND            (GSList         *list,
2551                                  gpointer        data)
2552 {
2553    return g_slist_find          (list,
2554                                  data);
2555 }
2556
2557 void       GTK_WINDOW_SET_GEOMETRY_HINTS       (GtkWindow           *window,
2558                                                 GtkWidget           *geometry_widget,
2559                                                 GdkGeometry         *geometry,
2560                                                 GdkWindowHints       geom_mask)
2561 {
2562    gtk_window_set_geometry_hints       (window,
2563                                         geometry_widget,
2564                                         geometry,
2565                                         geom_mask);
2566 }
2567
2568 #undef GDK_THREADS_ENTER
2569 void     GDK_THREADS_ENTER                (void)
2570 {
2571    gdk_threads_enter1                ();
2572 }
2573
2574 #undef GDK_THREADS_LEAVE
2575 void     GDK_THREADS_LEAVE                (void)
2576 {
2577    gdk_threads_leave1                ();
2578 }