]> git.saurik.com Git - wxWidgets.git/blob - 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
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 }