callisto-debian/gtk3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new functions gtk_selection_data_copy and gtk_selection_data_free.

Browse Source 
Tue Jun  9 01:57:23 1998  Tim Janik  <timj@gtk.org>

        * gtk/gtkselection.h:
        * gtk/gtkselection.c: new functions gtk_selection_data_copy and
        gtk_selection_data_free.

        * gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
        for "selection_received", which was completely bogus.
        * other fixups to gtk_signal_new() calls all over the place.

        * gtk/gtktypebuiltins.h: types as variables (formerly macros).
        * gtk/gtktypebuiltins_vars.c: type variable implementations.
        * gtk/gtktypebuiltins_ids.c: array entries for builtin type
        declarations.
        * gtk/gtktypebuiltins_evals.c: enum value arrays.
        * gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
        gtk.defs.
        * gtk/gtk.defs: generated file with scheme syntax for type definitions
        of gtk and gdk structures and enums.
        * gtk/gtktypeutils.h:
        * gtk/gtktypeutils.c: reworked type ids, so they are variables not
        macros anymore (this fixes binary incompatibility with new enum
        definitions).

        * gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
        key bindings for this widget.
        * gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
        handler.

        * gtk/gtkobject.h:
        * gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
        again. new functions gtk_object_class_user_signal_new () and
        gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
        flag on the signal creation.
Mon Jun  8 20:52:21 1998  Tim Janik  <timj@gtk.org>

        * gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
This commit is contained in:
Tim Janik
1998-06-09 07:11:55 +00:00
committed by Tim Janik
parent 257c54a021
commit a21d063ef8
42 changed files with 1268 additions and 645 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
ChangeLog
View File

@ -1,3 +1,42 @@
Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
* gtk/gtkselection.h:
* gtk/gtkselection.c: new functions gtk_selection_data_copy and
gtk_selection_data_free.
* gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
for "selection_received", which was completely bogus.
* other fixups to gtk_signal_new() calls all over the place.
* gtk/gtktypebuiltins.h: types as variables (formerly macros).
* gtk/gtktypebuiltins_vars.c: type variable implementations.
* gtk/gtktypebuiltins_ids.c: array entries for builtin type
declarations.
* gtk/gtktypebuiltins_evals.c: enum value arrays.
* gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
gtk.defs.
* gtk/gtk.defs: generated file with scheme syntax for type definitions
of gtk and gdk structures and enums.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c: reworked type ids, so they are variables not
macros anymore (this fixes binary incompatibility with new enum
definitions).
* gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
key bindings for this widget.
* gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
handler.
* gtk/gtkobject.h:
* gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
again. new functions gtk_object_class_user_signal_new () and
gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
flag on the signal creation.
Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
* gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:

39
ChangeLog.pre-2-0
View File

@ -1,3 +1,42 @@
Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
* gtk/gtkselection.h:
* gtk/gtkselection.c: new functions gtk_selection_data_copy and
gtk_selection_data_free.
* gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
for "selection_received", which was completely bogus.
* other fixups to gtk_signal_new() calls all over the place.
* gtk/gtktypebuiltins.h: types as variables (formerly macros).
* gtk/gtktypebuiltins_vars.c: type variable implementations.
* gtk/gtktypebuiltins_ids.c: array entries for builtin type
declarations.
* gtk/gtktypebuiltins_evals.c: enum value arrays.
* gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
gtk.defs.
* gtk/gtk.defs: generated file with scheme syntax for type definitions
of gtk and gdk structures and enums.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c: reworked type ids, so they are variables not
macros anymore (this fixes binary incompatibility with new enum
definitions).
* gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
key bindings for this widget.
* gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
handler.
* gtk/gtkobject.h:
* gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
again. new functions gtk_object_class_user_signal_new () and
gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
flag on the signal creation.
Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
* gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:

39
ChangeLog.pre-2-10
View File

@ -1,3 +1,42 @@
Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
* gtk/gtkselection.h:
* gtk/gtkselection.c: new functions gtk_selection_data_copy and
gtk_selection_data_free.
* gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
for "selection_received", which was completely bogus.
* other fixups to gtk_signal_new() calls all over the place.
* gtk/gtktypebuiltins.h: types as variables (formerly macros).
* gtk/gtktypebuiltins_vars.c: type variable implementations.
* gtk/gtktypebuiltins_ids.c: array entries for builtin type
declarations.
* gtk/gtktypebuiltins_evals.c: enum value arrays.
* gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
gtk.defs.
* gtk/gtk.defs: generated file with scheme syntax for type definitions
of gtk and gdk structures and enums.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c: reworked type ids, so they are variables not
macros anymore (this fixes binary incompatibility with new enum
definitions).
* gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
key bindings for this widget.
* gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
handler.
* gtk/gtkobject.h:
* gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
again. new functions gtk_object_class_user_signal_new () and
gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
flag on the signal creation.
Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
* gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:

39
ChangeLog.pre-2-2
View File

@ -1,3 +1,42 @@
Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
* gtk/gtkselection.h:
* gtk/gtkselection.c: new functions gtk_selection_data_copy and
gtk_selection_data_free.
* gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
for "selection_received", which was completely bogus.
* other fixups to gtk_signal_new() calls all over the place.
* gtk/gtktypebuiltins.h: types as variables (formerly macros).
* gtk/gtktypebuiltins_vars.c: type variable implementations.
* gtk/gtktypebuiltins_ids.c: array entries for builtin type
declarations.
* gtk/gtktypebuiltins_evals.c: enum value arrays.
* gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
gtk.defs.
* gtk/gtk.defs: generated file with scheme syntax for type definitions
of gtk and gdk structures and enums.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c: reworked type ids, so they are variables not
macros anymore (this fixes binary incompatibility with new enum
definitions).
* gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
key bindings for this widget.
* gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
handler.
* gtk/gtkobject.h:
* gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
again. new functions gtk_object_class_user_signal_new () and
gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
flag on the signal creation.
Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
* gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:

39
ChangeLog.pre-2-4
View File

@ -1,3 +1,42 @@
Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
* gtk/gtkselection.h:
* gtk/gtkselection.c: new functions gtk_selection_data_copy and
gtk_selection_data_free.
* gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
for "selection_received", which was completely bogus.
* other fixups to gtk_signal_new() calls all over the place.
* gtk/gtktypebuiltins.h: types as variables (formerly macros).
* gtk/gtktypebuiltins_vars.c: type variable implementations.
* gtk/gtktypebuiltins_ids.c: array entries for builtin type
declarations.
* gtk/gtktypebuiltins_evals.c: enum value arrays.
* gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
gtk.defs.
* gtk/gtk.defs: generated file with scheme syntax for type definitions
of gtk and gdk structures and enums.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c: reworked type ids, so they are variables not
macros anymore (this fixes binary incompatibility with new enum
definitions).
* gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
key bindings for this widget.
* gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
handler.
* gtk/gtkobject.h:
* gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
again. new functions gtk_object_class_user_signal_new () and
gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
flag on the signal creation.
Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
* gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:

39
ChangeLog.pre-2-6
View File

@ -1,3 +1,42 @@
Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
* gtk/gtkselection.h:
* gtk/gtkselection.c: new functions gtk_selection_data_copy and
gtk_selection_data_free.
* gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
for "selection_received", which was completely bogus.
* other fixups to gtk_signal_new() calls all over the place.
* gtk/gtktypebuiltins.h: types as variables (formerly macros).
* gtk/gtktypebuiltins_vars.c: type variable implementations.
* gtk/gtktypebuiltins_ids.c: array entries for builtin type
declarations.
* gtk/gtktypebuiltins_evals.c: enum value arrays.
* gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
gtk.defs.
* gtk/gtk.defs: generated file with scheme syntax for type definitions
of gtk and gdk structures and enums.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c: reworked type ids, so they are variables not
macros anymore (this fixes binary incompatibility with new enum
definitions).
* gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
key bindings for this widget.
* gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
handler.
* gtk/gtkobject.h:
* gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
again. new functions gtk_object_class_user_signal_new () and
gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
flag on the signal creation.
Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
* gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:

39
ChangeLog.pre-2-8
View File

@ -1,3 +1,42 @@
Tue Jun 9 01:57:23 1998 Tim Janik <timj@gtk.org>
* gtk/gtkselection.h:
* gtk/gtkselection.c: new functions gtk_selection_data_copy and
gtk_selection_data_free.
* gtk/gtkwidget.c (gtk_widget_class_init): fixed gtk_signal_new() call
for "selection_received", which was completely bogus.
* other fixups to gtk_signal_new() calls all over the place.
* gtk/gtktypebuiltins.h: types as variables (formerly macros).
* gtk/gtktypebuiltins_vars.c: type variable implementations.
* gtk/gtktypebuiltins_ids.c: array entries for builtin type
declarations.
* gtk/gtktypebuiltins_evals.c: enum value arrays.
* gtk/gtk-boxed.defs: gtk and gdk structure definitions, used to build
gtk.defs.
* gtk/gtk.defs: generated file with scheme syntax for type definitions
of gtk and gdk structures and enums.
* gtk/gtktypeutils.h:
* gtk/gtktypeutils.c: reworked type ids, so they are variables not
macros anymore (this fixes binary incompatibility with new enum
definitions).
* gtk/gtkwidget.c (gtk_widget_real_key_press_event): proccess possible
key bindings for this widget.
* gtk/gtkwindow.c (gtk_window_key_press_event): chain parent class'
handler.
* gtk/gtkobject.h:
* gtk/gtkobject.c: removed gtk_object_class_new_user_signal_no_recurse()
again. new functions gtk_object_class_user_signal_new () and
gtk_object_class_user_signal_newv (), to feature the GtkSignalRunType
flag on the signal creation.
Mon Jun 8 20:52:21 1998 Tim Janik <timj@gtk.org>
* gtk/gtkcontainer.h: new signal GtkContainer::set_focus_child.
Mon Jun 8 02:52:37 1998 Tim Janik <timj@gtk.org>
* gdk/gdkprivate.h:

3
gdk/gdktypes.h
View File

@ -445,8 +445,7 @@ typedef enum
G_NV (GDK_BUTTON3_MASK, button3-mask, 1 << 10),
G_NV (GDK_BUTTON4_MASK, button4-mask, 1 << 11),
G_NV (GDK_BUTTON5_MASK, button5-mask, 1 << 12),
G_NV (GDK_AFTER_MASK, after-mask, 1 << 13),
G_NV (GDK_MODIFIER_MASK, modifier-mask, 0x3fff)
G_NV (GDK_MODIFIER_MASK, modifier-mask, 0x1fff)
} G_FLAGS (GdkModifierType);
typedef enum

55
gtk/Makefile.am
View File

@ -203,37 +203,50 @@ gtkinclude_HEADERS = \
gtktypebuiltins.h
auto-files:
make $(srcdir)/gtk.defs
make $(srcdir)/gtktypebuiltins1.c
make $(srcdir)/gtktypebuiltins2.c
rm -f $(srcdir)/gtk.defs
make $(srcdir)/gtktypebuiltins_evals.c
make $(srcdir)/gtktypebuiltins_ids.c
make $(srcdir)/gtktypebuiltins_vars.c
make $(srcdir)/gtktypebuiltins.h
# generate gtk.defs file from gtk-boxed.defs and gcc -E
$(srcdir)/gtk.defs: @MAINT@
$(COMPILE) -E -DG_CODE_GENERATION $(srcdir)/makeenums.h $(CFLAGS) | \
awk -f $(srcdir)/makeenums.awk - defs > $@
cat $(srcdir)/gtk-boxed.defs >> $@
$(srcdir)/gtktypebuiltins1.c: @MAINT@
# generate type identifier header (GTK_TYPE_WIDGET_FLAGS)
$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/maketypes.awk
awk -f $(srcdir)/maketypes.awk gtk.defs macros > $@
# generate type identifier variables (GTK_TYPE_WIDGET_FLAGS)
$(srcdir)/gtktypebuiltins_vars.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/maketypes.awk
awk -f $(srcdir)/maketypes.awk gtk.defs variables > $@
# generate type entries for type-id registration
$(srcdir)/gtktypebuiltins_ids.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/maketypes.awk
awk -f $(srcdir)/maketypes.awk gtk.defs entries > $@
# generate enum value arrays from gcc -E
$(srcdir)/gtktypebuiltins_evals.c: @MAINT@
$(COMPILE) -E -DG_CODE_GENERATION $(srcdir)/makeenums.h $(CFLAGS) | \
awk -f $(srcdir)/makeenums.awk - arrays > $@
$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/gentypeinfo.el
$(SHELL) $(srcdir)/runelisp $(srcdir)/gentypeinfo.el id $< $@
$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/gentypeinfo.el
$(SHELL) $(srcdir)/runelisp $(srcdir)/gentypeinfo.el idmac $< $@
# special remake rules
$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/makeenums.awk
$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/makeenums.h
$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/gtk-boxed.defs
$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/gtk.defs
$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/makeenums.awk
$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/makeenums.h
$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gtk.defs
$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gentypeinfo.el
$(srcdir)/gtktypebuiltins_vars.c: @MAINT@ $(srcdir)/maketypes.awk
$(srcdir)/gtktypebuiltins_vars.c: @MAINT@ $(srcdir)/gtk.defs
$(srcdir)/gtktypebuiltins_ids.c: @MAINT@ $(srcdir)/maketypes.awk
$(srcdir)/gtktypebuiltins_ids.c: @MAINT@ $(srcdir)/gtk.defs
$(srcdir)/gtktypebuiltins_evals.c: @MAINT@ $(srcdir)/makeenums.awk
$(srcdir)/gtktypebuiltins_evals.c: @MAINT@ $(srcdir)/makeenums.h
$(srcdir)/gtktypebuiltins_evals.c: @MAINT@ $(srcdir)/gtk.defs
$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/maketypes.awk
$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gtk.defs
$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gentypeinfo.el
$(srcdir)/makeenums.h: @MAINT@ $(srcdir)/gtk.h
$(srcdir)/makeenums.h: @MAINT@ $(srcdir)/gtkprivate.h
libgtk_1_1_la_LDFLAGS = -version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
@ -244,11 +257,11 @@ EXTRA_DIST = \
testgtkrc2 \
gtkfeatures.h.in \
makeenums.awk \
maketypes.awk \
makeenums.h \
runelisp \
gentypeinfo.el \
gtktypebuiltins1.c \
gtktypebuiltins2.c \
gtktypebuiltins_vars.c \
gtktypebuiltins_ids.c \
gtktypebuiltins_evals.c \
gtk-boxed.defs \
gtk.defs \
test.xpm \

145
gtk/gentypeinfo.el
View File

@ -1,145 +0,0 @@
(require 'cl)
;;; file access
(defun read-file (name)
(let ((buf (generate-new-buffer "infile"))
(res nil))
(save-excursion
(set-buffer buf)
(insert-file-contents name)
(condition-case nil
(while t
(setq res (cons (read buf) res)))
(end-of-file (reverse res))))))
(defun setup-outfile ()
(setq standard-output (generate-new-buffer "outfile")))
(defun write-outfile (name)
(save-excursion
(set-buffer standard-output)
(write-region (point-min) (point-max) name)))
;;; string stunts
(defun char-upper-case-p (ch)
(eql (upcase ch) ch))
(defun char-lower-case-p (ch)
(eql (downcase ch) ch))
(defun canonicalize (str)
(if (symbolp str)
(setq str (symbol-name str)))
(let ((res nil)
(start 0)
(pos 0)
(end (length str))
(prevlower nil))
(while (< pos end)
(let ((ch (elt str pos)))
(cond ((memq ch '(?- ?_))
(setq res (cons (substring str start pos) res)
prevlower nil
pos (1+ pos)
start pos))
((and (char-upper-case-p ch)
prevlower)
(setq res (cons (substring str start pos) res)
start pos
pos (1+ pos)
prevlower nil))
(t
(setq pos (1+ pos)
prevlower (char-lower-case-p ch))))))
(reverse (mapcar 'downcase (cons (substring str start end) res)))))
(defun syllables-to-string (syls del)
(let ((res ""))
(while syls
(setq res (format "%s%s%s" res (car syls)
(if (cdr syls) del ""))
syls (cdr syls)))
res))
(defun macroname (canon)
(syllables-to-string (mapcar 'upcase canon) "_"))
(defun funcname (canon)
(syllables-to-string canon "_"))
(defun typename (canon)
(syllables-to-string (mapcar 'capitalize canon) ""))
(defun scmname (canon)
(syllables-to-string canon "-"))
(defun short-name (canon)
(if (equal (car canon) "gtk") (cdr canon) canon))
;;; Code generation
(defun printf (&rest args)
(princ (apply 'format args)))
(defun interestingp (form)
(and (listp form)
(memq (car form) '(define-enum define-flags define-boxed))))
(defun map-interesting (func defs)
(mapcar #'(lambda (form)
(if (interestingp form)
(funcall func form)))
defs))
(defun emit-idmacs (defs)
(let ((i 0))
(map-interesting
#'(lambda (form)
(let ((name (canonicalize (cadr form))))
(printf "#define GTK_TYPE_%s (gtk_type_builtins[%d])\n"
(macroname (short-name name)) i))
(setq i (1+ i)))
defs)
(printf "#define GTK_TYPE_NUM_BUILTINS %d\n" i)))
(defun emit-ids (defs)
(map-interesting
#'(lambda (form)
(printf " { %S, %s, %s%s },\n"
(symbol-name (cadr form))
(case (car form)
((define-enum) "GTK_TYPE_ENUM")
((define-flags) "GTK_TYPE_FLAGS")
((define-boxed) "GTK_TYPE_BOXED"))
(case (car form)
((define-enum) "enum_values_")
((define-flags) "enum_values_")
((define-boxed) "NULL"))
(case (car form)
((define-enum) (symbol-name (cadr form)))
((define-flags) (symbol-name (cadr form)))
((define-boxed) ""))))
defs))
(if (< (length command-line-args-left) 3)
(error "args: op def-file output-file"))
(setq op (intern (car command-line-args-left)))
(setq defs (read-file (cadr command-line-args-left)))
(setq outfile (caddr command-line-args-left))
(setq command-line-args-left nil)
(setup-outfile)
(printf "/* generated by gentypeinfo from \"gtk.defs\" */\n\n")
(case op
((idmac)
(emit-idmacs defs))
((id)
(emit-ids defs))
(else
(error "supported ops are: idmac id")))
(write-outfile outfile)

3
gtk/gtk-boxed.defs
View File

@ -13,6 +13,9 @@
gtk_accel_group_ref
gtk_accel_group_unref)
(define-boxed GtkSelectionData
)
(define-boxed GtkStyle
gtk_style_ref
gtk_style_unref)

39
gtk/gtk.defs
View File

@ -1,6 +1,8 @@
;; generated by makeenums.awk ; -*- scheme -*-
; enumerations from "gdktypes.h"
(define-enum GdkWindowType
(root GDK_WINDOW_ROOT)
(toplevel GDK_WINDOW_TOPLEVEL)
@ -77,6 +79,8 @@
(round GDK_JOIN_ROUND)
(bevel GDK_JOIN_BEVEL))
; enumerations from "gdktypes.h"
(define-enum GdkFilterReturn
(continue GDK_FILTER_CONTINUE)
(translate GDK_FILTER_TRANSLATE)
@ -171,7 +175,6 @@
(button3-mask GDK_BUTTON3_MASK)
(button4-mask GDK_BUTTON4_MASK)
(button5-mask GDK_BUTTON5_MASK)
(after-mask GDK_AFTER_MASK)
(modifier-mask GDK_MODIFIER_MASK))
(define-enum GdkSubwindowMode
@ -313,6 +316,17 @@
(out GDK_OVERLAP_RECTANGLE_OUT)
(part GDK_OVERLAP_RECTANGLE_PART))
; enumerations from "gdkprivate.h"
(define-flags GdkDebugFlag
(misc GDK_DEBUG_MISC)
(events GDK_DEBUG_EVENTS)
(dnd GDK_DEBUG_DND)
(color-context GDK_DEBUG_COLOR_CONTEXT)
(xim GDK_DEBUG_XIM))
; enumerations from "gtkenums.h"
(define-flags GtkAccelFlags
(visible GTK_ACCEL_VISIBLE)
(signal-visible GTK_ACCEL_SIGNAL_VISIBLE)
@ -440,7 +454,8 @@
(last GTK_RUN_LAST)
(both GTK_RUN_BOTH)
(mask GTK_RUN_MASK)
(no-recurse GTK_RUN_NO_RECURSE))
(no-recurse GTK_RUN_NO_RECURSE)
(action GTK_RUN_ACTION))
(define-enum GtkStateType
(normal GTK_STATE_NORMAL)
@ -488,6 +503,8 @@
(dialog GTK_WINDOW_DIALOG)
(popup GTK_WINDOW_POPUP))
; enumerations from "gtktypeutils.h"
(define-enum GtkFundamentalType
(invalid GTK_TYPE_INVALID)
(none GTK_TYPE_NONE)
@ -511,11 +528,15 @@
(c-callback GTK_TYPE_C_CALLBACK)
(object GTK_TYPE_OBJECT))
; enumerations from "gtkdebug.h"
(define-flags GtkDebugFlag
(objects GTK_DEBUG_OBJECTS)
(misc GTK_DEBUG_MISC)
(signals GTK_DEBUG_SIGNALS))
; enumerations from "gtkobject.h"
(define-flags GtkObjectFlags
(destroyed GTK_DESTROYED)
(floating GTK_FLOATING)
@ -529,6 +550,8 @@
(mask GTK_ARG_MASK)
(readwrite GTK_ARG_READWRITE))
; enumerations from "gtkwidget.h"
(define-flags GtkWidgetFlags
(toplevel GTK_TOPLEVEL)
(no-window GTK_NO_WINDOW)
@ -545,6 +568,8 @@
(rc-style GTK_RC_STYLE)
(basic GTK_BASIC))
; enumerations from "gtkprivate.h"
(define-flags GtkPrivateFlags
(user-style PRIVATE_GTK_USER_STYLE)
(redraw-pending PRIVATE_GTK_REDRAW_PENDING)
@ -554,13 +579,6 @@
(has-shape-mask PRIVATE_GTK_HAS_SHAPE_MASK)
(in-reparent PRIVATE_GTK_IN_REPARENT))
(define-flags GdkDebugFlag
(misc GDK_DEBUG_MISC)
(events GDK_DEBUG_EVENTS)
(dnd GDK_DEBUG_DND)
(color-context GDK_DEBUG_COLOR_CONTEXT)
(xim GDK_DEBUG_XIM))
;; -*- scheme -*-
@ -576,6 +594,9 @@
gtk_accel_group_ref
gtk_accel_group_unref)
(define-boxed GtkSelectionData
)
(define-boxed GtkStyle
gtk_style_ref
gtk_style_unref)

74
gtk/gtkaccelgroup.c
View File

@ -32,13 +32,13 @@ typedef void (*GtkSignalAddAccelerator) (GtkObject *object,
guint accel_signal_id,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
GtkAccelFlags accel_flags,
gpointer func_data);
typedef void (*GtkSignalRemoveAccelerator) (GtkObject *object,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
gpointer func_data);
/* --- variables --- */
@ -233,7 +233,7 @@ gtk_accel_group_unlock (GtkAccelGroup *accel_group)
static GtkAccelEntry*
gtk_accel_group_lookup (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods)
GdkModifierType accel_mods)
{
GtkAccelEntry key_entry = { 0 };
@ -247,7 +247,7 @@ gtk_accel_group_lookup (GtkAccelGroup *accel_group,
gboolean
gtk_accel_group_activate (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods)
GdkModifierType accel_mods)
{
GtkAccelEntry *entry;
@ -265,7 +265,7 @@ gtk_accel_group_activate (GtkAccelGroup *accel_group,
gboolean
gtk_accel_groups_activate (GtkObject *object,
guint accel_key,
guint accel_mods)
GdkModifierType accel_mods)
{
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (GTK_IS_OBJECT (object), FALSE);
@ -286,7 +286,7 @@ gtk_accel_groups_activate (GtkObject *object,
void
gtk_accel_group_lock_entry (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods)
GdkModifierType accel_mods)
{
GtkAccelEntry *entry;
@ -300,7 +300,7 @@ gtk_accel_group_lock_entry (GtkAccelGroup *accel_group,
void
gtk_accel_group_unlock_entry (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods)
GdkModifierType accel_mods)
{
GtkAccelEntry *entry;
@ -314,7 +314,7 @@ gtk_accel_group_unlock_entry (GtkAccelGroup *accel_group,
GtkAccelEntry*
gtk_accel_group_get_entry (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods)
GdkModifierType accel_mods)
{
g_return_val_if_fail (accel_group != NULL, 0);
@ -324,7 +324,7 @@ gtk_accel_group_get_entry (GtkAccelGroup *accel_group,
void
gtk_accel_group_add (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
GtkAccelFlags accel_flags,
GtkObject *object,
const gchar *accel_signal)
@ -497,7 +497,7 @@ gtk_accel_group_handle_add (GtkObject *object,
guint accel_signal_id,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
GtkAccelFlags accel_flags)
{
GtkAccelEntry *entry;
@ -541,7 +541,7 @@ gtk_accel_group_handle_add (GtkObject *object,
void
gtk_accel_group_remove (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
GtkObject *object)
{
GtkAccelEntry *entry;
@ -599,7 +599,7 @@ void
gtk_accel_group_handle_remove (GtkObject *object,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods)
GdkModifierType accel_mods)
{
GtkAccelEntry *entry;
@ -640,40 +640,40 @@ gtk_accel_group_handle_remove (GtkObject *object,
guint
gtk_accel_group_create_add (GtkType class_type,
GtkSignalRunType run_type,
GtkSignalRunType signal_flags,
guint handler_offset)
{
g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_OBJECT), 0);
return gtk_signal_new ("add-accelerator",
run_type,
signal_flags,
class_type,
handler_offset,
gtk_accel_group_marshal_add,
GTK_TYPE_NONE, 5,
GTK_TYPE_UINT,
GTK_TYPE_BOXED,
GTK_TYPE_ACCEL_GROUP,
GTK_TYPE_UINT,
GTK_TYPE_UINT,
GTK_TYPE_ENUM);
GTK_TYPE_GDK_MODIFIER_TYPE,
GTK_TYPE_ACCEL_FLAGS);
}
guint
gtk_accel_group_create_remove (GtkType class_type,
GtkSignalRunType run_type,
GtkSignalRunType signal_flags,
guint handler_offset)
{
g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_OBJECT), 0);
return gtk_signal_new ("remove-accelerator",
run_type,
signal_flags,
class_type,
handler_offset,
gtk_accel_group_marshal_remove,
GTK_TYPE_NONE, 3,
GTK_TYPE_BOXED,
GTK_TYPE_ACCEL_GROUP,
GTK_TYPE_UINT,
GTK_TYPE_UINT);
GTK_TYPE_GDK_MODIFIER_TYPE);
}
void
@ -830,18 +830,6 @@ is_shift (const gchar *string)
(string[6] == '>'));
}
static inline gboolean
is_after (const gchar *string)
{
return ((string[0] == '<') &&
(string[1] == 'a' || string[1] == 'A') &&
(string[2] == 'f' || string[2] == 'F') &&
(string[3] == 't' || string[3] == 'T') &&
(string[4] == 'e' || string[4] == 'E') &&
(string[5] == 'r' || string[5] == 'R') &&
(string[6] == '>'));
}
static inline gboolean
is_control (const gchar *string)
{
@ -859,10 +847,10 @@ is_control (const gchar *string)
void
gtk_accelerator_parse (const gchar *accelerator,
guint *accelerator_key,
guint *accelerator_mods)
GdkModifierType*accelerator_mods)
{
guint keyval;
guint mods;
GdkModifierType mods;
gint len;
if (accelerator_key)
@ -890,12 +878,6 @@ gtk_accelerator_parse (const gchar *accelerator,
len -= 7;
mods |= GDK_SHIFT_MASK;
}
else if (len >= 7 && is_after (accelerator))
{
accelerator += 7;
len -= 7;
mods |= GDK_AFTER_MASK;
}
else if (len >= 6 && is_shft (accelerator))
{
accelerator += 6;
@ -961,7 +943,7 @@ gtk_accelerator_parse (const gchar *accelerator,
gchar*
gtk_accelerator_name (guint accelerator_key,
guint accelerator_mods)
GdkModifierType accelerator_mods)
{
static const gchar text_shift[] = "<Shift>";
static const gchar text_control[] = "<Control>";
@ -970,7 +952,6 @@ gtk_accelerator_name (guint accelerator_key,
static const gchar text_mod3[] = "<Mod3>";
static const gchar text_mod4[] = "<Mod4>";
static const gchar text_mod5[] = "<Mod5>";
static const gchar text_after[] = "<After>";
guint l;
gchar *keyval_name;
gchar *accelerator;
@ -996,8 +977,6 @@ gtk_accelerator_name (guint accelerator_key,
l += sizeof (text_mod4) - 1;
if (accelerator_mods & GDK_MOD5_MASK)
l += sizeof (text_mod5) - 1;
if (accelerator_mods & GDK_AFTER_MASK)
l += sizeof (text_after) - 1;
l += strlen (keyval_name);
accelerator = g_new (gchar, l + 1);
@ -1039,11 +1018,6 @@ gtk_accelerator_name (guint accelerator_key,
strcpy (accelerator + l, text_mod5);
l += sizeof (text_mod5) - 1;
}
if (accelerator_mods & GDK_AFTER_MASK)
{
strcpy (accelerator + l, text_after);
l += sizeof (text_after) - 1;
}
strcpy (accelerator + l, keyval_name);
return accelerator;

50
gtk/gtkaccelgroup.h
View File

@ -48,10 +48,10 @@ typedef struct _GtkAccelEntry GtkAccelEntry;
struct _GtkAccelGroup
{
guint ref_count;
guint lock_count;
guint modifier_mask;
GSList *attach_objects;
guint ref_count;
guint lock_count;
GdkModifierType modifier_mask;
GSList *attach_objects;
};
struct _GtkAccelEntry
@ -60,7 +60,7 @@ struct _GtkAccelEntry
*/
GtkAccelGroup *accel_group;
guint accelerator_key;
guint accelerator_mods;
GdkModifierType accelerator_mods;
GtkAccelFlags accel_flags;
GtkObject *object;
@ -76,10 +76,10 @@ GtkAccelGroup* gtk_accel_group_ref (GtkAccelGroup *accel_group);
void gtk_accel_group_unref (GtkAccelGroup *accel_group);
gboolean gtk_accel_group_activate (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods);
GdkModifierType accel_mods);
gboolean gtk_accel_groups_activate (GtkObject *object,
guint accel_key,
guint accel_mods);
GdkModifierType accel_mods);
void gtk_accel_group_attach (GtkAccelGroup *accel_group,
GtkObject *object);
void gtk_accel_group_detach (GtkAccelGroup *accel_group,
@ -91,22 +91,22 @@ void gtk_accel_group_unlock (GtkAccelGroup *accel_group);
*/
GtkAccelEntry* gtk_accel_group_get_entry (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods);
GdkModifierType accel_mods);
void gtk_accel_group_lock_entry (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods);
GdkModifierType accel_mods);
void gtk_accel_group_unlock_entry (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods);
GdkModifierType accel_mods);
void gtk_accel_group_add (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
GtkAccelFlags accel_flags,
GtkObject *object,
const gchar *accel_signal);
void gtk_accel_group_remove (GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
GtkObject *object);
/* Accelerator Signals
@ -115,17 +115,17 @@ void gtk_accel_group_handle_add (GtkObject *object,
guint accel_signal_id,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
GtkAccelFlags accel_flags);
void gtk_accel_group_handle_remove (GtkObject *object,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods);
GdkModifierType accel_mods);
guint gtk_accel_group_create_add (GtkType class_type,
GtkSignalRunType run_type,
GtkSignalRunType signal_flags,
guint handler_offset);
guint gtk_accel_group_create_remove (GtkType class_type,
GtkSignalRunType run_type,
GtkSignalRunType signal_flags,
guint handler_offset);
void gtk_accel_group_marshal_add (GtkObject *object,
GtkSignalFunc func,
@ -144,15 +144,15 @@ GSList* gtk_accel_group_entries_from_object (GtkObject *object);
/* Accelerators
*/
gboolean gtk_accelerator_valid (guint keyval,
guint modifiers);
void gtk_accelerator_parse (const gchar *accelerator,
guint *accelerator_key,
guint *accelerator_mods);
gchar* gtk_accelerator_name (guint accelerator_key,
guint accelerator_mods);
void gtk_accelerator_set_default_mod_mask (guint default_mod_mask);
guint gtk_accelerator_get_default_mod_mask (void);
gboolean gtk_accelerator_valid (guint keyval,
GdkModifierType modifiers);
void gtk_accelerator_parse (const gchar *accelerator,
guint *accelerator_key,
GdkModifierType *accelerator_mods);
gchar* gtk_accelerator_name (guint accelerator_key,
GdkModifierType accelerator_mods);
void gtk_accelerator_set_default_mod_mask (GdkModifierType default_mod_mask);
guint gtk_accelerator_get_default_mod_mask (void);

23
gtk/gtkbindings.c
View File

@ -28,7 +28,7 @@
/* --- defines --- */
#define BINDING_MOD_MASK() (gtk_accelerator_get_default_mod_mask () | GDK_AFTER_MASK)
#define BINDING_MOD_MASK() (gtk_accelerator_get_default_mod_mask ())
/* --- variables --- */
@ -337,12 +337,11 @@ gtk_binding_entry_activate (GtkBindingEntry *entry,
GtkSignalQuery *query;
guint signal_id;
GtkArg *params = NULL;
gchar *accelerator = NULL;
signal_id = gtk_signal_lookup (sig->signal_name, GTK_OBJECT_TYPE (object));
if (!signal_id)
{
gchar *accelerator;
accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
"could not find signal \"%s\" in the `%s' class ancestry",
@ -359,8 +358,6 @@ gtk_binding_entry_activate (GtkBindingEntry *entry,
query->return_val != GTK_TYPE_NONE ||
!binding_compose_params (sig->args, query, &params))
{
gchar *accelerator;
accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
"signature mismatch for signal \"%s\" in the `%s' class ancestry",
@ -368,11 +365,21 @@ gtk_binding_entry_activate (GtkBindingEntry *entry,
accelerator,
sig->signal_name,
gtk_type_name (GTK_OBJECT_TYPE (object)));
g_free (accelerator);
g_free (query);
continue;
}
else if (!(query->signal_flags & GTK_RUN_ACTION))
{
accelerator = gtk_accelerator_name (entry->keyval, entry->modifiers);
g_warning ("gtk_binding_entry_activate(): binding \"%s::%s\": "
"signal \"%s\" in the `%s' class ancestry cannot be used for action emissions",
entry->binding_set->set_name,
accelerator,
sig->signal_name,
gtk_type_name (GTK_OBJECT_TYPE (object)));
}
g_free (accelerator);
g_free (query);
if (accelerator)
continue;
gtk_signal_emitv (object, signal_id, params);
g_free (params);

62
gtk/gtkcontainer.c
View File

@ -28,6 +28,7 @@ enum {
NEED_RESIZE,
FOREACH,
FOCUS,
SET_FOCUS_CHILD,
LAST_SIGNAL
};
enum {
@ -84,9 +85,11 @@ static void gtk_container_add_unimplemented (GtkContainer *container,
GtkWidget *widget);
static void gtk_container_remove_unimplemented (GtkContainer *container,
GtkWidget *widget);
static gint gtk_real_container_need_resize (GtkContainer *container);
static gint gtk_real_container_focus (GtkContainer *container,
static gint gtk_container_real_need_resize (GtkContainer *container);
static gint gtk_container_real_focus (GtkContainer *container,
GtkDirectionType direction);
static void gtk_container_real_set_focus_child (GtkContainer *container,
GtkWidget *widget);
static gint gtk_container_focus_tab (GtkContainer *container,
GList *children,
GtkDirectionType direction);
@ -197,7 +200,14 @@ gtk_container_class_init (GtkContainerClass *class)
gtk_container_marshal_signal_3,
GTK_TYPE_DIRECTION_TYPE, 1,
GTK_TYPE_DIRECTION_TYPE);
container_signals[SET_FOCUS_CHILD] =
gtk_signal_new ("set-focus-child",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GtkContainerClass, set_focus_child),
gtk_container_marshal_signal_1,
GTK_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
gtk_object_class_add_signals (object_class, container_signals, LAST_SIGNAL);
object_class->destroy = gtk_container_destroy;
@ -211,9 +221,10 @@ gtk_container_class_init (GtkContainerClass *class)
class->add = gtk_container_add_unimplemented;
class->remove = gtk_container_remove_unimplemented;
class->need_resize = gtk_real_container_need_resize;
class->need_resize = gtk_container_real_need_resize;
class->foreach = NULL;
class->focus = gtk_real_container_focus;
class->focus = gtk_container_real_focus;
class->set_focus_child = gtk_container_real_set_focus_child;
}
static void
@ -430,6 +441,10 @@ gtk_container_foreach (GtkContainer *container,
GtkCallback callback,
gpointer callback_data)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (callback != NULL);
gtk_signal_emit (GTK_OBJECT (container),
container_signals[FOREACH],
callback, callback_data);
@ -479,6 +494,9 @@ gtk_container_foreach_full (GtkContainer *container,
gpointer callback_data,
GtkDestroyNotify notify)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
if (marshal)
{
GtkForeachData fdata;
@ -490,9 +508,14 @@ gtk_container_foreach_full (GtkContainer *container,
gtk_container_foreach (container, gtk_container_foreach_unmarshal, &fdata);
}
else
gtk_container_foreach (container, callback, &callback_data);
notify (callback_data);
{
g_return_if_fail (callback != NULL);
gtk_container_foreach (container, callback, &callback_data);
}
if (notify)
notify (callback_data);
}
gint
@ -500,6 +523,9 @@ gtk_container_focus (GtkContainer *container,
GtkDirectionType direction)
{
gint return_val;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
gtk_signal_emit (GTK_OBJECT (container),
container_signals[FOCUS],
@ -508,6 +534,18 @@ gtk_container_focus (GtkContainer *container,
return return_val;
}
void
gtk_container_set_focus_child (GtkContainer *container,
GtkWidget *widget)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
if (widget)
g_return_if_fail (GTK_IS_WIDGET (container));
gtk_signal_emit (GTK_OBJECT (container), container_signals[SET_FOCUS_CHILD], widget);
}
GList*
gtk_container_children (GtkContainer *container)
{
@ -536,8 +574,8 @@ gtk_container_unregister_toplevel (GtkContainer *container)
}
void
gtk_container_set_focus_child (GtkContainer *container,
GtkWidget *child)
gtk_container_real_set_focus_child (GtkContainer *container,
GtkWidget *child)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
@ -636,7 +674,7 @@ gtk_container_marshal_signal_4 (GtkObject *object,
}
static gint
gtk_real_container_need_resize (GtkContainer *container)
gtk_container_real_need_resize (GtkContainer *container)
{
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
@ -648,7 +686,7 @@ gtk_real_container_need_resize (GtkContainer *container)
}
static gint
gtk_real_container_focus (GtkContainer *container,
gtk_container_real_focus (GtkContainer *container,
GtkDirectionType direction)
{
GList *children;

23
gtk/gtkcontainer.h
View File

@ -63,16 +63,18 @@ struct _GtkContainerClass
{
GtkWidgetClass parent_class;
void (* add) (GtkContainer *container,
GtkWidget *widget);
void (* remove) (GtkContainer *container,
GtkWidget *widget);
gint (* need_resize) (GtkContainer *container);
void (* foreach) (GtkContainer *container,
GtkCallback callback,
gpointer callbabck_data);
gint (* focus) (GtkContainer *container,
GtkDirectionType direction);
void (* add) (GtkContainer *container,
GtkWidget *widget);
void (* remove) (GtkContainer *container,
GtkWidget *widget);
gint (* need_resize) (GtkContainer *container);
void (* foreach) (GtkContainer *container,
GtkCallback callback,
gpointer callbabck_data);
gint (* focus) (GtkContainer *container,
GtkDirectionType direction);
void (* set_focus_child) (GtkContainer *container,
GtkWidget *widget);
};
@ -112,6 +114,7 @@ void gtk_container_set_focus_vadjustment (GtkContainer *container,
GtkAdjustment *adjustment);
void gtk_container_set_focus_hadjustment (GtkContainer *container,
GtkAdjustment *adjustment);

3
gtk/gtkenums.h
View File

@ -228,7 +228,8 @@ typedef enum
G_NV (GTK_RUN_LAST, last, 0x2),
G_NV (GTK_RUN_BOTH, both, 0x3),
G_NV (GTK_RUN_MASK, mask, 0xF),
G_NV (GTK_RUN_NO_RECURSE, no-recurse, 0x10)
G_NV (GTK_RUN_NO_RECURSE, no-recurse, 0x10),
G_NV (GTK_RUN_ACTION, action, 0x20)
} G_FLAGS (GtkSignalRunType);
/* Widget states */

2
gtk/gtkframe.c
View File

@ -92,7 +92,7 @@ gtk_frame_class_init (GtkFrameClass *class)
gtk_object_add_arg_type ("GtkFrame::label", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL);
gtk_object_add_arg_type ("GtkFrame::label_xalign", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_LABEL_XALIGN);
gtk_object_add_arg_type ("GtkFrame::label_yalign", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_LABEL_YALIGN);
gtk_object_add_arg_type ("GtkFrame::shadow", GTK_TYPE_ENUM, GTK_ARG_READWRITE, ARG_SHADOW);
gtk_object_add_arg_type ("GtkFrame::shadow", GTK_TYPE_SHADOW_TYPE, GTK_ARG_READWRITE, ARG_SHADOW);
object_class->finalize = gtk_frame_finalize;

2
gtk/gtklabel.c
View File

@ -86,7 +86,7 @@ gtk_label_class_init (GtkLabelClass *class)
parent_class = gtk_type_class (gtk_misc_get_type ());
gtk_object_add_arg_type ("GtkLabel::label", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL);
gtk_object_add_arg_type ("GtkLabel::justify", GTK_TYPE_ENUM, GTK_ARG_READWRITE, ARG_JUSTIFY);
gtk_object_add_arg_type ("GtkLabel::justify", GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFY);
object_class->finalize = gtk_label_finalize;

46
gtk/gtkobject.c
View File

@ -412,12 +412,13 @@ gtk_object_class_add_user_signal (GtkObjectClass *class,
}
guint
gtk_object_class_add_user_signal_no_recurse (GtkObjectClass *class,
const gchar *name,
GtkSignalMarshaller marshaller,
GtkType return_val,
guint nparams,
...)
gtk_object_class_user_signal_new (GtkObjectClass *class,
const gchar *name,
GtkSignalRunType signal_flags,
GtkSignalMarshaller marshaller,
GtkType return_val,
guint nparams,
...)
{
GtkType *params;
guint i;
@ -441,7 +442,7 @@ gtk_object_class_add_user_signal_no_recurse (GtkObjectClass *class,
params = NULL;
signal_id = gtk_signal_newv (name,
GTK_RUN_NO_RECURSE,
signal_flags,
class->type,
0,
marshaller,
@ -457,6 +458,37 @@ gtk_object_class_add_user_signal_no_recurse (GtkObjectClass *class,
return signal_id;
}
guint
gtk_object_class_user_signal_newv (GtkObjectClass *class,
const gchar *name,
GtkSignalRunType signal_flags,
GtkSignalMarshaller marshaller,
GtkType return_val,
guint nparams,
GtkType *params)
{
guint signal_id;
g_return_val_if_fail (class != NULL, 0);
if (nparams > 0)
g_return_val_if_fail (params != NULL, 0);
signal_id = gtk_signal_newv (name,
signal_flags,
class->type,
0,
marshaller,
return_val,
nparams,
params);
if (signal_id)
gtk_object_class_add_signals (class, &signal_id, 1);
return signal_id;
}
/*****************************************
* gtk_object_sink:
*

31
gtk/gtkobject.h
View File

@ -228,18 +228,27 @@ void gtk_object_class_add_signals (GtkObjectClass *klass,
/* Append a user defined signal without default handler to a class.
*/
guint gtk_object_class_add_user_signal (GtkObjectClass *klass,
const gchar *name,
GtkSignalMarshaller marshaller,
GtkType return_val,
guint nparams,
guint gtk_object_class_user_signal_new (GtkObjectClass *klass,
const gchar *name,
GtkSignalRunType signal_flags,
GtkSignalMarshaller marshaller,
GtkType return_val,
guint nparams,
...);
guint gtk_object_class_user_signal_newv (GtkObjectClass *klass,
const gchar *name,
GtkSignalRunType signal_flags,
GtkSignalMarshaller marshaller,
GtkType return_val,
guint nparams,
GtkType *params);
/* Outdated */
guint gtk_object_class_add_user_signal (GtkObjectClass *klass,
const gchar *name,
GtkSignalMarshaller marshaller,
GtkType return_val,
guint nparams,
...);
guint gtk_object_class_add_user_signal_no_recurse (GtkObjectClass *klass,
const gchar *name,
GtkSignalMarshaller marshaller,
GtkType return_val,
guint nparams,
...);
GtkObject* gtk_object_new (GtkType type,
...);

22
gtk/gtkselection.c
View File

@ -1412,3 +1412,25 @@ gtk_selection_default_handler (GtkWidget *widget,
data->length = -1;
}
}
GtkSelectioData*
gtk_selection_data_copy (GtkSelectionData *data)
{
GtkSelectionData *new_data;
g_return_val_if_fail (data != NULL, NULL);
new_data = g_new (GtkSelectionData, 1);
*new_data = *data;
return new_data;
}
void
gtk_selection_data_free (GtkSelectionData *data)
{
g_return_if_fail (data != NULL);
g_free (data);
}

3
gtk/gtkselection.h
View File

@ -26,6 +26,7 @@
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus */
typedef struct _GtkSelectionData GtkSelectioData;
@ -87,6 +88,8 @@ gint gtk_selection_notify (GtkWidget *widget,
GdkEventSelection *event);
gint gtk_selection_property_notify (GtkWidget *widget,
GdkEventProperty *event);
GtkSelectioData *gtk_selection_data_copy (GtkSelectionData *data);
void gtk_selection_data_free (GtkSelectionData *data);

32
gtk/gtksignal.c
View File

@ -55,7 +55,7 @@ struct _GtkSignal
GtkType object_type;
gchar *name;
guint function_offset;
GtkSignalRunType run_type;
GtkSignalRunType signal_flags;
GtkSignalMarshaller marshaller;
GtkType return_val;
GtkType *params;
@ -92,7 +92,7 @@ struct _GtkHandlerInfo
GtkArg *params;
GtkType *param_types;
GtkType return_val;
GtkSignalRunType run_type;
GtkSignalRunType signal_flags;
guint nparams;
guint signal_id;
};
@ -260,7 +260,7 @@ gtk_signal_init (void)
guint
gtk_signal_newv (const gchar *r_name,
GtkSignalRunType run_type,
GtkSignalRunType signal_flags,
GtkType object_type,
guint function_offset,
GtkSignalMarshaller marshaller,
@ -298,7 +298,7 @@ gtk_signal_newv (const gchar *r_name,
}
if (return_val != GTK_TYPE_NONE &&
(run_type & GTK_RUN_BOTH) == GTK_RUN_FIRST)
(signal_flags & GTK_RUN_BOTH) == GTK_RUN_FIRST)
{
g_warning ("gtk_signal_newv(): signal \"%s\" with return value `%s' excludes GTK_RUN_LAST",
name, gtk_type_name (return_val));
@ -312,7 +312,7 @@ gtk_signal_newv (const gchar *r_name,
signal->object_type = object_type;
signal->name = name;
signal->function_offset = function_offset;
signal->run_type = run_type;
signal->signal_flags = signal_flags;
signal->marshaller = marshaller;
signal->return_val = return_val;
signal->nparams = nparams;
@ -353,7 +353,7 @@ gtk_signal_newv (const gchar *r_name,
guint
gtk_signal_new (const gchar *name,
GtkSignalRunType run_type,
GtkSignalRunType signal_flags,
GtkType object_type,
guint function_offset,
GtkSignalMarshaller marshaller,
@ -383,7 +383,7 @@ gtk_signal_new (const gchar *name,
params = NULL;
signal_id = gtk_signal_newv (name,
run_type,
signal_flags,
object_type,
function_offset,
marshaller,
@ -442,7 +442,7 @@ gtk_signal_query (guint signal_id)
query->signal_id = signal_id;
query->signal_name = signal->name;
query->is_user_signal = signal->function_offset == 0;
query->run_type = signal->run_type;
query->signal_flags = signal->signal_flags;
query->return_val = signal->return_val;
query->nparams = signal->nparams;
query->params = signal->params;
@ -1365,7 +1365,7 @@ gtk_signal_real_emit (GtkObject *object,
object);
#endif /* G_ENABLE_DEBUG */
if ((signal->run_type & GTK_RUN_NO_RECURSE) &&
if ((signal->signal_flags & GTK_RUN_NO_RECURSE) &&
gtk_emission_check (current_emissions, object, signal_id))
{
gtk_emission_add (&restart_emissions, object, signal_id);
@ -1377,7 +1377,7 @@ gtk_signal_real_emit (GtkObject *object,
gtk_emission_add (&current_emissions, object, signal_id);
emission_restart:
if (GTK_RUN_TYPE (signal->run_type) != GTK_RUN_LAST && signal->function_offset != 0)
if (GTK_RUN_TYPE (signal->signal_flags) != GTK_RUN_LAST && signal->function_offset != 0)
{
signal_func_offset = (guchar**) ((guchar*) object->klass +
signal->function_offset);
@ -1397,7 +1397,7 @@ gtk_signal_real_emit (GtkObject *object,
info.param_types = signal->params;
info.return_val = signal->return_val;
info.nparams = signal->nparams;
info.run_type = signal->run_type;
info.signal_flags = signal->signal_flags;
info.signal_id = signal_id;
switch (gtk_handlers_run (handlers, &info, FALSE))
@ -1416,7 +1416,7 @@ gtk_signal_real_emit (GtkObject *object,
else
info.object = NULL;
if (GTK_RUN_TYPE (signal->run_type) != GTK_RUN_FIRST && signal->function_offset != 0)
if (GTK_RUN_TYPE (signal->signal_flags) != GTK_RUN_FIRST && signal->function_offset != 0)
{
signal_func_offset = (guchar**) ((guchar*) object->klass +
signal->function_offset);
@ -1438,7 +1438,7 @@ gtk_signal_real_emit (GtkObject *object,
info.param_types = signal->params;
info.return_val = signal->return_val;
info.nparams = signal->nparams;
info.run_type = signal->run_type;
info.signal_flags = signal->signal_flags;
info.signal_id = signal_id;
}
switch (gtk_handlers_run (handlers, &info, TRUE))
@ -1457,7 +1457,7 @@ gtk_signal_real_emit (GtkObject *object,
gtk_emission_remove (&current_emissions, object, signal_id);
if (signal->run_type & GTK_RUN_NO_RECURSE)
if (signal->signal_flags & GTK_RUN_NO_RECURSE)
gtk_emission_remove (&restart_emissions, object, signal_id);
gtk_object_unref (object);
@ -1731,13 +1731,13 @@ gtk_handlers_run (GtkHandler *handlers,
gtk_emission_remove (&stop_emissions, info->object,
info->signal_id);
if (info->run_type & GTK_RUN_NO_RECURSE)
if (info->signal_flags & GTK_RUN_NO_RECURSE)
gtk_emission_remove (&restart_emissions, info->object,
info->signal_id);
gtk_signal_handler_unref (handlers, info->object);
return EMISSION_DONE;
}
else if ((info->run_type & GTK_RUN_NO_RECURSE) &&
else if ((info->signal_flags & GTK_RUN_NO_RECURSE) &&
gtk_emission_check (restart_emissions, info->object,
info->signal_id))
{

6
gtk/gtksignal.h
View File

@ -54,7 +54,7 @@ struct _GtkSignalQuery
guint signal_id;
const gchar *signal_name;
guint is_user_signal : 1;
GtkSignalRunType run_type;
GtkSignalRunType signal_flags;
GtkType return_val;
guint nparams;
const GtkType *params;
@ -62,7 +62,7 @@ struct _GtkSignalQuery
void gtk_signal_init (void);
guint gtk_signal_new (const gchar *name,
GtkSignalRunType run_type,
GtkSignalRunType signal_flags,
GtkType object_type,
guint function_offset,
GtkSignalMarshaller marshaller,
@ -70,7 +70,7 @@ guint gtk_signal_new (const gchar *name,
guint nparams,
...);
guint gtk_signal_newv (const gchar *name,
GtkSignalRunType run_type,
GtkSignalRunType signal_flags,
GtkType object_type,
guint function_offset,
GtkSignalMarshaller marshaller,

2
gtk/gtktipsquery.c
View File

@ -192,7 +192,7 @@ gtk_tips_query_class_init (GtkTipsQueryClass *class)
GTK_TYPE_WIDGET,
GTK_TYPE_STRING,
GTK_TYPE_STRING,
GTK_TYPE_BOXED);
GTK_TYPE_GDK_EVENT);
gtk_object_class_add_signals (object_class, tips_query_signals, SIGNAL_LAST);
object_class->destroy = gtk_tips_query_destroy;

8
gtk/gtktipsquery.h
View File

@ -33,9 +33,11 @@ extern "C" {
/* --- type macros --- */
#define GTK_TIPS_QUERY(obj) (GTK_CHECK_CAST (obj, gtk_tips_query_get_type (), GtkTipsQuery))
#define GTK_TIPS_QUERY_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, gtk_tips_query_get_type (), GtkTipsQueryClass))
#define GTK_IS_TIPS_QUERY(obj) (GTK_CHECK_TYPE (obj, gtk_tips_query_get_type ()))
#define GTK_TYPE_TIPS_QUERY (gtk_tips_query_get_type ())
#define GTK_TIPS_QUERY(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_TIPS_QUERY, GtkTipsQuery))
#define GTK_TIPS_QUERY_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_TIPS_QUERY, GtkTipsQueryClass))
#define GTK_IS_TIPS_QUERY(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_TIPS_QUERY))
#define GTK_IS_TIPS_QUERY_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TIPS_QUERY))
/* --- typedefs --- */

176
gtk/gtktypebuiltins.h
View File

@ -1,88 +1,90 @@
/* generated by gentypeinfo from "gtk.defs" */
/* type macros, generated by maketypes.awk */
#define GTK_TYPE_GDK_WINDOW_TYPE (gtk_type_builtins[0])
#define GTK_TYPE_GDK_WINDOW_CLASS (gtk_type_builtins[1])
#define GTK_TYPE_GDK_IMAGE_TYPE (gtk_type_builtins[2])
#define GTK_TYPE_GDK_VISUAL_TYPE (gtk_type_builtins[3])
#define GTK_TYPE_GDK_FONT_TYPE (gtk_type_builtins[4])
#define GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE (gtk_type_builtins[5])
#define GTK_TYPE_GDK_WINDOW_HINTS (gtk_type_builtins[6])
#define GTK_TYPE_GDK_FUNCTION (gtk_type_builtins[7])
#define GTK_TYPE_GDK_FILL (gtk_type_builtins[8])
#define GTK_TYPE_GDK_FILL_RULE (gtk_type_builtins[9])
#define GTK_TYPE_GDK_LINE_STYLE (gtk_type_builtins[10])
#define GTK_TYPE_GDK_CAP_STYLE (gtk_type_builtins[11])
#define GTK_TYPE_GDK_JOIN_STYLE (gtk_type_builtins[12])
#define GTK_TYPE_GDK_FILTER_RETURN (gtk_type_builtins[13])
#define GTK_TYPE_GDK_VISIBILITY_STATE (gtk_type_builtins[14])
#define GTK_TYPE_GDK_EVENT_TYPE (gtk_type_builtins[15])
#define GTK_TYPE_GDK_EVENT_MASK (gtk_type_builtins[16])
#define GTK_TYPE_GDK_NOTIFY_TYPE (gtk_type_builtins[17])
#define GTK_TYPE_GDK_CROSSING_MODE (gtk_type_builtins[18])
#define GTK_TYPE_GDK_MODIFIER_TYPE (gtk_type_builtins[19])
#define GTK_TYPE_GDK_SUBWINDOW_MODE (gtk_type_builtins[20])
#define GTK_TYPE_GDK_INPUT_CONDITION (gtk_type_builtins[21])
#define GTK_TYPE_GDK_STATUS (gtk_type_builtins[22])
#define GTK_TYPE_GDK_BYTE_ORDER (gtk_type_builtins[23])
#define GTK_TYPE_GDK_GCVALUES_MASK (gtk_type_builtins[24])
#define GTK_TYPE_GDK_SELECTION (gtk_type_builtins[25])
#define GTK_TYPE_GDK_PROPERTY_STATE (gtk_type_builtins[26])
#define GTK_TYPE_GDK_PROP_MODE (gtk_type_builtins[27])
#define GTK_TYPE_GDK_DND_TYPE (gtk_type_builtins[28])
#define GTK_TYPE_GDK_INPUT_SOURCE (gtk_type_builtins[29])
#define GTK_TYPE_GDK_INPUT_MODE (gtk_type_builtins[30])
#define GTK_TYPE_GDK_AXIS_USE (gtk_type_builtins[31])
#define GTK_TYPE_GDK_TARGET (gtk_type_builtins[32])
#define GTK_TYPE_GDK_SELECTION_TYPE (gtk_type_builtins[33])
#define GTK_TYPE_GDK_EXTENSION_MODE (gtk_type_builtins[34])
#define GTK_TYPE_GDK_WMDECORATION (gtk_type_builtins[35])
#define GTK_TYPE_GDK_WMFUNCTION (gtk_type_builtins[36])
#define GTK_TYPE_GDK_COLOR_CONTEXT_MODE (gtk_type_builtins[37])
#define GTK_TYPE_GDK_OVERLAP_TYPE (gtk_type_builtins[38])
#define GTK_TYPE_ACCEL_FLAGS (gtk_type_builtins[39])
#define GTK_TYPE_ARROW_TYPE (gtk_type_builtins[40])
#define GTK_TYPE_ATTACH_OPTIONS (gtk_type_builtins[41])
#define GTK_TYPE_BUTTON_BOX_STYLE (gtk_type_builtins[42])
#define GTK_TYPE_CURVE_TYPE (gtk_type_builtins[43])
#define GTK_TYPE_DIRECTION_TYPE (gtk_type_builtins[44])
#define GTK_TYPE_JUSTIFICATION (gtk_type_builtins[45])
#define GTK_TYPE_MATCH_TYPE (gtk_type_builtins[46])
#define GTK_TYPE_MENU_FACTORY_TYPE (gtk_type_builtins[47])
#define GTK_TYPE_METRIC_TYPE (gtk_type_builtins[48])
#define GTK_TYPE_ORIENTATION (gtk_type_builtins[49])
#define GTK_TYPE_PACK_TYPE (gtk_type_builtins[50])
#define GTK_TYPE_PATH_PRIORITY_TYPE (gtk_type_builtins[51])
#define GTK_TYPE_PATH_TYPE (gtk_type_builtins[52])
#define GTK_TYPE_POLICY_TYPE (gtk_type_builtins[53])
#define GTK_TYPE_POSITION_TYPE (gtk_type_builtins[54])
#define GTK_TYPE_PREVIEW_TYPE (gtk_type_builtins[55])
#define GTK_TYPE_RELIEF_STYLE (gtk_type_builtins[56])
#define GTK_TYPE_SCROLL_TYPE (gtk_type_builtins[57])
#define GTK_TYPE_SELECTION_MODE (gtk_type_builtins[58])
#define GTK_TYPE_SHADOW_TYPE (gtk_type_builtins[59])
#define GTK_TYPE_SIGNAL_RUN_TYPE (gtk_type_builtins[60])
#define GTK_TYPE_STATE_TYPE (gtk_type_builtins[61])
#define GTK_TYPE_SUBMENU_DIRECTION (gtk_type_builtins[62])
#define GTK_TYPE_SUBMENU_PLACEMENT (gtk_type_builtins[63])
#define GTK_TYPE_TOOLBAR_STYLE (gtk_type_builtins[64])
#define GTK_TYPE_TROUGH_TYPE (gtk_type_builtins[65])
#define GTK_TYPE_UPDATE_TYPE (gtk_type_builtins[66])
#define GTK_TYPE_VISIBILITY (gtk_type_builtins[67])
#define GTK_TYPE_WINDOW_POSITION (gtk_type_builtins[68])
#define GTK_TYPE_WINDOW_TYPE (gtk_type_builtins[69])
#define GTK_TYPE_FUNDAMENTAL_TYPE (gtk_type_builtins[70])
#define GTK_TYPE_DEBUG_FLAG (gtk_type_builtins[71])
#define GTK_TYPE_OBJECT_FLAGS (gtk_type_builtins[72])
#define GTK_TYPE_ARG_FLAGS (gtk_type_builtins[73])
#define GTK_TYPE_WIDGET_FLAGS (gtk_type_builtins[74])
#define GTK_TYPE_PRIVATE_FLAGS (gtk_type_builtins[75])
#define GTK_TYPE_GDK_DEBUG_FLAG (gtk_type_builtins[76])
#define GTK_TYPE_ACCEL_GROUP (gtk_type_builtins[77])
#define GTK_TYPE_STYLE (gtk_type_builtins[78])
#define GTK_TYPE_GDK_COLORMAP (gtk_type_builtins[79])
#define GTK_TYPE_GDK_VISUAL (gtk_type_builtins[80])
#define GTK_TYPE_GDK_FONT (gtk_type_builtins[81])
#define GTK_TYPE_GDK_WINDOW (gtk_type_builtins[82])
#define GTK_TYPE_GDK_EVENT (gtk_type_builtins[83])
#define GTK_TYPE_GDK_COLOR (gtk_type_builtins[84])
#define GTK_TYPE_NUM_BUILTINS 85
extern GtkType GTK_TYPE_GDK_WINDOW_TYPE;
extern GtkType GTK_TYPE_GDK_WINDOW_CLASS;
extern GtkType GTK_TYPE_GDK_IMAGE_TYPE;
extern GtkType GTK_TYPE_GDK_VISUAL_TYPE;
extern GtkType GTK_TYPE_GDK_FONT_TYPE;
extern GtkType GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE;
extern GtkType GTK_TYPE_GDK_WINDOW_HINTS;
extern GtkType GTK_TYPE_GDK_FUNCTION;
extern GtkType GTK_TYPE_GDK_FILL;
extern GtkType GTK_TYPE_GDK_FILL_RULE;
extern GtkType GTK_TYPE_GDK_LINE_STYLE;
extern GtkType GTK_TYPE_GDK_CAP_STYLE;
extern GtkType GTK_TYPE_GDK_JOIN_STYLE;
extern GtkType GTK_TYPE_GDK_FILTER_RETURN;
extern GtkType GTK_TYPE_GDK_VISIBILITY_STATE;
extern GtkType GTK_TYPE_GDK_EVENT_TYPE;
extern GtkType GTK_TYPE_GDK_EVENT_MASK;
extern GtkType GTK_TYPE_GDK_NOTIFY_TYPE;
extern GtkType GTK_TYPE_GDK_CROSSING_MODE;
extern GtkType GTK_TYPE_GDK_MODIFIER_TYPE;
extern GtkType GTK_TYPE_GDK_SUBWINDOW_MODE;
extern GtkType GTK_TYPE_GDK_INPUT_CONDITION;
extern GtkType GTK_TYPE_GDK_STATUS;
extern GtkType GTK_TYPE_GDK_BYTE_ORDER;
extern GtkType GTK_TYPE_GDK_G_C_VALUES_MASK;
extern GtkType GTK_TYPE_GDK_SELECTION;
extern GtkType GTK_TYPE_GDK_PROPERTY_STATE;
extern GtkType GTK_TYPE_GDK_PROP_MODE;
extern GtkType GTK_TYPE_GDK_DND_TYPE;
extern GtkType GTK_TYPE_GDK_INPUT_SOURCE;
extern GtkType GTK_TYPE_GDK_INPUT_MODE;
extern GtkType GTK_TYPE_GDK_AXIS_USE;
extern GtkType GTK_TYPE_GDK_TARGET;
extern GtkType GTK_TYPE_GDK_SELECTION_TYPE;
extern GtkType GTK_TYPE_GDK_EXTENSION_MODE;
extern GtkType GTK_TYPE_GDK_W_M_DECORATION;
extern GtkType GTK_TYPE_GDK_W_M_FUNCTION;
extern GtkType GTK_TYPE_GDK_COLOR_CONTEXT_MODE;
extern GtkType GTK_TYPE_GDK_OVERLAP_TYPE;
extern GtkType GTK_TYPE_GDK_DEBUG_FLAG;
extern GtkType GTK_TYPE_ACCEL_FLAGS;
extern GtkType GTK_TYPE_ARROW_TYPE;
extern GtkType GTK_TYPE_ATTACH_OPTIONS;
extern GtkType GTK_TYPE_BUTTON_BOX_STYLE;
extern GtkType GTK_TYPE_CURVE_TYPE;
extern GtkType GTK_TYPE_DIRECTION_TYPE;
extern GtkType GTK_TYPE_JUSTIFICATION;
extern GtkType GTK_TYPE_MATCH_TYPE;
extern GtkType GTK_TYPE_MENU_FACTORY_TYPE;
extern GtkType GTK_TYPE_METRIC_TYPE;
extern GtkType GTK_TYPE_ORIENTATION;
extern GtkType GTK_TYPE_PACK_TYPE;
extern GtkType GTK_TYPE_PATH_PRIORITY_TYPE;
extern GtkType GTK_TYPE_PATH_TYPE;
extern GtkType GTK_TYPE_POLICY_TYPE;
extern GtkType GTK_TYPE_POSITION_TYPE;
extern GtkType GTK_TYPE_PREVIEW_TYPE;
extern GtkType GTK_TYPE_RELIEF_STYLE;
extern GtkType GTK_TYPE_SCROLL_TYPE;
extern GtkType GTK_TYPE_SELECTION_MODE;
extern GtkType GTK_TYPE_SHADOW_TYPE;
extern GtkType GTK_TYPE_SIGNAL_RUN_TYPE;
extern GtkType GTK_TYPE_STATE_TYPE;
extern GtkType GTK_TYPE_SUBMENU_DIRECTION;
extern GtkType GTK_TYPE_SUBMENU_PLACEMENT;
extern GtkType GTK_TYPE_TOOLBAR_STYLE;
extern GtkType GTK_TYPE_TROUGH_TYPE;
extern GtkType GTK_TYPE_UPDATE_TYPE;
extern GtkType GTK_TYPE_VISIBILITY;
extern GtkType GTK_TYPE_WINDOW_POSITION;
extern GtkType GTK_TYPE_WINDOW_TYPE;
extern GtkType GTK_TYPE_FUNDAMENTAL_TYPE;
extern GtkType GTK_TYPE_DEBUG_FLAG;
extern GtkType GTK_TYPE_OBJECT_FLAGS;
extern GtkType GTK_TYPE_ARG_FLAGS;
extern GtkType GTK_TYPE_WIDGET_FLAGS;
extern GtkType GTK_TYPE_PRIVATE_FLAGS;
extern GtkType GTK_TYPE_ACCEL_GROUP;
extern GtkType GTK_TYPE_SELECTION_DATA;
extern GtkType GTK_TYPE_STYLE;
extern GtkType GTK_TYPE_GDK_COLORMAP;
extern GtkType GTK_TYPE_GDK_VISUAL;
extern GtkType GTK_TYPE_GDK_FONT;
extern GtkType GTK_TYPE_GDK_WINDOW;
extern GtkType GTK_TYPE_GDK_EVENT;
extern GtkType GTK_TYPE_GDK_COLOR;
#define GTK_TYPE_NUM_BUILTINS (86)

87
gtk/gtktypebuiltins2.c
View File

@ -1,87 +0,0 @@
/* generated by gentypeinfo from "gtk.defs" */
{ "GdkWindowType", GTK_TYPE_ENUM, enum_values_GdkWindowType },
{ "GdkWindowClass", GTK_TYPE_ENUM, enum_values_GdkWindowClass },
{ "GdkImageType", GTK_TYPE_ENUM, enum_values_GdkImageType },
{ "GdkVisualType", GTK_TYPE_ENUM, enum_values_GdkVisualType },
{ "GdkFontType", GTK_TYPE_ENUM, enum_values_GdkFontType },
{ "GdkWindowAttributesType", GTK_TYPE_FLAGS, enum_values_GdkWindowAttributesType },
{ "GdkWindowHints", GTK_TYPE_FLAGS, enum_values_GdkWindowHints },
{ "GdkFunction", GTK_TYPE_ENUM, enum_values_GdkFunction },
{ "GdkFill", GTK_TYPE_ENUM, enum_values_GdkFill },
{ "GdkFillRule", GTK_TYPE_ENUM, enum_values_GdkFillRule },
{ "GdkLineStyle", GTK_TYPE_ENUM, enum_values_GdkLineStyle },
{ "GdkCapStyle", GTK_TYPE_ENUM, enum_values_GdkCapStyle },
{ "GdkJoinStyle", GTK_TYPE_ENUM, enum_values_GdkJoinStyle },
{ "GdkFilterReturn", GTK_TYPE_ENUM, enum_values_GdkFilterReturn },
{ "GdkVisibilityState", GTK_TYPE_ENUM, enum_values_GdkVisibilityState },
{ "GdkEventType", GTK_TYPE_ENUM, enum_values_GdkEventType },
{ "GdkEventMask", GTK_TYPE_FLAGS, enum_values_GdkEventMask },
{ "GdkNotifyType", GTK_TYPE_ENUM, enum_values_GdkNotifyType },
{ "GdkCrossingMode", GTK_TYPE_ENUM, enum_values_GdkCrossingMode },
{ "GdkModifierType", GTK_TYPE_FLAGS, enum_values_GdkModifierType },
{ "GdkSubwindowMode", GTK_TYPE_ENUM, enum_values_GdkSubwindowMode },
{ "GdkInputCondition", GTK_TYPE_FLAGS, enum_values_GdkInputCondition },
{ "GdkStatus", GTK_TYPE_ENUM, enum_values_GdkStatus },
{ "GdkByteOrder", GTK_TYPE_ENUM, enum_values_GdkByteOrder },
{ "GdkGCValuesMask", GTK_TYPE_FLAGS, enum_values_GdkGCValuesMask },
{ "GdkSelection", GTK_TYPE_ENUM, enum_values_GdkSelection },
{ "GdkPropertyState", GTK_TYPE_ENUM, enum_values_GdkPropertyState },
{ "GdkPropMode", GTK_TYPE_ENUM, enum_values_GdkPropMode },
{ "GdkDndType", GTK_TYPE_ENUM, enum_values_GdkDndType },
{ "GdkInputSource", GTK_TYPE_ENUM, enum_values_GdkInputSource },
{ "GdkInputMode", GTK_TYPE_ENUM, enum_values_GdkInputMode },
{ "GdkAxisUse", GTK_TYPE_ENUM, enum_values_GdkAxisUse },
{ "GdkTarget", GTK_TYPE_ENUM, enum_values_GdkTarget },
{ "GdkSelectionType", GTK_TYPE_ENUM, enum_values_GdkSelectionType },
{ "GdkExtensionMode", GTK_TYPE_ENUM, enum_values_GdkExtensionMode },
{ "GdkWMDecoration", GTK_TYPE_FLAGS, enum_values_GdkWMDecoration },
{ "GdkWMFunction", GTK_TYPE_FLAGS, enum_values_GdkWMFunction },
{ "GdkColorContextMode", GTK_TYPE_ENUM, enum_values_GdkColorContextMode },
{ "GdkOverlapType", GTK_TYPE_ENUM, enum_values_GdkOverlapType },
{ "GtkAccelFlags", GTK_TYPE_FLAGS, enum_values_GtkAccelFlags },
{ "GtkArrowType", GTK_TYPE_ENUM, enum_values_GtkArrowType },
{ "GtkAttachOptions", GTK_TYPE_FLAGS, enum_values_GtkAttachOptions },
{ "GtkButtonBoxStyle", GTK_TYPE_ENUM, enum_values_GtkButtonBoxStyle },
{ "GtkCurveType", GTK_TYPE_ENUM, enum_values_GtkCurveType },
{ "GtkDirectionType", GTK_TYPE_ENUM, enum_values_GtkDirectionType },
{ "GtkJustification", GTK_TYPE_ENUM, enum_values_GtkJustification },
{ "GtkMatchType", GTK_TYPE_ENUM, enum_values_GtkMatchType },
{ "GtkMenuFactoryType", GTK_TYPE_ENUM, enum_values_GtkMenuFactoryType },
{ "GtkMetricType", GTK_TYPE_ENUM, enum_values_GtkMetricType },
{ "GtkOrientation", GTK_TYPE_ENUM, enum_values_GtkOrientation },
{ "GtkPackType", GTK_TYPE_ENUM, enum_values_GtkPackType },
{ "GtkPathPriorityType", GTK_TYPE_ENUM, enum_values_GtkPathPriorityType },
{ "GtkPathType", GTK_TYPE_ENUM, enum_values_GtkPathType },
{ "GtkPolicyType", GTK_TYPE_ENUM, enum_values_GtkPolicyType },
{ "GtkPositionType", GTK_TYPE_ENUM, enum_values_GtkPositionType },
{ "GtkPreviewType", GTK_TYPE_ENUM, enum_values_GtkPreviewType },
{ "GtkReliefStyle", GTK_TYPE_ENUM, enum_values_GtkReliefStyle },
{ "GtkScrollType", GTK_TYPE_ENUM, enum_values_GtkScrollType },
{ "GtkSelectionMode", GTK_TYPE_ENUM, enum_values_GtkSelectionMode },
{ "GtkShadowType", GTK_TYPE_ENUM, enum_values_GtkShadowType },
{ "GtkSignalRunType", GTK_TYPE_FLAGS, enum_values_GtkSignalRunType },
{ "GtkStateType", GTK_TYPE_ENUM, enum_values_GtkStateType },
{ "GtkSubmenuDirection", GTK_TYPE_ENUM, enum_values_GtkSubmenuDirection },
{ "GtkSubmenuPlacement", GTK_TYPE_ENUM, enum_values_GtkSubmenuPlacement },
{ "GtkToolbarStyle", GTK_TYPE_ENUM, enum_values_GtkToolbarStyle },
{ "GtkTroughType", GTK_TYPE_ENUM, enum_values_GtkTroughType },
{ "GtkUpdateType", GTK_TYPE_ENUM, enum_values_GtkUpdateType },
{ "GtkVisibility", GTK_TYPE_ENUM, enum_values_GtkVisibility },
{ "GtkWindowPosition", GTK_TYPE_ENUM, enum_values_GtkWindowPosition },
{ "GtkWindowType", GTK_TYPE_ENUM, enum_values_GtkWindowType },
{ "GtkFundamentalType", GTK_TYPE_ENUM, enum_values_GtkFundamentalType },
{ "GtkDebugFlag", GTK_TYPE_FLAGS, enum_values_GtkDebugFlag },
{ "GtkObjectFlags", GTK_TYPE_FLAGS, enum_values_GtkObjectFlags },
{ "GtkArgFlags", GTK_TYPE_FLAGS, enum_values_GtkArgFlags },
{ "GtkWidgetFlags", GTK_TYPE_FLAGS, enum_values_GtkWidgetFlags },
{ "GtkPrivateFlags", GTK_TYPE_FLAGS, enum_values_GtkPrivateFlags },
{ "GdkDebugFlag", GTK_TYPE_FLAGS, enum_values_GdkDebugFlag },
{ "GtkAccelGroup", GTK_TYPE_BOXED, NULL },
{ "GtkStyle", GTK_TYPE_BOXED, NULL },
{ "GdkColormap", GTK_TYPE_BOXED, NULL },
{ "GdkVisual", GTK_TYPE_BOXED, NULL },
{ "GdkFont", GTK_TYPE_BOXED, NULL },
{ "GdkWindow", GTK_TYPE_BOXED, NULL },
{ "GdkEvent", GTK_TYPE_BOXED, NULL },
{ "GdkColor", GTK_TYPE_BOXED, NULL },

168
gtk/gtktypebuiltins1.c → gtk/gtktypebuiltins_evals.c
View File

@ -1,6 +1,6 @@
/* generated by makeenums.awk */
static GtkEnumValue enum_values_GdkWindowType[] = {
static GtkEnumValue _gdk_window_type_values[] = {
{ GDK_WINDOW_ROOT, "GDK_WINDOW_ROOT", "root" },
{ GDK_WINDOW_TOPLEVEL, "GDK_WINDOW_TOPLEVEL", "toplevel" },
{ GDK_WINDOW_CHILD, "GDK_WINDOW_CHILD", "child" },
@ -9,16 +9,16 @@ static GtkEnumValue enum_values_GdkWindowType[] = {
{ GDK_WINDOW_PIXMAP, "GDK_WINDOW_PIXMAP", "pixmap" },
{ GDK_WINDOW_FOREIGN, "GDK_WINDOW_FOREIGN", "foreign" },
};
static GtkEnumValue enum_values_GdkWindowClass[] = {
static GtkEnumValue _gdk_window_class_values[] = {
{ GDK_INPUT_OUTPUT, "GDK_INPUT_OUTPUT", "input-output" },
{ GDK_INPUT_ONLY, "GDK_INPUT_ONLY", "input-only" },
};
static GtkEnumValue enum_values_GdkImageType[] = {
static GtkEnumValue _gdk_image_type_values[] = {
{ GDK_IMAGE_NORMAL, "GDK_IMAGE_NORMAL", "normal" },
{ GDK_IMAGE_SHARED, "GDK_IMAGE_SHARED", "shared" },
{ GDK_IMAGE_FASTEST, "GDK_IMAGE_FASTEST", "fastest" },
};
static GtkEnumValue enum_values_GdkVisualType[] = {
static GtkEnumValue _gdk_visual_type_values[] = {
{ GDK_VISUAL_STATIC_GRAY, "GDK_VISUAL_STATIC_GRAY", "static-gray" },
{ GDK_VISUAL_GRAYSCALE, "GDK_VISUAL_GRAYSCALE", "grayscale" },
{ GDK_VISUAL_STATIC_COLOR, "GDK_VISUAL_STATIC_COLOR", "static-color" },
@ -26,11 +26,11 @@ static GtkEnumValue enum_values_GdkVisualType[] = {
{ GDK_VISUAL_TRUE_COLOR, "GDK_VISUAL_TRUE_COLOR", "true-color" },
{ GDK_VISUAL_DIRECT_COLOR, "GDK_VISUAL_DIRECT_COLOR", "direct-color" },
};
static GtkEnumValue enum_values_GdkFontType[] = {
static GtkEnumValue _gdk_font_type_values[] = {
{ GDK_FONT_FONT, "GDK_FONT_FONT", "font" },
{ GDK_FONT_FONTSET, "GDK_FONT_FONTSET", "fontset" },
};
static GtkEnumValue enum_values_GdkWindowAttributesType[] = {
static GtkEnumValue _gdk_window_attributes_type_values[] = {
{ GDK_WA_TITLE, "GDK_WA_TITLE", "title" },
{ GDK_WA_X, "GDK_WA_X", "x" },
{ GDK_WA_Y, "GDK_WA_Y", "y" },
@ -40,53 +40,53 @@ static GtkEnumValue enum_values_GdkWindowAttributesType[] = {
{ GDK_WA_WMCLASS, "GDK_WA_WMCLASS", "wmclass" },
{ GDK_WA_NOREDIR, "GDK_WA_NOREDIR", "noredir" },
};
static GtkEnumValue enum_values_GdkWindowHints[] = {
static GtkEnumValue _gdk_window_hints_values[] = {
{ GDK_HINT_POS, "GDK_HINT_POS", "pos" },
{ GDK_HINT_MIN_SIZE, "GDK_HINT_MIN_SIZE", "min-size" },
{ GDK_HINT_MAX_SIZE, "GDK_HINT_MAX_SIZE", "max-size" },
};
static GtkEnumValue enum_values_GdkFunction[] = {
static GtkEnumValue _gdk_function_values[] = {
{ GDK_COPY, "GDK_COPY", "copy" },
{ GDK_INVERT, "GDK_INVERT", "invert" },
{ GDK_XOR, "GDK_XOR", "xor" },
};
static GtkEnumValue enum_values_GdkFill[] = {
static GtkEnumValue _gdk_fill_values[] = {
{ GDK_SOLID, "GDK_SOLID", "solid" },
{ GDK_TILED, "GDK_TILED", "tiled" },
{ GDK_STIPPLED, "GDK_STIPPLED", "stippled" },
{ GDK_OPAQUE_STIPPLED, "GDK_OPAQUE_STIPPLED", "opaque-stippled" },
};
static GtkEnumValue enum_values_GdkFillRule[] = {
static GtkEnumValue _gdk_fill_rule_values[] = {
{ GDK_EVEN_ODD_RULE, "GDK_EVEN_ODD_RULE", "even-odd-rule" },
{ GDK_WINDING_RULE, "GDK_WINDING_RULE", "winding-rule" },
};
static GtkEnumValue enum_values_GdkLineStyle[] = {
static GtkEnumValue _gdk_line_style_values[] = {
{ GDK_LINE_SOLID, "GDK_LINE_SOLID", "solid" },
{ GDK_LINE_ON_OFF_DASH, "GDK_LINE_ON_OFF_DASH", "on-off-dash" },
{ GDK_LINE_DOUBLE_DASH, "GDK_LINE_DOUBLE_DASH", "double-dash" },
};
static GtkEnumValue enum_values_GdkCapStyle[] = {
static GtkEnumValue _gdk_cap_style_values[] = {
{ GDK_CAP_NOT_LAST, "GDK_CAP_NOT_LAST", "not-last" },
{ GDK_CAP_BUTT, "GDK_CAP_BUTT", "butt" },
{ GDK_CAP_ROUND, "GDK_CAP_ROUND", "round" },
{ GDK_CAP_PROJECTING, "GDK_CAP_PROJECTING", "projecting" },
};
static GtkEnumValue enum_values_GdkJoinStyle[] = {
static GtkEnumValue _gdk_join_style_values[] = {
{ GDK_JOIN_MITER, "GDK_JOIN_MITER", "miter" },
{ GDK_JOIN_ROUND, "GDK_JOIN_ROUND", "round" },
{ GDK_JOIN_BEVEL, "GDK_JOIN_BEVEL", "bevel" },
};
static GtkEnumValue enum_values_GdkFilterReturn[] = {
static GtkEnumValue _gdk_filter_return_values[] = {
{ GDK_FILTER_CONTINUE, "GDK_FILTER_CONTINUE", "continue" },
{ GDK_FILTER_TRANSLATE, "GDK_FILTER_TRANSLATE", "translate" },
{ GDK_FILTER_REMOVE, "GDK_FILTER_REMOVE", "remove" },
};
static GtkEnumValue enum_values_GdkVisibilityState[] = {
static GtkEnumValue _gdk_visibility_state_values[] = {
{ GDK_VISIBILITY_UNOBSCURED, "GDK_VISIBILITY_UNOBSCURED", "unobscured" },
{ GDK_VISIBILITY_PARTIAL, "GDK_VISIBILITY_PARTIAL", "partial" },
{ GDK_VISIBILITY_FULLY_OBSCURED, "GDK_VISIBILITY_FULLY_OBSCURED", "fully-obscured" },
};
static GtkEnumValue enum_values_GdkEventType[] = {
static GtkEnumValue _gdk_event_type_values[] = {
{ GDK_NOTHING, "GDK_NOTHING", "nothing" },
{ GDK_DELETE, "GDK_DELETE", "delete" },
{ GDK_DESTROY, "GDK_DESTROY", "destroy" },
@ -120,7 +120,7 @@ static GtkEnumValue enum_values_GdkEventType[] = {
{ GDK_NO_EXPOSE, "GDK_NO_EXPOSE", "no-expose" },
{ GDK_OTHER_EVENT, "GDK_OTHER_EVENT", "other-event" },
};
static GtkEnumValue enum_values_GdkEventMask[] = {
static GtkEnumValue _gdk_event_mask_values[] = {
{ GDK_EXPOSURE_MASK, "GDK_EXPOSURE_MASK", "exposure-mask" },
{ GDK_POINTER_MOTION_MASK, "GDK_POINTER_MOTION_MASK", "pointer-motion-mask" },
{ GDK_POINTER_MOTION_HINT_MASK, "GDK_POINTER_MOTION_HINT_MASK", "pointer-motion-hint-mask" },
@ -143,7 +143,7 @@ static GtkEnumValue enum_values_GdkEventMask[] = {
{ GDK_SUBSTRUCTURE_MASK, "GDK_SUBSTRUCTURE_MASK", "substructure-mask" },
{ GDK_ALL_EVENTS_MASK, "GDK_ALL_EVENTS_MASK", "all-events-mask" },
};
static GtkEnumValue enum_values_GdkNotifyType[] = {
static GtkEnumValue _gdk_notify_type_values[] = {
{ GDK_NOTIFY_ANCESTOR, "GDK_NOTIFY_ANCESTOR", "ancestor" },
{ GDK_NOTIFY_VIRTUAL, "GDK_NOTIFY_VIRTUAL", "virtual" },
{ GDK_NOTIFY_INFERIOR, "GDK_NOTIFY_INFERIOR", "inferior" },
@ -151,12 +151,12 @@ static GtkEnumValue enum_values_GdkNotifyType[] = {
{ GDK_NOTIFY_NONLINEAR_VIRTUAL, "GDK_NOTIFY_NONLINEAR_VIRTUAL", "nonlinear-virtual" },
{ GDK_NOTIFY_UNKNOWN, "GDK_NOTIFY_UNKNOWN", "unknown" },
};
static GtkEnumValue enum_values_GdkCrossingMode[] = {
static GtkEnumValue _gdk_crossing_mode_values[] = {
{ GDK_CROSSING_NORMAL, "GDK_CROSSING_NORMAL", "crossing-normal" },
{ GDK_CROSSING_GRAB, "GDK_CROSSING_GRAB", "crossing-grab" },
{ GDK_CROSSING_UNGRAB, "GDK_CROSSING_UNGRAB", "crossing-ungrab" },
};
static GtkEnumValue enum_values_GdkModifierType[] = {
static GtkEnumValue _gdk_modifier_type_values[] = {
{ GDK_SHIFT_MASK, "GDK_SHIFT_MASK", "shift-mask" },
{ GDK_LOCK_MASK, "GDK_LOCK_MASK", "lock-mask" },
{ GDK_CONTROL_MASK, "GDK_CONTROL_MASK", "control-mask" },
@ -170,30 +170,29 @@ static GtkEnumValue enum_values_GdkModifierType[] = {
{ GDK_BUTTON3_MASK, "GDK_BUTTON3_MASK", "button3-mask" },
{ GDK_BUTTON4_MASK, "GDK_BUTTON4_MASK", "button4-mask" },
{ GDK_BUTTON5_MASK, "GDK_BUTTON5_MASK", "button5-mask" },
{ GDK_AFTER_MASK, "GDK_AFTER_MASK", "after-mask" },
{ GDK_MODIFIER_MASK, "GDK_MODIFIER_MASK", "modifier-mask" },
};
static GtkEnumValue enum_values_GdkSubwindowMode[] = {
static GtkEnumValue _gdk_subwindow_mode_values[] = {
{ GDK_CLIP_BY_CHILDREN, "GDK_CLIP_BY_CHILDREN", "clip-by-children" },
{ GDK_INCLUDE_INFERIORS, "GDK_INCLUDE_INFERIORS", "include-inferiors" },
};
static GtkEnumValue enum_values_GdkInputCondition[] = {
static GtkEnumValue _gdk_input_condition_values[] = {
{ GDK_INPUT_READ, "GDK_INPUT_READ", "read" },
{ GDK_INPUT_WRITE, "GDK_INPUT_WRITE", "write" },
{ GDK_INPUT_EXCEPTION, "GDK_INPUT_EXCEPTION", "exception" },
};
static GtkEnumValue enum_values_GdkStatus[] = {
static GtkEnumValue _gdk_status_values[] = {
{ GDK_OK, "GDK_OK", "ok" },
{ GDK_ERROR, "GDK_ERROR", "error" },
{ GDK_ERROR_PARAM, "GDK_ERROR_PARAM", "error-param" },
{ GDK_ERROR_FILE, "GDK_ERROR_FILE", "error-file" },
{ GDK_ERROR_MEM, "GDK_ERROR_MEM", "error-mem" },
};
static GtkEnumValue enum_values_GdkByteOrder[] = {
static GtkEnumValue _gdk_byte_order_values[] = {
{ GDK_LSB_FIRST, "GDK_LSB_FIRST", "lsb-first" },
{ GDK_MSB_FIRST, "GDK_MSB_FIRST", "msb-first" },
};
static GtkEnumValue enum_values_GdkGCValuesMask[] = {
static GtkEnumValue _gdk_g_c_values_mask_values[] = {
{ GDK_GC_FOREGROUND, "GDK_GC_FOREGROUND", "foreground" },
{ GDK_GC_BACKGROUND, "GDK_GC_BACKGROUND", "background" },
{ GDK_GC_FONT, "GDK_GC_FONT", "font" },
@ -213,20 +212,20 @@ static GtkEnumValue enum_values_GdkGCValuesMask[] = {
{ GDK_GC_CAP_STYLE, "GDK_GC_CAP_STYLE", "cap-style" },
{ GDK_GC_JOIN_STYLE, "GDK_GC_JOIN_STYLE", "join-style" },
};
static GtkEnumValue enum_values_GdkSelection[] = {
static GtkEnumValue _gdk_selection_values[] = {
{ GDK_SELECTION_PRIMARY, "GDK_SELECTION_PRIMARY", "primary" },
{ GDK_SELECTION_SECONDARY, "GDK_SELECTION_SECONDARY", "secondary" },
};
static GtkEnumValue enum_values_GdkPropertyState[] = {
static GtkEnumValue _gdk_property_state_values[] = {
{ GDK_PROPERTY_NEW_VALUE, "GDK_PROPERTY_NEW_VALUE", "new-value" },
{ GDK_PROPERTY_DELETE, "GDK_PROPERTY_DELETE", "delete" },
};
static GtkEnumValue enum_values_GdkPropMode[] = {
static GtkEnumValue _gdk_prop_mode_values[] = {
{ GDK_PROP_MODE_REPLACE, "GDK_PROP_MODE_REPLACE", "replace" },
{ GDK_PROP_MODE_PREPEND, "GDK_PROP_MODE_PREPEND", "prepend" },
{ GDK_PROP_MODE_APPEND, "GDK_PROP_MODE_APPEND", "append" },
};
static GtkEnumValue enum_values_GdkDndType[] = {
static GtkEnumValue _gdk_dnd_type_values[] = {
{ GDK_DNDTYPE_NOTDND, "GDK_DNDTYPE_NOTDND", "notdnd" },
{ GDK_DNDTYPE_UNKNOWN, "GDK_DNDTYPE_UNKNOWN", "unknown" },
{ GDK_DNDTYPE_RAWDATA, "GDK_DNDTYPE_RAWDATA", "rawdata" },
@ -240,18 +239,18 @@ static GtkEnumValue enum_values_GdkDndType[] = {
{ GDK_DNDTYPE_MIME, "GDK_DNDTYPE_MIME", "mime" },
{ GDK_DNDTYPE_END, "GDK_DNDTYPE_END", "end" },
};
static GtkEnumValue enum_values_GdkInputSource[] = {
static GtkEnumValue _gdk_input_source_values[] = {
{ GDK_SOURCE_MOUSE, "GDK_SOURCE_MOUSE", "mouse" },
{ GDK_SOURCE_PEN, "GDK_SOURCE_PEN", "pen" },
{ GDK_SOURCE_ERASER, "GDK_SOURCE_ERASER", "eraser" },
{ GDK_SOURCE_CURSOR, "GDK_SOURCE_CURSOR", "cursor" },
};
static GtkEnumValue enum_values_GdkInputMode[] = {
static GtkEnumValue _gdk_input_mode_values[] = {
{ GDK_MODE_DISABLED, "GDK_MODE_DISABLED", "disabled" },
{ GDK_MODE_SCREEN, "GDK_MODE_SCREEN", "screen" },
{ GDK_MODE_WINDOW, "GDK_MODE_WINDOW", "window" },
};
static GtkEnumValue enum_values_GdkAxisUse[] = {
static GtkEnumValue _gdk_axis_use_values[] = {
{ GDK_AXIS_IGNORE, "GDK_AXIS_IGNORE", "ignore" },
{ GDK_AXIS_X, "GDK_AXIS_X", "x" },
{ GDK_AXIS_Y, "GDK_AXIS_Y", "y" },
@ -260,14 +259,14 @@ static GtkEnumValue enum_values_GdkAxisUse[] = {
{ GDK_AXIS_YTILT, "GDK_AXIS_YTILT", "ytilt" },
{ GDK_AXIS_LAST, "GDK_AXIS_LAST", "last" },
};
static GtkEnumValue enum_values_GdkTarget[] = {
static GtkEnumValue _gdk_target_values[] = {
{ GDK_TARGET_BITMAP, "GDK_TARGET_BITMAP", "bitmap" },
{ GDK_TARGET_COLORMAP, "GDK_TARGET_COLORMAP", "colormap" },
{ GDK_TARGET_DRAWABLE, "GDK_TARGET_DRAWABLE", "drawable" },
{ GDK_TARGET_PIXMAP, "GDK_TARGET_PIXMAP", "pixmap" },
{ GDK_TARGET_STRING, "GDK_TARGET_STRING", "string" },
};
static GtkEnumValue enum_values_GdkSelectionType[] = {
static GtkEnumValue _gdk_selection_type_values[] = {
{ GDK_SELECTION_TYPE_ATOM, "GDK_SELECTION_TYPE_ATOM", "atom" },
{ GDK_SELECTION_TYPE_BITMAP, "GDK_SELECTION_TYPE_BITMAP", "bitmap" },
{ GDK_SELECTION_TYPE_COLORMAP, "GDK_SELECTION_TYPE_COLORMAP", "colormap" },
@ -277,12 +276,12 @@ static GtkEnumValue enum_values_GdkSelectionType[] = {
{ GDK_SELECTION_TYPE_WINDOW, "GDK_SELECTION_TYPE_WINDOW", "window" },
{ GDK_SELECTION_TYPE_STRING, "GDK_SELECTION_TYPE_STRING", "string" },
};
static GtkEnumValue enum_values_GdkExtensionMode[] = {
static GtkEnumValue _gdk_extension_mode_values[] = {
{ GDK_EXTENSION_EVENTS_NONE, "GDK_EXTENSION_EVENTS_NONE", "none" },
{ GDK_EXTENSION_EVENTS_ALL, "GDK_EXTENSION_EVENTS_ALL", "all" },
{ GDK_EXTENSION_EVENTS_CURSOR, "GDK_EXTENSION_EVENTS_CURSOR", "cursor" },
};
static GtkEnumValue enum_values_GdkWMDecoration[] = {
static GtkEnumValue _gdk_w_m_decoration_values[] = {
{ GDK_DECOR_ALL, "GDK_DECOR_ALL", "all" },
{ GDK_DECOR_BORDER, "GDK_DECOR_BORDER", "border" },
{ GDK_DECOR_RESIZEH, "GDK_DECOR_RESIZEH", "resizeh" },
@ -291,7 +290,7 @@ static GtkEnumValue enum_values_GdkWMDecoration[] = {
{ GDK_DECOR_MINIMIZE, "GDK_DECOR_MINIMIZE", "minimize" },
{ GDK_DECOR_MAXIMIZE, "GDK_DECOR_MAXIMIZE", "maximize" },
};
static GtkEnumValue enum_values_GdkWMFunction[] = {
static GtkEnumValue _gdk_w_m_function_values[] = {
{ GDK_FUNC_ALL, "GDK_FUNC_ALL", "all" },
{ GDK_FUNC_RESIZE, "GDK_FUNC_RESIZE", "resize" },
{ GDK_FUNC_MOVE, "GDK_FUNC_MOVE", "move" },
@ -299,7 +298,7 @@ static GtkEnumValue enum_values_GdkWMFunction[] = {
{ GDK_FUNC_MAXIMIZE, "GDK_FUNC_MAXIMIZE", "maximize" },
{ GDK_FUNC_CLOSE, "GDK_FUNC_CLOSE", "close" },
};
static GtkEnumValue enum_values_GdkColorContextMode[] = {
static GtkEnumValue _gdk_color_context_mode_values[] = {
{ GDK_CC_MODE_UNDEFINED, "GDK_CC_MODE_UNDEFINED", "undefined" },
{ GDK_CC_MODE_BW, "GDK_CC_MODE_BW", "bw" },
{ GDK_CC_MODE_STD_CMAP, "GDK_CC_MODE_STD_CMAP", "std-cmap" },
@ -307,41 +306,48 @@ static GtkEnumValue enum_values_GdkColorContextMode[] = {
{ GDK_CC_MODE_MY_GRAY, "GDK_CC_MODE_MY_GRAY", "my-gray" },
{ GDK_CC_MODE_PALETTE, "GDK_CC_MODE_PALETTE", "palette" },
};
static GtkEnumValue enum_values_GdkOverlapType[] = {
static GtkEnumValue _gdk_overlap_type_values[] = {
{ GDK_OVERLAP_RECTANGLE_IN, "GDK_OVERLAP_RECTANGLE_IN", "in" },
{ GDK_OVERLAP_RECTANGLE_OUT, "GDK_OVERLAP_RECTANGLE_OUT", "out" },
{ GDK_OVERLAP_RECTANGLE_PART, "GDK_OVERLAP_RECTANGLE_PART", "part" },
};
static GtkEnumValue enum_values_GtkAccelFlags[] = {
static GtkEnumValue _gdk_debug_flag_values[] = {
{ GDK_DEBUG_MISC, "GDK_DEBUG_MISC", "misc" },
{ GDK_DEBUG_EVENTS, "GDK_DEBUG_EVENTS", "events" },
{ GDK_DEBUG_DND, "GDK_DEBUG_DND", "dnd" },
{ GDK_DEBUG_COLOR_CONTEXT, "GDK_DEBUG_COLOR_CONTEXT", "color-context" },
{ GDK_DEBUG_XIM, "GDK_DEBUG_XIM", "xim" },
};
static GtkEnumValue _gtk_accel_flags_values[] = {
{ GTK_ACCEL_VISIBLE, "GTK_ACCEL_VISIBLE", "visible" },
{ GTK_ACCEL_SIGNAL_VISIBLE, "GTK_ACCEL_SIGNAL_VISIBLE", "signal-visible" },
{ GTK_ACCEL_LOCKED, "GTK_ACCEL_LOCKED", "locked" },
{ GTK_ACCEL_MASK, "GTK_ACCEL_MASK", "mask" },
};
static GtkEnumValue enum_values_GtkArrowType[] = {
static GtkEnumValue _gtk_arrow_type_values[] = {
{ GTK_ARROW_UP, "GTK_ARROW_UP", "up" },
{ GTK_ARROW_DOWN, "GTK_ARROW_DOWN", "down" },
{ GTK_ARROW_LEFT, "GTK_ARROW_LEFT", "left" },
{ GTK_ARROW_RIGHT, "GTK_ARROW_RIGHT", "right" },
};
static GtkEnumValue enum_values_GtkAttachOptions[] = {
static GtkEnumValue _gtk_attach_options_values[] = {
{ GTK_EXPAND, "GTK_EXPAND", "expand" },
{ GTK_SHRINK, "GTK_SHRINK", "shrink" },
{ GTK_FILL, "GTK_FILL", "fill" },
};
static GtkEnumValue enum_values_GtkButtonBoxStyle[] = {
static GtkEnumValue _gtk_button_box_style_values[] = {
{ GTK_BUTTONBOX_DEFAULT_STYLE, "GTK_BUTTONBOX_DEFAULT_STYLE", "default" },
{ GTK_BUTTONBOX_SPREAD, "GTK_BUTTONBOX_SPREAD", "spread" },
{ GTK_BUTTONBOX_EDGE, "GTK_BUTTONBOX_EDGE", "edge" },
{ GTK_BUTTONBOX_START, "GTK_BUTTONBOX_START", "start" },
{ GTK_BUTTONBOX_END, "GTK_BUTTONBOX_END", "end" },
};
static GtkEnumValue enum_values_GtkCurveType[] = {
static GtkEnumValue _gtk_curve_type_values[] = {
{ GTK_CURVE_TYPE_LINEAR, "GTK_CURVE_TYPE_LINEAR", "linear" },
{ GTK_CURVE_TYPE_SPLINE, "GTK_CURVE_TYPE_SPLINE", "spline" },
{ GTK_CURVE_TYPE_FREE, "GTK_CURVE_TYPE_FREE", "free" },
};
static GtkEnumValue enum_values_GtkDirectionType[] = {
static GtkEnumValue _gtk_direction_type_values[] = {
{ GTK_DIR_TAB_FORWARD, "GTK_DIR_TAB_FORWARD", "tab-forward" },
{ GTK_DIR_TAB_BACKWARD, "GTK_DIR_TAB_BACKWARD", "tab-backward" },
{ GTK_DIR_UP, "GTK_DIR_UP", "up" },
@ -349,13 +355,13 @@ static GtkEnumValue enum_values_GtkDirectionType[] = {
{ GTK_DIR_LEFT, "GTK_DIR_LEFT", "left" },
{ GTK_DIR_RIGHT, "GTK_DIR_RIGHT", "right" },
};
static GtkEnumValue enum_values_GtkJustification[] = {
static GtkEnumValue _gtk_justification_values[] = {
{ GTK_JUSTIFY_LEFT, "GTK_JUSTIFY_LEFT", "left" },
{ GTK_JUSTIFY_RIGHT, "GTK_JUSTIFY_RIGHT", "right" },
{ GTK_JUSTIFY_CENTER, "GTK_JUSTIFY_CENTER", "center" },
{ GTK_JUSTIFY_FILL, "GTK_JUSTIFY_FILL", "fill" },
};
static GtkEnumValue enum_values_GtkMatchType[] = {
static GtkEnumValue _gtk_match_type_values[] = {
{ GTK_MATCH_ALL, "GTK_MATCH_ALL", "all" },
{ GTK_MATCH_ALL_TAIL, "GTK_MATCH_ALL_TAIL", "all-tail" },
{ GTK_MATCH_HEAD, "GTK_MATCH_HEAD", "head" },
@ -363,25 +369,25 @@ static GtkEnumValue enum_values_GtkMatchType[] = {
{ GTK_MATCH_EXACT, "GTK_MATCH_EXACT", "exact" },
{ GTK_MATCH_LAST, "GTK_MATCH_LAST", "last" },
};
static GtkEnumValue enum_values_GtkMenuFactoryType[] = {
static GtkEnumValue _gtk_menu_factory_type_values[] = {
{ GTK_MENU_FACTORY_MENU, "GTK_MENU_FACTORY_MENU", "menu" },
{ GTK_MENU_FACTORY_MENU_BAR, "GTK_MENU_FACTORY_MENU_BAR", "menu-bar" },
{ GTK_MENU_FACTORY_OPTION_MENU, "GTK_MENU_FACTORY_OPTION_MENU", "option-menu" },
};
static GtkEnumValue enum_values_GtkMetricType[] = {
static GtkEnumValue _gtk_metric_type_values[] = {
{ GTK_PIXELS, "GTK_PIXELS", "pixels" },
{ GTK_INCHES, "GTK_INCHES", "inches" },
{ GTK_CENTIMETERS, "GTK_CENTIMETERS", "centimeters" },
};
static GtkEnumValue enum_values_GtkOrientation[] = {
static GtkEnumValue _gtk_orientation_values[] = {
{ GTK_ORIENTATION_HORIZONTAL, "GTK_ORIENTATION_HORIZONTAL", "horizontal" },
{ GTK_ORIENTATION_VERTICAL, "GTK_ORIENTATION_VERTICAL", "vertical" },
};
static GtkEnumValue enum_values_GtkPackType[] = {
static GtkEnumValue _gtk_pack_type_values[] = {
{ GTK_PACK_START, "GTK_PACK_START", "start" },
{ GTK_PACK_END, "GTK_PACK_END", "end" },
};
static GtkEnumValue enum_values_GtkPathPriorityType[] = {
static GtkEnumValue _gtk_path_priority_type_values[] = {
{ GTK_PATH_PRIO_LOWEST, "GTK_PATH_PRIO_LOWEST", "lowest" },
{ GTK_PATH_PRIO_GTK, "GTK_PATH_PRIO_GTK", "gtk" },
{ GTK_PATH_PRIO_APPLICATION, "GTK_PATH_PRIO_APPLICATION", "application" },
@ -389,31 +395,31 @@ static GtkEnumValue enum_values_GtkPathPriorityType[] = {
{ GTK_PATH_PRIO_HIGHEST, "GTK_PATH_PRIO_HIGHEST", "highest" },
{ GTK_PATH_PRIO_MASK, "GTK_PATH_PRIO_MASK", "mask" },
};
static GtkEnumValue enum_values_GtkPathType[] = {
static GtkEnumValue _gtk_path_type_values[] = {
{ GTK_PATH_WIDGET, "GTK_PATH_WIDGET", "widget" },
{ GTK_PATH_WIDGET_CLASS, "GTK_PATH_WIDGET_CLASS", "widget-class" },
{ GTK_PATH_CLASS, "GTK_PATH_CLASS", "class" },
};
static GtkEnumValue enum_values_GtkPolicyType[] = {
static GtkEnumValue _gtk_policy_type_values[] = {
{ GTK_POLICY_ALWAYS, "GTK_POLICY_ALWAYS", "always" },
{ GTK_POLICY_AUTOMATIC, "GTK_POLICY_AUTOMATIC", "automatic" },
};
static GtkEnumValue enum_values_GtkPositionType[] = {
static GtkEnumValue _gtk_position_type_values[] = {
{ GTK_POS_LEFT, "GTK_POS_LEFT", "left" },
{ GTK_POS_RIGHT, "GTK_POS_RIGHT", "right" },
{ GTK_POS_TOP, "GTK_POS_TOP", "top" },
{ GTK_POS_BOTTOM, "GTK_POS_BOTTOM", "bottom" },
};
static GtkEnumValue enum_values_GtkPreviewType[] = {
static GtkEnumValue _gtk_preview_type_values[] = {
{ GTK_PREVIEW_COLOR, "GTK_PREVIEW_COLOR", "color" },
{ GTK_PREVIEW_GRAYSCALE, "GTK_PREVIEW_GRAYSCALE", "grayscale" },
{ GTK_PREVIEW_GREYSCALE, "GTK_PREVIEW_GREYSCALE", "greyscale" },
};
static GtkEnumValue enum_values_GtkReliefStyle[] = {
static GtkEnumValue _gtk_relief_style_values[] = {
{ GTK_RELIEF_NORMAL, "GTK_RELIEF_NORMAL", "normal" },
{ GTK_RELIEF_NONE, "GTK_RELIEF_NONE", "none" },
};
static GtkEnumValue enum_values_GtkScrollType[] = {
static GtkEnumValue _gtk_scroll_type_values[] = {
{ GTK_SCROLL_NONE, "GTK_SCROLL_NONE", "none" },
{ GTK_SCROLL_STEP_BACKWARD, "GTK_SCROLL_STEP_BACKWARD", "step-backward" },
{ GTK_SCROLL_STEP_FORWARD, "GTK_SCROLL_STEP_FORWARD", "step-forward" },
@ -421,73 +427,74 @@ static GtkEnumValue enum_values_GtkScrollType[] = {
{ GTK_SCROLL_PAGE_FORWARD, "GTK_SCROLL_PAGE_FORWARD", "page-forward" },
{ GTK_SCROLL_JUMP, "GTK_SCROLL_JUMP", "jump" },
};
static GtkEnumValue enum_values_GtkSelectionMode[] = {
static GtkEnumValue _gtk_selection_mode_values[] = {
{ GTK_SELECTION_SINGLE, "GTK_SELECTION_SINGLE", "single" },
{ GTK_SELECTION_BROWSE, "GTK_SELECTION_BROWSE", "browse" },
{ GTK_SELECTION_MULTIPLE, "GTK_SELECTION_MULTIPLE", "multiple" },
{ GTK_SELECTION_EXTENDED, "GTK_SELECTION_EXTENDED", "extended" },
};
static GtkEnumValue enum_values_GtkShadowType[] = {
static GtkEnumValue _gtk_shadow_type_values[] = {
{ GTK_SHADOW_NONE, "GTK_SHADOW_NONE", "none" },
{ GTK_SHADOW_IN, "GTK_SHADOW_IN", "in" },
{ GTK_SHADOW_OUT, "GTK_SHADOW_OUT", "out" },
{ GTK_SHADOW_ETCHED_IN, "GTK_SHADOW_ETCHED_IN", "etched-in" },
{ GTK_SHADOW_ETCHED_OUT, "GTK_SHADOW_ETCHED_OUT", "etched-out" },
};
static GtkEnumValue enum_values_GtkSignalRunType[] = {
static GtkEnumValue _gtk_signal_run_type_values[] = {
{ GTK_RUN_FIRST, "GTK_RUN_FIRST", "first" },
{ GTK_RUN_LAST, "GTK_RUN_LAST", "last" },
{ GTK_RUN_BOTH, "GTK_RUN_BOTH", "both" },
{ GTK_RUN_MASK, "GTK_RUN_MASK", "mask" },
{ GTK_RUN_NO_RECURSE, "GTK_RUN_NO_RECURSE", "no-recurse" },
{ GTK_RUN_ACTION, "GTK_RUN_ACTION", "action" },
};
static GtkEnumValue enum_values_GtkStateType[] = {
static GtkEnumValue _gtk_state_type_values[] = {
{ GTK_STATE_NORMAL, "GTK_STATE_NORMAL", "normal" },
{ GTK_STATE_ACTIVE, "GTK_STATE_ACTIVE", "active" },
{ GTK_STATE_PRELIGHT, "GTK_STATE_PRELIGHT", "prelight" },
{ GTK_STATE_SELECTED, "GTK_STATE_SELECTED", "selected" },
{ GTK_STATE_INSENSITIVE, "GTK_STATE_INSENSITIVE", "insensitive" },
};
static GtkEnumValue enum_values_GtkSubmenuDirection[] = {
static GtkEnumValue _gtk_submenu_direction_values[] = {
{ GTK_DIRECTION_LEFT, "GTK_DIRECTION_LEFT", "left" },
{ GTK_DIRECTION_RIGHT, "GTK_DIRECTION_RIGHT", "right" },
};
static GtkEnumValue enum_values_GtkSubmenuPlacement[] = {
static GtkEnumValue _gtk_submenu_placement_values[] = {
{ GTK_TOP_BOTTOM, "GTK_TOP_BOTTOM", "top-bottom" },
{ GTK_LEFT_RIGHT, "GTK_LEFT_RIGHT", "left-right" },
};
static GtkEnumValue enum_values_GtkToolbarStyle[] = {
static GtkEnumValue _gtk_toolbar_style_values[] = {
{ GTK_TOOLBAR_ICONS, "GTK_TOOLBAR_ICONS", "icons" },
{ GTK_TOOLBAR_TEXT, "GTK_TOOLBAR_TEXT", "text" },
{ GTK_TOOLBAR_BOTH, "GTK_TOOLBAR_BOTH", "both" },
};
static GtkEnumValue enum_values_GtkTroughType[] = {
static GtkEnumValue _gtk_trough_type_values[] = {
{ GTK_TROUGH_NONE, "GTK_TROUGH_NONE", "none" },
{ GTK_TROUGH_START, "GTK_TROUGH_START", "start" },
{ GTK_TROUGH_END, "GTK_TROUGH_END", "end" },
{ GTK_TROUGH_JUMP, "GTK_TROUGH_JUMP", "jump" },
};
static GtkEnumValue enum_values_GtkUpdateType[] = {
static GtkEnumValue _gtk_update_type_values[] = {
{ GTK_UPDATE_CONTINUOUS, "GTK_UPDATE_CONTINUOUS", "continuous" },
{ GTK_UPDATE_DISCONTINUOUS, "GTK_UPDATE_DISCONTINUOUS", "discontinuous" },
{ GTK_UPDATE_DELAYED, "GTK_UPDATE_DELAYED", "delayed" },
};
static GtkEnumValue enum_values_GtkVisibility[] = {
static GtkEnumValue _gtk_visibility_values[] = {
{ GTK_VISIBILITY_NONE, "GTK_VISIBILITY_NONE", "none" },
{ GTK_VISIBILITY_PARTIAL, "GTK_VISIBILITY_PARTIAL", "partial" },
{ GTK_VISIBILITY_FULL, "GTK_VISIBILITY_FULL", "full" },
};
static GtkEnumValue enum_values_GtkWindowPosition[] = {
static GtkEnumValue _gtk_window_position_values[] = {
{ GTK_WIN_POS_NONE, "GTK_WIN_POS_NONE", "none" },
{ GTK_WIN_POS_CENTER, "GTK_WIN_POS_CENTER", "center" },
{ GTK_WIN_POS_MOUSE, "GTK_WIN_POS_MOUSE", "mouse" },
};
static GtkEnumValue enum_values_GtkWindowType[] = {
static GtkEnumValue _gtk_window_type_values[] = {
{ GTK_WINDOW_TOPLEVEL, "GTK_WINDOW_TOPLEVEL", "toplevel" },
{ GTK_WINDOW_DIALOG, "GTK_WINDOW_DIALOG", "dialog" },
{ GTK_WINDOW_POPUP, "GTK_WINDOW_POPUP", "popup" },
};
static GtkEnumValue enum_values_GtkFundamentalType[] = {
static GtkEnumValue _gtk_fundamental_type_values[] = {
{ GTK_TYPE_INVALID, "GTK_TYPE_INVALID", "invalid" },
{ GTK_TYPE_NONE, "GTK_TYPE_NONE", "none" },
{ GTK_TYPE_CHAR, "GTK_TYPE_CHAR", "char" },
@ -510,25 +517,25 @@ static GtkEnumValue enum_values_GtkFundamentalType[] = {
{ GTK_TYPE_C_CALLBACK, "GTK_TYPE_C_CALLBACK", "c-callback" },
{ GTK_TYPE_OBJECT, "GTK_TYPE_OBJECT", "object" },
};
static GtkEnumValue enum_values_GtkDebugFlag[] = {
static GtkEnumValue _gtk_debug_flag_values[] = {
{ GTK_DEBUG_OBJECTS, "GTK_DEBUG_OBJECTS", "objects" },
{ GTK_DEBUG_MISC, "GTK_DEBUG_MISC", "misc" },
{ GTK_DEBUG_SIGNALS, "GTK_DEBUG_SIGNALS", "signals" },
};
static GtkEnumValue enum_values_GtkObjectFlags[] = {
static GtkEnumValue _gtk_object_flags_values[] = {
{ GTK_DESTROYED, "GTK_DESTROYED", "destroyed" },
{ GTK_FLOATING, "GTK_FLOATING", "floating" },
{ GTK_CONNECTED, "GTK_CONNECTED", "connected" },
{ GTK_OBJECT_FLAG_LAST, "GTK_OBJECT_FLAG_LAST", "object-flag-last" },
};
static GtkEnumValue enum_values_GtkArgFlags[] = {
static GtkEnumValue _gtk_arg_flags_values[] = {
{ GTK_ARG_READABLE, "GTK_ARG_READABLE", "readable" },
{ GTK_ARG_WRITABLE, "GTK_ARG_WRITABLE", "writable" },
{ GTK_ARG_CONSTRUCT, "GTK_ARG_CONSTRUCT", "construct" },
{ GTK_ARG_MASK, "GTK_ARG_MASK", "mask" },
{ GTK_ARG_READWRITE, "GTK_ARG_READWRITE", "readwrite" },
};
static GtkEnumValue enum_values_GtkWidgetFlags[] = {
static GtkEnumValue _gtk_widget_flags_values[] = {
{ GTK_TOPLEVEL, "GTK_TOPLEVEL", "toplevel" },
{ GTK_NO_WINDOW, "GTK_NO_WINDOW", "no-window" },
{ GTK_REALIZED, "GTK_REALIZED", "realized" },
@ -544,7 +551,7 @@ static GtkEnumValue enum_values_GtkWidgetFlags[] = {
{ GTK_RC_STYLE, "GTK_RC_STYLE", "rc-style" },
{ GTK_BASIC, "GTK_BASIC", "basic" },
};
static GtkEnumValue enum_values_GtkPrivateFlags[] = {
static GtkEnumValue _gtk_private_flags_values[] = {
{ PRIVATE_GTK_USER_STYLE, "PRIVATE_GTK_USER_STYLE", "user-style" },
{ PRIVATE_GTK_REDRAW_PENDING, "PRIVATE_GTK_REDRAW_PENDING", "redraw-pending" },
{ PRIVATE_GTK_RESIZE_PENDING, "PRIVATE_GTK_RESIZE_PENDING", "resize-pending" },
@ -553,11 +560,4 @@ static GtkEnumValue enum_values_GtkPrivateFlags[] = {
{ PRIVATE_GTK_HAS_SHAPE_MASK, "PRIVATE_GTK_HAS_SHAPE_MASK", "has-shape-mask" },
{ PRIVATE_GTK_IN_REPARENT, "PRIVATE_GTK_IN_REPARENT", "in-reparent" },
};
static GtkEnumValue enum_values_GdkDebugFlag[] = {
{ GDK_DEBUG_MISC, "GDK_DEBUG_MISC", "misc" },
{ GDK_DEBUG_EVENTS, "GDK_DEBUG_EVENTS", "events" },
{ GDK_DEBUG_DND, "GDK_DEBUG_DND", "dnd" },
{ GDK_DEBUG_COLOR_CONTEXT, "GDK_DEBUG_COLOR_CONTEXT", "color-context" },
{ GDK_DEBUG_XIM, "GDK_DEBUG_XIM", "xim" },
};

174
gtk/gtktypebuiltins_ids.c Normal file
View File

@ -0,0 +1,174 @@
/* type entries, generated by maketypes.awk */
{ "GdkWindowType", &GTK_TYPE_GDK_WINDOW_TYPE,
GTK_TYPE_ENUM, _gdk_window_type_values },
{ "GdkWindowClass", &GTK_TYPE_GDK_WINDOW_CLASS,
GTK_TYPE_ENUM, _gdk_window_class_values },
{ "GdkImageType", &GTK_TYPE_GDK_IMAGE_TYPE,
GTK_TYPE_ENUM, _gdk_image_type_values },
{ "GdkVisualType", &GTK_TYPE_GDK_VISUAL_TYPE,
GTK_TYPE_ENUM, _gdk_visual_type_values },
{ "GdkFontType", &GTK_TYPE_GDK_FONT_TYPE,
GTK_TYPE_ENUM, _gdk_font_type_values },
{ "GdkWindowAttributesType", &GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE,
GTK_TYPE_FLAGS, _gdk_window_attributes_type_values },
{ "GdkWindowHints", &GTK_TYPE_GDK_WINDOW_HINTS,
GTK_TYPE_FLAGS, _gdk_window_hints_values },
{ "GdkFunction", &GTK_TYPE_GDK_FUNCTION,
GTK_TYPE_ENUM, _gdk_function_values },
{ "GdkFill", &GTK_TYPE_GDK_FILL,
GTK_TYPE_ENUM, _gdk_fill_values },
{ "GdkFillRule", &GTK_TYPE_GDK_FILL_RULE,
GTK_TYPE_ENUM, _gdk_fill_rule_values },
{ "GdkLineStyle", &GTK_TYPE_GDK_LINE_STYLE,
GTK_TYPE_ENUM, _gdk_line_style_values },
{ "GdkCapStyle", &GTK_TYPE_GDK_CAP_STYLE,
GTK_TYPE_ENUM, _gdk_cap_style_values },
{ "GdkJoinStyle", &GTK_TYPE_GDK_JOIN_STYLE,
GTK_TYPE_ENUM, _gdk_join_style_values },
{ "GdkFilterReturn", &GTK_TYPE_GDK_FILTER_RETURN,
GTK_TYPE_ENUM, _gdk_filter_return_values },
{ "GdkVisibilityState", &GTK_TYPE_GDK_VISIBILITY_STATE,
GTK_TYPE_ENUM, _gdk_visibility_state_values },
{ "GdkEventType", &GTK_TYPE_GDK_EVENT_TYPE,
GTK_TYPE_ENUM, _gdk_event_type_values },
{ "GdkEventMask", &GTK_TYPE_GDK_EVENT_MASK,
GTK_TYPE_FLAGS, _gdk_event_mask_values },
{ "GdkNotifyType", &GTK_TYPE_GDK_NOTIFY_TYPE,
GTK_TYPE_ENUM, _gdk_notify_type_values },
{ "GdkCrossingMode", &GTK_TYPE_GDK_CROSSING_MODE,
GTK_TYPE_ENUM, _gdk_crossing_mode_values },
{ "GdkModifierType", &GTK_TYPE_GDK_MODIFIER_TYPE,
GTK_TYPE_FLAGS, _gdk_modifier_type_values },
{ "GdkSubwindowMode", &GTK_TYPE_GDK_SUBWINDOW_MODE,
GTK_TYPE_ENUM, _gdk_subwindow_mode_values },
{ "GdkInputCondition", &GTK_TYPE_GDK_INPUT_CONDITION,
GTK_TYPE_FLAGS, _gdk_input_condition_values },
{ "GdkStatus", &GTK_TYPE_GDK_STATUS,
GTK_TYPE_ENUM, _gdk_status_values },
{ "GdkByteOrder", &GTK_TYPE_GDK_BYTE_ORDER,
GTK_TYPE_ENUM, _gdk_byte_order_values },
{ "GdkGCValuesMask", &GTK_TYPE_GDK_G_C_VALUES_MASK,
GTK_TYPE_FLAGS, _gdk_g_c_values_mask_values },
{ "GdkSelection", &GTK_TYPE_GDK_SELECTION,
GTK_TYPE_ENUM, _gdk_selection_values },
{ "GdkPropertyState", &GTK_TYPE_GDK_PROPERTY_STATE,
GTK_TYPE_ENUM, _gdk_property_state_values },
{ "GdkPropMode", &GTK_TYPE_GDK_PROP_MODE,
GTK_TYPE_ENUM, _gdk_prop_mode_values },
{ "GdkDndType", &GTK_TYPE_GDK_DND_TYPE,
GTK_TYPE_ENUM, _gdk_dnd_type_values },
{ "GdkInputSource", &GTK_TYPE_GDK_INPUT_SOURCE,
GTK_TYPE_ENUM, _gdk_input_source_values },
{ "GdkInputMode", &GTK_TYPE_GDK_INPUT_MODE,
GTK_TYPE_ENUM, _gdk_input_mode_values },
{ "GdkAxisUse", &GTK_TYPE_GDK_AXIS_USE,
GTK_TYPE_ENUM, _gdk_axis_use_values },
{ "GdkTarget", &GTK_TYPE_GDK_TARGET,
GTK_TYPE_ENUM, _gdk_target_values },
{ "GdkSelectionType", &GTK_TYPE_GDK_SELECTION_TYPE,
GTK_TYPE_ENUM, _gdk_selection_type_values },
{ "GdkExtensionMode", &GTK_TYPE_GDK_EXTENSION_MODE,
GTK_TYPE_ENUM, _gdk_extension_mode_values },
{ "GdkWMDecoration", &GTK_TYPE_GDK_W_M_DECORATION,
GTK_TYPE_FLAGS, _gdk_w_m_decoration_values },
{ "GdkWMFunction", &GTK_TYPE_GDK_W_M_FUNCTION,
GTK_TYPE_FLAGS, _gdk_w_m_function_values },
{ "GdkColorContextMode", &GTK_TYPE_GDK_COLOR_CONTEXT_MODE,
GTK_TYPE_ENUM, _gdk_color_context_mode_values },
{ "GdkOverlapType", &GTK_TYPE_GDK_OVERLAP_TYPE,
GTK_TYPE_ENUM, _gdk_overlap_type_values },
{ "GdkDebugFlag", &GTK_TYPE_GDK_DEBUG_FLAG,
GTK_TYPE_FLAGS, _gdk_debug_flag_values },
{ "GtkAccelFlags", &GTK_TYPE_ACCEL_FLAGS,
GTK_TYPE_FLAGS, _gtk_accel_flags_values },
{ "GtkArrowType", &GTK_TYPE_ARROW_TYPE,
GTK_TYPE_ENUM, _gtk_arrow_type_values },
{ "GtkAttachOptions", &GTK_TYPE_ATTACH_OPTIONS,
GTK_TYPE_FLAGS, _gtk_attach_options_values },
{ "GtkButtonBoxStyle", &GTK_TYPE_BUTTON_BOX_STYLE,
GTK_TYPE_ENUM, _gtk_button_box_style_values },
{ "GtkCurveType", &GTK_TYPE_CURVE_TYPE,
GTK_TYPE_ENUM, _gtk_curve_type_values },
{ "GtkDirectionType", &GTK_TYPE_DIRECTION_TYPE,
GTK_TYPE_ENUM, _gtk_direction_type_values },
{ "GtkJustification", &GTK_TYPE_JUSTIFICATION,
GTK_TYPE_ENUM, _gtk_justification_values },
{ "GtkMatchType", &GTK_TYPE_MATCH_TYPE,
GTK_TYPE_ENUM, _gtk_match_type_values },
{ "GtkMenuFactoryType", &GTK_TYPE_MENU_FACTORY_TYPE,
GTK_TYPE_ENUM, _gtk_menu_factory_type_values },
{ "GtkMetricType", &GTK_TYPE_METRIC_TYPE,
GTK_TYPE_ENUM, _gtk_metric_type_values },
{ "GtkOrientation", &GTK_TYPE_ORIENTATION,
GTK_TYPE_ENUM, _gtk_orientation_values },
{ "GtkPackType", &GTK_TYPE_PACK_TYPE,
GTK_TYPE_ENUM, _gtk_pack_type_values },
{ "GtkPathPriorityType", &GTK_TYPE_PATH_PRIORITY_TYPE,
GTK_TYPE_ENUM, _gtk_path_priority_type_values },
{ "GtkPathType", &GTK_TYPE_PATH_TYPE,
GTK_TYPE_ENUM, _gtk_path_type_values },
{ "GtkPolicyType", &GTK_TYPE_POLICY_TYPE,
GTK_TYPE_ENUM, _gtk_policy_type_values },
{ "GtkPositionType", &GTK_TYPE_POSITION_TYPE,
GTK_TYPE_ENUM, _gtk_position_type_values },
{ "GtkPreviewType", &GTK_TYPE_PREVIEW_TYPE,
GTK_TYPE_ENUM, _gtk_preview_type_values },
{ "GtkReliefStyle", &GTK_TYPE_RELIEF_STYLE,
GTK_TYPE_ENUM, _gtk_relief_style_values },
{ "GtkScrollType", &GTK_TYPE_SCROLL_TYPE,
GTK_TYPE_ENUM, _gtk_scroll_type_values },
{ "GtkSelectionMode", &GTK_TYPE_SELECTION_MODE,
GTK_TYPE_ENUM, _gtk_selection_mode_values },
{ "GtkShadowType", &GTK_TYPE_SHADOW_TYPE,
GTK_TYPE_ENUM, _gtk_shadow_type_values },
{ "GtkSignalRunType", &GTK_TYPE_SIGNAL_RUN_TYPE,
GTK_TYPE_FLAGS, _gtk_signal_run_type_values },
{ "GtkStateType", &GTK_TYPE_STATE_TYPE,
GTK_TYPE_ENUM, _gtk_state_type_values },
{ "GtkSubmenuDirection", &GTK_TYPE_SUBMENU_DIRECTION,
GTK_TYPE_ENUM, _gtk_submenu_direction_values },
{ "GtkSubmenuPlacement", &GTK_TYPE_SUBMENU_PLACEMENT,
GTK_TYPE_ENUM, _gtk_submenu_placement_values },
{ "GtkToolbarStyle", &GTK_TYPE_TOOLBAR_STYLE,
GTK_TYPE_ENUM, _gtk_toolbar_style_values },
{ "GtkTroughType", &GTK_TYPE_TROUGH_TYPE,
GTK_TYPE_ENUM, _gtk_trough_type_values },
{ "GtkUpdateType", &GTK_TYPE_UPDATE_TYPE,
GTK_TYPE_ENUM, _gtk_update_type_values },
{ "GtkVisibility", &GTK_TYPE_VISIBILITY,
GTK_TYPE_ENUM, _gtk_visibility_values },
{ "GtkWindowPosition", &GTK_TYPE_WINDOW_POSITION,
GTK_TYPE_ENUM, _gtk_window_position_values },
{ "GtkWindowType", &GTK_TYPE_WINDOW_TYPE,
GTK_TYPE_ENUM, _gtk_window_type_values },
{ "GtkFundamentalType", &GTK_TYPE_FUNDAMENTAL_TYPE,
GTK_TYPE_ENUM, _gtk_fundamental_type_values },
{ "GtkDebugFlag", &GTK_TYPE_DEBUG_FLAG,
GTK_TYPE_FLAGS, _gtk_debug_flag_values },
{ "GtkObjectFlags", &GTK_TYPE_OBJECT_FLAGS,
GTK_TYPE_FLAGS, _gtk_object_flags_values },
{ "GtkArgFlags", &GTK_TYPE_ARG_FLAGS,
GTK_TYPE_FLAGS, _gtk_arg_flags_values },
{ "GtkWidgetFlags", &GTK_TYPE_WIDGET_FLAGS,
GTK_TYPE_FLAGS, _gtk_widget_flags_values },
{ "GtkPrivateFlags", &GTK_TYPE_PRIVATE_FLAGS,
GTK_TYPE_FLAGS, _gtk_private_flags_values },
{ "GtkAccelGroup", &GTK_TYPE_ACCEL_GROUP,
GTK_TYPE_BOXED, NULL },
{ "GtkSelectionData", &GTK_TYPE_SELECTION_DATA,
GTK_TYPE_BOXED, NULL },
{ "GtkStyle", &GTK_TYPE_STYLE,
GTK_TYPE_BOXED, NULL },
{ "GdkColormap", &GTK_TYPE_GDK_COLORMAP,
GTK_TYPE_BOXED, NULL },
{ "GdkVisual", &GTK_TYPE_GDK_VISUAL,
GTK_TYPE_BOXED, NULL },
{ "GdkFont", &GTK_TYPE_GDK_FONT,
GTK_TYPE_BOXED, NULL },
{ "GdkWindow", &GTK_TYPE_GDK_WINDOW,
GTK_TYPE_BOXED, NULL },
{ "GdkEvent", &GTK_TYPE_GDK_EVENT,
GTK_TYPE_BOXED, NULL },
{ "GdkColor", &GTK_TYPE_GDK_COLOR,
GTK_TYPE_BOXED, NULL },

88
gtk/gtktypebuiltins_vars.c Normal file
View File

@ -0,0 +1,88 @@
/* type variables, generated by maketypes.awk */
GtkType GTK_TYPE_GDK_WINDOW_TYPE = 0;
GtkType GTK_TYPE_GDK_WINDOW_CLASS = 0;
GtkType GTK_TYPE_GDK_IMAGE_TYPE = 0;
GtkType GTK_TYPE_GDK_VISUAL_TYPE = 0;
GtkType GTK_TYPE_GDK_FONT_TYPE = 0;
GtkType GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE = 0;
GtkType GTK_TYPE_GDK_WINDOW_HINTS = 0;
GtkType GTK_TYPE_GDK_FUNCTION = 0;
GtkType GTK_TYPE_GDK_FILL = 0;
GtkType GTK_TYPE_GDK_FILL_RULE = 0;
GtkType GTK_TYPE_GDK_LINE_STYLE = 0;
GtkType GTK_TYPE_GDK_CAP_STYLE = 0;
GtkType GTK_TYPE_GDK_JOIN_STYLE = 0;
GtkType GTK_TYPE_GDK_FILTER_RETURN = 0;
GtkType GTK_TYPE_GDK_VISIBILITY_STATE = 0;
GtkType GTK_TYPE_GDK_EVENT_TYPE = 0;
GtkType GTK_TYPE_GDK_EVENT_MASK = 0;
GtkType GTK_TYPE_GDK_NOTIFY_TYPE = 0;
GtkType GTK_TYPE_GDK_CROSSING_MODE = 0;
GtkType GTK_TYPE_GDK_MODIFIER_TYPE = 0;
GtkType GTK_TYPE_GDK_SUBWINDOW_MODE = 0;
GtkType GTK_TYPE_GDK_INPUT_CONDITION = 0;
GtkType GTK_TYPE_GDK_STATUS = 0;
GtkType GTK_TYPE_GDK_BYTE_ORDER = 0;
GtkType GTK_TYPE_GDK_G_C_VALUES_MASK = 0;
GtkType GTK_TYPE_GDK_SELECTION = 0;
GtkType GTK_TYPE_GDK_PROPERTY_STATE = 0;
GtkType GTK_TYPE_GDK_PROP_MODE = 0;
GtkType GTK_TYPE_GDK_DND_TYPE = 0;
GtkType GTK_TYPE_GDK_INPUT_SOURCE = 0;
GtkType GTK_TYPE_GDK_INPUT_MODE = 0;
GtkType GTK_TYPE_GDK_AXIS_USE = 0;
GtkType GTK_TYPE_GDK_TARGET = 0;
GtkType GTK_TYPE_GDK_SELECTION_TYPE = 0;
GtkType GTK_TYPE_GDK_EXTENSION_MODE = 0;
GtkType GTK_TYPE_GDK_W_M_DECORATION = 0;
GtkType GTK_TYPE_GDK_W_M_FUNCTION = 0;
GtkType GTK_TYPE_GDK_COLOR_CONTEXT_MODE = 0;
GtkType GTK_TYPE_GDK_OVERLAP_TYPE = 0;
GtkType GTK_TYPE_GDK_DEBUG_FLAG = 0;
GtkType GTK_TYPE_ACCEL_FLAGS = 0;
GtkType GTK_TYPE_ARROW_TYPE = 0;
GtkType GTK_TYPE_ATTACH_OPTIONS = 0;
GtkType GTK_TYPE_BUTTON_BOX_STYLE = 0;
GtkType GTK_TYPE_CURVE_TYPE = 0;
GtkType GTK_TYPE_DIRECTION_TYPE = 0;
GtkType GTK_TYPE_JUSTIFICATION = 0;
GtkType GTK_TYPE_MATCH_TYPE = 0;
GtkType GTK_TYPE_MENU_FACTORY_TYPE = 0;
GtkType GTK_TYPE_METRIC_TYPE = 0;
GtkType GTK_TYPE_ORIENTATION = 0;
GtkType GTK_TYPE_PACK_TYPE = 0;
GtkType GTK_TYPE_PATH_PRIORITY_TYPE = 0;
GtkType GTK_TYPE_PATH_TYPE = 0;
GtkType GTK_TYPE_POLICY_TYPE = 0;
GtkType GTK_TYPE_POSITION_TYPE = 0;
GtkType GTK_TYPE_PREVIEW_TYPE = 0;
GtkType GTK_TYPE_RELIEF_STYLE = 0;
GtkType GTK_TYPE_SCROLL_TYPE = 0;
GtkType GTK_TYPE_SELECTION_MODE = 0;
GtkType GTK_TYPE_SHADOW_TYPE = 0;
GtkType GTK_TYPE_SIGNAL_RUN_TYPE = 0;
GtkType GTK_TYPE_STATE_TYPE = 0;
GtkType GTK_TYPE_SUBMENU_DIRECTION = 0;
GtkType GTK_TYPE_SUBMENU_PLACEMENT = 0;
GtkType GTK_TYPE_TOOLBAR_STYLE = 0;
GtkType GTK_TYPE_TROUGH_TYPE = 0;
GtkType GTK_TYPE_UPDATE_TYPE = 0;
GtkType GTK_TYPE_VISIBILITY = 0;
GtkType GTK_TYPE_WINDOW_POSITION = 0;
GtkType GTK_TYPE_WINDOW_TYPE = 0;
GtkType GTK_TYPE_FUNDAMENTAL_TYPE = 0;
GtkType GTK_TYPE_DEBUG_FLAG = 0;
GtkType GTK_TYPE_OBJECT_FLAGS = 0;
GtkType GTK_TYPE_ARG_FLAGS = 0;
GtkType GTK_TYPE_WIDGET_FLAGS = 0;
GtkType GTK_TYPE_PRIVATE_FLAGS = 0;
GtkType GTK_TYPE_ACCEL_GROUP = 0;
GtkType GTK_TYPE_SELECTION_DATA = 0;
GtkType GTK_TYPE_STYLE = 0;
GtkType GTK_TYPE_GDK_COLORMAP = 0;
GtkType GTK_TYPE_GDK_VISUAL = 0;
GtkType GTK_TYPE_GDK_FONT = 0;
GtkType GTK_TYPE_GDK_WINDOW = 0;
GtkType GTK_TYPE_GDK_EVENT = 0;
GtkType GTK_TYPE_GDK_COLOR = 0;

104
gtk/gtktypeutils.c
View File

@ -148,37 +148,34 @@ gtk_type_set_chunk_alloc (GtkType type,
G_ALLOC_AND_FREE);
}
GtkType
gtk_type_unique (GtkType parent_type,
static GtkType
gtk_type_create (GtkType parent_type,
gchar *type_name,
GtkTypeInfo *type_info)
{
GtkTypeNode *new_node;
GtkTypeNode *parent;
guint i;
g_return_val_if_fail (type_info != NULL, 0);
if (n_type_nodes == 0)
gtk_type_init ();
if (g_hash_table_lookup (type_name_2_type_ht, type_info->type_name))
if (g_hash_table_lookup (type_name_2_type_ht, type_name))
{
g_warning ("gtk_type_unique(): type `%s' already exists.", type_info->type_name);
g_warning ("gtk_type_create(): type `%s' already exists.", type_name);
return 0;
}
if (parent_type)
{
GtkTypeNode *tmp_node;
LOOKUP_TYPE_NODE (tmp_node, parent_type);
if (!tmp_node)
{
g_warning ("gtk_type_unique(): unknown parent type `%u'.", parent_type);
g_warning ("gtk_type_create(): unknown parent type `%u'.", parent_type);
return 0;
}
}
/* relookup pointer afterwards.
/* relookup pointers afterwards.
*/
new_node = gtk_type_node_next_and_invalidate ();
@ -194,7 +191,7 @@ gtk_type_unique (GtkType parent_type,
}
new_node->type_info = *type_info;
new_node->type_info.type_name = g_strdup (type_info->type_name);
new_node->type_info.type_name = type_name;
new_node->n_supers = parent ? parent->n_supers + 1 : 0;
new_node->chunk_alloc_locked = FALSE;
new_node->supers = g_new0 (GtkType, new_node->n_supers + 1);
@ -218,6 +215,31 @@ gtk_type_unique (GtkType parent_type,
return new_node->type;
}
GtkType
gtk_type_unique (GtkType parent_type,
GtkTypeInfo *type_info)
{
GtkType new_type;
gchar *type_name;
g_return_val_if_fail (type_info != NULL, 0);
g_return_val_if_fail (type_info->type_name != NULL, 0);
if (n_type_nodes == 0)
gtk_type_init ();
type_name = g_strdup (type_info->type_name);
/* relookup pointers afterwards.
*/
new_type = gtk_type_create (parent_type, type_name, type_info);
if (!new_type)
g_free (type_name);
return new_type;
}
gchar*
gtk_type_name (GtkType type)
{
@ -595,8 +617,8 @@ gtk_type_name_compare (const char *a,
return (strcmp (a, b) == 0);
}
static GtkType
gtk_type_register_builtin (char *name,
static inline GtkType
gtk_type_register_builtin (gchar *name,
GtkType parent)
{
GtkTypeInfo info;
@ -608,15 +630,18 @@ gtk_type_register_builtin (char *name,
info.arg_set_func = NULL;
info.arg_get_func = NULL;
return gtk_type_unique (parent, &info);
return gtk_type_create (parent, name, &info);
}
extern void gtk_object_init_type (void);
GtkType gtk_type_builtins[GTK_TYPE_NUM_BUILTINS];
#include "makeenums.h" /* include for various places with enum definitions */
#include "gtktypebuiltins1.c"
#include "makeenums.h" /* include for various places
* with enum definitions
*/
#include "gtktypebuiltins_vars.c" /* type variable declarations
*/
#include "gtktypebuiltins_evals.c" /* enum value definition arrays
*/
static void
gtk_type_init_builtin_types (void)
@ -651,33 +676,48 @@ gtk_type_init_builtin_types (void)
{ GTK_TYPE_C_CALLBACK, "c_callback" }
};
struct {
gchar *name;
gchar *type_name;
GtkType *type_id;
GtkType parent;
GtkEnumValue *values;
} builtin_info[] = {
#include "gtktypebuiltins2.c"
} builtin_info[GTK_TYPE_NUM_BUILTINS + 1] = {
#include "gtktypebuiltins_ids.c" /* type entries */
{ NULL }
};
guint i;
for (i = 0; i < sizeof (fundamental_info) / sizeof (fundamental_info[0]); i++)
{
GtkType id;
GtkType type_id;
id = gtk_type_register_builtin (fundamental_info[i].name,
type_id = gtk_type_register_builtin (fundamental_info[i].name,
GTK_TYPE_INVALID);
g_assert (id == fundamental_info[i].type_id);
g_assert (type_id == fundamental_info[i].type_id);
}
gtk_object_init_type ();
for (i = 0; builtin_info[i].name; i++)
for (i = 0; i < GTK_TYPE_NUM_BUILTINS; i++)
{
gtk_type_builtins[i] =
gtk_type_register_builtin (builtin_info[i].name,
GtkType type_id;
g_assert (builtin_info[i].type_name != NULL);
type_id =
gtk_type_register_builtin (builtin_info[i].type_name,
builtin_info[i].parent);
if (gtk_type_is_a (gtk_type_builtins[i], GTK_TYPE_ENUM) ||
gtk_type_is_a (gtk_type_builtins[i], GTK_TYPE_FLAGS))
gtk_enum_set_values (gtk_type_builtins[i], builtin_info[i].values);
g_assert (type_id != GTK_TYPE_INVALID);
(*builtin_info[i].type_id) = type_id;
if (builtin_info[i].values)
{
g_assert (gtk_type_is_a (type_id, GTK_TYPE_ENUM) ||
gtk_type_is_a (type_id, GTK_TYPE_FLAGS));
gtk_enum_set_values (type_id, builtin_info[i].values);
}
}
}

1
gtk/gtktypeutils.h
View File

@ -67,7 +67,6 @@ typedef guint GtkType;
/* Builtin Types
*/
extern GtkType gtk_type_builtins[];
#include <gtk/gtktypebuiltins.h>
/* Macros

29
gtk/gtkwidget.c
View File

@ -184,6 +184,8 @@ static void gtk_widget_real_draw (GtkWidget *widget,
GdkRectangle *area);
static void gtk_widget_real_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static gint gtk_widget_real_key_press_event (GtkWidget *widget,
GdkEventKey *event);
static void gtk_widget_style_set (GtkWidget *widget,
GtkStyle *previous_style);
@ -394,7 +396,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
gtk_widget_marshal_signal_5,
GTK_TYPE_NONE, 1,
GTK_TYPE_UINT);
GTK_TYPE_STATE_TYPE);
widget_signals[PARENT_SET] =
gtk_signal_new ("parent_set",
GTK_RUN_FIRST,
@ -410,7 +412,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
GTK_SIGNAL_OFFSET (GtkWidgetClass, style_set),
gtk_widget_marshal_signal_7,
GTK_TYPE_NONE, 1,
GTK_TYPE_BOXED);
GTK_TYPE_STYLE);
widget_signals[ADD_ACCELERATOR] =
gtk_accel_group_create_add (object_class->type, GTK_RUN_LAST,
GTK_SIGNAL_OFFSET (GtkWidgetClass, add_accelerator));
@ -583,8 +585,8 @@ gtk_widget_class_init (GtkWidgetClass *klass)
object_class->type,
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_received),
gtk_widget_marshal_signal_1,
GTK_TYPE_BOOL, 1,
GTK_TYPE_GDK_EVENT);
GTK_TYPE_NONE, 1,
GTK_TYPE_SELECTION_DATA);
widget_signals[PROXIMITY_IN_EVENT] =
gtk_signal_new ("proximity_in_event",
GTK_RUN_LAST,
@ -714,7 +716,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
klass->delete_event = NULL;
klass->destroy_event = NULL;
klass->expose_event = NULL;
klass->key_press_event = NULL;
klass->key_press_event = gtk_widget_real_key_press_event;
klass->key_release_event = NULL;
klass->enter_notify_event = NULL;
klass->leave_notify_event = NULL;
@ -1941,6 +1943,23 @@ gtk_widget_accelerator_signal (GtkWidget *widget,
return 0;
}
static gint
gtk_widget_real_key_press_event (GtkWidget *widget,
GdkEventKey *event)
{
gboolean handled = FALSE;
g_return_val_if_fail (widget != NULL, handled);
g_return_val_if_fail (GTK_IS_WIDGET (widget), handled);
g_return_val_if_fail (event != NULL, handled);
if (!handled)
handled = gtk_bindings_activate (GTK_OBJECT (widget),
event->keyval, event->state);
return handled;
}
/*****************************************
* gtk_widget_event:
*

10
gtk/gtkwidget.h
View File

@ -251,7 +251,7 @@ struct _GtkWidgetClass
void (* size_allocate) (GtkWidget *widget,
GtkAllocation *allocation);
void (* state_changed) (GtkWidget *widget,
guint previous_state);
GtkStateType previous_state);
void (* parent_set) (GtkWidget *widget,
GtkWidget *previous_parent);
void (* style_set) (GtkWidget *widget,
@ -262,12 +262,12 @@ struct _GtkWidgetClass
guint accel_signal_id,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods,
GdkModifierType accel_mods,
GtkAccelFlags accel_flags);
void (* remove_accelerator) (GtkWidget *widget,
GtkAccelGroup *accel_group,
guint accel_key,
guint accel_mods);
GdkModifierType accel_mods);
/* events */
gint (* event) (GtkWidget *widget,
@ -336,8 +336,8 @@ struct _GtkWidgetClass
GdkEventOther *event);
/* selection */
void (* selection_received) (GtkWidget *widget,
GtkSelectionData *selection_data);
void (* selection_received) (GtkWidget *widget,
GtkSelectionData *selection_data);
};
struct _GtkWidgetAuxInfo

18
gtk/gtkwindow.c
View File

@ -159,7 +159,7 @@ gtk_window_class_init (GtkWindowClass *klass)
gtk_object_add_arg_type ("GtkWindow::auto_shrink", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_AUTO_SHRINK);
gtk_object_add_arg_type ("GtkWindow::allow_shrink", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ALLOW_SHRINK);
gtk_object_add_arg_type ("GtkWindow::allow_grow", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ALLOW_GROW);
gtk_object_add_arg_type ("GtkWindow::window_position", GTK_TYPE_ENUM, GTK_ARG_READWRITE, ARG_WIN_POS);
gtk_object_add_arg_type ("GtkWindow::window_position", GTK_TYPE_WINDOW_POSITION, GTK_ARG_READWRITE, ARG_WIN_POS);
window_signals[MOVE_RESIZE] =
gtk_signal_new ("move_resize",
@ -755,10 +755,6 @@ gtk_window_key_press_event (GtkWidget *widget,
if (window->focus_widget)
{
handled = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
if (!handled)
handled = gtk_bindings_activate (GTK_OBJECT (window->focus_widget),
event->keyval, event->state);
}
if (!handled)
@ -829,6 +825,9 @@ gtk_window_key_press_event (GtkWidget *widget,
}
}
if (!handled && GTK_WIDGET_CLASS (parent_class)->key_press_event)
handled = GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
return handled;
}
@ -848,12 +847,11 @@ gtk_window_key_release_event (GtkWidget *widget,
if (window->focus_widget)
{
handled = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
if (!handled)
handled = gtk_bindings_activate (GTK_OBJECT (window->focus_widget),
event->keyval, event->state | GDK_AFTER_MASK);
}
if (!handled && GTK_WIDGET_CLASS (parent_class)->key_release_event)
handled = GTK_WIDGET_CLASS (parent_class)->key_release_event (widget, event);
return handled;
}

23
gtk/makeenums.awk
View File

@ -10,6 +10,7 @@ BEGIN {
VI = 0;
gen_arrays = 0;
gen_defs = 0;
comment_file = "";
for (i = 1; i < ARGC; i++)
{
@ -65,7 +66,7 @@ function generate_arrays ()
{
if (gen_arrays)
{
printf ("static GtkEnumValue enum_values_%s[] = {\n", type_name);
printf ("static GtkEnumValue %s_values[] = {\n", type_ident);
for (i = 0; i < VI; i++)
{
printf (" { %s, \"%s\", \"%s\" },\n",
@ -79,6 +80,12 @@ function generate_defs ()
{
if (gen_defs)
{
if (comment_file != "")
{
printf ("\n; enumerations from \"%s\"\n", comment_file);
comment_file = "";
}
printf ("\n(define-%s %s",
type_flags ? "flags" : "enum",
type_name);
@ -91,6 +98,15 @@ function generate_defs ()
}
}
function basename (basename_1)
{
sub ("\"", "", basename_1);
while (match (basename_1, "/"))
sub (".*/", "", basename_1);
sub ("\"", "", basename_1);
return basename_1;
}
# parse keywords
/G_ENUM_E/ {
@ -125,6 +141,11 @@ function generate_defs ()
VI += 1;
}
# feature per file comments
/# / {
comment_file = basename($3);
}
END {
printf("\n");
}

3
gtk/makeenums.h
View File

@ -1,4 +1,5 @@
#include <gdk/gdkprivate.h>
#include <gdk/gdk.h>
#include <gtk/gtk.h>
#include <gtk/gtkprivate.h>
#include <gtk/gtkdebug.h>
#include <gdk/gdkprivate.h>

119
gtk/maketypes.awk Normal file
View File

@ -0,0 +1,119 @@
BEGIN {
type_name = ""; # GtkEnumType
type_macro = ""; # GTK_TYPE_ENUM_TYPE
type_ident = ""; # _gtk_enum_type
type_counter = 0;
gen_macros = 0;
gen_entries = 0;
gen_vars = 0;
for (i = 2; i < ARGC; i++)
{
if (ARGV[i] == "macros")
gen_macros = 1;
else if (ARGV[i] == "entries")
gen_entries = 1;
else if (ARGV[i] == "variables")
gen_vars = 1;
ARGV[i] = "";
}
if (gen_macros)
printf ("/* type macros, generated by maketypes.awk */\n\n");
else if (gen_entries)
printf ("/* type entries, generated by maketypes.awk */\n\n");
else if (gen_vars)
printf ("/* type variables, generated by maketypes.awk */\n\n");
else
{
printf ("hm? what do you want me to do?\n") > "/dev/stderr";
exit 1;
}
}
function set_type (set_type_1)
{
type_counter += 1;
type_name = set_type_1;
type_macro = "GTK_TYPE";
type_ident = "";
for (i = 0; i < length (type_name); i++)
{
ch = substr (type_name, i + 1, 1);
Ch = toupper (ch);
if (Ch == ch)
{
type_macro = type_macro "_" Ch;
type_ident = type_ident "_" tolower (ch);
}
else
{
type_macro = type_macro Ch;
type_ident = type_ident ch;
}
}
sub ("^GTK_TYPE_GTK_", "GTK_TYPE_", type_macro);
}
function generate (generate_1)
{
if (gen_macros)
{
printf ("extern GtkType %s;\n", type_macro);
}
if (gen_entries)
{
printf (" { \"%s\", &%s,\n", type_name, type_macro);
if (generate_1 == "BOXED")
printf (" GTK_TYPE_%s, NULL },\n", generate_1);
else
printf (" GTK_TYPE_%s, %s_values },\n", generate_1, type_ident);
}
if (gen_vars)
{
printf ("GtkType %s = 0;\n", type_macro);
}
}
# skip scheme comments
";" {
sub (";.*", "");
}
# parse keywords
/\(define-enum/ {
if ($2 == "")
printf ("huh? define-enum keyword without arg?\n") > "/dev/stderr";
else
{
set_type($2);
generate("ENUM");
}
}
/\(define-flags/ {
if ($2 == "")
printf ("huh? define-flags keyword without arg?\n") > "/dev/stderr";
else
{
set_type($2);
generate("FLAGS");
}
}
/\(define-boxed/ {
if ($2 == "")
printf ("huh? define-boxed keyword without arg?\n") > "/dev/stderr";
else
{
set_type($2);
generate("BOXED");
}
}
END {
if (gen_macros)
printf("\n#define\tGTK_TYPE_NUM_BUILTINS\t(%u)\n", type_counter);
}

6
gtk/runelisp
View File

@ -1,6 +0,0 @@
#! /bin/sh
if test $# -lt 1; then
echo >&2 "usage: $0 file.el"
exit 1
fi
exec emacs --no-init-file --no-site-file --batch --load $*