]> git.saurik.com Git - wxWidgets.git/blame - src/gtk1/wx_gtk_vmsjackets.c
added possibility to throw different objects and crash directly from the main frame...
[wxWidgets.git] / src / gtk1 / wx_gtk_vmsjackets.c
CommitLineData
27df579a
JJ
1/* Jackets for VMS only */
2
3#include <stdarg.h>
4
5#include <glib.h>
3fa056ab 6#include <gdk/gdk.h>
27df579a
JJ
7#include <gdk/gdkprivate.h>
8#include <gdk/gdkx.h>
9#include <gtk/gtk.h>
3fa056ab
JJ
10
11void GDK_BEEP (void)
12{
13 gdk_beep();
14}
15
16GdkBitmap* 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
27void GDK_BITMAP_UNREF (GdkBitmap *pixmap)
28{
29 gdk_bitmap_unref (pixmap);
30}
31
32gint GDK_CHAR_HEIGHT (GdkFont *font,
33 gchar character)
34{
35 return gdk_char_height (font,
36 character);
37}
38
39GdkColormap* GDK_COLORMAP_GET_SYSTEM (void)
40{
41 return gdk_colormap_get_system();
42}
43
44GdkVisual* GDK_COLORMAP_GET_VISUAL (GdkColormap *colormap)
45{
46 return gdk_colormap_get_visual (colormap);
47}
48
27df579a
JJ
49GdkColormap* GDK_COLORMAP_NEW (GdkVisual *visual,
50 gboolean allocate)
51{
52 return gdk_colormap_new (visual,
53 allocate);
54}
55
56void GDK_COLORMAP_UNREF (GdkColormap *cmap)
57{
58 gdk_colormap_unref (cmap);
59}
60
61gboolean GDK_COLOR_ALLOC (GdkColormap *colormap,
62 GdkColor *color)
63{
64 return gdk_color_alloc (colormap,
65 color);
66}
67
68gboolean GDK_COLOR_PARSE (const gchar *spec,
69 GdkColor *color)
70{
71 return gdk_color_parse (spec,
72 color);
73}
74
75void GDK_CURSOR_DESTROY (GdkCursor *cursor)
76{
77 gdk_cursor_destroy (cursor);
78}
79
80GdkCursor* GDK_CURSOR_NEW (GdkCursorType cursor_type)
81{
82 return gdk_cursor_new (cursor_type);
83}
84
85void 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
106void 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
127void 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
142void 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
163void 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
174void 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
187void 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
204void 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
219void GDK_FLUSH (void)
220{
221 gdk_flush ();
222}
223
224GdkFont* GDK_FONT_LOAD (const gchar *font_name)
225{
226 return gdk_font_load (font_name);
227}
228
229GdkFont* GDK_FONT_REF (GdkFont *font)
230{
231 return gdk_font_ref (font);
232}
233
234void GDK_FONT_UNREF (GdkFont *font)
235{
236 gdk_font_unref (font);
237}
238
239void GDK_GC_DESTROY (GdkGC *gc)
240{
241 gdk_gc_destroy (gc);
242}
243
244GdkGC* GDK_GC_NEW (GdkWindow *window)
245{
246 return gdk_gc_new (window);
247}
248
249void GDK_GC_SET_BACKGROUND (GdkGC *gc,
250 GdkColor *color)
251{
252 gdk_gc_set_background (gc,
253 color);
254}
255
256void GDK_GC_SET_CLIP_MASK (GdkGC *gc,
257 GdkBitmap *mask)
258{
259 gdk_gc_set_clip_mask (gc,
260 mask);
261}
262
263void 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
272void GDK_GC_SET_CLIP_RECTANGLE (GdkGC *gc,
273 GdkRectangle *rectangle)
274{
275 gdk_gc_set_clip_rectangle (gc,
276 rectangle);
277}
278
279void GDK_GC_SET_CLIP_REGION (GdkGC *gc,
280 GdkRegion *region)
281{
282 gdk_gc_set_clip_region (gc,
283 region);
284}
285
286void 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
297void GDK_GC_SET_EXPOSURES (GdkGC *gc,
298 gboolean exposures)
299{
300 gdk_gc_set_exposures (gc,
301 exposures);
302}
303
304void GDK_GC_SET_FILL (GdkGC *gc,
305 GdkFill fill)
306{
307 gdk_gc_set_fill (gc,
308 fill);
309}
310
311void GDK_GC_SET_FOREGROUND (GdkGC *gc,
312 GdkColor *color)
313{
314 gdk_gc_set_foreground (gc,
315 color);
316}
317
318void GDK_GC_SET_FUNCTION (GdkGC *gc,
319 GdkFunction function)
320{
321 gdk_gc_set_function (gc,
322 function);
323}
324
325void 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
338void GDK_GC_SET_STIPPLE (GdkGC *gc,
339 GdkPixmap *stipple)
340{
341 gdk_gc_set_stipple (gc,
342 stipple);
343}
344
345void GDK_GC_SET_SUBWINDOW (GdkGC *gc,
346 GdkSubwindowMode mode)
347{
348 gdk_gc_set_subwindow (gc,
349 mode);
350}
351
352void GDK_GC_SET_TILE (GdkGC *gc,
353 GdkPixmap *tile)
354{
355 gdk_gc_set_tile (gc,
356 tile);
357}
358
359void 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
368void GDK_GC_UNREF (GdkGC *gc)
369{
370 gdk_gc_unref (gc);
371}
372
373void GDK_IMAGE_DESTROY (GdkImage *image)
374{
375 gdk_image_destroy (image);
376}
377
378GdkImage* 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
391guint32 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
400GdkImage* 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
411GdkImage* 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
422void 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
434gint 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
447void GDK_INPUT_REMOVE (gint tag)
448{
449 gdk_input_remove (tag);
450}
451
452guint GDK_KEYVAL_TO_UPPER (guint keyval)
453{
454 return gdk_keyval_to_upper (keyval);
455}
456
457GdkPixmap* 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
468GdkPixmap* 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
479GdkPixmap* 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
490void GDK_PIXMAP_UNREF (GdkPixmap *pixmap)
491{
492 gdk_pixmap_unref (pixmap);
493}
494
495gint 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
510void GDK_POINTER_UNGRAB (guint32 time)
511{
512 gdk_pointer_ungrab (time);
513}
514
515GdkRegion* GDK_REGIONS_INTERSECT (GdkRegion *source1,
516 GdkRegion *source2)
517{
518 return gdk_regions_intersect (source1,
519 source2);
520
521}
522
523GdkRegion* GDK_REGIONS_SUBTRACT (GdkRegion *source1,
524 GdkRegion *source2)
525{
526 return gdk_regions_subtract (source1,
527 source2);
528}
529
530GdkRegion* GDK_REGIONS_UNION (GdkRegion *source1,
531 GdkRegion *source2)
532{
533 return gdk_regions_union (source1,
534 source2);
535}
536
537GdkRegion* GDK_REGIONS_XOR (GdkRegion *source1,
538 GdkRegion *source2)
539{
540 return gdk_regions_xor (source1,
541 source2);
542}
543
544void GDK_REGION_DESTROY (GdkRegion *region)
545{
546 gdk_region_destroy (region);
547}
548
549gboolean GDK_REGION_EMPTY (GdkRegion *region)
550{
551 return gdk_region_empty (region);
552}
553
554void GDK_REGION_GET_CLIPBOX(GdkRegion *region,
555 GdkRectangle *rectangle)
556{
557 gdk_region_get_clipbox(region,
558 rectangle);
559}
560
561GdkRegion* GDK_REGION_NEW (void)
562{
563 return gdk_region_new ();
564}
565
566gboolean 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
575GdkOverlapType GDK_REGION_RECT_IN (GdkRegion *region,
576 GdkRectangle *rect)
577{
578 return gdk_region_rect_in (region,
579 rect);
580}
581
582GdkRegion* GDK_REGION_UNION_WITH_RECT (GdkRegion *region,
583 GdkRectangle *rect)
584{
585 return gdk_region_union_with_rect (region,
586 rect);
587}
588
589gint GDK_SCREEN_HEIGHT (void)
590{
591 return gdk_screen_height ();
592}
593
594gint GDK_SCREEN_WIDTH (void)
595{
596 return gdk_screen_width ();
597}
598
599gint GDK_STRING_WIDTH (GdkFont *font,
600 const gchar *string)
601{
602 return gdk_string_width (font,
603 string);
604}
605
606void gdk_threads_enter1 (void)
607{
608 gdk_threads_enter ();
609}
610
611void gdk_threads_leave1 (void)
612{
613 gdk_threads_leave ();
614}
615
616GdkVisual* GDK_VISUAL_GET_BEST (void)
617{
618 return gdk_visual_get_best ();
619}
620
621GdkVisual* GDK_VISUAL_GET_SYSTEM (void)
622{
623 return gdk_visual_get_system ();
624}
625
626void 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
635void GDK_WINDOW_CLEAR (GdkWindow *window)
636{
637 gdk_window_clear (window);
638}
639
640void 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
653void 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
674void GDK_WINDOW_DESTROY (GdkWindow *window)
675{
676 gdk_window_destroy (window);
677}
678
679GdkColormap* GDK_WINDOW_GET_COLORMAP (GdkWindow *window)
680{
681 return gdk_window_get_colormap (window);
682}
683
684gint 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
693GdkWindow* 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
704void 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
713void 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
722void GDK_WINDOW_GET_USER_DATA (GdkWindow *window,
723 gpointer *data)
724{
725 gdk_window_get_user_data (window,
726 data);
727}
728
729GdkVisual* GDK_WINDOW_GET_VISUAL (GdkWindow *window)
730{
731 return gdk_window_get_visual (window);
732}
733
734void GDK_WINDOW_LOWER (GdkWindow *window)
735{
736 gdk_window_lower (window);
737}
738
739void GDK_WINDOW_MOVE (GdkWindow *window,
740 gint x,
741 gint y)
742{
743 gdk_window_move (window,
744 x,
745 y);
746}
747
748void 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
761GdkWindow* 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
770void GDK_WINDOW_RAISE (GdkWindow *window)
771{
772 gdk_window_raise (window);
773}
774
775GdkWindow* GDK_WINDOW_REF (GdkWindow *window)
776{
777 return gdk_window_ref (window);
778}
779
780void GDK_WINDOW_RESIZE (GdkWindow *window,
781 gint width,
782 gint height)
783{
784 gdk_window_resize (window,
785 width,
786 height);
787}
788
789void GDK_WINDOW_SET_BACKGROUND (GdkWindow *window,
790 GdkColor *color)
791{
792 gdk_window_set_background (window,
793 color);
794}
795
796void GDK_WINDOW_SET_CURSOR (GdkWindow *window,
797 GdkCursor *cursor)
798{
799 gdk_window_set_cursor (window,
800 cursor);
801}
802
803void GDK_WINDOW_SET_DECORATIONS (GdkWindow *window,
804 GdkWMDecoration decorations)
805{
806 gdk_window_set_decorations (window,
807 decorations);
808}
809
810void GDK_WINDOW_SET_FUNCTIONS (GdkWindow *window,
811 GdkWMFunction functions)
812{
813 gdk_window_set_functions (window,
814 functions);
815}
816
817void 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
836void 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
847gboolean 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
854void GDK_WINDOW_SET_USER_DATA (GdkWindow *window,
855 gpointer user_data)
856{
857 gdk_window_set_user_data (window,
858 user_data);
859}
860
861void GDK_WINDOW_SHOW (GdkWindow *window)
862{
863 gdk_window_show (window);
864}
865
866void GDK_WINDOW_UNREF (GdkWindow *window)
867{
868 gdk_window_unref (window);
869}
870
871void
872GDK_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{
882gdk_draw_rgb_image (drawable,
883 gc,
884 x,
885 y,
886 width,
887 height,
888 dith,
889 rgb_buf,
890 rowstride);
891}
892
893void
894GDK_RGB_INIT (void)
895{
896gdk_rgb_init ();
897}
898
899gpointer GDK_XID_TABLE_LOOKUP (XID xid)
900{
901 return gdk_xid_table_lookup (xid);
902}
903
904
905Display* GDK_DISPLAY0( void )
906{
907 return gdk_display;
908}
909
910gint 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
921GdkWindow* GDK_ROOT_PARENT0( void )
922{
923 return ((GdkWindow *)&gdk_root_parent);
924}
925
926void GTK_ACCEL_GROUP_ATTACH (GtkAccelGroup *accel_group,
927 GtkObject *object)
928{
929 gtk_accel_group_attach (accel_group,
930 object);
931}
932
933void GTK_ACCEL_GROUP_DETACH (GtkAccelGroup *accel_group,
934 GtkObject *object)
935{
936 gtk_accel_group_detach (accel_group,
937 object);
938}
939
940GtkAccelGroup* GTK_ACCEL_GROUP_NEW (void)
941{
942 return gtk_accel_group_new ();
943}
944
945GtkType GTK_ACCEL_LABEL_GET_TYPE (void)
946{
947 return gtk_accel_label_get_type ();
948}
949
950gboolean GTK_ACCEL_LABEL_REFETCH (GtkAccelLabel *accel_label)
951{
952 return gtk_accel_label_refetch (accel_label);
953}
954
955GtkType GTK_ADJUSTMENT_GET_TYPE (void)
956{
957 return gtk_adjustment_get_type ();
958}
959
960GtkType GTK_BIN_GET_TYPE (void)
961{
962 return gtk_bin_get_type ();
963}
964
965GtkType GTK_BOX_GET_TYPE (void)
966{
967 return gtk_box_get_type ();
968}
969
970void 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
983GtkType GTK_BUTTON_GET_TYPE (void)
984{
985 return gtk_button_get_type ();
986}
987
988GtkWidget* GTK_BUTTON_NEW (void)
989{
990 return gtk_button_new ();
991}
992
993GtkWidget* GTK_BUTTON_NEW_WITH_LABEL (const gchar *label)
994{
995 return gtk_button_new_with_label (label);
996}
997
998void GTK_BUTTON_SET_RELIEF (GtkButton *button,
999 GtkReliefStyle newstyle)
1000{
1001 gtk_button_set_relief (button,
1002 newstyle);
1003}
1004
1005GtkWidget* GTK_CHECK_BUTTON_NEW (void)
1006{
1007 return gtk_check_button_new ();
1008}
1009
1010GtkWidget* GTK_CHECK_BUTTON_NEW_WITH_LABEL (const gchar *label)
1011{
1012 return gtk_check_button_new_with_label (label);
1013}
1014
1015void 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
1022guint GTK_COMBO_GET_TYPE (void)
1023{
1024 return gtk_combo_get_type ();
1025}
1026
1027GtkWidget *GTK_COMBO_NEW (void)
1028{
1029 return gtk_combo_new ();
1030}
1031
1032void GTK_COMBO_SET_USE_ARROWS_ALWAYS (GtkCombo* combo,
1033 gint val)
1034{
1035 gtk_combo_set_use_arrows_always (combo,
1036 val);
1037}
1038
1039void GTK_CONTAINER_ADD (GtkContainer *container,
1040 GtkWidget *widget)
1041{
1042 gtk_container_add (container,
1043 widget);
1044}
1045
1046gint GTK_CONTAINER_FOCUS (GtkContainer *container,
1047 GtkDirectionType direction)
1048{
1049 return gtk_container_focus (container,
1050 direction);
1051}
1052
1053void 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
1062GtkType GTK_CONTAINER_GET_TYPE (void)
1063{
1064 return gtk_container_get_type ();
1065}
1066
1067void GTK_CONTAINER_REMOVE (GtkContainer *container,
1068 GtkWidget *widget)
1069{
1070 gtk_container_remove (container,
1071 widget);
1072}
1073
1074void GTK_CONTAINER_SET_FOCUS_VADJUST (GtkContainer *container,
1075 GtkAdjustment *adjustment)
1076{
1077 gtk_container_set_focus_vadjustment (container,
1078 adjustment);
1079}
1080
1081void 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
1100void GTK_EDITABLE_COPY_CLIPBOARD (GtkEditable *editable)
1101{
1102 gtk_editable_copy_clipboard (editable);
1103}
1104
1105void GTK_EDITABLE_CUT_CLIPBOARD (GtkEditable *editable)
1106{
1107 gtk_editable_cut_clipboard (editable);
1108}
1109
1110void 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
1119gchar* 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
1128GtkType GTK_EDITABLE_GET_TYPE (void)
1129{
1130 return gtk_editable_get_type ();
1131}
1132
1133void 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
1144void GTK_EDITABLE_PASTE_CLIPBOARD (GtkEditable *editable)
1145{
1146 gtk_editable_paste_clipboard (editable);
1147}
1148
1149void 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
1158void GTK_ENTRY_APPEND_TEXT (GtkEntry *entry,
1159 const gchar *text)
1160{
1161 gtk_entry_append_text (entry,
1162 text);
1163}
1164
1165gchar* GTK_ENTRY_GET_TEXT (GtkEntry *entry)
1166{
1167 return gtk_entry_get_text (entry);
1168}
1169
1170GtkType GTK_ENTRY_GET_TYPE (void)
1171{
1172 return gtk_entry_get_type ();
1173}
1174
1175GtkWidget* GTK_ENTRY_NEW (void)
1176{
1177 return gtk_entry_new ();
1178}
1179
1180void GTK_ENTRY_SET_EDITABLE (GtkEntry *entry,
1181 gboolean editable)
1182{
1183 gtk_entry_set_editable (entry,
1184 editable);
1185}
1186
1187void GTK_ENTRY_SET_POSITION (GtkEntry *entry,
1188 gint position)
1189{
1190 gtk_entry_set_position (entry,
1191 position);
1192}
1193
1194void GTK_ENTRY_SET_TEXT (GtkEntry *entry,
1195 const gchar *text)
1196{
1197 gtk_entry_set_text (entry,
1198 text);
1199}
1200
1201void GTK_ENTRY_SET_VISIBILITY (GtkEntry *entry,
1202 gboolean visible)
1203{
1204 gtk_entry_set_visibility (entry,
1205 visible);
1206}
1207
1208gint GTK_EVENTS_PENDING (void)
1209{
1210 return gtk_events_pending ();
1211}
1212
1213gchar* GTK_FILE_SELECTION_GET_FILENAME (GtkFileSelection *filesel)
1214{
1215 return gtk_file_selection_get_filename (filesel);
1216}
1217
1218GtkType GTK_FILE_SELECTION_GET_TYPE (void)
1219{
1220 return gtk_file_selection_get_type ();
1221}
1222
1223void GTK_FILE_SELECTION_HIDE_FILEOP_ (GtkFileSelection *filesel)
1224{
1225 gtk_file_selection_hide_fileop_buttons (filesel);
1226}
1227
1228GtkWidget* GTK_FILE_SELECTION_NEW (const gchar *title)
1229{
1230 return gtk_file_selection_new (title);
1231}
1232
1233void GTK_FILE_SELECTION_SET_FILENAME (GtkFileSelection *filesel,
1234 const gchar *filename)
1235{
1236 gtk_file_selection_set_filename (filesel,
1237 filename);
1238}
1239
1240gchar* GTK_FONT_SELECTION_DIALOG_GETNF (GtkFontSelectionDialog *fsd)
1241{
1242 return gtk_font_selection_dialog_get_font_name (fsd);
1243}
1244
1245GdkFont* GTK_FONT_SELECTION_DIALOG_GET_F (GtkFontSelectionDialog *fsd)
1246{
1247 return gtk_font_selection_dialog_get_font (fsd);
1248}
1249
1250GtkType GTK_FONT_SELECTION_DIALOG_GET_T (void)
1251{
1252 return gtk_font_selection_dialog_get_type ();
1253}
1254
1255GtkWidget* GTK_FONT_SELECTION_DIALOG_NEW (const gchar *title)
1256{
1257 return gtk_font_selection_dialog_new (title);
1258}
1259
1260GtkType GTK_FRAME_GET_TYPE (void)
1261{
1262 return gtk_frame_get_type ();
1263}
1264
1265GtkWidget* GTK_FRAME_NEW (const gchar *label)
1266{
1267 return gtk_frame_new (label);
1268}
1269
1270void GTK_FRAME_SET_LABEL (GtkFrame *frame,
1271 const gchar *label)
1272{
1273 gtk_frame_set_label (frame,
1274 label);
1275}
1276
1277void GTK_GRAB_ADD (GtkWidget *widget)
1278{
1279 gtk_grab_add (widget);
1280}
1281
1282void GTK_GRAB_REMOVE (GtkWidget *widget)
1283{
1284 gtk_grab_remove (widget);
1285}
1286
1287GtkType GTK_HANDLE_BOX_GET_TYPE (void)
1288{
1289 return gtk_handle_box_get_type ();
1290}
1291
1292GtkWidget* GTK_HANDLE_BOX_NEW (void)
1293{
1294 return gtk_handle_box_new ();
1295}
1296
1297void 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
1304GtkWidget* GTK_HBOX_NEW (gboolean homogeneous,
1305 gint spacing)
1306{
1307 return gtk_hbox_new (homogeneous,
1308 spacing);
1309}
1310
1311GtkWidget* GTK_HSCALE_NEW (GtkAdjustment *adjustment)
1312{
1313 return gtk_hscale_new (adjustment);
1314}
1315
1316GtkWidget* GTK_HSCROLLBAR_NEW (GtkAdjustment *adjustment)
1317{
1318 return gtk_hscrollbar_new (adjustment);
1319}
1320
1321GtkWidget* GTK_HSEPARATOR_NEW (void)
1322{
1323 return gtk_hseparator_new ();
1324}
1325
1326guint GTK_IDLE_ADD (GtkFunction function,
1327 gpointer data)
1328{
1329 return gtk_idle_add (function,
1330 data);
1331}
1332
1333void GTK_IDLE_REMOVE (guint idle_handler_id)
1334{
1335 gtk_idle_remove (idle_handler_id);
1336}
1337
1338void GTK_INIT (int *argc,
1339 char ***argv)
1340{
1341 gtk_init (argc,
1342 argv);
1343}
1344
1345void 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
1356GtkWidget* GTK_ITEM_FACTORY_GET_ITEM (GtkItemFactory *ifactory,
1357 const gchar *path)
1358{
1359 return gtk_item_factory_get_item (ifactory,
1360 path);
1361}
1362
1363GtkWidget* GTK_ITEM_FACTORY_GET_WIDGET (GtkItemFactory *ifactory,
1364 const gchar *path)
1365{
1366 return gtk_item_factory_get_widget (ifactory,
1367 path);
1368}
1369
1370GtkItemFactory* 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
1379void GTK_LABEL_GET (GtkLabel *label,
1380 gchar **str)
1381{
1382 gtk_label_get (label,
1383 str);
1384}
1385
1386GtkType GTK_LABEL_GET_TYPE (void)
1387{
1388 return gtk_label_get_type ();
1389}
1390
1391GtkWidget* GTK_LABEL_NEW (const gchar *str)
1392{
1393 return gtk_label_new (str);
1394}
1395
1396guint GTK_LABEL_PARSE_ULINE (GtkLabel *label,
1397 const gchar *string)
1398{
1399 return gtk_label_parse_uline (label,
1400 string);
1401}
1402
1403void GTK_LABEL_SET_JUSTIFY (GtkLabel *label,
1404 GtkJustification jtype)
1405{
1406 gtk_label_set_justify (label,
1407 jtype);
1408}
1409
1410void GTK_LABEL_SET_LINE_WRAP (GtkLabel *label,
1411 gboolean wrap)
1412{
1413 gtk_label_set_line_wrap (label,
1414 wrap);
1415}
1416
1417void GTK_LABEL_SET_TEXT (GtkLabel *label,
1418 const gchar *str)
1419{
1420 gtk_label_set_text (label,
1421 str);
1422}
1423
1424void GTK_LIST_APPEND_ITEMS (GtkList *list,
1425 GList *items)
1426{
1427 gtk_list_append_items (list,
1428 items);
1429}
1430
1431void 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
1440GtkType GTK_LIST_GET_TYPE (void)
1441{
1442 return gtk_list_get_type ();
1443}
1444
1445void 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
1454GtkWidget* GTK_LIST_ITEM_NEW_WITH_LABEL (const gchar *label)
1455{
1456 return gtk_list_item_new_with_label (label);
1457}
1458
1459GtkWidget* GTK_LIST_NEW (void)
1460{
1461 return gtk_list_new ();
1462}
1463
1464void GTK_LIST_REMOVE_ITEMS (GtkList *list,
1465 GList *items)
1466{
1467 gtk_list_remove_items (list,
1468 items);
1469}
1470
1471void GTK_LIST_SELECT_ITEM (GtkList *list,
1472 gint item)
1473{
1474 gtk_list_select_item (list,
1475 item);
1476}
1477
1478void GTK_LIST_SET_SELECTION_MODE (GtkList *list,
1479 GtkSelectionMode mode)
1480{
1481 gtk_list_set_selection_mode (list,
1482 mode);
1483}
1484
1485void GTK_LIST_UNSELECT_ITEM (GtkList *list,
1486 gint item)
1487{
1488 gtk_list_unselect_item (list,
1489 item);
1490}
1491
1492void GTK_MAIN (void)
1493{
1494 gtk_main ();
1495}
1496
1497gint GTK_MAIN_ITERATION (void)
1498{
1499 return gtk_main_iteration ();
1500}
1501
1502guint GTK_MAIN_LEVEL (void)
1503{
1504 return gtk_main_level ();
1505}
1506
1507void GTK_MAIN_QUIT (void)
1508{
1509 gtk_main_quit ();
1510}
1511
1512GdkEventMask GDK_WINDOW_GET_EVENTS (GdkWindow *window)
1513{
1514 return gdk_window_get_events (window);
1515}
1516
1517void GDK_WINDOW_SET_EVENTS (GdkWindow *window,
1518 GdkEventMask event_mask)
1519{
1520 gdk_window_set_events (window,
1521 event_mask);
1522}
1523
1524guint 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
1533guint VMS_GTK_MAJOR_VERSION( void )
1534{
1535 return gtk_major_version;
1536}
1537
1538guint VMS_GTK_MINOR_VERSION( void )
1539{
1540 return gtk_minor_version;
1541}
1542
1543guint VMS_GTK_MICRO_VERSION( void )
1544{
1545 return gtk_micro_version;
1546}
1547
1548GtkWidget*
1549gtk_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
1565void 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
1574void GTK_MENU_APPEND (GtkMenu *menu,
1575 GtkWidget *child)
1576{
1577 gtk_menu_append (menu,
1578 child);
1579}
1580
1581GtkType GTK_MENU_BAR_GET_TYPE (void)
1582{
1583 return gtk_menu_bar_get_type ();
1584}
1585
1586GtkType GTK_MENU_GET_TYPE (void)
1587{
1588 return gtk_menu_get_type ();
1589}
1590
1591void GTK_MENU_INSERT (GtkMenu *menu,
1592 GtkWidget *child,
1593 gint position)
1594{
1595 gtk_menu_insert (menu,
1596 child,
1597 position);
1598}
1599
1600GtkType GTK_MENU_ITEM_GET_TYPE (void)
1601{
1602 return gtk_menu_item_get_type ();
1603}
1604
1605GtkWidget* GTK_MENU_ITEM_NEW_WITH_LABEL (const gchar *label)
1606{
1607 return gtk_menu_item_new_with_label (label);
1608}
1609
1610void GTK_MENU_ITEM_SET_SUBMENU (GtkMenuItem *menu_item,
1611 GtkWidget *submenu)
1612{
1613 gtk_menu_item_set_submenu (menu_item,
1614 submenu);
1615}
1616
1617GtkWidget* GTK_MENU_NEW (void)
1618{
1619 return gtk_menu_new ();
1620}
1621
1622void 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
1639GtkType GTK_MENU_SHELL_GET_TYPE (void)
1640{
1641 return gtk_menu_shell_get_type ();
1642}
1643
1644GtkType GTK_MISC_GET_TYPE (void)
1645{
1646 return gtk_misc_get_type ();
1647}
1648
1649void 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
1658void GTK_OBJECT_UNREF (GtkObject *object)
1659{
1660 gtk_object_unref (object);
1661}
1662
1663GtkWidget* GTK_OPTION_MENU_GET_MENU (GtkOptionMenu *option_menu)
1664{
1665 return gtk_option_menu_get_menu (option_menu);
1666}
1667
1668GtkType GTK_OPTION_MENU_GET_TYPE (void)
1669{
1670 return gtk_option_menu_get_type ();
1671}
1672
1673GtkWidget* GTK_OPTION_MENU_NEW (void)
1674{
1675 return gtk_option_menu_new ();
1676}
1677
1678void GTK_OPTION_MENU_REMOVE_MENU (GtkOptionMenu *option_menu)
1679{
1680 gtk_option_menu_remove_menu (option_menu);
1681}
1682
1683void GTK_OPTION_MENU_SET_HISTORY (GtkOptionMenu *option_menu,
1684 guint index)
1685{
1686 gtk_option_menu_set_history (option_menu,
1687 index);
1688}
1689
1690void GTK_OPTION_MENU_SET_MENU (GtkOptionMenu *option_menu,
1691 GtkWidget *menu)
1692{
1693 gtk_option_menu_set_menu (option_menu,
1694 menu);
1695}
1696
1697GtkType GTK_PIXMAP_GET_TYPE (void)
1698{
1699 return gtk_pixmap_get_type ();
1700}
1701
1702GtkWidget* GTK_PIXMAP_NEW (GdkPixmap *pixmap,
1703 GdkBitmap *mask)
1704{
1705 return gtk_pixmap_new (pixmap,
1706 mask);
1707}
1708
1709void GTK_PIXMAP_SET (GtkPixmap *pixmap,
1710 GdkPixmap *val,
1711 GdkBitmap *mask)
1712{
1713 gtk_pixmap_set (pixmap,
1714 val,
1715 mask);
1716}
1717
1718void GTK_PIXMAP_SET_BUILD_INSENSITIV (GtkPixmap *pixmap,
1719 guint build)
1720{
1721 gtk_pixmap_set_build_insensitive (pixmap,
1722 build);
1723}
1724
1725GtkType GTK_PROGRESS_BAR_GET_TYPE (void)
1726{
1727 return gtk_progress_bar_get_type ();
1728}
1729
1730GtkWidget* GTK_PROGRESS_BAR_NEW (void)
1731{
1732 return gtk_progress_bar_new ();
1733}
1734
1735void GTK_PROGRESS_BAR_UPDATE (GtkProgressBar *pbar,
1736 gfloat percentage)
1737{
1738 gtk_progress_bar_update (pbar,
1739 percentage);
1740}
1741
1742GtkType GTK_RADIO_BUTTON_GET_TYPE (void)
1743{
1744 return gtk_radio_button_get_type ();
1745}
1746
1747GSList* GTK_RADIO_BUTTON_GROUP (GtkRadioButton *radio_button)
1748{
1749 return gtk_radio_button_group (radio_button);
1750}
1751
1752GtkWidget* 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
1759GtkAdjustment* GTK_RANGE_GET_ADJUSTMENT (GtkRange *range)
1760{
1761 return gtk_range_get_adjustment (range);
1762}
1763
1764GtkType GTK_RANGE_GET_TYPE (void)
1765{
1766 return gtk_range_get_type ();
1767}
1768
1769GtkStyle* GTK_RC_GET_STYLE (GtkWidget *widget)
1770{
1771 return gtk_rc_get_style (widget);
1772}
1773
1774GtkType GTK_SCALE_GET_TYPE (void)
1775{
1776 return gtk_scale_get_type ();
1777}
1778
1779void GTK_SCALE_SET_DIGITS (GtkScale *scale,
1780 gint digits)
1781{
1782 gtk_scale_set_digits (scale,
1783 digits);
1784}
1785
1786void GTK_SCALE_SET_DRAW_VALUE (GtkScale *scale,
1787 gboolean draw_value)
1788{
1789 gtk_scale_set_draw_value (scale,
1790 draw_value);
1791}
1792
1793void 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
1800GtkType GTK_SCROLLED_WINDOW_GET_TYPE (void)
1801{
1802 return gtk_scrolled_window_get_type ();
1803}
1804
1805GtkAdjustment* GTK_SCROLLED_WINDOW_GET_VADJUST (GtkScrolledWindow *scrolled_window)
1806{
1807 return gtk_scrolled_window_get_vadjustment (scrolled_window);
1808}
1809
1810GtkWidget* GTK_SCROLLED_WINDOW_NEW (GtkAdjustment *hadjustment,
1811 GtkAdjustment *vadjustment)
1812{
1813 return gtk_scrolled_window_new (hadjustment,
1814 vadjustment);
1815}
1816
1817void 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
1826gchar* GTK_SET_LOCALE (void)
1827{
1828 return gtk_set_locale ();
1829}
1830
1831guint 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
1842guint 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
1853void 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
1862void 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
1872void 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
1881guint 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
1925GtkStyle* GTK_STYLE_ATTACH (GtkStyle *style,
1926 GdkWindow *window)
1927{
1928 return gtk_style_attach (style,
1929 window);
1930}
1931
1932GtkStyle* GTK_STYLE_COPY (GtkStyle *style)
1933{
1934 return gtk_style_copy (style);
1935}
1936
1937void 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
1946void GTK_STYLE_UNREF (GtkStyle *style)
1947{
1948 gtk_style_unref (style);
1949}
1950
1951void 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
1974GtkType GTK_TABLE_GET_TYPE (void)
1975{
1976 return gtk_table_get_type ();
1977}
1978
1979GtkWidget* GTK_TABLE_NEW (guint rows,
1980 guint columns,
1981 gboolean homogeneous)
1982{
1983 return gtk_table_new (rows,
1984 columns,
1985 homogeneous);
1986}
1987
1988guint GTK_TEXT_GET_LENGTH (GtkText *text)
1989{
1990 return gtk_text_get_length (text);
1991}
1992
1993guint GTK_TEXT_GET_POINT (GtkText *text)
1994{
1995 return gtk_text_get_point (text);
1996}
1997
1998GtkType GTK_TEXT_GET_TYPE (void)
1999{
2000 return gtk_text_get_type ();
2001}
2002
2003void 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
2018GtkWidget* GTK_TEXT_NEW (GtkAdjustment *hadj,
2019 GtkAdjustment *vadj)
2020{
2021 return gtk_text_new (hadj,
2022 vadj);
2023}
2024
2025void GTK_TEXT_SET_EDITABLE (GtkText *text,
2026 gboolean editable)
2027{
2028 gtk_text_set_editable (text,
2029 editable);
2030}
2031
2032void GTK_TEXT_SET_WORD_WRAP (GtkText *text,
2033 gint word_wrap)
2034{
2035 gtk_text_set_word_wrap (text,
2036 word_wrap);
2037}
2038
2039guint GTK_TIMEOUT_ADD (guint32 interval,
2040 GtkFunction function,
2041 gpointer data)
2042{
2043 return gtk_timeout_add (interval,
2044 function,
2045 data);
2046}
2047
2048void GTK_TIMEOUT_REMOVE (guint timeout_handler_id)
2049{
2050 gtk_timeout_remove (timeout_handler_id);
2051}
2052
2053GtkType GTK_TOGGLE_BUTTON_GET_TYPE (void)
2054{
2055 return gtk_toggle_button_get_type ();
2056}
2057
2058void 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
2065void GTK_TOOLBAR_APPEND_SPACE (GtkToolbar *toolbar)
2066{
2067 gtk_toolbar_append_space (toolbar);
2068}
2069
2070GtkType GTK_TOOLBAR_GET_TYPE (void)
2071{
2072 return gtk_toolbar_get_type ();
2073}
2074
2075GtkWidget* 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
2098void 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
2113GtkWidget* GTK_TOOLBAR_NEW (GtkOrientation orientation,
2114 GtkToolbarStyle style)
2115{
2116 return gtk_toolbar_new (orientation,
2117 style);
2118}
2119
2120void GTK_TOOLBAR_SET_BUTTON_RELIEF (GtkToolbar *toolbar,
2121 GtkReliefStyle relief)
2122{
2123 gtk_toolbar_set_button_relief (toolbar,
2124 relief);
2125}
2126
2127void GTK_TOOLBAR_SET_SPACE_SIZE (GtkToolbar *toolbar,
2128 gint space_size)
2129{
2130 gtk_toolbar_set_space_size (toolbar,
2131 space_size);
2132}
2133
2134void GTK_TOOLBAR_SET_TOOLTIPS (GtkToolbar *toolbar,
2135 gint enable)
2136{
2137 gtk_toolbar_set_tooltips (toolbar,
2138 enable);
2139}
2140
2141void GTK_TOOLTIPS_FORCE_WINDOW (GtkTooltips *tooltips)
2142{
2143 gtk_tooltips_force_window (tooltips);
2144}
2145
2146GtkTypeClass* 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
2153GtkTypeObject* 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
2160gpointer GTK_TYPE_CLASS (GtkType type)
2161{
2162 return gtk_type_class (type);
2163}
2164
2165gboolean 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
2172gpointer GTK_TYPE_NEW (GtkType type)
2173{
2174 return gtk_type_new (type);
2175}
2176
2177GtkType GTK_TYPE_UNIQUE (GtkType parent_type,
2178 const GtkTypeInfo *type_info)
2179{
2180 return gtk_type_unique (parent_type,
2181 type_info);
2182}
2183
2184GtkWidget* GTK_VSCALE_NEW (GtkAdjustment *adjustment)
2185{
2186 return gtk_vscale_new (adjustment);
2187}
2188
2189GtkWidget* GTK_VSCROLLBAR_NEW (GtkAdjustment *adjustment)
2190{
2191 return gtk_vscrollbar_new (adjustment);
2192}
2193
2194GtkWidget* GTK_VSEPARATOR_NEW (void)
2195{
2196 return gtk_vseparator_new ();
2197}
2198
2199gboolean GTK_WIDGET_ACTIVATE (GtkWidget *widget)
2200{
2201 return gtk_widget_activate (widget);
2202}
2203
2204void GTK_WIDGET_DESTROY (GtkWidget *widget)
2205{
2206 gtk_widget_destroy (widget);
2207}
2208
2209void GTK_WIDGET_DRAW (GtkWidget *widget,
2210 GdkRectangle *area)
2211{
2212 gtk_widget_draw (widget,
2213 area);
2214}
2215
2216gint GTK_WIDGET_EVENT (GtkWidget *widget,
2217 GdkEvent *event)
2218{
2219 return gtk_widget_event (widget,
2220 event);
2221}
2222
2223void GTK_WIDGET_GET_CHILD_REQUISITIO (GtkWidget *widget,
2224 GtkRequisition *requisition)
2225{
2226 gtk_widget_get_child_requisition (widget,
2227 requisition);
2228}
2229
2230GdkColormap* GTK_WIDGET_GET_COLORMAP (GtkWidget *widget)
2231{
2232 return gtk_widget_get_colormap (widget);
2233}
2234
2235GdkColormap* GTK_WIDGET_GET_DEFAULT_COLORMAP (void)
2236{
2237 return gtk_widget_get_default_colormap ();
2238}
2239
2240GtkStyle* GTK_WIDGET_GET_DEFAULT_STYLE (void)
2241{
2242 return gtk_widget_get_default_style ();
2243}
2244
2245gint GTK_WIDGET_GET_EVENTS (GtkWidget *widget)
2246{
2247 return gtk_widget_get_events (widget);
2248}
2249
2250GdkWindow *GTK_WIDGET_GET_PARENT_WINDOW (GtkWidget *widget)
2251{
2252 return gtk_widget_get_parent_window (widget);
2253}
2254
2255GtkStyle* GTK_WIDGET_GET_STYLE (GtkWidget *widget)
2256{
2257 return gtk_widget_get_style (widget);
2258}
2259
2260GtkType GTK_WIDGET_GET_TYPE (void)
2261{
2262 return gtk_widget_get_type ();
2263}
2264
2265GdkVisual* GTK_WIDGET_GET_VISUAL (GtkWidget *widget)
2266{
2267 return gtk_widget_get_visual (widget);
2268}
2269
2270void GTK_WIDGET_GRAB_DEFAULT (GtkWidget *widget)
2271{
2272 gtk_widget_grab_default (widget);
2273}
2274
2275void GTK_WIDGET_GRAB_FOCUS (GtkWidget *widget)
2276{
2277 gtk_widget_grab_focus (widget);
2278}
2279
2280void GTK_WIDGET_HIDE (GtkWidget *widget)
2281{
2282 gtk_widget_hide (widget);
2283}
2284
2285gint GTK_WIDGET_INTERSECT (GtkWidget *widget,
2286 GdkRectangle *area,
2287 GdkRectangle *intersection)
2288{
2289 return gtk_widget_intersect (widget,
2290 area,
2291 intersection);
2292}
2293
2294void GTK_WIDGET_MAP (GtkWidget *widget)
2295{
2296 gtk_widget_map (widget);
2297}
2298
2299void GTK_WIDGET_QUEUE_DRAW (GtkWidget *widget)
2300{
2301 gtk_widget_queue_draw (widget);
2302}
2303
2304void GTK_WIDGET_QUEUE_RESIZE (GtkWidget *widget)
2305{
2306 gtk_widget_queue_resize (widget);
2307}
2308
2309void GTK_WIDGET_REALIZE (GtkWidget *widget)
2310{
2311 gtk_widget_realize (widget);
2312}
2313
2314void GTK_WIDGET_REF (GtkWidget *widget)
2315{
2316 gtk_widget_ref (widget);
2317}
2318
2319void GTK_WIDGET_REPARENT (GtkWidget *widget,
2320 GtkWidget *new_parent)
2321{
2322 gtk_widget_reparent (widget,
2323 new_parent);
2324}
2325
2326void GTK_WIDGET_SET_DEFAULT_COLORMAP (GdkColormap *colormap)
2327{
2328 gtk_widget_set_default_colormap (colormap);
2329}
2330
2331void GTK_WIDGET_SET_DEFAULT_VISUAL (GdkVisual *visual)
2332{
2333 gtk_widget_set_default_visual (visual);
2334}
2335
2336void GTK_WIDGET_SET_PARENT (GtkWidget *widget,
2337 GtkWidget *parent)
2338{
2339 gtk_widget_set_parent (widget,
2340 parent);
2341}
2342
2343void GTK_WIDGET_SET_PARENT_WINDOW (GtkWidget *widget,
2344 GdkWindow *parent_window)
2345{
2346 gtk_widget_set_parent_window (widget,
2347 parent_window);
2348}
2349
2350void GTK_WIDGET_SET_SENSITIVE (GtkWidget *widget,
2351 gboolean sensitive)
2352{
2353 gtk_widget_set_sensitive (widget,
2354 sensitive);
2355}
2356
2357void GTK_WIDGET_SET_STYLE (GtkWidget *widget,
2358 GtkStyle *style)
2359{
2360 gtk_widget_set_style (widget,
2361 style);
2362}
2363
2364void 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
2373void 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
2382void GTK_WIDGET_SHOW (GtkWidget *widget)
2383{
2384 gtk_widget_show (widget);
2385}
2386
2387void GTK_WIDGET_SIZE_ALLOCATE (GtkWidget *widget,
2388 GtkAllocation *allocation)
2389{
2390 gtk_widget_size_allocate (widget,
2391 allocation);
2392}
2393
2394void GTK_WIDGET_SIZE_REQUEST (GtkWidget *widget,
2395 GtkRequisition *requisition)
2396{
2397 gtk_widget_size_request (widget,
2398 requisition);
2399}
2400
2401void GTK_WIDGET_UNMAP (GtkWidget *widget)
2402{
2403 gtk_widget_unmap (widget);
2404}
2405
2406void GTK_WIDGET_UNPARENT (GtkWidget *widget)
2407{
2408 gtk_widget_unparent (widget);
2409}
2410
2411void GTK_WIDGET_UNREF (GtkWidget *widget)
2412{
2413 gtk_widget_unref (widget);
2414}
2415
2416GtkType GTK_WINDOW_GET_TYPE (void)
2417{
2418 return gtk_window_get_type ();
2419}
2420
2421GtkWidget* GTK_WINDOW_NEW (GtkWindowType type)
2422{
2423 return gtk_window_new (type);
2424}
2425
2426void 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
2437void GTK_WINDOW_SET_TITLE (GtkWindow *window,
2438 const gchar *title)
2439{
2440 gtk_window_set_title (window,
2441 title);
2442}
2443
2444void GTK_WINDOW_SET_TRANSIENT_FOR (GtkWindow *window,
2445 GtkWindow *parent)
2446{
2447 gtk_window_set_transient_for (window,
2448 parent);
2449}
2450
2451void 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
2460void G_FREE (gpointer mem)
2461{
2462 g_free (mem);
2463}
2464
2465GList* G_LIST_ALLOC (void)
2466{
2467 return g_list_alloc ();
2468}
2469
2470GList* G_LIST_APPEND (GList *list,
2471 gpointer data)
2472{
2473 return g_list_append (list,
2474 data);
2475}
2476
2477void G_LIST_FREE (GList *list)
2478{
2479 g_list_free (list);
2480}
2481
2482GList* G_LIST_INSERT (GList *list,
2483 gpointer data,
2484 gint position)
2485{
2486 return g_list_insert (list,
2487 data,
2488 position);
2489}
2490
2491GList* G_LIST_LAST (GList *list)
2492{
2493 return g_list_last (list);
2494}
2495
2496guint G_LIST_LENGTH (GList *list)
2497{
2498 return g_list_length (list);
2499}
2500
2501GList* G_LIST_NTH (GList *list,
2502 guint n)
2503{
2504 return g_list_nth (list,
2505 n);
2506}
2507
2508GList* G_LIST_REMOVE (GList *list,
2509 gpointer data)
2510{
2511 return g_list_remove (list,
2512 data);
2513}
2514
2515GList* G_LIST_REMOVE_LINK (GList *list,
2516 GList *llink)
2517{
2518 return g_list_remove_link (list,
2519 llink);
2520}
2521
2522void 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
2534void 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
2545gpointer G_MALLOC (gulong size)
2546{
2547 return g_malloc (size);
2548}
2549
2550GSList* G_SLIST_FIND (GSList *list,
2551 gpointer data)
2552{
2553 return g_slist_find (list,
2554 data);
2555}
2556
02c6eadb
JJ
2557void 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
27df579a
JJ
2568#undef GDK_THREADS_ENTER
2569void GDK_THREADS_ENTER (void)
2570{
2571 gdk_threads_enter1 ();
2572}
2573
2574#undef GDK_THREADS_LEAVE
2575void GDK_THREADS_LEAVE (void)
2576{
2577 gdk_threads_leave1 ();
2578}