Gen: re-run gen script

commit: 888497b96c877e65af7a99a8e94254f705936076
author: jwijenbergh · 2y ago · 2024-01-15 09:01 UTC
parent: 562a1aa
signature: GPG Unverified1A2298F6C34F96E5 The key is unknown

124 files · +1128 -1128

M v4/adw/adw-animation-target.go +4 -4


@@ -119,14 +119,14 @@ func NewPropertyAnimationTarget(ObjectVar *gobject.Object, PropertyNameVar strin
119	119		return cls
120	120		}
121	121
122		-	var xNewForPspecPropertyAnimationTarget func(uintptr, uintptr) uintptr
	122	+	var xNewPropertyAnimationTargetForPspec func(uintptr, uintptr) uintptr
123	123
124	124		// Creates a new `AdwPropertyAnimationTarget` for the @pspec property on
125	125		// @object.
126		-	func NewForPspecPropertyAnimationTarget(ObjectVar gobject.Object, PspecVar gobject.ParamSpec) *PropertyAnimationTarget {
	126	+	func NewPropertyAnimationTargetForPspec(ObjectVar gobject.Object, PspecVar gobject.ParamSpec) *PropertyAnimationTarget {
127	127		var cls *PropertyAnimationTarget
128	128
129		-	cret := xNewForPspecPropertyAnimationTarget(ObjectVar.GoPointer(), PspecVar.GoPointer())
	129	+	cret := xNewPropertyAnimationTargetForPspec(ObjectVar.GoPointer(), PspecVar.GoPointer())
130	130
131	131		if cret == 0 {
132	132		return nil

@@ -191,7 +191,7 @@ func init() {
191	191		core.PuregoSafeRegister(&xNewCallbackAnimationTarget, lib, "adw_callback_animation_target_new")
192	192
193	193		core.PuregoSafeRegister(&xNewPropertyAnimationTarget, lib, "adw_property_animation_target_new")
194		-	core.PuregoSafeRegister(&xNewForPspecPropertyAnimationTarget, lib, "adw_property_animation_target_new_for_pspec")
	194	+	core.PuregoSafeRegister(&xNewPropertyAnimationTargetForPspec, lib, "adw_property_animation_target_new_for_pspec")
195	195
196	196		core.PuregoSafeRegister(&xPropertyAnimationTargetGetObject, lib, "adw_property_animation_target_get_object")
197	197		core.PuregoSafeRegister(&xPropertyAnimationTargetGetPspec, lib, "adw_property_animation_target_get_pspec")

M v4/adw/adw-spring-params.go +4 -4


@@ -68,15 +68,15 @@ func NewSpringParams(DampingRatioVar float64, MassVar float64, StiffnessVar floa
68	68		return cret
69	69		}
70	70
71		-	var xNewFullSpringParams func(float64, float64, float64) *SpringParams
	71	+	var xNewSpringParamsFull func(float64, float64, float64) *SpringParams
72	72
73	73		// Creates a new `AdwSpringParams` from @mass, @stiffness and @damping.
74	74		//
75	75		// See [ctor@SpringParams.new] for a simplified constructor using damping ratio
76	76		// instead of @damping.
77		-	func NewFullSpringParams(DampingVar float64, MassVar float64, StiffnessVar float64) *SpringParams {
	77	+	func NewSpringParamsFull(DampingVar float64, MassVar float64, StiffnessVar float64) *SpringParams {
78	78
79		-	cret := xNewFullSpringParams(DampingVar, MassVar, StiffnessVar)
	79	+	cret := xNewSpringParamsFull(DampingVar, MassVar, StiffnessVar)
80	80		return cret
81	81		}
82	82

@@ -143,7 +143,7 @@ func init() {
143	143		}
144	144
145	145		core.PuregoSafeRegister(&xNewSpringParams, lib, "adw_spring_params_new")
146		-	core.PuregoSafeRegister(&xNewFullSpringParams, lib, "adw_spring_params_new_full")
	146	+	core.PuregoSafeRegister(&xNewSpringParamsFull, lib, "adw_spring_params_new_full")
147	147
148	148		core.PuregoSafeRegister(&xSpringParamsGetDamping, lib, "adw_spring_params_get_damping")
149	149		core.PuregoSafeRegister(&xSpringParamsGetDampingRatio, lib, "adw_spring_params_get_damping_ratio")

M v4/adw/adw-toast.go +4 -4


@@ -193,17 +193,17 @@ func NewToast(TitleVar string) *Toast {
193	193		return cls
194	194		}
195	195
196		-	var xNewFormatToast func(string, ...interface{}) uintptr
	196	+	var xNewToastFormat func(string, ...interface{}) uintptr
197	197
198	198		// Creates a new `AdwToast`.
199	199		//
200	200		// The toast will use the format string as its title.
201	201		//
202	202		// See also: [ctor@Toast.new]
203		-	func NewFormatToast(FormatVar string, varArgs ...interface{}) *Toast {
	203	+	func NewToastFormat(FormatVar string, varArgs ...interface{}) *Toast {
204	204		var cls *Toast
205	205
206		-	cret := xNewFormatToast(FormatVar, varArgs...)
	206	+	cret := xNewToastFormat(FormatVar, varArgs...)
207	207
208	208		if cret == 0 {
209	209		return nil

@@ -470,7 +470,7 @@ func init() {
470	470		}
471	471
472	472		core.PuregoSafeRegister(&xNewToast, lib, "adw_toast_new")
473		-	core.PuregoSafeRegister(&xNewFormatToast, lib, "adw_toast_new_format")
	473	+	core.PuregoSafeRegister(&xNewToastFormat, lib, "adw_toast_new_format")
474	474
475	475		core.PuregoSafeRegister(&xToastDismiss, lib, "adw_toast_dismiss")
476	476		core.PuregoSafeRegister(&xToastGetActionName, lib, "adw_toast_get_action_name")

M v4/gdk/gdkcontentformats.go +8 -8


@@ -112,26 +112,26 @@ func (x *FileList) GoPointer() uintptr {
112	112		return uintptr(unsafe.Pointer(x))
113	113		}
114	114
115		-	var xNewFromArrayFileList func(uintptr, uint) *FileList
	115	+	var xNewFileListFromArray func(uintptr, uint) *FileList
116	116
117	117		// Creates a new `GdkFileList` for the given array of files.
118	118		//
119	119		// This function is meant to be used by language bindings.
120		-	func NewFromArrayFileList(FilesVar uintptr, NFilesVar uint) *FileList {
	120	+	func NewFileListFromArray(FilesVar uintptr, NFilesVar uint) *FileList {
121	121
122		-	cret := xNewFromArrayFileList(FilesVar, NFilesVar)
	122	+	cret := xNewFileListFromArray(FilesVar, NFilesVar)
123	123		return cret
124	124		}
125	125
126		-	var xNewFromListFileList func(glib.SList) FileList
	126	+	var xNewFileListFromList func(glib.SList) FileList
127	127
128	128		// Creates a new files list container from a singly linked list of
129	129		// `GFile` instances.
130	130		//
131	131		// This function is meant to be used by language bindings
132		-	func NewFromListFileList(FilesVar glib.SList) FileList {
	132	+	func NewFileListFromList(FilesVar glib.SList) FileList {
133	133
134		-	cret := xNewFromListFileList(FilesVar)
	134	+	cret := xNewFileListFromList(FilesVar)
135	135		return cret
136	136		}
137	137

@@ -192,8 +192,8 @@ func init() {
192	192		core.PuregoSafeRegister(&xContentFormatsBuilderToFormats, lib, "gdk_content_formats_builder_to_formats")
193	193		core.PuregoSafeRegister(&xContentFormatsBuilderUnref, lib, "gdk_content_formats_builder_unref")
194	194
195		-	core.PuregoSafeRegister(&xNewFromArrayFileList, lib, "gdk_file_list_new_from_array")
196		-	core.PuregoSafeRegister(&xNewFromListFileList, lib, "gdk_file_list_new_from_list")
	195	+	core.PuregoSafeRegister(&xNewFileListFromArray, lib, "gdk_file_list_new_from_array")
	196	+	core.PuregoSafeRegister(&xNewFileListFromList, lib, "gdk_file_list_new_from_list")
197	197
198	198		core.PuregoSafeRegister(&xFileListGetFiles, lib, "gdk_file_list_get_files")
199	199

M v4/gdk/gdkcontentprovider.go +16 -16


@@ -41,14 +41,14 @@ func ContentProviderNewFromInternalPtr(ptr uintptr) *ContentProvider {
41	41		return cls
42	42		}
43	43
44		-	var xNewForBytesContentProvider func(string, *glib.Bytes) uintptr
	44	+	var xNewContentProviderForBytes func(string, *glib.Bytes) uintptr
45	45
46	46		// Create a content provider that provides the given @bytes as data for
47	47		// the given @mime_type.
48		-	func NewForBytesContentProvider(MimeTypeVar string, BytesVar glib.Bytes) ContentProvider {
	48	+	func NewContentProviderForBytes(MimeTypeVar string, BytesVar glib.Bytes) ContentProvider {
49	49		var cls *ContentProvider
50	50
51		-	cret := xNewForBytesContentProvider(MimeTypeVar, BytesVar)
	51	+	cret := xNewContentProviderForBytes(MimeTypeVar, BytesVar)
52	52
53	53		if cret == 0 {
54	54		return nil

@@ -58,13 +58,13 @@ func NewForBytesContentProvider(MimeTypeVar string, BytesVar glib.Bytes) Conte
58	58		return cls
59	59		}
60	60
61		-	var xNewForValueContentProvider func(*gobject.Value) uintptr
	61	+	var xNewContentProviderForValue func(*gobject.Value) uintptr
62	62
63	63		// Create a content provider that provides the given @value.
64		-	func NewForValueContentProvider(ValueVar gobject.Value) ContentProvider {
	64	+	func NewContentProviderForValue(ValueVar gobject.Value) ContentProvider {
65	65		var cls *ContentProvider
66	66
67		-	cret := xNewForValueContentProvider(ValueVar)
	67	+	cret := xNewContentProviderForValue(ValueVar)
68	68
69	69		if cret == 0 {
70	70		return nil

@@ -74,17 +74,17 @@ func NewForValueContentProvider(ValueVar gobject.Value) ContentProvider {
74	74		return cls
75	75		}
76	76
77		-	var xNewTypedContentProvider func([]interface{}, ...interface{}) uintptr
	77	+	var xNewContentProviderTyped func([]interface{}, ...interface{}) uintptr
78	78
79	79		// Create a content provider that provides the value of the given
80	80		// @type.
81	81		//
82	82		// The value is provided using G_VALUE_COLLECT(), so the same rules
83	83		// apply as when calling g_object_new() or g_object_set().
84		-	func NewTypedContentProvider(TypeVar []interface{}, varArgs ...interface{}) *ContentProvider {
	84	+	func NewContentProviderTyped(TypeVar []interface{}, varArgs ...interface{}) *ContentProvider {
85	85		var cls *ContentProvider
86	86
87		-	cret := xNewTypedContentProvider(TypeVar, varArgs...)
	87	+	cret := xNewContentProviderTyped(TypeVar, varArgs...)
88	88
89	89		if cret == 0 {
90	90		return nil

@@ -94,7 +94,7 @@ func NewTypedContentProvider(TypeVar []interface{}, varArgs ...interface{}) *Con
94	94		return cls
95	95		}
96	96
97		-	var xNewUnionContentProvider func(uintptr, uint) uintptr
	97	+	var xNewContentProviderUnion func(uintptr, uint) uintptr
98	98
99	99		// Creates a content provider that represents all the given @providers.
100	100		//

@@ -113,10 +113,10 @@ var xNewUnionContentProvider func(uintptr, uint) uintptr
113	113		// }, 2);
114	114		//
115	115		// ```
116		-	func NewUnionContentProvider(ProvidersVar uintptr, NProvidersVar uint) *ContentProvider {
	116	+	func NewContentProviderUnion(ProvidersVar uintptr, NProvidersVar uint) *ContentProvider {
117	117		var cls *ContentProvider
118	118
119		-	cret := xNewUnionContentProvider(ProvidersVar, NProvidersVar)
	119	+	cret := xNewContentProviderUnion(ProvidersVar, NProvidersVar)
120	120
121	121		if cret == 0 {
122	122		return nil

@@ -240,10 +240,10 @@ func init() {
240	240		panic(err)
241	241		}
242	242
243		-	core.PuregoSafeRegister(&xNewForBytesContentProvider, lib, "gdk_content_provider_new_for_bytes")
244		-	core.PuregoSafeRegister(&xNewForValueContentProvider, lib, "gdk_content_provider_new_for_value")
245		-	core.PuregoSafeRegister(&xNewTypedContentProvider, lib, "gdk_content_provider_new_typed")
246		-	core.PuregoSafeRegister(&xNewUnionContentProvider, lib, "gdk_content_provider_new_union")
	243	+	core.PuregoSafeRegister(&xNewContentProviderForBytes, lib, "gdk_content_provider_new_for_bytes")
	244	+	core.PuregoSafeRegister(&xNewContentProviderForValue, lib, "gdk_content_provider_new_for_value")
	245	+	core.PuregoSafeRegister(&xNewContentProviderTyped, lib, "gdk_content_provider_new_typed")
	246	+	core.PuregoSafeRegister(&xNewContentProviderUnion, lib, "gdk_content_provider_new_union")
247	247
248	248		core.PuregoSafeRegister(&xContentProviderContentChanged, lib, "gdk_content_provider_content_changed")
249	249		core.PuregoSafeRegister(&xContentProviderGetValue, lib, "gdk_content_provider_get_value")

M v4/gdk/gdkcursor.go +8 -8


@@ -50,7 +50,7 @@ func CursorNewFromInternalPtr(ptr uintptr) *Cursor {
50	50		return cls
51	51		}
52	52
53		-	var xNewFromNameCursor func(string, uintptr) uintptr
	53	+	var xNewCursorFromName func(string, uintptr) uintptr
54	54
55	55		// Creates a new cursor by looking up @name in the current cursor
56	56		// theme.

@@ -69,10 +69,10 @@ var xNewFromNameCursor func(string, uintptr) uintptr
69	69		// \| ![](w_resize_cursor.png) "w-resize" \| ![](ne_resize_cursor.png) "ne-resize" \| ![](nw_resize_cursor.png) "nw-resize" \| ![](sw_resize_cursor.png) "sw-resize" \|
70	70		// \| ![](se_resize_cursor.png) "se-resize" \| ![](ew_resize_cursor.png) "ew-resize" \| ![](ns_resize_cursor.png) "ns-resize" \| ![](nesw_resize_cursor.png) "nesw-resize" \|
71	71		// \| ![](nwse_resize_cursor.png) "nwse-resize" \| ![](zoom_in_cursor.png) "zoom-in" \| ![](zoom_out_cursor.png) "zoom-out" \| \|
72		-	func NewFromNameCursor(NameVar string, FallbackVar Cursor) Cursor {
	72	+	func NewCursorFromName(NameVar string, FallbackVar Cursor) Cursor {
73	73		var cls *Cursor
74	74
75		-	cret := xNewFromNameCursor(NameVar, FallbackVar.GoPointer())
	75	+	cret := xNewCursorFromName(NameVar, FallbackVar.GoPointer())
76	76
77	77		if cret == 0 {
78	78		return nil

@@ -82,13 +82,13 @@ func NewFromNameCursor(NameVar string, FallbackVar Cursor) Cursor {
82	82		return cls
83	83		}
84	84
85		-	var xNewFromTextureCursor func(uintptr, int, int, uintptr) uintptr
	85	+	var xNewCursorFromTexture func(uintptr, int, int, uintptr) uintptr
86	86
87	87		// Creates a new cursor from a `GdkTexture`.
88		-	func NewFromTextureCursor(TextureVar Texture, HotspotXVar int, HotspotYVar int, FallbackVar Cursor) *Cursor {
	88	+	func NewCursorFromTexture(TextureVar Texture, HotspotXVar int, HotspotYVar int, FallbackVar Cursor) *Cursor {
89	89		var cls *Cursor
90	90
91		-	cret := xNewFromTextureCursor(TextureVar.GoPointer(), HotspotXVar, HotspotYVar, FallbackVar.GoPointer())
	91	+	cret := xNewCursorFromTexture(TextureVar.GoPointer(), HotspotXVar, HotspotYVar, FallbackVar.GoPointer())
92	92
93	93		if cret == 0 {
94	94		return nil

@@ -195,8 +195,8 @@ func init() {
195	195		panic(err)
196	196		}
197	197
198		-	core.PuregoSafeRegister(&xNewFromNameCursor, lib, "gdk_cursor_new_from_name")
199		-	core.PuregoSafeRegister(&xNewFromTextureCursor, lib, "gdk_cursor_new_from_texture")
	198	+	core.PuregoSafeRegister(&xNewCursorFromName, lib, "gdk_cursor_new_from_name")
	199	+	core.PuregoSafeRegister(&xNewCursorFromTexture, lib, "gdk_cursor_new_from_texture")
200	200
201	201		core.PuregoSafeRegister(&xCursorGetFallback, lib, "gdk_cursor_get_fallback")
202	202		core.PuregoSafeRegister(&xCursorGetHotspotX, lib, "gdk_cursor_get_hotspot_x")

M v4/gdk/gdksurface.go +8 -8


@@ -37,16 +37,16 @@ func SurfaceNewFromInternalPtr(ptr uintptr) *Surface {
37	37		return cls
38	38		}
39	39
40		-	var xNewPopupSurface func(uintptr, bool) uintptr
	40	+	var xNewSurfacePopup func(uintptr, bool) uintptr
41	41
42	42		// Create a new popup surface.
43	43		//
44	44		// The surface will be attached to @parent and can be positioned
45	45		// relative to it using [method@Gdk.Popup.present].
46		-	func NewPopupSurface(ParentVar Surface, AutohideVar bool) Surface {
	46	+	func NewSurfacePopup(ParentVar Surface, AutohideVar bool) Surface {
47	47		var cls *Surface
48	48
49		-	cret := xNewPopupSurface(ParentVar.GoPointer(), AutohideVar)
	49	+	cret := xNewSurfacePopup(ParentVar.GoPointer(), AutohideVar)
50	50
51	51		if cret == 0 {
52	52		return nil

@@ -56,13 +56,13 @@ func NewPopupSurface(ParentVar Surface, AutohideVar bool) Surface {
56	56		return cls
57	57		}
58	58
59		-	var xNewToplevelSurface func(uintptr) uintptr
	59	+	var xNewSurfaceToplevel func(uintptr) uintptr
60	60
61	61		// Creates a new toplevel surface.
62		-	func NewToplevelSurface(DisplayVar Display) Surface {
	62	+	func NewSurfaceToplevel(DisplayVar Display) Surface {
63	63		var cls *Surface
64	64
65		-	cret := xNewToplevelSurface(DisplayVar.GoPointer())
	65	+	cret := xNewSurfaceToplevel(DisplayVar.GoPointer())
66	66
67	67		if cret == 0 {
68	68		return nil

@@ -552,8 +552,8 @@ func init() {
552	552		panic(err)
553	553		}
554	554
555		-	core.PuregoSafeRegister(&xNewPopupSurface, lib, "gdk_surface_new_popup")
556		-	core.PuregoSafeRegister(&xNewToplevelSurface, lib, "gdk_surface_new_toplevel")
	555	+	core.PuregoSafeRegister(&xNewSurfacePopup, lib, "gdk_surface_new_popup")
	556	+	core.PuregoSafeRegister(&xNewSurfaceToplevel, lib, "gdk_surface_new_toplevel")
557	557
558	558		core.PuregoSafeRegister(&xSurfaceBeep, lib, "gdk_surface_beep")
559	559		core.PuregoSafeRegister(&xSurfaceCreateCairoContext, lib, "gdk_surface_create_cairo_context")

M v4/gdk/gdktexture.go +20 -20


@@ -59,17 +59,17 @@ func TextureNewFromInternalPtr(ptr uintptr) *Texture {
59	59		return cls
60	60		}
61	61
62		-	var xNewForPixbufTexture func(uintptr) uintptr
	62	+	var xNewTextureForPixbuf func(uintptr) uintptr
63	63
64	64		// Creates a new texture object representing the `GdkPixbuf`.
65	65		//
66	66		// This function is threadsafe, so that you can e.g. use GTask
67	67		// and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
68	68		// while loading a big image.
69		-	func NewForPixbufTexture(PixbufVar gdkpixbuf.Pixbuf) Texture {
	69	+	func NewTextureForPixbuf(PixbufVar gdkpixbuf.Pixbuf) Texture {
70	70		var cls *Texture
71	71
72		-	cret := xNewForPixbufTexture(PixbufVar.GoPointer())
	72	+	cret := xNewTextureForPixbuf(PixbufVar.GoPointer())
73	73
74	74		if cret == 0 {
75	75		return nil

@@ -79,7 +79,7 @@ func NewForPixbufTexture(PixbufVar gdkpixbuf.Pixbuf) Texture {
79	79		return cls
80	80		}
81	81
82		-	var xNewFromBytesTexture func(glib.Bytes, *glib.Error) uintptr
	82	+	var xNewTextureFromBytes func(glib.Bytes, *glib.Error) uintptr
83	83
84	84		// Creates a new texture by loading an image from memory,
85	85		//

@@ -91,11 +91,11 @@ var xNewFromBytesTexture func(glib.Bytes, *glib.Error) uintptr
91	91		// This function is threadsafe, so that you can e.g. use GTask
92	92		// and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
93	93		// while loading a big image.
94		-	func NewFromBytesTexture(BytesVar glib.Bytes) (Texture, error) {
	94	+	func NewTextureFromBytes(BytesVar glib.Bytes) (Texture, error) {
95	95		var cls *Texture
96	96		var cerr *glib.Error
97	97
98		-	cret := xNewFromBytesTexture(BytesVar, &cerr)
	98	+	cret := xNewTextureFromBytes(BytesVar, &cerr)
99	99
100	100		if cret == 0 {
101	101		return nil, cerr

@@ -109,7 +109,7 @@ func NewFromBytesTexture(BytesVar glib.Bytes) (Texture, error) {
109	109
110	110		}
111	111
112		-	var xNewFromFileTexture func(uintptr, **glib.Error) uintptr
	112	+	var xNewTextureFromFile func(uintptr, **glib.Error) uintptr
113	113
114	114		// Creates a new texture by loading an image from a file.
115	115		//

@@ -121,11 +121,11 @@ var xNewFromFileTexture func(uintptr, **glib.Error) uintptr
121	121		// This function is threadsafe, so that you can e.g. use GTask
122	122		// and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
123	123		// while loading a big image.
124		-	func NewFromFileTexture(FileVar gio.File) (*Texture, error) {
	124	+	func NewTextureFromFile(FileVar gio.File) (*Texture, error) {
125	125		var cls *Texture
126	126		var cerr *glib.Error
127	127
128		-	cret := xNewFromFileTexture(FileVar.GoPointer(), &cerr)
	128	+	cret := xNewTextureFromFile(FileVar.GoPointer(), &cerr)
129	129
130	130		if cret == 0 {
131	131		return nil, cerr

@@ -139,7 +139,7 @@ func NewFromFileTexture(FileVar gio.File) (*Texture, error) {
139	139
140	140		}
141	141
142		-	var xNewFromFilenameTexture func(string, **glib.Error) uintptr
	142	+	var xNewTextureFromFilename func(string, **glib.Error) uintptr
143	143
144	144		// Creates a new texture by loading an image from a file.
145	145		//

@@ -151,11 +151,11 @@ var xNewFromFilenameTexture func(string, **glib.Error) uintptr
151	151		// This function is threadsafe, so that you can e.g. use GTask
152	152		// and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
153	153		// while loading a big image.
154		-	func NewFromFilenameTexture(PathVar string) (*Texture, error) {
	154	+	func NewTextureFromFilename(PathVar string) (*Texture, error) {
155	155		var cls *Texture
156	156		var cerr *glib.Error
157	157
158		-	cret := xNewFromFilenameTexture(PathVar, &cerr)
	158	+	cret := xNewTextureFromFilename(PathVar, &cerr)
159	159
160	160		if cret == 0 {
161	161		return nil, cerr

@@ -169,7 +169,7 @@ func NewFromFilenameTexture(PathVar string) (*Texture, error) {
169	169
170	170		}
171	171
172		-	var xNewFromResourceTexture func(string) uintptr
	172	+	var xNewTextureFromResource func(string) uintptr
173	173
174	174		// Creates a new texture by loading an image from a resource.
175	175		//

@@ -184,10 +184,10 @@ var xNewFromResourceTexture func(string) uintptr
184	184		// This function is threadsafe, so that you can e.g. use GTask
185	185		// and [method@Gio.Task.run_in_thread] to avoid blocking the main thread
186	186		// while loading a big image.
187		-	func NewFromResourceTexture(ResourcePathVar string) *Texture {
	187	+	func NewTextureFromResource(ResourcePathVar string) *Texture {
188	188		var cls *Texture
189	189
190		-	cret := xNewFromResourceTexture(ResourcePathVar)
	190	+	cret := xNewTextureFromResource(ResourcePathVar)
191	191
192	192		if cret == 0 {
193	193		return nil

@@ -560,11 +560,11 @@ func init() {
560	560		panic(err)
561	561		}
562	562
563		-	core.PuregoSafeRegister(&xNewForPixbufTexture, lib, "gdk_texture_new_for_pixbuf")
564		-	core.PuregoSafeRegister(&xNewFromBytesTexture, lib, "gdk_texture_new_from_bytes")
565		-	core.PuregoSafeRegister(&xNewFromFileTexture, lib, "gdk_texture_new_from_file")
566		-	core.PuregoSafeRegister(&xNewFromFilenameTexture, lib, "gdk_texture_new_from_filename")
567		-	core.PuregoSafeRegister(&xNewFromResourceTexture, lib, "gdk_texture_new_from_resource")
	563	+	core.PuregoSafeRegister(&xNewTextureForPixbuf, lib, "gdk_texture_new_for_pixbuf")
	564	+	core.PuregoSafeRegister(&xNewTextureFromBytes, lib, "gdk_texture_new_from_bytes")
	565	+	core.PuregoSafeRegister(&xNewTextureFromFile, lib, "gdk_texture_new_from_file")
	566	+	core.PuregoSafeRegister(&xNewTextureFromFilename, lib, "gdk_texture_new_from_filename")
	567	+	core.PuregoSafeRegister(&xNewTextureFromResource, lib, "gdk_texture_new_from_resource")
568	568
569	569		core.PuregoSafeRegister(&xTextureDownload, lib, "gdk_texture_download")
570	570		core.PuregoSafeRegister(&xTextureGetHeight, lib, "gdk_texture_get_height")

M v4/gdk/gdktypes.go +4 -4


@@ -61,12 +61,12 @@ func NewContentFormats(MimeTypesVar []string, NMimeTypesVar uint) *ContentFormat
61	61		return cret
62	62		}
63	63
64		-	var xNewForGtypeContentFormats func([]interface{}) *ContentFormats
	64	+	var xNewContentFormatsForGtype func([]interface{}) *ContentFormats
65	65
66	66		// Creates a new `GdkContentFormats` for a given `GType`.
67		-	func NewForGtypeContentFormats(TypeVar []interface{}) *ContentFormats {
	67	+	func NewContentFormatsForGtype(TypeVar []interface{}) *ContentFormats {
68	68
69		-	cret := xNewForGtypeContentFormats(TypeVar)
	69	+	cret := xNewContentFormatsForGtype(TypeVar)
70	70		return cret
71	71		}
72	72

@@ -344,7 +344,7 @@ func init() {
344	344		}
345	345
346	346		core.PuregoSafeRegister(&xNewContentFormats, lib, "gdk_content_formats_new")
347		-	core.PuregoSafeRegister(&xNewForGtypeContentFormats, lib, "gdk_content_formats_new_for_gtype")
	347	+	core.PuregoSafeRegister(&xNewContentFormatsForGtype, lib, "gdk_content_formats_new_for_gtype")
348	348
349	349		core.PuregoSafeRegister(&xContentFormatsContainGtype, lib, "gdk_content_formats_contain_gtype")
350	350		core.PuregoSafeRegister(&xContentFormatsContainMimeType, lib, "gdk_content_formats_contain_mime_type")

M v4/gdkpixbuf/gdk-pixbuf-animation.go +16 -16


@@ -56,7 +56,7 @@ func PixbufAnimationNewFromInternalPtr(ptr uintptr) *PixbufAnimation {
56	56		return cls
57	57		}
58	58
59		-	var xNewFromFilePixbufAnimation func(string, **glib.Error) uintptr
	59	+	var xNewPixbufAnimationFromFile func(string, **glib.Error) uintptr
60	60
61	61		// Creates a new animation by loading it from a file.
62	62		//

@@ -66,11 +66,11 @@ var xNewFromFilePixbufAnimation func(string, **glib.Error) uintptr
66	66		// with a single frame will be created.
67	67		//
68	68		// Possible errors are in the `GDK_PIXBUF_ERROR` and `G_FILE_ERROR` domains.
69		-	func NewFromFilePixbufAnimation(FilenameVar string) (*PixbufAnimation, error) {
	69	+	func NewPixbufAnimationFromFile(FilenameVar string) (*PixbufAnimation, error) {
70	70		var cls *PixbufAnimation
71	71		var cerr *glib.Error
72	72
73		-	cret := xNewFromFilePixbufAnimation(FilenameVar, &cerr)
	73	+	cret := xNewPixbufAnimationFromFile(FilenameVar, &cerr)
74	74
75	75		if cret == 0 {
76	76		return nil, cerr

@@ -84,17 +84,17 @@ func NewFromFilePixbufAnimation(FilenameVar string) (*PixbufAnimation, error) {
84	84
85	85		}
86	86
87		-	var xNewFromResourcePixbufAnimation func(string, **glib.Error) uintptr
	87	+	var xNewPixbufAnimationFromResource func(string, **glib.Error) uintptr
88	88
89	89		// Creates a new pixbuf animation by loading an image from an resource.
90	90		//
91	91		// The file format is detected automatically. If `NULL` is returned, then
92	92		// @error will be set.
93		-	func NewFromResourcePixbufAnimation(ResourcePathVar string) (*PixbufAnimation, error) {
	93	+	func NewPixbufAnimationFromResource(ResourcePathVar string) (*PixbufAnimation, error) {
94	94		var cls *PixbufAnimation
95	95		var cerr *glib.Error
96	96
97		-	cret := xNewFromResourcePixbufAnimation(ResourcePathVar, &cerr)
	97	+	cret := xNewPixbufAnimationFromResource(ResourcePathVar, &cerr)
98	98
99	99		if cret == 0 {
100	100		return nil, cerr

@@ -108,7 +108,7 @@ func NewFromResourcePixbufAnimation(ResourcePathVar string) (*PixbufAnimation, e
108	108
109	109		}
110	110
111		-	var xNewFromStreamPixbufAnimation func(uintptr, uintptr, **glib.Error) uintptr
	111	+	var xNewPixbufAnimationFromStream func(uintptr, uintptr, **glib.Error) uintptr
112	112
113	113		// Creates a new animation by loading it from an input stream.
114	114		//

@@ -122,11 +122,11 @@ var xNewFromStreamPixbufAnimation func(uintptr, uintptr, **glib.Error) uintptr
122	122		// `G_IO_ERROR` domains.
123	123		//
124	124		// The stream is not closed.
125		-	func NewFromStreamPixbufAnimation(StreamVar gio.InputStream, CancellableVar gio.Cancellable) (*PixbufAnimation, error) {
	125	+	func NewPixbufAnimationFromStream(StreamVar gio.InputStream, CancellableVar gio.Cancellable) (*PixbufAnimation, error) {
126	126		var cls *PixbufAnimation
127	127		var cerr *glib.Error
128	128
129		-	cret := xNewFromStreamPixbufAnimation(StreamVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
	129	+	cret := xNewPixbufAnimationFromStream(StreamVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
130	130
131	131		if cret == 0 {
132	132		return nil, cerr

@@ -140,15 +140,15 @@ func NewFromStreamPixbufAnimation(StreamVar gio.InputStream, CancellableVar gi
140	140
141	141		}
142	142
143		-	var xNewFromStreamFinishPixbufAnimation func(uintptr, **glib.Error) uintptr
	143	+	var xNewPixbufAnimationFromStreamFinish func(uintptr, **glib.Error) uintptr
144	144
145	145		// Finishes an asynchronous pixbuf animation creation operation started with
146	146		// [func@GdkPixbuf.PixbufAnimation.new_from_stream_async].
147		-	func NewFromStreamFinishPixbufAnimation(AsyncResultVar gio.AsyncResult) (*PixbufAnimation, error) {
	147	+	func NewPixbufAnimationFromStreamFinish(AsyncResultVar gio.AsyncResult) (*PixbufAnimation, error) {
148	148		var cls *PixbufAnimation
149	149		var cerr *glib.Error
150	150
151		-	cret := xNewFromStreamFinishPixbufAnimation(AsyncResultVar.GoPointer(), &cerr)
	151	+	cret := xNewPixbufAnimationFromStreamFinish(AsyncResultVar.GoPointer(), &cerr)
152	152
153	153		if cret == 0 {
154	154		return nil, cerr

@@ -436,10 +436,10 @@ func init() {
436	436		panic(err)
437	437		}
438	438
439		-	core.PuregoSafeRegister(&xNewFromFilePixbufAnimation, lib, "gdk_pixbuf_animation_new_from_file")
440		-	core.PuregoSafeRegister(&xNewFromResourcePixbufAnimation, lib, "gdk_pixbuf_animation_new_from_resource")
441		-	core.PuregoSafeRegister(&xNewFromStreamPixbufAnimation, lib, "gdk_pixbuf_animation_new_from_stream")
442		-	core.PuregoSafeRegister(&xNewFromStreamFinishPixbufAnimation, lib, "gdk_pixbuf_animation_new_from_stream_finish")
	439	+	core.PuregoSafeRegister(&xNewPixbufAnimationFromFile, lib, "gdk_pixbuf_animation_new_from_file")
	440	+	core.PuregoSafeRegister(&xNewPixbufAnimationFromResource, lib, "gdk_pixbuf_animation_new_from_resource")
	441	+	core.PuregoSafeRegister(&xNewPixbufAnimationFromStream, lib, "gdk_pixbuf_animation_new_from_stream")
	442	+	core.PuregoSafeRegister(&xNewPixbufAnimationFromStreamFinish, lib, "gdk_pixbuf_animation_new_from_stream_finish")
443	443
444	444		core.PuregoSafeRegister(&xPixbufAnimationGetHeight, lib, "gdk_pixbuf_animation_get_height")
445	445		core.PuregoSafeRegister(&xPixbufAnimationGetIter, lib, "gdk_pixbuf_animation_get_iter")

M v4/gdkpixbuf/gdk-pixbuf-loader.go +8 -8


@@ -89,7 +89,7 @@ func NewPixbufLoader() *PixbufLoader {
89	89		return cls
90	90		}
91	91
92		-	var xNewWithMimeTypePixbufLoader func(string, **glib.Error) uintptr
	92	+	var xNewPixbufLoaderWithMimeType func(string, **glib.Error) uintptr
93	93
94	94		// Creates a new pixbuf loader object that always attempts to parse
95	95		// image data as if it were an image of MIME type @mime_type, instead of

@@ -106,11 +106,11 @@ var xNewWithMimeTypePixbufLoader func(string, **glib.Error) uintptr
106	106		// To obtain the full list of supported mime types, call
107	107		// gdk_pixbuf_format_get_mime_types() on each of the #GdkPixbufFormat
108	108		// structs returned by gdk_pixbuf_get_formats().
109		-	func NewWithMimeTypePixbufLoader(MimeTypeVar string) (*PixbufLoader, error) {
	109	+	func NewPixbufLoaderWithMimeType(MimeTypeVar string) (*PixbufLoader, error) {
110	110		var cls *PixbufLoader
111	111		var cerr *glib.Error
112	112
113		-	cret := xNewWithMimeTypePixbufLoader(MimeTypeVar, &cerr)
	113	+	cret := xNewPixbufLoaderWithMimeType(MimeTypeVar, &cerr)
114	114
115	115		if cret == 0 {
116	116		return nil, cerr

@@ -124,7 +124,7 @@ func NewWithMimeTypePixbufLoader(MimeTypeVar string) (*PixbufLoader, error) {
124	124
125	125		}
126	126
127		-	var xNewWithTypePixbufLoader func(string, **glib.Error) uintptr
	127	+	var xNewPixbufLoaderWithType func(string, **glib.Error) uintptr
128	128
129	129		// Creates a new pixbuf loader object that always attempts to parse
130	130		// image data as if it were an image of type @image_type, instead of

@@ -140,11 +140,11 @@ var xNewWithTypePixbufLoader func(string, **glib.Error) uintptr
140	140		// "xpm" are among the supported formats. To obtain the full list of
141	141		// supported image formats, call gdk_pixbuf_format_get_name() on each
142	142		// of the #GdkPixbufFormat structs returned by gdk_pixbuf_get_formats().
143		-	func NewWithTypePixbufLoader(ImageTypeVar string) (*PixbufLoader, error) {
	143	+	func NewPixbufLoaderWithType(ImageTypeVar string) (*PixbufLoader, error) {
144	144		var cls *PixbufLoader
145	145		var cerr *glib.Error
146	146
147		-	cret := xNewWithTypePixbufLoader(ImageTypeVar, &cerr)
	147	+	cret := xNewPixbufLoaderWithType(ImageTypeVar, &cerr)
148	148
149	149		if cret == 0 {
150	150		return nil, cerr

@@ -380,8 +380,8 @@ func init() {
380	380		}
381	381
382	382		core.PuregoSafeRegister(&xNewPixbufLoader, lib, "gdk_pixbuf_loader_new")
383		-	core.PuregoSafeRegister(&xNewWithMimeTypePixbufLoader, lib, "gdk_pixbuf_loader_new_with_mime_type")
384		-	core.PuregoSafeRegister(&xNewWithTypePixbufLoader, lib, "gdk_pixbuf_loader_new_with_type")
	383	+	core.PuregoSafeRegister(&xNewPixbufLoaderWithMimeType, lib, "gdk_pixbuf_loader_new_with_mime_type")
	384	+	core.PuregoSafeRegister(&xNewPixbufLoaderWithType, lib, "gdk_pixbuf_loader_new_with_type")
385	385
386	386		core.PuregoSafeRegister(&xPixbufLoaderClose, lib, "gdk_pixbuf_loader_close")
387	387		core.PuregoSafeRegister(&xPixbufLoaderGetAnimation, lib, "gdk_pixbuf_loader_get_animation")

M v4/gdkpixbuf/gdk-pixbuf.go +48 -48


@@ -178,7 +178,7 @@ func NewPixbuf(ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int,
178	178		return cls
179	179		}
180	180
181		-	var xNewFromBytesPixbuf func(*glib.Bytes, Colorspace, bool, int, int, int, int) uintptr
	181	+	var xNewPixbufFromBytes func(*glib.Bytes, Colorspace, bool, int, int, int, int) uintptr
182	182
183	183		// Creates a new #GdkPixbuf out of in-memory readonly image data.
184	184		//

@@ -186,10 +186,10 @@ var xNewFromBytesPixbuf func(*glib.Bytes, Colorspace, bool, int, int, int, int)
186	186		//
187	187		// This is the `GBytes` variant of gdk_pixbuf_new_from_data(), useful
188	188		// for language bindings.
189		-	func NewFromBytesPixbuf(DataVar glib.Bytes, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int) Pixbuf {
	189	+	func NewPixbufFromBytes(DataVar glib.Bytes, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int) Pixbuf {
190	190		var cls *Pixbuf
191	191
192		-	cret := xNewFromBytesPixbuf(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar)
	192	+	cret := xNewPixbufFromBytes(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar)
193	193
194	194		if cret == 0 {
195	195		return nil

@@ -199,7 +199,7 @@ func NewFromBytesPixbuf(DataVar *glib.Bytes, ColorspaceVar Colorspace, HasAlphaV
199	199		return cls
200	200		}
201	201
202		-	var xNewFromDataPixbuf func(uintptr, Colorspace, bool, int, int, int, int, uintptr, uintptr) uintptr
	202	+	var xNewPixbufFromData func(uintptr, Colorspace, bool, int, int, int, int, uintptr, uintptr) uintptr
203	203
204	204		// Creates a new #GdkPixbuf out of in-memory image data.
205	205		//

@@ -212,10 +212,10 @@ var xNewFromDataPixbuf func(uintptr, Colorspace, bool, int, int, int, int, uintp
212	212		// it is its responsibility to free the pixel array.
213	213		//
214	214		// See also: [ctor@GdkPixbuf.Pixbuf.new_from_bytes]
215		-	func NewFromDataPixbuf(DataVar uintptr, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar PixbufDestroyNotify, DestroyFnDataVar uintptr) *Pixbuf {
	215	+	func NewPixbufFromData(DataVar uintptr, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar PixbufDestroyNotify, DestroyFnDataVar uintptr) *Pixbuf {
216	216		var cls *Pixbuf
217	217
218		-	cret := xNewFromDataPixbuf(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar, purego.NewCallback(DestroyFnVar), DestroyFnDataVar)
	218	+	cret := xNewPixbufFromData(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar, purego.NewCallback(DestroyFnVar), DestroyFnDataVar)
219	219
220	220		if cret == 0 {
221	221		return nil

@@ -225,7 +225,7 @@ func NewFromDataPixbuf(DataVar uintptr, ColorspaceVar Colorspace, HasAlphaVar bo
225	225		return cls
226	226		}
227	227
228		-	var xNewFromFilePixbuf func(string, **glib.Error) uintptr
	228	+	var xNewPixbufFromFile func(string, **glib.Error) uintptr
229	229
230	230		// Creates a new pixbuf by loading an image from a file.
231	231		//

@@ -239,11 +239,11 @@ var xNewFromFilePixbuf func(string, **glib.Error) uintptr
239	239		// - the image buffer contains invalid data
240	240		//
241	241		// The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
242		-	func NewFromFilePixbuf(FilenameVar string) (*Pixbuf, error) {
	242	+	func NewPixbufFromFile(FilenameVar string) (*Pixbuf, error) {
243	243		var cls *Pixbuf
244	244		var cerr *glib.Error
245	245
246		-	cret := xNewFromFilePixbuf(FilenameVar, &cerr)
	246	+	cret := xNewPixbufFromFile(FilenameVar, &cerr)
247	247
248	248		if cret == 0 {
249	249		return nil, cerr

@@ -257,7 +257,7 @@ func NewFromFilePixbuf(FilenameVar string) (*Pixbuf, error) {
257	257
258	258		}
259	259
260		-	var xNewFromFileAtScalePixbuf func(string, int, int, bool, **glib.Error) uintptr
	260	+	var xNewPixbufFromFileAtScale func(string, int, int, bool, **glib.Error) uintptr
261	261
262	262		// Creates a new pixbuf by loading an image from a file.
263	263		//

@@ -281,11 +281,11 @@ var xNewFromFileAtScalePixbuf func(string, int, int, bool, **glib.Error) uintptr
281	281		// aspect ratio, a `width` or `height` of -1 means to not scale the image
282	282		// at all in that dimension. Negative values for `width` and `height` are
283	283		// allowed since 2.8.
284		-	func NewFromFileAtScalePixbuf(FilenameVar string, WidthVar int, HeightVar int, PreserveAspectRatioVar bool) (*Pixbuf, error) {
	284	+	func NewPixbufFromFileAtScale(FilenameVar string, WidthVar int, HeightVar int, PreserveAspectRatioVar bool) (*Pixbuf, error) {
285	285		var cls *Pixbuf
286	286		var cerr *glib.Error
287	287
288		-	cret := xNewFromFileAtScalePixbuf(FilenameVar, WidthVar, HeightVar, PreserveAspectRatioVar, &cerr)
	288	+	cret := xNewPixbufFromFileAtScale(FilenameVar, WidthVar, HeightVar, PreserveAspectRatioVar, &cerr)
289	289
290	290		if cret == 0 {
291	291		return nil, cerr

@@ -299,7 +299,7 @@ func NewFromFileAtScalePixbuf(FilenameVar string, WidthVar int, HeightVar int, P
299	299
300	300		}
301	301
302		-	var xNewFromFileAtSizePixbuf func(string, int, int, **glib.Error) uintptr
	302	+	var xNewPixbufFromFileAtSize func(string, int, int, **glib.Error) uintptr
303	303
304	304		// Creates a new pixbuf by loading an image from a file.
305	305		//

@@ -319,11 +319,11 @@ var xNewFromFileAtSizePixbuf func(string, int, int, **glib.Error) uintptr
319	319		// than `width` x `height`, if the aspect ratio requires it. To load
320	320		// and image at the requested size, regardless of aspect ratio, use
321	321		// [ctor@GdkPixbuf.Pixbuf.new_from_file_at_scale].
322		-	func NewFromFileAtSizePixbuf(FilenameVar string, WidthVar int, HeightVar int) (*Pixbuf, error) {
	322	+	func NewPixbufFromFileAtSize(FilenameVar string, WidthVar int, HeightVar int) (*Pixbuf, error) {
323	323		var cls *Pixbuf
324	324		var cerr *glib.Error
325	325
326		-	cret := xNewFromFileAtSizePixbuf(FilenameVar, WidthVar, HeightVar, &cerr)
	326	+	cret := xNewPixbufFromFileAtSize(FilenameVar, WidthVar, HeightVar, &cerr)
327	327
328	328		if cret == 0 {
329	329		return nil, cerr

@@ -337,7 +337,7 @@ func NewFromFileAtSizePixbuf(FilenameVar string, WidthVar int, HeightVar int) (*
337	337
338	338		}
339	339
340		-	var xNewFromInlinePixbuf func(int, uintptr, bool, **glib.Error) uintptr
	340	+	var xNewPixbufFromInline func(int, uintptr, bool, **glib.Error) uintptr
341	341
342	342		// Creates a `GdkPixbuf` from a flat representation that is suitable for
343	343		// storing as inline data in a program.

@@ -372,11 +372,11 @@ var xNewFromInlinePixbuf func(int, uintptr, bool, **glib.Error) uintptr
372	372		// For non-const inline data, you could get out of memory. For untrusted
373	373		// inline data located at runtime, you could have corrupt inline data in
374	374		// addition.
375		-	func NewFromInlinePixbuf(DataLengthVar int, DataVar uintptr, CopyPixelsVar bool) (*Pixbuf, error) {
	375	+	func NewPixbufFromInline(DataLengthVar int, DataVar uintptr, CopyPixelsVar bool) (*Pixbuf, error) {
376	376		var cls *Pixbuf
377	377		var cerr *glib.Error
378	378
379		-	cret := xNewFromInlinePixbuf(DataLengthVar, DataVar, CopyPixelsVar, &cerr)
	379	+	cret := xNewPixbufFromInline(DataLengthVar, DataVar, CopyPixelsVar, &cerr)
380	380
381	381		if cret == 0 {
382	382		return nil, cerr

@@ -390,17 +390,17 @@ func NewFromInlinePixbuf(DataLengthVar int, DataVar uintptr, CopyPixelsVar bool)
390	390
391	391		}
392	392
393		-	var xNewFromResourcePixbuf func(string, **glib.Error) uintptr
	393	+	var xNewPixbufFromResource func(string, **glib.Error) uintptr
394	394
395	395		// Creates a new pixbuf by loading an image from an resource.
396	396		//
397	397		// The file format is detected automatically. If `NULL` is returned, then
398	398		// @error will be set.
399		-	func NewFromResourcePixbuf(ResourcePathVar string) (*Pixbuf, error) {
	399	+	func NewPixbufFromResource(ResourcePathVar string) (*Pixbuf, error) {
400	400		var cls *Pixbuf
401	401		var cerr *glib.Error
402	402
403		-	cret := xNewFromResourcePixbuf(ResourcePathVar, &cerr)
	403	+	cret := xNewPixbufFromResource(ResourcePathVar, &cerr)
404	404
405	405		if cret == 0 {
406	406		return nil, cerr

@@ -414,7 +414,7 @@ func NewFromResourcePixbuf(ResourcePathVar string) (*Pixbuf, error) {
414	414
415	415		}
416	416
417		-	var xNewFromResourceAtScalePixbuf func(string, int, int, bool, **glib.Error) uintptr
	417	+	var xNewPixbufFromResourceAtScale func(string, int, int, bool, **glib.Error) uintptr
418	418
419	419		// Creates a new pixbuf by loading an image from an resource.
420	420		//

@@ -429,11 +429,11 @@ var xNewFromResourceAtScalePixbuf func(string, int, int, bool, **glib.Error) uin
429	429		// @height of -1 means to not scale the image at all in that dimension.
430	430		//
431	431		// The stream is not closed.
432		-	func NewFromResourceAtScalePixbuf(ResourcePathVar string, WidthVar int, HeightVar int, PreserveAspectRatioVar bool) (*Pixbuf, error) {
	432	+	func NewPixbufFromResourceAtScale(ResourcePathVar string, WidthVar int, HeightVar int, PreserveAspectRatioVar bool) (*Pixbuf, error) {
433	433		var cls *Pixbuf
434	434		var cerr *glib.Error
435	435
436		-	cret := xNewFromResourceAtScalePixbuf(ResourcePathVar, WidthVar, HeightVar, PreserveAspectRatioVar, &cerr)
	436	+	cret := xNewPixbufFromResourceAtScale(ResourcePathVar, WidthVar, HeightVar, PreserveAspectRatioVar, &cerr)
437	437
438	438		if cret == 0 {
439	439		return nil, cerr

@@ -447,7 +447,7 @@ func NewFromResourceAtScalePixbuf(ResourcePathVar string, WidthVar int, HeightVa
447	447
448	448		}
449	449
450		-	var xNewFromStreamPixbuf func(uintptr, uintptr, **glib.Error) uintptr
	450	+	var xNewPixbufFromStream func(uintptr, uintptr, **glib.Error) uintptr
451	451
452	452		// Creates a new pixbuf by loading an image from an input stream.
453	453		//

@@ -461,11 +461,11 @@ var xNewFromStreamPixbuf func(uintptr, uintptr, **glib.Error) uintptr
461	461		// `G_IO_ERROR` domains.
462	462		//
463	463		// The stream is not closed.
464		-	func NewFromStreamPixbuf(StreamVar gio.InputStream, CancellableVar gio.Cancellable) (*Pixbuf, error) {
	464	+	func NewPixbufFromStream(StreamVar gio.InputStream, CancellableVar gio.Cancellable) (*Pixbuf, error) {
465	465		var cls *Pixbuf
466	466		var cerr *glib.Error
467	467
468		-	cret := xNewFromStreamPixbuf(StreamVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
	468	+	cret := xNewPixbufFromStream(StreamVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
469	469
470	470		if cret == 0 {
471	471		return nil, cerr

@@ -479,7 +479,7 @@ func NewFromStreamPixbuf(StreamVar gio.InputStream, CancellableVar gio.Cancell
479	479
480	480		}
481	481
482		-	var xNewFromStreamAtScalePixbuf func(uintptr, int, int, bool, uintptr, **glib.Error) uintptr
	482	+	var xNewPixbufFromStreamAtScale func(uintptr, int, int, bool, uintptr, **glib.Error) uintptr
483	483
484	484		// Creates a new pixbuf by loading an image from an input stream.
485	485		//

@@ -502,11 +502,11 @@ var xNewFromStreamAtScalePixbuf func(uintptr, int, int, bool, uintptr, **glib.Er
502	502		// scale the image at all in that dimension.
503	503		//
504	504		// The stream is not closed.
505		-	func NewFromStreamAtScalePixbuf(StreamVar gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar gio.Cancellable) (*Pixbuf, error) {
	505	+	func NewPixbufFromStreamAtScale(StreamVar gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar gio.Cancellable) (*Pixbuf, error) {
506	506		var cls *Pixbuf
507	507		var cerr *glib.Error
508	508
509		-	cret := xNewFromStreamAtScalePixbuf(StreamVar.GoPointer(), WidthVar, HeightVar, PreserveAspectRatioVar, CancellableVar.GoPointer(), &cerr)
	509	+	cret := xNewPixbufFromStreamAtScale(StreamVar.GoPointer(), WidthVar, HeightVar, PreserveAspectRatioVar, CancellableVar.GoPointer(), &cerr)
510	510
511	511		if cret == 0 {
512	512		return nil, cerr

@@ -520,15 +520,15 @@ func NewFromStreamAtScalePixbuf(StreamVar *gio.InputStream, WidthVar int, Height
520	520
521	521		}
522	522
523		-	var xNewFromStreamFinishPixbuf func(uintptr, **glib.Error) uintptr
	523	+	var xNewPixbufFromStreamFinish func(uintptr, **glib.Error) uintptr
524	524
525	525		// Finishes an asynchronous pixbuf creation operation started with
526	526		// gdk_pixbuf_new_from_stream_async().
527		-	func NewFromStreamFinishPixbuf(AsyncResultVar gio.AsyncResult) (*Pixbuf, error) {
	527	+	func NewPixbufFromStreamFinish(AsyncResultVar gio.AsyncResult) (*Pixbuf, error) {
528	528		var cls *Pixbuf
529	529		var cerr *glib.Error
530	530
531		-	cret := xNewFromStreamFinishPixbuf(AsyncResultVar.GoPointer(), &cerr)
	531	+	cret := xNewPixbufFromStreamFinish(AsyncResultVar.GoPointer(), &cerr)
532	532
533	533		if cret == 0 {
534	534		return nil, cerr

@@ -542,16 +542,16 @@ func NewFromStreamFinishPixbuf(AsyncResultVar gio.AsyncResult) (*Pixbuf, error)
542	542
543	543		}
544	544
545		-	var xNewFromXpmDataPixbuf func([]string) uintptr
	545	+	var xNewPixbufFromXpmData func([]string) uintptr
546	546
547	547		// Creates a new pixbuf by parsing XPM data in memory.
548	548		//
549	549		// This data is commonly the result of including an XPM file into a
550	550		// program's C source.
551		-	func NewFromXpmDataPixbuf(DataVar []string) *Pixbuf {
	551	+	func NewPixbufFromXpmData(DataVar []string) *Pixbuf {
552	552		var cls *Pixbuf
553	553
554		-	cret := xNewFromXpmDataPixbuf(DataVar)
	554	+	cret := xNewPixbufFromXpmData(DataVar)
555	555
556	556		if cret == 0 {
557	557		return nil

@@ -1571,18 +1571,18 @@ func init() {
1571	1571		}
1572	1572
1573	1573		core.PuregoSafeRegister(&xNewPixbuf, lib, "gdk_pixbuf_new")
1574		-	core.PuregoSafeRegister(&xNewFromBytesPixbuf, lib, "gdk_pixbuf_new_from_bytes")
1575		-	core.PuregoSafeRegister(&xNewFromDataPixbuf, lib, "gdk_pixbuf_new_from_data")
1576		-	core.PuregoSafeRegister(&xNewFromFilePixbuf, lib, "gdk_pixbuf_new_from_file")
1577		-	core.PuregoSafeRegister(&xNewFromFileAtScalePixbuf, lib, "gdk_pixbuf_new_from_file_at_scale")
1578		-	core.PuregoSafeRegister(&xNewFromFileAtSizePixbuf, lib, "gdk_pixbuf_new_from_file_at_size")
1579		-	core.PuregoSafeRegister(&xNewFromInlinePixbuf, lib, "gdk_pixbuf_new_from_inline")
1580		-	core.PuregoSafeRegister(&xNewFromResourcePixbuf, lib, "gdk_pixbuf_new_from_resource")
1581		-	core.PuregoSafeRegister(&xNewFromResourceAtScalePixbuf, lib, "gdk_pixbuf_new_from_resource_at_scale")
1582		-	core.PuregoSafeRegister(&xNewFromStreamPixbuf, lib, "gdk_pixbuf_new_from_stream")
1583		-	core.PuregoSafeRegister(&xNewFromStreamAtScalePixbuf, lib, "gdk_pixbuf_new_from_stream_at_scale")
1584		-	core.PuregoSafeRegister(&xNewFromStreamFinishPixbuf, lib, "gdk_pixbuf_new_from_stream_finish")
1585		-	core.PuregoSafeRegister(&xNewFromXpmDataPixbuf, lib, "gdk_pixbuf_new_from_xpm_data")
	1574	+	core.PuregoSafeRegister(&xNewPixbufFromBytes, lib, "gdk_pixbuf_new_from_bytes")
	1575	+	core.PuregoSafeRegister(&xNewPixbufFromData, lib, "gdk_pixbuf_new_from_data")
	1576	+	core.PuregoSafeRegister(&xNewPixbufFromFile, lib, "gdk_pixbuf_new_from_file")
	1577	+	core.PuregoSafeRegister(&xNewPixbufFromFileAtScale, lib, "gdk_pixbuf_new_from_file_at_scale")
	1578	+	core.PuregoSafeRegister(&xNewPixbufFromFileAtSize, lib, "gdk_pixbuf_new_from_file_at_size")
	1579	+	core.PuregoSafeRegister(&xNewPixbufFromInline, lib, "gdk_pixbuf_new_from_inline")
	1580	+	core.PuregoSafeRegister(&xNewPixbufFromResource, lib, "gdk_pixbuf_new_from_resource")
	1581	+	core.PuregoSafeRegister(&xNewPixbufFromResourceAtScale, lib, "gdk_pixbuf_new_from_resource_at_scale")
	1582	+	core.PuregoSafeRegister(&xNewPixbufFromStream, lib, "gdk_pixbuf_new_from_stream")
	1583	+	core.PuregoSafeRegister(&xNewPixbufFromStreamAtScale, lib, "gdk_pixbuf_new_from_stream_at_scale")
	1584	+	core.PuregoSafeRegister(&xNewPixbufFromStreamFinish, lib, "gdk_pixbuf_new_from_stream_finish")
	1585	+	core.PuregoSafeRegister(&xNewPixbufFromXpmData, lib, "gdk_pixbuf_new_from_xpm_data")
1586	1586
1587	1587		core.PuregoSafeRegister(&xPixbufAddAlpha, lib, "gdk_pixbuf_add_alpha")
1588	1588		core.PuregoSafeRegister(&xPixbufApplyEmbeddedOrientation, lib, "gdk_pixbuf_apply_embedded_orientation")

M v4/gio/gbufferedinputstream.go +4 -4


@@ -65,14 +65,14 @@ func NewBufferedInputStream(BaseStreamVar InputStream) BufferedInputStream {
65	65		return cls
66	66		}
67	67
68		-	var xNewSizedBufferedInputStream func(uintptr, uint) uintptr
	68	+	var xNewBufferedInputStreamSized func(uintptr, uint) uintptr
69	69
70	70		// Creates a new #GBufferedInputStream from the given @base_stream,
71	71		// with a buffer set to @size.
72		-	func NewSizedBufferedInputStream(BaseStreamVar InputStream, SizeVar uint) BufferedInputStream {
	72	+	func NewBufferedInputStreamSized(BaseStreamVar InputStream, SizeVar uint) BufferedInputStream {
73	73		var cls *BufferedInputStream
74	74
75		-	cret := xNewSizedBufferedInputStream(BaseStreamVar.GoPointer(), SizeVar)
	75	+	cret := xNewBufferedInputStreamSized(BaseStreamVar.GoPointer(), SizeVar)
76	76
77	77		if cret == 0 {
78	78		return nil

@@ -305,7 +305,7 @@ func init() {
305	305		}
306	306
307	307		core.PuregoSafeRegister(&xNewBufferedInputStream, lib, "g_buffered_input_stream_new")
308		-	core.PuregoSafeRegister(&xNewSizedBufferedInputStream, lib, "g_buffered_input_stream_new_sized")
	308	+	core.PuregoSafeRegister(&xNewBufferedInputStreamSized, lib, "g_buffered_input_stream_new_sized")
309	309
310	310		core.PuregoSafeRegister(&xBufferedInputStreamFill, lib, "g_buffered_input_stream_fill")
311	311		core.PuregoSafeRegister(&xBufferedInputStreamFillAsync, lib, "g_buffered_input_stream_fill_async")

M v4/gio/gbufferedoutputstream.go +4 -4


@@ -64,13 +64,13 @@ func NewBufferedOutputStream(BaseStreamVar OutputStream) BufferedOutputStream
64	64		return cls
65	65		}
66	66
67		-	var xNewSizedBufferedOutputStream func(uintptr, uint) uintptr
	67	+	var xNewBufferedOutputStreamSized func(uintptr, uint) uintptr
68	68
69	69		// Creates a new buffered output stream with a given buffer size.
70		-	func NewSizedBufferedOutputStream(BaseStreamVar OutputStream, SizeVar uint) BufferedOutputStream {
	70	+	func NewBufferedOutputStreamSized(BaseStreamVar OutputStream, SizeVar uint) BufferedOutputStream {
71	71		var cls *BufferedOutputStream
72	72
73		-	cret := xNewSizedBufferedOutputStream(BaseStreamVar.GoPointer(), SizeVar)
	73	+	cret := xNewBufferedOutputStreamSized(BaseStreamVar.GoPointer(), SizeVar)
74	74
75	75		if cret == 0 {
76	76		return nil

@@ -201,7 +201,7 @@ func init() {
201	201		}
202	202
203	203		core.PuregoSafeRegister(&xNewBufferedOutputStream, lib, "g_buffered_output_stream_new")
204		-	core.PuregoSafeRegister(&xNewSizedBufferedOutputStream, lib, "g_buffered_output_stream_new_sized")
	204	+	core.PuregoSafeRegister(&xNewBufferedOutputStreamSized, lib, "g_buffered_output_stream_new_sized")
205	205
206	206		core.PuregoSafeRegister(&xBufferedOutputStreamGetAutoGrow, lib, "g_buffered_output_stream_get_auto_grow")
207	207		core.PuregoSafeRegister(&xBufferedOutputStreamGetBufferSize, lib, "g_buffered_output_stream_get_buffer_size")

M v4/gio/gdbusintrospection.go +4 -4


@@ -255,7 +255,7 @@ func (x *DBusNodeInfo) GoPointer() uintptr {
255	255		return uintptr(unsafe.Pointer(x))
256	256		}
257	257
258		-	var xNewForXmlDBusNodeInfo func(string, *glib.Error) DBusNodeInfo
	258	+	var xNewDBusNodeInfoForXml func(string, *glib.Error) DBusNodeInfo
259	259
260	260		// Parses @xml_data and returns a #GDBusNodeInfo representing the data.
261	261		//

@@ -265,10 +265,10 @@ var xNewForXmlDBusNodeInfo func(string, *glib.Error) DBusNodeInfo
265	265		// Note that this routine is using a
266	266		// [GMarkup][glib-Simple-XML-Subset-Parser.description]-based
267	267		// parser that only accepts a subset of valid XML documents.
268		-	func NewForXmlDBusNodeInfo(XmlDataVar string) (*DBusNodeInfo, error) {
	268	+	func NewDBusNodeInfoForXml(XmlDataVar string) (*DBusNodeInfo, error) {
269	269		var cerr *glib.Error
270	270
271		-	cret := xNewForXmlDBusNodeInfo(XmlDataVar, &cerr)
	271	+	cret := xNewDBusNodeInfoForXml(XmlDataVar, &cerr)
272	272		if cerr == nil {
273	273		return cret, nil
274	274		}

@@ -430,7 +430,7 @@ func init() {
430	430		core.PuregoSafeRegister(&xDBusMethodInfoRef, lib, "g_dbus_method_info_ref")
431	431		core.PuregoSafeRegister(&xDBusMethodInfoUnref, lib, "g_dbus_method_info_unref")
432	432
433		-	core.PuregoSafeRegister(&xNewForXmlDBusNodeInfo, lib, "g_dbus_node_info_new_for_xml")
	433	+	core.PuregoSafeRegister(&xNewDBusNodeInfoForXml, lib, "g_dbus_node_info_new_for_xml")
434	434
435	435		core.PuregoSafeRegister(&xDBusNodeInfoGenerateXml, lib, "g_dbus_node_info_generate_xml")
436	436		core.PuregoSafeRegister(&xDBusNodeInfoLookupInterface, lib, "g_dbus_node_info_lookup_interface")

M v4/gio/gdbusobjectmanagerclient.go +16 -16


@@ -113,14 +113,14 @@ func DBusObjectManagerClientNewFromInternalPtr(ptr uintptr) *DBusObjectManagerCl
113	113		return cls
114	114		}
115	115
116		-	var xNewFinishDBusObjectManagerClient func(uintptr, **glib.Error) uintptr
	116	+	var xNewDBusObjectManagerClientFinish func(uintptr, **glib.Error) uintptr
117	117
118	118		// Finishes an operation started with g_dbus_object_manager_client_new().
119		-	func NewFinishDBusObjectManagerClient(ResVar AsyncResult) (*DBusObjectManagerClient, error) {
	119	+	func NewDBusObjectManagerClientFinish(ResVar AsyncResult) (*DBusObjectManagerClient, error) {
120	120		var cls *DBusObjectManagerClient
121	121		var cerr *glib.Error
122	122
123		-	cret := xNewFinishDBusObjectManagerClient(ResVar.GoPointer(), &cerr)
	123	+	cret := xNewDBusObjectManagerClientFinish(ResVar.GoPointer(), &cerr)
124	124
125	125		if cret == 0 {
126	126		return nil, cerr

@@ -134,14 +134,14 @@ func NewFinishDBusObjectManagerClient(ResVar AsyncResult) (*DBusObjectManagerCli
134	134
135	135		}
136	136
137		-	var xNewForBusFinishDBusObjectManagerClient func(uintptr, **glib.Error) uintptr
	137	+	var xNewDBusObjectManagerClientForBusFinish func(uintptr, **glib.Error) uintptr
138	138
139	139		// Finishes an operation started with g_dbus_object_manager_client_new_for_bus().
140		-	func NewForBusFinishDBusObjectManagerClient(ResVar AsyncResult) (*DBusObjectManagerClient, error) {
	140	+	func NewDBusObjectManagerClientForBusFinish(ResVar AsyncResult) (*DBusObjectManagerClient, error) {
141	141		var cls *DBusObjectManagerClient
142	142		var cerr *glib.Error
143	143
144		-	cret := xNewForBusFinishDBusObjectManagerClient(ResVar.GoPointer(), &cerr)
	144	+	cret := xNewDBusObjectManagerClientForBusFinish(ResVar.GoPointer(), &cerr)
145	145
146	146		if cret == 0 {
147	147		return nil, cerr

@@ -155,7 +155,7 @@ func NewForBusFinishDBusObjectManagerClient(ResVar AsyncResult) (*DBusObjectMana
155	155
156	156		}
157	157
158		-	var xNewForBusSyncDBusObjectManagerClient func(BusType, DBusObjectManagerClientFlags, string, string, uintptr, uintptr, uintptr, uintptr, **glib.Error) uintptr
	158	+	var xNewDBusObjectManagerClientForBusSync func(BusType, DBusObjectManagerClientFlags, string, string, uintptr, uintptr, uintptr, uintptr, **glib.Error) uintptr
159	159
160	160		// Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead
161	161		// of a #GDBusConnection.

@@ -163,11 +163,11 @@ var xNewForBusSyncDBusObjectManagerClient func(BusType, DBusObjectManagerClientF
163	163		// This is a synchronous failable constructor - the calling thread is
164	164		// blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
165	165		// for the asynchronous version.
166		-	func NewForBusSyncDBusObjectManagerClient(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable) (DBusObjectManagerClient, error) {
	166	+	func NewDBusObjectManagerClientForBusSync(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable) (DBusObjectManagerClient, error) {
167	167		var cls *DBusObjectManagerClient
168	168		var cerr *glib.Error
169	169
170		-	cret := xNewForBusSyncDBusObjectManagerClient(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, purego.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, purego.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
	170	+	cret := xNewDBusObjectManagerClientForBusSync(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, purego.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, purego.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
171	171
172	172		if cret == 0 {
173	173		return nil, cerr

@@ -181,18 +181,18 @@ func NewForBusSyncDBusObjectManagerClient(BusTypeVar BusType, FlagsVar DBusObjec
181	181
182	182		}
183	183
184		-	var xNewSyncDBusObjectManagerClient func(uintptr, DBusObjectManagerClientFlags, string, string, uintptr, uintptr, uintptr, uintptr, **glib.Error) uintptr
	184	+	var xNewDBusObjectManagerClientSync func(uintptr, DBusObjectManagerClientFlags, string, string, uintptr, uintptr, uintptr, uintptr, **glib.Error) uintptr
185	185
186	186		// Creates a new #GDBusObjectManagerClient object.
187	187		//
188	188		// This is a synchronous failable constructor - the calling thread is
189	189		// blocked until a reply is received. See g_dbus_object_manager_client_new()
190	190		// for the asynchronous version.
191		-	func NewSyncDBusObjectManagerClient(ConnectionVar DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable) (*DBusObjectManagerClient, error) {
	191	+	func NewDBusObjectManagerClientSync(ConnectionVar DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable) (*DBusObjectManagerClient, error) {
192	192		var cls *DBusObjectManagerClient
193	193		var cerr *glib.Error
194	194
195		-	cret := xNewSyncDBusObjectManagerClient(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, purego.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, purego.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
	195	+	cret := xNewDBusObjectManagerClientSync(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, purego.NewCallback(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, purego.NewCallback(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)
196	196
197	197		if cret == 0 {
198	198		return nil, cerr

@@ -509,10 +509,10 @@ func init() {
509	509		panic(err)
510	510		}
511	511
512		-	core.PuregoSafeRegister(&xNewFinishDBusObjectManagerClient, lib, "g_dbus_object_manager_client_new_finish")
513		-	core.PuregoSafeRegister(&xNewForBusFinishDBusObjectManagerClient, lib, "g_dbus_object_manager_client_new_for_bus_finish")
514		-	core.PuregoSafeRegister(&xNewForBusSyncDBusObjectManagerClient, lib, "g_dbus_object_manager_client_new_for_bus_sync")
515		-	core.PuregoSafeRegister(&xNewSyncDBusObjectManagerClient, lib, "g_dbus_object_manager_client_new_sync")
	512	+	core.PuregoSafeRegister(&xNewDBusObjectManagerClientFinish, lib, "g_dbus_object_manager_client_new_finish")
	513	+	core.PuregoSafeRegister(&xNewDBusObjectManagerClientForBusFinish, lib, "g_dbus_object_manager_client_new_for_bus_finish")
	514	+	core.PuregoSafeRegister(&xNewDBusObjectManagerClientForBusSync, lib, "g_dbus_object_manager_client_new_for_bus_sync")
	515	+	core.PuregoSafeRegister(&xNewDBusObjectManagerClientSync, lib, "g_dbus_object_manager_client_new_sync")
516	516
517	517		core.PuregoSafeRegister(&xDBusObjectManagerClientGetConnection, lib, "g_dbus_object_manager_client_get_connection")
518	518		core.PuregoSafeRegister(&xDBusObjectManagerClientGetFlags, lib, "g_dbus_object_manager_client_get_flags")

M v4/gio/gdbusproxy.go +16 -16


@@ -82,14 +82,14 @@ func DBusProxyNewFromInternalPtr(ptr uintptr) *DBusProxy {
82	82		return cls
83	83		}
84	84
85		-	var xNewFinishDBusProxy func(uintptr, **glib.Error) uintptr
	85	+	var xNewDBusProxyFinish func(uintptr, **glib.Error) uintptr
86	86
87	87		// Finishes creating a #GDBusProxy.
88		-	func NewFinishDBusProxy(ResVar AsyncResult) (*DBusProxy, error) {
	88	+	func NewDBusProxyFinish(ResVar AsyncResult) (*DBusProxy, error) {
89	89		var cls *DBusProxy
90	90		var cerr *glib.Error
91	91
92		-	cret := xNewFinishDBusProxy(ResVar.GoPointer(), &cerr)
	92	+	cret := xNewDBusProxyFinish(ResVar.GoPointer(), &cerr)
93	93
94	94		if cret == 0 {
95	95		return nil, cerr

@@ -103,14 +103,14 @@ func NewFinishDBusProxy(ResVar AsyncResult) (*DBusProxy, error) {
103	103
104	104		}
105	105
106		-	var xNewForBusFinishDBusProxy func(uintptr, **glib.Error) uintptr
	106	+	var xNewDBusProxyForBusFinish func(uintptr, **glib.Error) uintptr
107	107
108	108		// Finishes creating a #GDBusProxy.
109		-	func NewForBusFinishDBusProxy(ResVar AsyncResult) (*DBusProxy, error) {
	109	+	func NewDBusProxyForBusFinish(ResVar AsyncResult) (*DBusProxy, error) {
110	110		var cls *DBusProxy
111	111		var cerr *glib.Error
112	112
113		-	cret := xNewForBusFinishDBusProxy(ResVar.GoPointer(), &cerr)
	113	+	cret := xNewDBusProxyForBusFinish(ResVar.GoPointer(), &cerr)
114	114
115	115		if cret == 0 {
116	116		return nil, cerr

@@ -124,16 +124,16 @@ func NewForBusFinishDBusProxy(ResVar AsyncResult) (*DBusProxy, error) {
124	124
125	125		}
126	126
127		-	var xNewForBusSyncDBusProxy func(BusType, DBusProxyFlags, DBusInterfaceInfo, string, string, string, uintptr, *glib.Error) uintptr
	127	+	var xNewDBusProxyForBusSync func(BusType, DBusProxyFlags, DBusInterfaceInfo, string, string, string, uintptr, *glib.Error) uintptr
128	128
129	129		// Like g_dbus_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
130	130		//
131	131		// #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
132		-	func NewForBusSyncDBusProxy(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar Cancellable) (*DBusProxy, error) {
	132	+	func NewDBusProxyForBusSync(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar Cancellable) (*DBusProxy, error) {
133	133		var cls *DBusProxy
134	134		var cerr *glib.Error
135	135
136		-	cret := xNewForBusSyncDBusProxy(BusTypeVar, FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), &cerr)
	136	+	cret := xNewDBusProxyForBusSync(BusTypeVar, FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), &cerr)
137	137
138	138		if cret == 0 {
139	139		return nil, cerr

@@ -147,7 +147,7 @@ func NewForBusSyncDBusProxy(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar
147	147
148	148		}
149	149
150		-	var xNewSyncDBusProxy func(uintptr, DBusProxyFlags, DBusInterfaceInfo, string, string, string, uintptr, *glib.Error) uintptr
	150	+	var xNewDBusProxySync func(uintptr, DBusProxyFlags, DBusInterfaceInfo, string, string, string, uintptr, *glib.Error) uintptr
151	151
152	152		// Creates a proxy for accessing @interface_name on the remote object
153	153		// at @object_path owned by @name at @connection and synchronously

@@ -171,11 +171,11 @@ var xNewSyncDBusProxy func(uintptr, DBusProxyFlags, *DBusInterfaceInfo, string,
171	171		// and g_dbus_proxy_new_finish() for the asynchronous version.
172	172		//
173	173		// #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
174		-	func NewSyncDBusProxy(ConnectionVar DBusConnection, FlagsVar DBusProxyFlags, InfoVar DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar Cancellable) (DBusProxy, error) {
	174	+	func NewDBusProxySync(ConnectionVar DBusConnection, FlagsVar DBusProxyFlags, InfoVar DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar Cancellable) (DBusProxy, error) {
175	175		var cls *DBusProxy
176	176		var cerr *glib.Error
177	177
178		-	cret := xNewSyncDBusProxy(ConnectionVar.GoPointer(), FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), &cerr)
	178	+	cret := xNewDBusProxySync(ConnectionVar.GoPointer(), FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), &cerr)
179	179
180	180		if cret == 0 {
181	181		return nil, cerr

@@ -801,10 +801,10 @@ func init() {
801	801		panic(err)
802	802		}
803	803
804		-	core.PuregoSafeRegister(&xNewFinishDBusProxy, lib, "g_dbus_proxy_new_finish")
805		-	core.PuregoSafeRegister(&xNewForBusFinishDBusProxy, lib, "g_dbus_proxy_new_for_bus_finish")
806		-	core.PuregoSafeRegister(&xNewForBusSyncDBusProxy, lib, "g_dbus_proxy_new_for_bus_sync")
807		-	core.PuregoSafeRegister(&xNewSyncDBusProxy, lib, "g_dbus_proxy_new_sync")
	804	+	core.PuregoSafeRegister(&xNewDBusProxyFinish, lib, "g_dbus_proxy_new_finish")
	805	+	core.PuregoSafeRegister(&xNewDBusProxyForBusFinish, lib, "g_dbus_proxy_new_for_bus_finish")
	806	+	core.PuregoSafeRegister(&xNewDBusProxyForBusSync, lib, "g_dbus_proxy_new_for_bus_sync")
	807	+	core.PuregoSafeRegister(&xNewDBusProxySync, lib, "g_dbus_proxy_new_sync")
808	808
809	809		core.PuregoSafeRegister(&xDBusProxyCall, lib, "g_dbus_proxy_call")
810	810		core.PuregoSafeRegister(&xDBusProxyCallFinish, lib, "g_dbus_proxy_call_finish")

M v4/gio/gdesktopappinfo.go +8 -8


@@ -123,13 +123,13 @@ func NewDesktopAppInfo(DesktopIdVar string) *DesktopAppInfo {
123	123		return cls
124	124		}
125	125
126		-	var xNewFromFilenameDesktopAppInfo func(string) uintptr
	126	+	var xNewDesktopAppInfoFromFilename func(string) uintptr
127	127
128	128		// Creates a new #GDesktopAppInfo.
129		-	func NewFromFilenameDesktopAppInfo(FilenameVar string) *DesktopAppInfo {
	129	+	func NewDesktopAppInfoFromFilename(FilenameVar string) *DesktopAppInfo {
130	130		var cls *DesktopAppInfo
131	131
132		-	cret := xNewFromFilenameDesktopAppInfo(FilenameVar)
	132	+	cret := xNewDesktopAppInfoFromFilename(FilenameVar)
133	133
134	134		if cret == 0 {
135	135		return nil

@@ -139,13 +139,13 @@ func NewFromFilenameDesktopAppInfo(FilenameVar string) *DesktopAppInfo {
139	139		return cls
140	140		}
141	141
142		-	var xNewFromKeyfileDesktopAppInfo func(*glib.KeyFile) uintptr
	142	+	var xNewDesktopAppInfoFromKeyfile func(*glib.KeyFile) uintptr
143	143
144	144		// Creates a new #GDesktopAppInfo.
145		-	func NewFromKeyfileDesktopAppInfo(KeyFileVar glib.KeyFile) DesktopAppInfo {
	145	+	func NewDesktopAppInfoFromKeyfile(KeyFileVar glib.KeyFile) DesktopAppInfo {
146	146		var cls *DesktopAppInfo
147	147
148		-	cret := xNewFromKeyfileDesktopAppInfo(KeyFileVar)
	148	+	cret := xNewDesktopAppInfoFromKeyfile(KeyFileVar)
149	149
150	150		if cret == 0 {
151	151		return nil

@@ -757,8 +757,8 @@ func init() {
757	757		}
758	758
759	759		core.PuregoSafeRegister(&xNewDesktopAppInfo, lib, "g_desktop_app_info_new")
760		-	core.PuregoSafeRegister(&xNewFromFilenameDesktopAppInfo, lib, "g_desktop_app_info_new_from_filename")
761		-	core.PuregoSafeRegister(&xNewFromKeyfileDesktopAppInfo, lib, "g_desktop_app_info_new_from_keyfile")
	760	+	core.PuregoSafeRegister(&xNewDesktopAppInfoFromFilename, lib, "g_desktop_app_info_new_from_filename")
	761	+	core.PuregoSafeRegister(&xNewDesktopAppInfoFromKeyfile, lib, "g_desktop_app_info_new_from_keyfile")
762	762
763	763		core.PuregoSafeRegister(&xDesktopAppInfoGetActionName, lib, "g_desktop_app_info_get_action_name")
764	764		core.PuregoSafeRegister(&xDesktopAppInfoGetBoolean, lib, "g_desktop_app_info_get_boolean")

M v4/gio/gemblem.go +4 -4


@@ -49,13 +49,13 @@ func NewEmblem(IconVar Icon) *Emblem {
49	49		return cls
50	50		}
51	51
52		-	var xNewWithOriginEmblem func(uintptr, EmblemOrigin) uintptr
	52	+	var xNewEmblemWithOrigin func(uintptr, EmblemOrigin) uintptr
53	53
54	54		// Creates a new emblem for @icon.
55		-	func NewWithOriginEmblem(IconVar Icon, OriginVar EmblemOrigin) *Emblem {
	55	+	func NewEmblemWithOrigin(IconVar Icon, OriginVar EmblemOrigin) *Emblem {
56	56		var cls *Emblem
57	57
58		-	cret := xNewWithOriginEmblem(IconVar.GoPointer(), OriginVar)
	58	+	cret := xNewEmblemWithOrigin(IconVar.GoPointer(), OriginVar)
59	59
60	60		if cret == 0 {
61	61		return nil

@@ -146,7 +146,7 @@ func init() {
146	146		}
147	147
148	148		core.PuregoSafeRegister(&xNewEmblem, lib, "g_emblem_new")
149		-	core.PuregoSafeRegister(&xNewWithOriginEmblem, lib, "g_emblem_new_with_origin")
	149	+	core.PuregoSafeRegister(&xNewEmblemWithOrigin, lib, "g_emblem_new_with_origin")
150	150
151	151		core.PuregoSafeRegister(&xEmblemGetIcon, lib, "g_emblem_get_icon")
152	152		core.PuregoSafeRegister(&xEmblemGetOrigin, lib, "g_emblem_get_origin")

M v4/gio/ginetaddress.go +16 -16


@@ -44,14 +44,14 @@ func InetAddressNewFromInternalPtr(ptr uintptr) *InetAddress {
44	44		return cls
45	45		}
46	46
47		-	var xNewAnyInetAddress func(SocketFamily) uintptr
	47	+	var xNewInetAddressAny func(SocketFamily) uintptr
48	48
49	49		// Creates a #GInetAddress for the "any" address (unassigned/"don't
50	50		// care") for @family.
51		-	func NewAnyInetAddress(FamilyVar SocketFamily) *InetAddress {
	51	+	func NewInetAddressAny(FamilyVar SocketFamily) *InetAddress {
52	52		var cls *InetAddress
53	53
54		-	cret := xNewAnyInetAddress(FamilyVar)
	54	+	cret := xNewInetAddressAny(FamilyVar)
55	55
56	56		if cret == 0 {
57	57		return nil

@@ -61,15 +61,15 @@ func NewAnyInetAddress(FamilyVar SocketFamily) *InetAddress {
61	61		return cls
62	62		}
63	63
64		-	var xNewFromBytesInetAddress func(uintptr, SocketFamily) uintptr
	64	+	var xNewInetAddressFromBytes func(uintptr, SocketFamily) uintptr
65	65
66	66		// Creates a new #GInetAddress from the given @family and @bytes.
67	67		// @bytes should be 4 bytes for %G_SOCKET_FAMILY_IPV4 and 16 bytes for
68	68		// %G_SOCKET_FAMILY_IPV6.
69		-	func NewFromBytesInetAddress(BytesVar uintptr, FamilyVar SocketFamily) *InetAddress {
	69	+	func NewInetAddressFromBytes(BytesVar uintptr, FamilyVar SocketFamily) *InetAddress {
70	70		var cls *InetAddress
71	71
72		-	cret := xNewFromBytesInetAddress(BytesVar, FamilyVar)
	72	+	cret := xNewInetAddressFromBytes(BytesVar, FamilyVar)
73	73
74	74		if cret == 0 {
75	75		return nil

@@ -79,13 +79,13 @@ func NewFromBytesInetAddress(BytesVar uintptr, FamilyVar SocketFamily) *InetAddr
79	79		return cls
80	80		}
81	81
82		-	var xNewFromStringInetAddress func(string) uintptr
	82	+	var xNewInetAddressFromString func(string) uintptr
83	83
84	84		// Parses @string as an IP address and creates a new #GInetAddress.
85		-	func NewFromStringInetAddress(StringVar string) *InetAddress {
	85	+	func NewInetAddressFromString(StringVar string) *InetAddress {
86	86		var cls *InetAddress
87	87
88		-	cret := xNewFromStringInetAddress(StringVar)
	88	+	cret := xNewInetAddressFromString(StringVar)
89	89
90	90		if cret == 0 {
91	91		return nil

@@ -95,13 +95,13 @@ func NewFromStringInetAddress(StringVar string) *InetAddress {
95	95		return cls
96	96		}
97	97
98		-	var xNewLoopbackInetAddress func(SocketFamily) uintptr
	98	+	var xNewInetAddressLoopback func(SocketFamily) uintptr
99	99
100	100		// Creates a #GInetAddress for the loopback address for @family.
101		-	func NewLoopbackInetAddress(FamilyVar SocketFamily) *InetAddress {
	101	+	func NewInetAddressLoopback(FamilyVar SocketFamily) *InetAddress {
102	102		var cls *InetAddress
103	103
104		-	cret := xNewLoopbackInetAddress(FamilyVar)
	104	+	cret := xNewInetAddressLoopback(FamilyVar)
105	105
106	106		if cret == 0 {
107	107		return nil

@@ -266,10 +266,10 @@ func init() {
266	266		panic(err)
267	267		}
268	268
269		-	core.PuregoSafeRegister(&xNewAnyInetAddress, lib, "g_inet_address_new_any")
270		-	core.PuregoSafeRegister(&xNewFromBytesInetAddress, lib, "g_inet_address_new_from_bytes")
271		-	core.PuregoSafeRegister(&xNewFromStringInetAddress, lib, "g_inet_address_new_from_string")
272		-	core.PuregoSafeRegister(&xNewLoopbackInetAddress, lib, "g_inet_address_new_loopback")
	269	+	core.PuregoSafeRegister(&xNewInetAddressAny, lib, "g_inet_address_new_any")
	270	+	core.PuregoSafeRegister(&xNewInetAddressFromBytes, lib, "g_inet_address_new_from_bytes")
	271	+	core.PuregoSafeRegister(&xNewInetAddressFromString, lib, "g_inet_address_new_from_string")
	272	+	core.PuregoSafeRegister(&xNewInetAddressLoopback, lib, "g_inet_address_new_loopback")
273	273
274	274		core.PuregoSafeRegister(&xInetAddressEqual, lib, "g_inet_address_equal")
275	275		core.PuregoSafeRegister(&xInetAddressGetFamily, lib, "g_inet_address_get_family")

M v4/gio/ginetaddressmask.go +4 -4


@@ -61,17 +61,17 @@ func NewInetAddressMask(AddrVar InetAddress, LengthVar uint) (InetAddressMask,
61	61
62	62		}
63	63
64		-	var xNewFromStringInetAddressMask func(string, **glib.Error) uintptr
	64	+	var xNewInetAddressMaskFromString func(string, **glib.Error) uintptr
65	65
66	66		// Parses @mask_string as an IP address and (optional) length, and
67	67		// creates a new #GInetAddressMask. The length, if present, is
68	68		// delimited by a "/". If it is not present, then the length is
69	69		// assumed to be the full length of the address.
70		-	func NewFromStringInetAddressMask(MaskStringVar string) (*InetAddressMask, error) {
	70	+	func NewInetAddressMaskFromString(MaskStringVar string) (*InetAddressMask, error) {
71	71		var cls *InetAddressMask
72	72		var cerr *glib.Error
73	73
74		-	cret := xNewFromStringInetAddressMask(MaskStringVar, &cerr)
	74	+	cret := xNewInetAddressMaskFromString(MaskStringVar, &cerr)
75	75
76	76		if cret == 0 {
77	77		return nil, cerr

@@ -211,7 +211,7 @@ func init() {
211	211		}
212	212
213	213		core.PuregoSafeRegister(&xNewInetAddressMask, lib, "g_inet_address_mask_new")
214		-	core.PuregoSafeRegister(&xNewFromStringInetAddressMask, lib, "g_inet_address_mask_new_from_string")
	214	+	core.PuregoSafeRegister(&xNewInetAddressMaskFromString, lib, "g_inet_address_mask_new_from_string")
215	215
216	216		core.PuregoSafeRegister(&xInetAddressMaskEqual, lib, "g_inet_address_mask_equal")
217	217		core.PuregoSafeRegister(&xInetAddressMaskGetAddress, lib, "g_inet_address_mask_get_address")

M v4/gio/ginetsocketaddress.go +4 -4


@@ -52,16 +52,16 @@ func NewInetSocketAddress(AddressVar InetAddress, PortVar uint16) InetSocketAd
52	52		return cls
53	53		}
54	54
55		-	var xNewFromStringInetSocketAddress func(string, uint) uintptr
	55	+	var xNewInetSocketAddressFromString func(string, uint) uintptr
56	56
57	57		// Creates a new #GInetSocketAddress for @address and @port.
58	58		//
59	59		// If @address is an IPv6 address, it can also contain a scope ID
60	60		// (separated from the address by a `%`).
61		-	func NewFromStringInetSocketAddress(AddressVar string, PortVar uint) *InetSocketAddress {
	61	+	func NewInetSocketAddressFromString(AddressVar string, PortVar uint) *InetSocketAddress {
62	62		var cls *InetSocketAddress
63	63
64		-	cret := xNewFromStringInetSocketAddress(AddressVar, PortVar)
	64	+	cret := xNewInetSocketAddressFromString(AddressVar, PortVar)
65	65
66	66		if cret == 0 {
67	67		return nil

@@ -179,7 +179,7 @@ func init() {
179	179		}
180	180
181	181		core.PuregoSafeRegister(&xNewInetSocketAddress, lib, "g_inet_socket_address_new")
182		-	core.PuregoSafeRegister(&xNewFromStringInetSocketAddress, lib, "g_inet_socket_address_new_from_string")
	182	+	core.PuregoSafeRegister(&xNewInetSocketAddressFromString, lib, "g_inet_socket_address_new_from_string")
183	183
184	184		core.PuregoSafeRegister(&xInetSocketAddressGetAddress, lib, "g_inet_socket_address_get_address")
185	185		core.PuregoSafeRegister(&xInetSocketAddressGetFlowinfo, lib, "g_inet_socket_address_get_flowinfo")

M v4/gio/gio-2.0.go +52 -52


@@ -775,14 +775,14 @@ func DBusConnectionNewFromInternalPtr(ptr uintptr) *DBusConnection {
775	775		return cls
776	776		}
777	777
778		-	var xNewFinishDBusConnection func(uintptr, **glib.Error) uintptr
	778	+	var xNewDBusConnectionFinish func(uintptr, **glib.Error) uintptr
779	779
780	780		// Finishes an operation started with g_dbus_connection_new().
781		-	func NewFinishDBusConnection(ResVar AsyncResult) (*DBusConnection, error) {
	781	+	func NewDBusConnectionFinish(ResVar AsyncResult) (*DBusConnection, error) {
782	782		var cls *DBusConnection
783	783		var cerr *glib.Error
784	784
785		-	cret := xNewFinishDBusConnection(ResVar.GoPointer(), &cerr)
	785	+	cret := xNewDBusConnectionFinish(ResVar.GoPointer(), &cerr)
786	786
787	787		if cret == 0 {
788	788		return nil, cerr

@@ -796,14 +796,14 @@ func NewFinishDBusConnection(ResVar AsyncResult) (*DBusConnection, error) {
796	796
797	797		}
798	798
799		-	var xNewForAddressFinishDBusConnection func(uintptr, **glib.Error) uintptr
	799	+	var xNewDBusConnectionForAddressFinish func(uintptr, **glib.Error) uintptr
800	800
801	801		// Finishes an operation started with g_dbus_connection_new_for_address().
802		-	func NewForAddressFinishDBusConnection(ResVar AsyncResult) (*DBusConnection, error) {
	802	+	func NewDBusConnectionForAddressFinish(ResVar AsyncResult) (*DBusConnection, error) {
803	803		var cls *DBusConnection
804	804		var cerr *glib.Error
805	805
806		-	cret := xNewForAddressFinishDBusConnection(ResVar.GoPointer(), &cerr)
	806	+	cret := xNewDBusConnectionForAddressFinish(ResVar.GoPointer(), &cerr)
807	807
808	808		if cret == 0 {
809	809		return nil, cerr

@@ -817,7 +817,7 @@ func NewForAddressFinishDBusConnection(ResVar AsyncResult) (*DBusConnection, err
817	817
818	818		}
819	819
820		-	var xNewForAddressSyncDBusConnection func(string, DBusConnectionFlags, uintptr, uintptr, **glib.Error) uintptr
	820	+	var xNewDBusConnectionForAddressSync func(string, DBusConnectionFlags, uintptr, uintptr, **glib.Error) uintptr
821	821
822	822		// Synchronously connects and sets up a D-Bus client connection for
823	823		// exchanging D-Bus messages with an endpoint specified by @address

@@ -836,11 +836,11 @@ var xNewForAddressSyncDBusConnection func(string, DBusConnectionFlags, uintptr,
836	836		//
837	837		// If @observer is not %NULL it may be used to control the
838	838		// authentication process.
839		-	func NewForAddressSyncDBusConnection(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable) (*DBusConnection, error) {
	839	+	func NewDBusConnectionForAddressSync(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable) (*DBusConnection, error) {
840	840		var cls *DBusConnection
841	841		var cerr *glib.Error
842	842
843		-	cret := xNewForAddressSyncDBusConnection(AddressVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
	843	+	cret := xNewDBusConnectionForAddressSync(AddressVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
844	844
845	845		if cret == 0 {
846	846		return nil, cerr

@@ -854,7 +854,7 @@ func NewForAddressSyncDBusConnection(AddressVar string, FlagsVar DBusConnectionF
854	854
855	855		}
856	856
857		-	var xNewSyncDBusConnection func(uintptr, string, DBusConnectionFlags, uintptr, uintptr, **glib.Error) uintptr
	857	+	var xNewDBusConnectionSync func(uintptr, string, DBusConnectionFlags, uintptr, uintptr, **glib.Error) uintptr
858	858
859	859		// Synchronously sets up a D-Bus connection for exchanging D-Bus messages
860	860		// with the end represented by @stream.

@@ -871,11 +871,11 @@ var xNewSyncDBusConnection func(uintptr, string, DBusConnectionFlags, uintptr, u
871	871		//
872	872		// This is a synchronous failable constructor. See
873	873		// g_dbus_connection_new() for the asynchronous version.
874		-	func NewSyncDBusConnection(StreamVar IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable) (DBusConnection, error) {
	874	+	func NewDBusConnectionSync(StreamVar IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable) (DBusConnection, error) {
875	875		var cls *DBusConnection
876	876		var cerr *glib.Error
877	877
878		-	cret := xNewSyncDBusConnection(StreamVar.GoPointer(), GuidVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
	878	+	cret := xNewDBusConnectionSync(StreamVar.GoPointer(), GuidVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
879	879
880	880		if cret == 0 {
881	881		return nil, cerr

@@ -2145,7 +2145,7 @@ func NewDBusMessage() *DBusMessage {
2145	2145		return cls
2146	2146		}
2147	2147
2148		-	var xNewFromBlobDBusMessage func(uintptr, uint, DBusCapabilityFlags, **glib.Error) uintptr
	2148	+	var xNewDBusMessageFromBlob func(uintptr, uint, DBusCapabilityFlags, **glib.Error) uintptr
2149	2149
2150	2150		// Creates a new #GDBusMessage from the data stored at @blob. The byte
2151	2151		// order that the message was in can be retrieved using

@@ -2153,11 +2153,11 @@ var xNewFromBlobDBusMessage func(uintptr, uint, DBusCapabilityFlags, **glib.Erro
2153	2153		//
2154	2154		// If the @blob cannot be parsed, contains invalid fields, or contains invalid
2155	2155		// headers, %G_IO_ERROR_INVALID_ARGUMENT will be returned.
2156		-	func NewFromBlobDBusMessage(BlobVar uintptr, BlobLenVar uint, CapabilitiesVar DBusCapabilityFlags) (*DBusMessage, error) {
	2156	+	func NewDBusMessageFromBlob(BlobVar uintptr, BlobLenVar uint, CapabilitiesVar DBusCapabilityFlags) (*DBusMessage, error) {
2157	2157		var cls *DBusMessage
2158	2158		var cerr *glib.Error
2159	2159
2160		-	cret := xNewFromBlobDBusMessage(BlobVar, BlobLenVar, CapabilitiesVar, &cerr)
	2160	+	cret := xNewDBusMessageFromBlob(BlobVar, BlobLenVar, CapabilitiesVar, &cerr)
2161	2161
2162	2162		if cret == 0 {
2163	2163		return nil, cerr

@@ -2171,13 +2171,13 @@ func NewFromBlobDBusMessage(BlobVar uintptr, BlobLenVar uint, CapabilitiesVar DB
2171	2171
2172	2172		}
2173	2173
2174		-	var xNewMethodCallDBusMessage func(string, string, string, string) uintptr
	2174	+	var xNewDBusMessageMethodCall func(string, string, string, string) uintptr
2175	2175
2176	2176		// Creates a new #GDBusMessage for a method call.
2177		-	func NewMethodCallDBusMessage(NameVar string, PathVar string, InterfaceVar string, MethodVar string) *DBusMessage {
	2177	+	func NewDBusMessageMethodCall(NameVar string, PathVar string, InterfaceVar string, MethodVar string) *DBusMessage {
2178	2178		var cls *DBusMessage
2179	2179
2180		-	cret := xNewMethodCallDBusMessage(NameVar, PathVar, InterfaceVar, MethodVar)
	2180	+	cret := xNewDBusMessageMethodCall(NameVar, PathVar, InterfaceVar, MethodVar)
2181	2181
2182	2182		if cret == 0 {
2183	2183		return nil

@@ -2187,13 +2187,13 @@ func NewMethodCallDBusMessage(NameVar string, PathVar string, InterfaceVar strin
2187	2187		return cls
2188	2188		}
2189	2189
2190		-	var xNewSignalDBusMessage func(string, string, string) uintptr
	2190	+	var xNewDBusMessageSignal func(string, string, string) uintptr
2191	2191
2192	2192		// Creates a new #GDBusMessage for a signal emission.
2193		-	func NewSignalDBusMessage(PathVar string, InterfaceVar string, SignalVar string) *DBusMessage {
	2193	+	func NewDBusMessageSignal(PathVar string, InterfaceVar string, SignalVar string) *DBusMessage {
2194	2194		var cls *DBusMessage
2195	2195
2196		-	cret := xNewSignalDBusMessage(PathVar, InterfaceVar, SignalVar)
	2196	+	cret := xNewDBusMessageSignal(PathVar, InterfaceVar, SignalVar)
2197	2197
2198	2198		if cret == 0 {
2199	2199		return nil

@@ -3103,7 +3103,7 @@ func DBusServerNewFromInternalPtr(ptr uintptr) *DBusServer {
3103	3103		return cls
3104	3104		}
3105	3105
3106		-	var xNewSyncDBusServer func(string, DBusServerFlags, string, uintptr, uintptr, **glib.Error) uintptr
	3106	+	var xNewDBusServerSync func(string, DBusServerFlags, string, uintptr, uintptr, **glib.Error) uintptr
3107	3107
3108	3108		// Creates a new D-Bus server that listens on the first address in
3109	3109		// @address that works.

@@ -3125,11 +3125,11 @@ var xNewSyncDBusServer func(string, DBusServerFlags, string, uintptr, uintptr, *
3125	3125		//
3126	3126		// This is a synchronous failable constructor. There is currently no
3127	3127		// asynchronous version.
3128		-	func NewSyncDBusServer(AddressVar string, FlagsVar DBusServerFlags, GuidVar string, ObserverVar DBusAuthObserver, CancellableVar Cancellable) (*DBusServer, error) {
	3128	+	func NewDBusServerSync(AddressVar string, FlagsVar DBusServerFlags, GuidVar string, ObserverVar DBusAuthObserver, CancellableVar Cancellable) (*DBusServer, error) {
3129	3129		var cls *DBusServer
3130	3130		var cerr *glib.Error
3131	3131
3132		-	cret := xNewSyncDBusServer(AddressVar, FlagsVar, GuidVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
	3132	+	cret := xNewDBusServerSync(AddressVar, FlagsVar, GuidVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
3133	3133
3134	3134		if cret == 0 {
3135	3135		return nil, cerr

@@ -3558,17 +3558,17 @@ func NewMenuItem(LabelVar string, DetailedActionVar string) *MenuItem {
3558	3558		return cls
3559	3559		}
3560	3560
3561		-	var xNewFromModelMenuItem func(uintptr, int) uintptr
	3561	+	var xNewMenuItemFromModel func(uintptr, int) uintptr
3562	3562
3563	3563		// Creates a #GMenuItem as an exact copy of an existing menu item in a
3564	3564		// #GMenuModel.
3565	3565		//
3566	3566		// @item_index must be valid (ie: be sure to call
3567	3567		// g_menu_model_get_n_items() first).
3568		-	func NewFromModelMenuItem(ModelVar MenuModel, ItemIndexVar int) MenuItem {
	3568	+	func NewMenuItemFromModel(ModelVar MenuModel, ItemIndexVar int) MenuItem {
3569	3569		var cls *MenuItem
3570	3570
3571		-	cret := xNewFromModelMenuItem(ModelVar.GoPointer(), ItemIndexVar)
	3571	+	cret := xNewMenuItemFromModel(ModelVar.GoPointer(), ItemIndexVar)
3572	3572
3573	3573		if cret == 0 {
3574	3574		return nil

@@ -3578,7 +3578,7 @@ func NewFromModelMenuItem(ModelVar MenuModel, ItemIndexVar int) MenuItem {
3578	3578		return cls
3579	3579		}
3580	3580
3581		-	var xNewSectionMenuItem func(string, uintptr) uintptr
	3581	+	var xNewMenuItemSection func(string, uintptr) uintptr
3582	3582
3583	3583		// Creates a new #GMenuItem representing a section.
3584	3584		//

@@ -3644,10 +3644,10 @@ var xNewSectionMenuItem func(string, uintptr) uintptr
3644	3644		//
3645	3645		// </menu>
3646	3646		// ]\|
3647		-	func NewSectionMenuItem(LabelVar string, SectionVar MenuModel) MenuItem {
	3647	+	func NewMenuItemSection(LabelVar string, SectionVar MenuModel) MenuItem {
3648	3648		var cls *MenuItem
3649	3649
3650		-	cret := xNewSectionMenuItem(LabelVar, SectionVar.GoPointer())
	3650	+	cret := xNewMenuItemSection(LabelVar, SectionVar.GoPointer())
3651	3651
3652	3652		if cret == 0 {
3653	3653		return nil

@@ -3657,16 +3657,16 @@ func NewSectionMenuItem(LabelVar string, SectionVar MenuModel) MenuItem {
3657	3657		return cls
3658	3658		}
3659	3659
3660		-	var xNewSubmenuMenuItem func(string, uintptr) uintptr
	3660	+	var xNewMenuItemSubmenu func(string, uintptr) uintptr
3661	3661
3662	3662		// Creates a new #GMenuItem representing a submenu.
3663	3663		//
3664	3664		// This is a convenience API around g_menu_item_new() and
3665	3665		// g_menu_item_set_submenu().
3666		-	func NewSubmenuMenuItem(LabelVar string, SubmenuVar MenuModel) MenuItem {
	3666	+	func NewMenuItemSubmenu(LabelVar string, SubmenuVar MenuModel) MenuItem {
3667	3667		var cls *MenuItem
3668	3668
3669		-	cret := xNewSubmenuMenuItem(LabelVar, SubmenuVar.GoPointer())
	3669	+	cret := xNewMenuItemSubmenu(LabelVar, SubmenuVar.GoPointer())
3670	3670
3671	3671		if cret == 0 {
3672	3672		return nil

@@ -4438,7 +4438,7 @@ func NewSimpleAction(NameVar string, ParameterTypeVar glib.VariantType) Simple
4438	4438		return cls
4439	4439		}
4440	4440
4441		-	var xNewStatefulSimpleAction func(string, glib.VariantType, glib.Variant) uintptr
	4441	+	var xNewSimpleActionStateful func(string, glib.VariantType, glib.Variant) uintptr
4442	4442
4443	4443		// Creates a new stateful action.
4444	4444		//

@@ -4446,10 +4446,10 @@ var xNewStatefulSimpleAction func(string, glib.VariantType, glib.Variant) uint
4446	4446		// @state.
4447	4447		//
4448	4448		// If the @state #GVariant is floating, it is consumed.
4449		-	func NewStatefulSimpleAction(NameVar string, ParameterTypeVar glib.VariantType, StateVar glib.Variant) *SimpleAction {
	4449	+	func NewSimpleActionStateful(NameVar string, ParameterTypeVar glib.VariantType, StateVar glib.Variant) *SimpleAction {
4450	4450		var cls *SimpleAction
4451	4451
4452		-	cret := xNewStatefulSimpleAction(NameVar, ParameterTypeVar, StateVar)
	4452	+	cret := xNewSimpleActionStateful(NameVar, ParameterTypeVar, StateVar)
4453	4453
4454	4454		if cret == 0 {
4455	4455		return nil

@@ -4871,16 +4871,16 @@ func NewSubprocess(FlagsVar SubprocessFlags, ErrorVar **glib.Error, Argv0Var str
4871	4871		return cls
4872	4872		}
4873	4873
4874		-	var xNewvSubprocess func(uintptr, SubprocessFlags, **glib.Error) uintptr
	4874	+	var xNewSubprocessv func(uintptr, SubprocessFlags, **glib.Error) uintptr
4875	4875
4876	4876		// Create a new process with the given flags and argument list.
4877	4877		//
4878	4878		// The argument list is expected to be %NULL-terminated.
4879		-	func NewvSubprocess(ArgvVar uintptr, FlagsVar SubprocessFlags) (*Subprocess, error) {
	4879	+	func NewSubprocessv(ArgvVar uintptr, FlagsVar SubprocessFlags) (*Subprocess, error) {
4880	4880		var cls *Subprocess
4881	4881		var cerr *glib.Error
4882	4882
4883		-	cret := xNewvSubprocess(ArgvVar, FlagsVar, &cerr)
	4883	+	cret := xNewSubprocessv(ArgvVar, FlagsVar, &cerr)
4884	4884
4885	4885		if cret == 0 {
4886	4886		return nil, cerr

@@ -5959,10 +5959,10 @@ func init() {
5959	5959		core.PuregoSafeRegister(&xDBusAuthObserverAllowMechanism, lib, "g_dbus_auth_observer_allow_mechanism")
5960	5960		core.PuregoSafeRegister(&xDBusAuthObserverAuthorizeAuthenticatedPeer, lib, "g_dbus_auth_observer_authorize_authenticated_peer")
5961	5961
5962		-	core.PuregoSafeRegister(&xNewFinishDBusConnection, lib, "g_dbus_connection_new_finish")
5963		-	core.PuregoSafeRegister(&xNewForAddressFinishDBusConnection, lib, "g_dbus_connection_new_for_address_finish")
5964		-	core.PuregoSafeRegister(&xNewForAddressSyncDBusConnection, lib, "g_dbus_connection_new_for_address_sync")
5965		-	core.PuregoSafeRegister(&xNewSyncDBusConnection, lib, "g_dbus_connection_new_sync")
	5962	+	core.PuregoSafeRegister(&xNewDBusConnectionFinish, lib, "g_dbus_connection_new_finish")
	5963	+	core.PuregoSafeRegister(&xNewDBusConnectionForAddressFinish, lib, "g_dbus_connection_new_for_address_finish")
	5964	+	core.PuregoSafeRegister(&xNewDBusConnectionForAddressSync, lib, "g_dbus_connection_new_for_address_sync")
	5965	+	core.PuregoSafeRegister(&xNewDBusConnectionSync, lib, "g_dbus_connection_new_sync")
5966	5966
5967	5967		core.PuregoSafeRegister(&xDBusConnectionAddFilter, lib, "g_dbus_connection_add_filter")
5968	5968		core.PuregoSafeRegister(&xDBusConnectionCall, lib, "g_dbus_connection_call")

@@ -6012,9 +6012,9 @@ func init() {
6012	6012		core.PuregoSafeRegister(&xDBusMenuModelGet, lib, "g_dbus_menu_model_get")
6013	6013
6014	6014		core.PuregoSafeRegister(&xNewDBusMessage, lib, "g_dbus_message_new")
6015		-	core.PuregoSafeRegister(&xNewFromBlobDBusMessage, lib, "g_dbus_message_new_from_blob")
6016		-	core.PuregoSafeRegister(&xNewMethodCallDBusMessage, lib, "g_dbus_message_new_method_call")
6017		-	core.PuregoSafeRegister(&xNewSignalDBusMessage, lib, "g_dbus_message_new_signal")
	6015	+	core.PuregoSafeRegister(&xNewDBusMessageFromBlob, lib, "g_dbus_message_new_from_blob")
	6016	+	core.PuregoSafeRegister(&xNewDBusMessageMethodCall, lib, "g_dbus_message_new_method_call")
	6017	+	core.PuregoSafeRegister(&xNewDBusMessageSignal, lib, "g_dbus_message_new_signal")
6018	6018
6019	6019		core.PuregoSafeRegister(&xDBusMessageCopy, lib, "g_dbus_message_copy")
6020	6020		core.PuregoSafeRegister(&xDBusMessageGetArg0, lib, "g_dbus_message_get_arg0")

@@ -6082,7 +6082,7 @@ func init() {
6082	6082		core.PuregoSafeRegister(&xDBusMethodInvocationReturnValueWithUnixFdList, lib, "g_dbus_method_invocation_return_value_with_unix_fd_list")
6083	6083		core.PuregoSafeRegister(&xDBusMethodInvocationTakeError, lib, "g_dbus_method_invocation_take_error")
6084	6084
6085		-	core.PuregoSafeRegister(&xNewSyncDBusServer, lib, "g_dbus_server_new_sync")
	6085	+	core.PuregoSafeRegister(&xNewDBusServerSync, lib, "g_dbus_server_new_sync")
6086	6086
6087	6087		core.PuregoSafeRegister(&xDBusServerGetClientAddress, lib, "g_dbus_server_get_client_address")
6088	6088		core.PuregoSafeRegister(&xDBusServerGetFlags, lib, "g_dbus_server_get_flags")

@@ -6110,9 +6110,9 @@ func init() {
6110	6110		core.PuregoSafeRegister(&xMenuRemoveAll, lib, "g_menu_remove_all")
6111	6111
6112	6112		core.PuregoSafeRegister(&xNewMenuItem, lib, "g_menu_item_new")
6113		-	core.PuregoSafeRegister(&xNewFromModelMenuItem, lib, "g_menu_item_new_from_model")
6114		-	core.PuregoSafeRegister(&xNewSectionMenuItem, lib, "g_menu_item_new_section")
6115		-	core.PuregoSafeRegister(&xNewSubmenuMenuItem, lib, "g_menu_item_new_submenu")
	6113	+	core.PuregoSafeRegister(&xNewMenuItemFromModel, lib, "g_menu_item_new_from_model")
	6114	+	core.PuregoSafeRegister(&xNewMenuItemSection, lib, "g_menu_item_new_section")
	6115	+	core.PuregoSafeRegister(&xNewMenuItemSubmenu, lib, "g_menu_item_new_submenu")
6116	6116
6117	6117		core.PuregoSafeRegister(&xMenuItemGetAttribute, lib, "g_menu_item_get_attribute")
6118	6118		core.PuregoSafeRegister(&xMenuItemGetAttributeValue, lib, "g_menu_item_get_attribute_value")

@@ -6146,7 +6146,7 @@ func init() {
6146	6146		core.PuregoSafeRegister(&xNewPropertyAction, lib, "g_property_action_new")
6147	6147
6148	6148		core.PuregoSafeRegister(&xNewSimpleAction, lib, "g_simple_action_new")
6149		-	core.PuregoSafeRegister(&xNewStatefulSimpleAction, lib, "g_simple_action_new_stateful")
	6149	+	core.PuregoSafeRegister(&xNewSimpleActionStateful, lib, "g_simple_action_new_stateful")
6150	6150
6151	6151		core.PuregoSafeRegister(&xSimpleActionSetEnabled, lib, "g_simple_action_set_enabled")
6152	6152		core.PuregoSafeRegister(&xSimpleActionSetState, lib, "g_simple_action_set_state")

@@ -6157,7 +6157,7 @@ func init() {
6157	6157		core.PuregoSafeRegister(&xNewSimplePermission, lib, "g_simple_permission_new")
6158	6158
6159	6159		core.PuregoSafeRegister(&xNewSubprocess, lib, "g_subprocess_new")
6160		-	core.PuregoSafeRegister(&xNewvSubprocess, lib, "g_subprocess_newv")
	6160	+	core.PuregoSafeRegister(&xNewSubprocessv, lib, "g_subprocess_newv")
6161	6161
6162	6162		core.PuregoSafeRegister(&xSubprocessCommunicate, lib, "g_subprocess_communicate")
6163	6163		core.PuregoSafeRegister(&xSubprocessCommunicateAsync, lib, "g_subprocess_communicate_async")

M v4/gio/giotypes.go +4 -4


@@ -604,7 +604,7 @@ func (x *Resource) GoPointer() uintptr {
604	604		return uintptr(unsafe.Pointer(x))
605	605		}
606	606
607		-	var xNewFromDataResource func(glib.Bytes, glib.Error) Resource
	607	+	var xNewResourceFromData func(glib.Bytes, glib.Error) Resource
608	608
609	609		// Creates a GResource from a reference to the binary resource bundle.
610	610		// This will keep a reference to @data while the resource lives, so

@@ -618,10 +618,10 @@ var xNewFromDataResource func(glib.Bytes, glib.Error) Resource
618	618		// GLib 2.56, or in older versions fail and exit the process.
619	619		//
620	620		// If @data is empty or corrupt, %G_RESOURCE_ERROR_INTERNAL will be returned.
621		-	func NewFromDataResource(DataVar glib.Bytes) (Resource, error) {
	621	+	func NewResourceFromData(DataVar glib.Bytes) (Resource, error) {
622	622		var cerr *glib.Error
623	623
624		-	cret := xNewFromDataResource(DataVar, &cerr)
	624	+	cret := xNewResourceFromData(DataVar, &cerr)
625	625		if cerr == nil {
626	626		return cret, nil
627	627		}

@@ -884,7 +884,7 @@ func init() {
884	884		core.PuregoSafeRegister(&xIOSchedulerJobSendToMainloop, lib, "g_io_scheduler_job_send_to_mainloop")
885	885		core.PuregoSafeRegister(&xIOSchedulerJobSendToMainloopAsync, lib, "g_io_scheduler_job_send_to_mainloop_async")
886	886
887		-	core.PuregoSafeRegister(&xNewFromDataResource, lib, "g_resource_new_from_data")
	887	+	core.PuregoSafeRegister(&xNewResourceFromData, lib, "g_resource_new_from_data")
888	888
889	889		core.PuregoSafeRegister(&xResourceRegister, lib, "g_resources_register")
890	890		core.PuregoSafeRegister(&xResourceUnregister, lib, "g_resources_unregister")

M v4/gio/gmemoryinputstream.go +8 -8


@@ -55,13 +55,13 @@ func NewMemoryInputStream() *MemoryInputStream {
55	55		return cls
56	56		}
57	57
58		-	var xNewFromBytesMemoryInputStream func(*glib.Bytes) uintptr
	58	+	var xNewMemoryInputStreamFromBytes func(*glib.Bytes) uintptr
59	59
60	60		// Creates a new #GMemoryInputStream with data from the given @bytes.
61		-	func NewFromBytesMemoryInputStream(BytesVar glib.Bytes) MemoryInputStream {
	61	+	func NewMemoryInputStreamFromBytes(BytesVar glib.Bytes) MemoryInputStream {
62	62		var cls *MemoryInputStream
63	63
64		-	cret := xNewFromBytesMemoryInputStream(BytesVar)
	64	+	cret := xNewMemoryInputStreamFromBytes(BytesVar)
65	65
66	66		if cret == 0 {
67	67		return nil

@@ -71,13 +71,13 @@ func NewFromBytesMemoryInputStream(BytesVar glib.Bytes) MemoryInputStream {
71	71		return cls
72	72		}
73	73
74		-	var xNewFromDataMemoryInputStream func(uintptr, int, uintptr) uintptr
	74	+	var xNewMemoryInputStreamFromData func(uintptr, int, uintptr) uintptr
75	75
76	76		// Creates a new #GMemoryInputStream with data in memory of a given size.
77		-	func NewFromDataMemoryInputStream(DataVar uintptr, LenVar int, DestroyVar glib.DestroyNotify) *MemoryInputStream {
	77	+	func NewMemoryInputStreamFromData(DataVar uintptr, LenVar int, DestroyVar glib.DestroyNotify) *MemoryInputStream {
78	78		var cls *MemoryInputStream
79	79
80		-	cret := xNewFromDataMemoryInputStream(DataVar, LenVar, purego.NewCallback(DestroyVar))
	80	+	cret := xNewMemoryInputStreamFromData(DataVar, LenVar, purego.NewCallback(DestroyVar))
81	81
82	82		if cret == 0 {
83	83		return nil

@@ -250,8 +250,8 @@ func init() {
250	250		}
251	251
252	252		core.PuregoSafeRegister(&xNewMemoryInputStream, lib, "g_memory_input_stream_new")
253		-	core.PuregoSafeRegister(&xNewFromBytesMemoryInputStream, lib, "g_memory_input_stream_new_from_bytes")
254		-	core.PuregoSafeRegister(&xNewFromDataMemoryInputStream, lib, "g_memory_input_stream_new_from_data")
	253	+	core.PuregoSafeRegister(&xNewMemoryInputStreamFromBytes, lib, "g_memory_input_stream_new_from_bytes")
	254	+	core.PuregoSafeRegister(&xNewMemoryInputStreamFromData, lib, "g_memory_input_stream_new_from_data")
255	255
256	256		core.PuregoSafeRegister(&xMemoryInputStreamAddBytes, lib, "g_memory_input_stream_add_bytes")
257	257		core.PuregoSafeRegister(&xMemoryInputStreamAddData, lib, "g_memory_input_stream_add_data")

M v4/gio/gmemoryoutputstream.go +4 -4


@@ -101,14 +101,14 @@ func NewMemoryOutputStream(DataVar uintptr, SizeVar uint, ReallocFunctionVar Rea
101	101		return cls
102	102		}
103	103
104		-	var xNewResizableMemoryOutputStream func() uintptr
	104	+	var xNewMemoryOutputStreamResizable func() uintptr
105	105
106	106		// Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
107	107		// for memory allocation.
108		-	func NewResizableMemoryOutputStream() *MemoryOutputStream {
	108	+	func NewMemoryOutputStreamResizable() *MemoryOutputStream {
109	109		var cls *MemoryOutputStream
110	110
111		-	cret := xNewResizableMemoryOutputStream()
	111	+	cret := xNewMemoryOutputStreamResizable()
112	112
113	113		if cret == 0 {
114	114		return nil

@@ -363,7 +363,7 @@ func init() {
363	363		}
364	364
365	365		core.PuregoSafeRegister(&xNewMemoryOutputStream, lib, "g_memory_output_stream_new")
366		-	core.PuregoSafeRegister(&xNewResizableMemoryOutputStream, lib, "g_memory_output_stream_new_resizable")
	366	+	core.PuregoSafeRegister(&xNewMemoryOutputStreamResizable, lib, "g_memory_output_stream_new_resizable")
367	367
368	368		core.PuregoSafeRegister(&xMemoryOutputStreamGetData, lib, "g_memory_output_stream_get_data")
369	369		core.PuregoSafeRegister(&xMemoryOutputStreamGetDataSize, lib, "g_memory_output_stream_get_data_size")

M v4/gio/gnetworkaddress.go +4 -4


@@ -68,7 +68,7 @@ func NewNetworkAddress(HostnameVar string, PortVar uint16) *NetworkAddress {
68	68		return cls
69	69		}
70	70
71		-	var xNewLoopbackNetworkAddress func(uint16) uintptr
	71	+	var xNewNetworkAddressLoopback func(uint16) uintptr
72	72
73	73		// Creates a new #GSocketConnectable for connecting to the local host
74	74		// over a loopback connection to the given @port. This is intended for

@@ -82,10 +82,10 @@ var xNewLoopbackNetworkAddress func(uint16) uintptr
82	82		//
83	83		// g_network_address_get_hostname() will always return `localhost` for
84	84		// a #GNetworkAddress created with this constructor.
85		-	func NewLoopbackNetworkAddress(PortVar uint16) *NetworkAddress {
	85	+	func NewNetworkAddressLoopback(PortVar uint16) *NetworkAddress {
86	86		var cls *NetworkAddress
87	87
88		-	cret := xNewLoopbackNetworkAddress(PortVar)
	88	+	cret := xNewNetworkAddressLoopback(PortVar)
89	89
90	90		if cret == 0 {
91	91		return nil

@@ -252,7 +252,7 @@ func init() {
252	252		}
253	253
254	254		core.PuregoSafeRegister(&xNewNetworkAddress, lib, "g_network_address_new")
255		-	core.PuregoSafeRegister(&xNewLoopbackNetworkAddress, lib, "g_network_address_new_loopback")
	255	+	core.PuregoSafeRegister(&xNewNetworkAddressLoopback, lib, "g_network_address_new_loopback")
256	256
257	257		core.PuregoSafeRegister(&xNetworkAddressGetHostname, lib, "g_network_address_get_hostname")
258	258		core.PuregoSafeRegister(&xNetworkAddressGetPort, lib, "g_network_address_get_port")

M v4/gio/gsettings.go +16 -16


@@ -408,7 +408,7 @@ func NewSettings(SchemaIdVar string) *Settings {
408	408		return cls
409	409		}
410	410
411		-	var xNewFullSettings func(*SettingsSchema, uintptr, string) uintptr
	411	+	var xNewSettingsFull func(*SettingsSchema, uintptr, string) uintptr
412	412
413	413		// Creates a new #GSettings object with a given schema, backend and
414	414		// path.

@@ -433,10 +433,10 @@ var xNewFullSettings func(*SettingsSchema, uintptr, string) uintptr
433	433		// error if @path is %NULL and the schema has no path of its own or if
434	434		// @path is non-%NULL and not equal to the path that the schema does
435	435		// have.
436		-	func NewFullSettings(SchemaVar SettingsSchema, BackendVar SettingsBackend, PathVar string) *Settings {
	436	+	func NewSettingsFull(SchemaVar SettingsSchema, BackendVar SettingsBackend, PathVar string) *Settings {
437	437		var cls *Settings
438	438
439		-	cret := xNewFullSettings(SchemaVar, BackendVar.GoPointer(), PathVar)
	439	+	cret := xNewSettingsFull(SchemaVar, BackendVar.GoPointer(), PathVar)
440	440
441	441		if cret == 0 {
442	442		return nil

@@ -446,7 +446,7 @@ func NewFullSettings(SchemaVar SettingsSchema, BackendVar SettingsBackend, Pat
446	446		return cls
447	447		}
448	448
449		-	var xNewWithBackendSettings func(string, uintptr) uintptr
	449	+	var xNewSettingsWithBackend func(string, uintptr) uintptr
450	450
451	451		// Creates a new #GSettings object with the schema specified by
452	452		// @schema_id and a given #GSettingsBackend.

@@ -456,10 +456,10 @@ var xNewWithBackendSettings func(string, uintptr) uintptr
456	456		// sense to pass a backend corresponding to the "defaults" settings database on
457	457		// the system to get a settings object that modifies the system default
458	458		// settings instead of the settings for this user.
459		-	func NewWithBackendSettings(SchemaIdVar string, BackendVar SettingsBackend) Settings {
	459	+	func NewSettingsWithBackend(SchemaIdVar string, BackendVar SettingsBackend) Settings {
460	460		var cls *Settings
461	461
462		-	cret := xNewWithBackendSettings(SchemaIdVar, BackendVar.GoPointer())
	462	+	cret := xNewSettingsWithBackend(SchemaIdVar, BackendVar.GoPointer())
463	463
464	464		if cret == 0 {
465	465		return nil

@@ -469,17 +469,17 @@ func NewWithBackendSettings(SchemaIdVar string, BackendVar SettingsBackend) Se
469	469		return cls
470	470		}
471	471
472		-	var xNewWithBackendAndPathSettings func(string, uintptr, string) uintptr
	472	+	var xNewSettingsWithBackendAndPath func(string, uintptr, string) uintptr
473	473
474	474		// Creates a new #GSettings object with the schema specified by
475	475		// @schema_id and a given #GSettingsBackend and path.
476	476		//
477	477		// This is a mix of g_settings_new_with_backend() and
478	478		// g_settings_new_with_path().
479		-	func NewWithBackendAndPathSettings(SchemaIdVar string, BackendVar SettingsBackend, PathVar string) Settings {
	479	+	func NewSettingsWithBackendAndPath(SchemaIdVar string, BackendVar SettingsBackend, PathVar string) Settings {
480	480		var cls *Settings
481	481
482		-	cret := xNewWithBackendAndPathSettings(SchemaIdVar, BackendVar.GoPointer(), PathVar)
	482	+	cret := xNewSettingsWithBackendAndPath(SchemaIdVar, BackendVar.GoPointer(), PathVar)
483	483
484	484		if cret == 0 {
485	485		return nil

@@ -489,7 +489,7 @@ func NewWithBackendAndPathSettings(SchemaIdVar string, BackendVar *SettingsBacke
489	489		return cls
490	490		}
491	491
492		-	var xNewWithPathSettings func(string, string) uintptr
	492	+	var xNewSettingsWithPath func(string, string) uintptr
493	493
494	494		// Creates a new #GSettings object with the relocatable schema specified
495	495		// by @schema_id and a given path.

@@ -504,10 +504,10 @@ var xNewWithPathSettings func(string, string) uintptr
504	504		// It is a programmer error if @path is not a valid path. A valid path
505	505		// begins and ends with '/' and does not contain two consecutive '/'
506	506		// characters.
507		-	func NewWithPathSettings(SchemaIdVar string, PathVar string) *Settings {
	507	+	func NewSettingsWithPath(SchemaIdVar string, PathVar string) *Settings {
508	508		var cls *Settings
509	509
510		-	cret := xNewWithPathSettings(SchemaIdVar, PathVar)
	510	+	cret := xNewSettingsWithPath(SchemaIdVar, PathVar)
511	511
512	512		if cret == 0 {
513	513		return nil

@@ -1375,10 +1375,10 @@ func init() {
1375	1375		}
1376	1376
1377	1377		core.PuregoSafeRegister(&xNewSettings, lib, "g_settings_new")
1378		-	core.PuregoSafeRegister(&xNewFullSettings, lib, "g_settings_new_full")
1379		-	core.PuregoSafeRegister(&xNewWithBackendSettings, lib, "g_settings_new_with_backend")
1380		-	core.PuregoSafeRegister(&xNewWithBackendAndPathSettings, lib, "g_settings_new_with_backend_and_path")
1381		-	core.PuregoSafeRegister(&xNewWithPathSettings, lib, "g_settings_new_with_path")
	1378	+	core.PuregoSafeRegister(&xNewSettingsFull, lib, "g_settings_new_full")
	1379	+	core.PuregoSafeRegister(&xNewSettingsWithBackend, lib, "g_settings_new_with_backend")
	1380	+	core.PuregoSafeRegister(&xNewSettingsWithBackendAndPath, lib, "g_settings_new_with_backend_and_path")
	1381	+	core.PuregoSafeRegister(&xNewSettingsWithPath, lib, "g_settings_new_with_path")
1382	1382
1383	1383		core.PuregoSafeRegister(&xSettingsApply, lib, "g_settings_apply")
1384	1384		core.PuregoSafeRegister(&xSettingsBind, lib, "g_settings_bind")

M v4/gio/gsettingsschema.go +4 -4


@@ -368,7 +368,7 @@ func (x *SettingsSchemaSource) GoPointer() uintptr {
368	368		return uintptr(unsafe.Pointer(x))
369	369		}
370	370
371		-	var xNewFromDirectorySettingsSchemaSource func(string, SettingsSchemaSource, bool, glib.Error) SettingsSchemaSource
	371	+	var xNewSettingsSchemaSourceFromDirectory func(string, SettingsSchemaSource, bool, glib.Error) SettingsSchemaSource
372	372
373	373		// Attempts to create a new schema source corresponding to the contents
374	374		// of the given directory.

@@ -401,10 +401,10 @@ var xNewFromDirectorySettingsSchemaSource func(string, *SettingsSchemaSource, bo
401	401		// For this second reason, except in very unusual situations, the
402	402		// @parent should probably be given as the default schema source, as
403	403		// returned by g_settings_schema_source_get_default().
404		-	func NewFromDirectorySettingsSchemaSource(DirectoryVar string, ParentVar SettingsSchemaSource, TrustedVar bool) (SettingsSchemaSource, error) {
	404	+	func NewSettingsSchemaSourceFromDirectory(DirectoryVar string, ParentVar SettingsSchemaSource, TrustedVar bool) (SettingsSchemaSource, error) {
405	405		var cerr *glib.Error
406	406
407		-	cret := xNewFromDirectorySettingsSchemaSource(DirectoryVar, ParentVar, TrustedVar, &cerr)
	407	+	cret := xNewSettingsSchemaSourceFromDirectory(DirectoryVar, ParentVar, TrustedVar, &cerr)
408	408		if cerr == nil {
409	409		return cret, nil
410	410		}

@@ -515,7 +515,7 @@ func init() {
515	515		core.PuregoSafeRegister(&xSettingsSchemaKeyRef, lib, "g_settings_schema_key_ref")
516	516		core.PuregoSafeRegister(&xSettingsSchemaKeyUnref, lib, "g_settings_schema_key_unref")
517	517
518		-	core.PuregoSafeRegister(&xNewFromDirectorySettingsSchemaSource, lib, "g_settings_schema_source_new_from_directory")
	518	+	core.PuregoSafeRegister(&xNewSettingsSchemaSourceFromDirectory, lib, "g_settings_schema_source_new_from_directory")
519	519
520	520		core.PuregoSafeRegister(&xSettingsSchemaSourceListSchemas, lib, "g_settings_schema_source_list_schemas")
521	521		core.PuregoSafeRegister(&xSettingsSchemaSourceLookup, lib, "g_settings_schema_source_lookup")

M v4/gio/gsimpleasyncresult.go +12 -12


@@ -257,13 +257,13 @@ func NewSimpleAsyncResult(SourceObjectVar *gobject.Object, CallbackVar AsyncRead
257	257		return cls
258	258		}
259	259
260		-	var xNewErrorSimpleAsyncResult func(uintptr, uintptr, uintptr, glib.Quark, int, string, ...interface{}) uintptr
	260	+	var xNewSimpleAsyncResultError func(uintptr, uintptr, uintptr, glib.Quark, int, string, ...interface{}) uintptr
261	261
262	262		// Creates a new #GSimpleAsyncResult with a set error.
263		-	func NewErrorSimpleAsyncResult(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) SimpleAsyncResult {
	263	+	func NewSimpleAsyncResultError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) SimpleAsyncResult {
264	264		var cls *SimpleAsyncResult
265	265
266		-	cret := xNewErrorSimpleAsyncResult(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
	266	+	cret := xNewSimpleAsyncResultError(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
267	267
268	268		if cret == 0 {
269	269		return nil

@@ -273,13 +273,13 @@ func NewErrorSimpleAsyncResult(SourceObjectVar *gobject.Object, CallbackVar Asyn
273	273		return cls
274	274		}
275	275
276		-	var xNewFromErrorSimpleAsyncResult func(uintptr, uintptr, uintptr, *glib.Error) uintptr
	276	+	var xNewSimpleAsyncResultFromError func(uintptr, uintptr, uintptr, *glib.Error) uintptr
277	277
278	278		// Creates a #GSimpleAsyncResult from an error condition.
279		-	func NewFromErrorSimpleAsyncResult(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) *SimpleAsyncResult {
	279	+	func NewSimpleAsyncResultFromError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) *SimpleAsyncResult {
280	280		var cls *SimpleAsyncResult
281	281
282		-	cret := xNewFromErrorSimpleAsyncResult(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, ErrorVar)
	282	+	cret := xNewSimpleAsyncResultFromError(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, ErrorVar)
283	283
284	284		if cret == 0 {
285	285		return nil

@@ -289,14 +289,14 @@ func NewFromErrorSimpleAsyncResult(SourceObjectVar *gobject.Object, CallbackVar
289	289		return cls
290	290		}
291	291
292		-	var xNewTakeErrorSimpleAsyncResult func(uintptr, uintptr, uintptr, *glib.Error) uintptr
	292	+	var xNewSimpleAsyncResultTakeError func(uintptr, uintptr, uintptr, *glib.Error) uintptr
293	293
294	294		// Creates a #GSimpleAsyncResult from an error condition, and takes over the
295	295		// caller's ownership of @error, so the caller does not need to free it anymore.
296		-	func NewTakeErrorSimpleAsyncResult(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) *SimpleAsyncResult {
	296	+	func NewSimpleAsyncResultTakeError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) *SimpleAsyncResult {
297	297		var cls *SimpleAsyncResult
298	298
299		-	cret := xNewTakeErrorSimpleAsyncResult(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, ErrorVar)
	299	+	cret := xNewSimpleAsyncResultTakeError(SourceObjectVar.GoPointer(), purego.NewCallback(CallbackVar), UserDataVar, ErrorVar)
300	300
301	301		if cret == 0 {
302	302		return nil

@@ -595,9 +595,9 @@ func init() {
595	595		core.PuregoSafeRegister(&xSimpleAsyncReportTakeGerrorInIdle, lib, "g_simple_async_report_take_gerror_in_idle")
596	596
597	597		core.PuregoSafeRegister(&xNewSimpleAsyncResult, lib, "g_simple_async_result_new")
598		-	core.PuregoSafeRegister(&xNewErrorSimpleAsyncResult, lib, "g_simple_async_result_new_error")
599		-	core.PuregoSafeRegister(&xNewFromErrorSimpleAsyncResult, lib, "g_simple_async_result_new_from_error")
600		-	core.PuregoSafeRegister(&xNewTakeErrorSimpleAsyncResult, lib, "g_simple_async_result_new_take_error")
	598	+	core.PuregoSafeRegister(&xNewSimpleAsyncResultError, lib, "g_simple_async_result_new_error")
	599	+	core.PuregoSafeRegister(&xNewSimpleAsyncResultFromError, lib, "g_simple_async_result_new_from_error")
	600	+	core.PuregoSafeRegister(&xNewSimpleAsyncResultTakeError, lib, "g_simple_async_result_new_take_error")
601	601
602	602		core.PuregoSafeRegister(&xSimpleAsyncResultComplete, lib, "g_simple_async_result_complete")
603	603		core.PuregoSafeRegister(&xSimpleAsyncResultCompleteInIdle, lib, "g_simple_async_result_complete_in_idle")

M v4/gio/gsocket.go +4 -4


@@ -119,7 +119,7 @@ func NewSocket(FamilyVar SocketFamily, TypeVar SocketType, ProtocolVar SocketPro
119	119
120	120		}
121	121
122		-	var xNewFromFdSocket func(int, **glib.Error) uintptr
	122	+	var xNewSocketFromFd func(int, **glib.Error) uintptr
123	123
124	124		// Creates a new #GSocket from a native file descriptor
125	125		// or winsock SOCKET handle.

@@ -134,11 +134,11 @@ var xNewFromFdSocket func(int, **glib.Error) uintptr
134	134		//
135	135		// Since GLib 2.46, it is no longer a fatal error to call this on a non-socket
136	136		// descriptor. Instead, a GError will be set with code %G_IO_ERROR_FAILED
137		-	func NewFromFdSocket(FdVar int) (*Socket, error) {
	137	+	func NewSocketFromFd(FdVar int) (*Socket, error) {
138	138		var cls *Socket
139	139		var cerr *glib.Error
140	140
141		-	cret := xNewFromFdSocket(FdVar, &cerr)
	141	+	cret := xNewSocketFromFd(FdVar, &cerr)
142	142
143	143		if cret == 0 {
144	144		return nil, cerr

@@ -1465,7 +1465,7 @@ func init() {
1465	1465		}
1466	1466
1467	1467		core.PuregoSafeRegister(&xNewSocket, lib, "g_socket_new")
1468		-	core.PuregoSafeRegister(&xNewFromFdSocket, lib, "g_socket_new_from_fd")
	1468	+	core.PuregoSafeRegister(&xNewSocketFromFd, lib, "g_socket_new_from_fd")
1469	1469
1470	1470		core.PuregoSafeRegister(&xSocketAccept, lib, "g_socket_accept")
1471	1471		core.PuregoSafeRegister(&xSocketBind, lib, "g_socket_bind")

M v4/gio/gsocketaddress.go +4 -4


@@ -31,14 +31,14 @@ func SocketAddressNewFromInternalPtr(ptr uintptr) *SocketAddress {
31	31		return cls
32	32		}
33	33
34		-	var xNewFromNativeSocketAddress func(uintptr, uint) uintptr
	34	+	var xNewSocketAddressFromNative func(uintptr, uint) uintptr
35	35
36	36		// Creates a #GSocketAddress subclass corresponding to the native
37	37		// struct sockaddr @native.
38		-	func NewFromNativeSocketAddress(NativeVar uintptr, LenVar uint) *SocketAddress {
	38	+	func NewSocketAddressFromNative(NativeVar uintptr, LenVar uint) *SocketAddress {
39	39		var cls *SocketAddress
40	40
41		-	cret := xNewFromNativeSocketAddress(NativeVar, LenVar)
	41	+	cret := xNewSocketAddressFromNative(NativeVar, LenVar)
42	42
43	43		if cret == 0 {
44	44		return nil

@@ -148,7 +148,7 @@ func init() {
148	148		panic(err)
149	149		}
150	150
151		-	core.PuregoSafeRegister(&xNewFromNativeSocketAddress, lib, "g_socket_address_new_from_native")
	151	+	core.PuregoSafeRegister(&xNewSocketAddressFromNative, lib, "g_socket_address_new_from_native")
152	152
153	153		core.PuregoSafeRegister(&xSocketAddressGetFamily, lib, "g_socket_address_get_family")
154	154		core.PuregoSafeRegister(&xSocketAddressGetNativeSize, lib, "g_socket_address_get_native_size")

M v4/gio/gthemedicon.go +8 -8


@@ -50,13 +50,13 @@ func NewThemedIcon(IconnameVar string) *ThemedIcon {
50	50		return cls
51	51		}
52	52
53		-	var xNewFromNamesThemedIcon func([]string, int) uintptr
	53	+	var xNewThemedIconFromNames func([]string, int) uintptr
54	54
55	55		// Creates a new themed icon for @iconnames.
56		-	func NewFromNamesThemedIcon(IconnamesVar []string, LenVar int) *ThemedIcon {
	56	+	func NewThemedIconFromNames(IconnamesVar []string, LenVar int) *ThemedIcon {
57	57		var cls *ThemedIcon
58	58
59		-	cret := xNewFromNamesThemedIcon(IconnamesVar, LenVar)
	59	+	cret := xNewThemedIconFromNames(IconnamesVar, LenVar)
60	60
61	61		if cret == 0 {
62	62		return nil

@@ -66,7 +66,7 @@ func NewFromNamesThemedIcon(IconnamesVar []string, LenVar int) *ThemedIcon {
66	66		return cls
67	67		}
68	68
69		-	var xNewWithDefaultFallbacksThemedIcon func(string) uintptr
	69	+	var xNewThemedIconWithDefaultFallbacks func(string) uintptr
70	70
71	71		// Creates a new themed icon for @iconname, and all the names
72	72		// that can be created by shortening @iconname at '-' characters.

@@ -84,10 +84,10 @@ var xNewWithDefaultFallbacksThemedIcon func(string) uintptr
84	84		// icon1 = g_themed_icon_new_from_names (names, 4);
85	85		// icon2 = g_themed_icon_new_with_default_fallbacks ("gnome-dev-cdrom-audio");
86	86		// ]\|
87		-	func NewWithDefaultFallbacksThemedIcon(IconnameVar string) *ThemedIcon {
	87	+	func NewThemedIconWithDefaultFallbacks(IconnameVar string) *ThemedIcon {
88	88		var cls *ThemedIcon
89	89
90		-	cret := xNewWithDefaultFallbacksThemedIcon(IconnameVar)
	90	+	cret := xNewThemedIconWithDefaultFallbacks(IconnameVar)
91	91
92	92		if cret == 0 {
93	93		return nil

@@ -185,8 +185,8 @@ func init() {
185	185		}
186	186
187	187		core.PuregoSafeRegister(&xNewThemedIcon, lib, "g_themed_icon_new")
188		-	core.PuregoSafeRegister(&xNewFromNamesThemedIcon, lib, "g_themed_icon_new_from_names")
189		-	core.PuregoSafeRegister(&xNewWithDefaultFallbacksThemedIcon, lib, "g_themed_icon_new_with_default_fallbacks")
	188	+	core.PuregoSafeRegister(&xNewThemedIconFromNames, lib, "g_themed_icon_new_from_names")
	189	+	core.PuregoSafeRegister(&xNewThemedIconWithDefaultFallbacks, lib, "g_themed_icon_new_with_default_fallbacks")
190	190
191	191		core.PuregoSafeRegister(&xThemedIconAppendName, lib, "g_themed_icon_append_name")
192	192		core.PuregoSafeRegister(&xThemedIconGetNames, lib, "g_themed_icon_get_names")

M v4/gio/gtlscertificate.go +24 -24


@@ -42,7 +42,7 @@ func TlsCertificateNewFromInternalPtr(ptr uintptr) *TlsCertificate {
42	42		return cls
43	43		}
44	44
45		-	var xNewFromFileTlsCertificate func(string, **glib.Error) uintptr
	45	+	var xNewTlsCertificateFromFile func(string, **glib.Error) uintptr
46	46
47	47		// Creates a #GTlsCertificate from the data in @file.
48	48		//

@@ -53,11 +53,11 @@ var xNewFromFileTlsCertificate func(string, **glib.Error) uintptr
53	53		//
54	54		// If @file cannot be read or parsed, the function will return %NULL and
55	55		// set @error.
56		-	func NewFromFileTlsCertificate(FileVar string) (*TlsCertificate, error) {
	56	+	func NewTlsCertificateFromFile(FileVar string) (*TlsCertificate, error) {
57	57		var cls *TlsCertificate
58	58		var cerr *glib.Error
59	59
60		-	cret := xNewFromFileTlsCertificate(FileVar, &cerr)
	60	+	cret := xNewTlsCertificateFromFile(FileVar, &cerr)
61	61
62	62		if cret == 0 {
63	63		return nil, cerr

@@ -71,7 +71,7 @@ func NewFromFileTlsCertificate(FileVar string) (*TlsCertificate, error) {
71	71
72	72		}
73	73
74		-	var xNewFromFileWithPasswordTlsCertificate func(string, string, **glib.Error) uintptr
	74	+	var xNewTlsCertificateFromFileWithPassword func(string, string, **glib.Error) uintptr
75	75
76	76		// Creates a #GTlsCertificate from the data in @file.
77	77		//

@@ -81,11 +81,11 @@ var xNewFromFileWithPasswordTlsCertificate func(string, string, **glib.Error) ui
81	81		// Any unknown file types will error with %G_IO_ERROR_NOT_SUPPORTED.
82	82		// Currently only `.p12` and `.pfx` files are supported.
83	83		// See g_tls_certificate_new_from_pkcs12() for more details.
84		-	func NewFromFileWithPasswordTlsCertificate(FileVar string, PasswordVar string) (*TlsCertificate, error) {
	84	+	func NewTlsCertificateFromFileWithPassword(FileVar string, PasswordVar string) (*TlsCertificate, error) {
85	85		var cls *TlsCertificate
86	86		var cerr *glib.Error
87	87
88		-	cret := xNewFromFileWithPasswordTlsCertificate(FileVar, PasswordVar, &cerr)
	88	+	cret := xNewTlsCertificateFromFileWithPassword(FileVar, PasswordVar, &cerr)
89	89
90	90		if cret == 0 {
91	91		return nil, cerr

@@ -99,7 +99,7 @@ func NewFromFileWithPasswordTlsCertificate(FileVar string, PasswordVar string) (
99	99
100	100		}
101	101
102		-	var xNewFromFilesTlsCertificate func(string, string, **glib.Error) uintptr
	102	+	var xNewTlsCertificateFromFiles func(string, string, **glib.Error) uintptr
103	103
104	104		// Creates a #GTlsCertificate from the PEM-encoded data in @cert_file
105	105		// and @key_file. The returned certificate will be the first certificate

@@ -115,11 +115,11 @@ var xNewFromFilesTlsCertificate func(string, string, **glib.Error) uintptr
115	115		// If either file cannot be read or parsed, the function will return
116	116		// %NULL and set @error. Otherwise, this behaves like
117	117		// g_tls_certificate_new_from_pem().
118		-	func NewFromFilesTlsCertificate(CertFileVar string, KeyFileVar string) (*TlsCertificate, error) {
	118	+	func NewTlsCertificateFromFiles(CertFileVar string, KeyFileVar string) (*TlsCertificate, error) {
119	119		var cls *TlsCertificate
120	120		var cerr *glib.Error
121	121
122		-	cret := xNewFromFilesTlsCertificate(CertFileVar, KeyFileVar, &cerr)
	122	+	cret := xNewTlsCertificateFromFiles(CertFileVar, KeyFileVar, &cerr)
123	123
124	124		if cret == 0 {
125	125		return nil, cerr

@@ -133,7 +133,7 @@ func NewFromFilesTlsCertificate(CertFileVar string, KeyFileVar string) (*TlsCert
133	133
134	134		}
135	135
136		-	var xNewFromPemTlsCertificate func(string, int, **glib.Error) uintptr
	136	+	var xNewTlsCertificateFromPem func(string, int, **glib.Error) uintptr
137	137
138	138		// Creates a #GTlsCertificate from the PEM-encoded data in @data. If
139	139		// @data includes both a certificate and a private key, then the

@@ -149,11 +149,11 @@ var xNewFromPemTlsCertificate func(string, int, **glib.Error) uintptr
149	149		// will be set accordingly if the verification succeeds. If any
150	150		// certificate in the chain cannot be verified, the first certificate in
151	151		// the file will still be returned.
152		-	func NewFromPemTlsCertificate(DataVar string, LengthVar int) (*TlsCertificate, error) {
	152	+	func NewTlsCertificateFromPem(DataVar string, LengthVar int) (*TlsCertificate, error) {
153	153		var cls *TlsCertificate
154	154		var cerr *glib.Error
155	155
156		-	cret := xNewFromPemTlsCertificate(DataVar, LengthVar, &cerr)
	156	+	cret := xNewTlsCertificateFromPem(DataVar, LengthVar, &cerr)
157	157
158	158		if cret == 0 {
159	159		return nil, cerr

@@ -167,7 +167,7 @@ func NewFromPemTlsCertificate(DataVar string, LengthVar int) (*TlsCertificate, e
167	167
168	168		}
169	169
170		-	var xNewFromPkcs11UrisTlsCertificate func(string, string, **glib.Error) uintptr
	170	+	var xNewTlsCertificateFromPkcs11Uris func(string, string, **glib.Error) uintptr
171	171
172	172		// Creates a #GTlsCertificate from a
173	173		// [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html) URI.

@@ -196,11 +196,11 @@ var xNewFromPkcs11UrisTlsCertificate func(string, string, **glib.Error) uintptr
196	196		// @private_key_pkcs11_uri allows using a private key exposed under a different URI.
197	197		//
198	198		// Note that the private key is not accessed until usage and may fail or require a PIN later.
199		-	func NewFromPkcs11UrisTlsCertificate(Pkcs11UriVar string, PrivateKeyPkcs11UriVar string) (*TlsCertificate, error) {
	199	+	func NewTlsCertificateFromPkcs11Uris(Pkcs11UriVar string, PrivateKeyPkcs11UriVar string) (*TlsCertificate, error) {
200	200		var cls *TlsCertificate
201	201		var cerr *glib.Error
202	202
203		-	cret := xNewFromPkcs11UrisTlsCertificate(Pkcs11UriVar, PrivateKeyPkcs11UriVar, &cerr)
	203	+	cret := xNewTlsCertificateFromPkcs11Uris(Pkcs11UriVar, PrivateKeyPkcs11UriVar, &cerr)
204	204
205	205		if cret == 0 {
206	206		return nil, cerr

@@ -214,7 +214,7 @@ func NewFromPkcs11UrisTlsCertificate(Pkcs11UriVar string, PrivateKeyPkcs11UriVar
214	214
215	215		}
216	216
217		-	var xNewFromPkcs12TlsCertificate func(uintptr, uint, string, **glib.Error) uintptr
	217	+	var xNewTlsCertificateFromPkcs12 func(uintptr, uint, string, **glib.Error) uintptr
218	218
219	219		// Creates a #GTlsCertificate from the data in @data. It must contain
220	220		// a certificate and matching private key.

@@ -233,11 +233,11 @@ var xNewFromPkcs12TlsCertificate func(uintptr, uint, string, **glib.Error) uintp
233	233		// %G_IO_ERROR_NOT_SUPPORTED.
234	234		//
235	235		// Other parsing failures will error with %G_TLS_ERROR_BAD_CERTIFICATE.
236		-	func NewFromPkcs12TlsCertificate(DataVar uintptr, LengthVar uint, PasswordVar string) (*TlsCertificate, error) {
	236	+	func NewTlsCertificateFromPkcs12(DataVar uintptr, LengthVar uint, PasswordVar string) (*TlsCertificate, error) {
237	237		var cls *TlsCertificate
238	238		var cerr *glib.Error
239	239
240		-	cret := xNewFromPkcs12TlsCertificate(DataVar, LengthVar, PasswordVar, &cerr)
	240	+	cret := xNewTlsCertificateFromPkcs12(DataVar, LengthVar, PasswordVar, &cerr)
241	241
242	242		if cret == 0 {
243	243		return nil, cerr

@@ -406,12 +406,12 @@ func init() {
406	406		panic(err)
407	407		}
408	408
409		-	core.PuregoSafeRegister(&xNewFromFileTlsCertificate, lib, "g_tls_certificate_new_from_file")
410		-	core.PuregoSafeRegister(&xNewFromFileWithPasswordTlsCertificate, lib, "g_tls_certificate_new_from_file_with_password")
411		-	core.PuregoSafeRegister(&xNewFromFilesTlsCertificate, lib, "g_tls_certificate_new_from_files")
412		-	core.PuregoSafeRegister(&xNewFromPemTlsCertificate, lib, "g_tls_certificate_new_from_pem")
413		-	core.PuregoSafeRegister(&xNewFromPkcs11UrisTlsCertificate, lib, "g_tls_certificate_new_from_pkcs11_uris")
414		-	core.PuregoSafeRegister(&xNewFromPkcs12TlsCertificate, lib, "g_tls_certificate_new_from_pkcs12")
	409	+	core.PuregoSafeRegister(&xNewTlsCertificateFromFile, lib, "g_tls_certificate_new_from_file")
	410	+	core.PuregoSafeRegister(&xNewTlsCertificateFromFileWithPassword, lib, "g_tls_certificate_new_from_file_with_password")
	411	+	core.PuregoSafeRegister(&xNewTlsCertificateFromFiles, lib, "g_tls_certificate_new_from_files")
	412	+	core.PuregoSafeRegister(&xNewTlsCertificateFromPem, lib, "g_tls_certificate_new_from_pem")
	413	+	core.PuregoSafeRegister(&xNewTlsCertificateFromPkcs11Uris, lib, "g_tls_certificate_new_from_pkcs11_uris")
	414	+	core.PuregoSafeRegister(&xNewTlsCertificateFromPkcs12, lib, "g_tls_certificate_new_from_pkcs12")
415	415
416	416		core.PuregoSafeRegister(&xTlsCertificateGetDnsNames, lib, "g_tls_certificate_get_dns_names")
417	417		core.PuregoSafeRegister(&xTlsCertificateGetIpAddresses, lib, "g_tls_certificate_get_ip_addresses")

M v4/gio/gunixcredentialsmessage.go +4 -4


@@ -70,13 +70,13 @@ func NewUnixCredentialsMessage() *UnixCredentialsMessage {
70	70		return cls
71	71		}
72	72
73		-	var xNewWithCredentialsUnixCredentialsMessage func(uintptr) uintptr
	73	+	var xNewUnixCredentialsMessageWithCredentials func(uintptr) uintptr
74	74
75	75		// Creates a new #GUnixCredentialsMessage holding @credentials.
76		-	func NewWithCredentialsUnixCredentialsMessage(CredentialsVar Credentials) UnixCredentialsMessage {
	76	+	func NewUnixCredentialsMessageWithCredentials(CredentialsVar Credentials) UnixCredentialsMessage {
77	77		var cls *UnixCredentialsMessage
78	78
79		-	cret := xNewWithCredentialsUnixCredentialsMessage(CredentialsVar.GoPointer())
	79	+	cret := xNewUnixCredentialsMessageWithCredentials(CredentialsVar.GoPointer())
80	80
81	81		if cret == 0 {
82	82		return nil

@@ -127,7 +127,7 @@ func init() {
127	127		}
128	128
129	129		core.PuregoSafeRegister(&xNewUnixCredentialsMessage, lib, "g_unix_credentials_message_new")
130		-	core.PuregoSafeRegister(&xNewWithCredentialsUnixCredentialsMessage, lib, "g_unix_credentials_message_new_with_credentials")
	130	+	core.PuregoSafeRegister(&xNewUnixCredentialsMessageWithCredentials, lib, "g_unix_credentials_message_new_with_credentials")
131	131
132	132		core.PuregoSafeRegister(&xUnixCredentialsMessageGetCredentials, lib, "g_unix_credentials_message_get_credentials")
133	133

M v4/gio/gunixfdlist.go +4 -4


@@ -61,7 +61,7 @@ func NewUnixFDList() *UnixFDList {
61	61		return cls
62	62		}
63	63
64		-	var xNewFromArrayUnixFDList func(uintptr, int) uintptr
	64	+	var xNewUnixFDListFromArray func(uintptr, int) uintptr
65	65
66	66		// Creates a new #GUnixFDList containing the file descriptors given in
67	67		// @fds. The file descriptors become the property of the new list and

@@ -71,10 +71,10 @@ var xNewFromArrayUnixFDList func(uintptr, int) uintptr
71	71		// Each file descriptor in the array should be set to close-on-exec.
72	72		//
73	73		// If @n_fds is -1 then @fds must be terminated with -1.
74		-	func NewFromArrayUnixFDList(FdsVar uintptr, NFdsVar int) *UnixFDList {
	74	+	func NewUnixFDListFromArray(FdsVar uintptr, NFdsVar int) *UnixFDList {
75	75		var cls *UnixFDList
76	76
77		-	cret := xNewFromArrayUnixFDList(FdsVar, NFdsVar)
	77	+	cret := xNewUnixFDListFromArray(FdsVar, NFdsVar)
78	78
79	79		if cret == 0 {
80	80		return nil

@@ -206,7 +206,7 @@ func init() {
206	206		}
207	207
208	208		core.PuregoSafeRegister(&xNewUnixFDList, lib, "g_unix_fd_list_new")
209		-	core.PuregoSafeRegister(&xNewFromArrayUnixFDList, lib, "g_unix_fd_list_new_from_array")
	209	+	core.PuregoSafeRegister(&xNewUnixFDListFromArray, lib, "g_unix_fd_list_new_from_array")
210	210
211	211		core.PuregoSafeRegister(&xUnixFDListAppend, lib, "g_unix_fd_list_append")
212	212		core.PuregoSafeRegister(&xUnixFDListGet, lib, "g_unix_fd_list_get")

M v4/gio/gunixfdmessage.go +4 -4


@@ -65,13 +65,13 @@ func NewUnixFDMessage() *UnixFDMessage {
65	65		return cls
66	66		}
67	67
68		-	var xNewWithFdListUnixFDMessage func(uintptr) uintptr
	68	+	var xNewUnixFDMessageWithFdList func(uintptr) uintptr
69	69
70	70		// Creates a new #GUnixFDMessage containing @list.
71		-	func NewWithFdListUnixFDMessage(FdListVar UnixFDList) UnixFDMessage {
	71	+	func NewUnixFDMessageWithFdList(FdListVar UnixFDList) UnixFDMessage {
72	72		var cls *UnixFDMessage
73	73
74		-	cret := xNewWithFdListUnixFDMessage(FdListVar.GoPointer())
	74	+	cret := xNewUnixFDMessageWithFdList(FdListVar.GoPointer())
75	75
76	76		if cret == 0 {
77	77		return nil

@@ -161,7 +161,7 @@ func init() {
161	161		}
162	162
163	163		core.PuregoSafeRegister(&xNewUnixFDMessage, lib, "g_unix_fd_message_new")
164		-	core.PuregoSafeRegister(&xNewWithFdListUnixFDMessage, lib, "g_unix_fd_message_new_with_fd_list")
	164	+	core.PuregoSafeRegister(&xNewUnixFDMessageWithFdList, lib, "g_unix_fd_message_new_with_fd_list")
165	165
166	166		core.PuregoSafeRegister(&xUnixFDMessageAppendFd, lib, "g_unix_fd_message_append_fd")
167	167		core.PuregoSafeRegister(&xUnixFDMessageGetFdList, lib, "g_unix_fd_message_get_fd_list")

M v4/gio/gunixsocketaddress.go +8 -8


@@ -70,14 +70,14 @@ func NewUnixSocketAddress(PathVar string) *UnixSocketAddress {
70	70		return cls
71	71		}
72	72
73		-	var xNewAbstractUnixSocketAddress func(uintptr, int) uintptr
	73	+	var xNewUnixSocketAddressAbstract func(uintptr, int) uintptr
74	74
75	75		// Creates a new %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
76	76		// #GUnixSocketAddress for @path.
77		-	func NewAbstractUnixSocketAddress(PathVar uintptr, PathLenVar int) *UnixSocketAddress {
	77	+	func NewUnixSocketAddressAbstract(PathVar uintptr, PathLenVar int) *UnixSocketAddress {
78	78		var cls *UnixSocketAddress
79	79
80		-	cret := xNewAbstractUnixSocketAddress(PathVar, PathLenVar)
	80	+	cret := xNewUnixSocketAddressAbstract(PathVar, PathLenVar)
81	81
82	82		if cret == 0 {
83	83		return nil

@@ -87,7 +87,7 @@ func NewAbstractUnixSocketAddress(PathVar uintptr, PathLenVar int) *UnixSocketAd
87	87		return cls
88	88		}
89	89
90		-	var xNewWithTypeUnixSocketAddress func(uintptr, int, UnixSocketAddressType) uintptr
	90	+	var xNewUnixSocketAddressWithType func(uintptr, int, UnixSocketAddressType) uintptr
91	91
92	92		// Creates a new #GUnixSocketAddress of type @type with name @path.
93	93		//

@@ -120,10 +120,10 @@ var xNewWithTypeUnixSocketAddress func(uintptr, int, UnixSocketAddressType) uint
120	120		// when connecting to a server created by another process, you must
121	121		// use the appropriate type corresponding to how that process created
122	122		// its listening socket.
123		-	func NewWithTypeUnixSocketAddress(PathVar uintptr, PathLenVar int, TypeVar UnixSocketAddressType) *UnixSocketAddress {
	123	+	func NewUnixSocketAddressWithType(PathVar uintptr, PathLenVar int, TypeVar UnixSocketAddressType) *UnixSocketAddress {
124	124		var cls *UnixSocketAddress
125	125
126		-	cret := xNewWithTypeUnixSocketAddress(PathVar, PathLenVar, TypeVar)
	126	+	cret := xNewUnixSocketAddressWithType(PathVar, PathLenVar, TypeVar)
127	127
128	128		if cret == 0 {
129	129		return nil

@@ -247,8 +247,8 @@ func init() {
247	247		}
248	248
249	249		core.PuregoSafeRegister(&xNewUnixSocketAddress, lib, "g_unix_socket_address_new")
250		-	core.PuregoSafeRegister(&xNewAbstractUnixSocketAddress, lib, "g_unix_socket_address_new_abstract")
251		-	core.PuregoSafeRegister(&xNewWithTypeUnixSocketAddress, lib, "g_unix_socket_address_new_with_type")
	250	+	core.PuregoSafeRegister(&xNewUnixSocketAddressAbstract, lib, "g_unix_socket_address_new_abstract")
	251	+	core.PuregoSafeRegister(&xNewUnixSocketAddressWithType, lib, "g_unix_socket_address_new_with_type")
252	252
253	253		core.PuregoSafeRegister(&xUnixSocketAddressGetAddressType, lib, "g_unix_socket_address_get_address_type")
254	254		core.PuregoSafeRegister(&xUnixSocketAddressGetIsAbstract, lib, "g_unix_socket_address_get_is_abstract")

M v4/glib/garray.go +12 -12


@@ -72,19 +72,19 @@ func NewBytes(DataVar uintptr, SizeVar uint) *Bytes {
72	72		return cret
73	73		}
74	74
75		-	var xNewStaticBytes func(uintptr, uint) *Bytes
	75	+	var xNewBytesStatic func(uintptr, uint) *Bytes
76	76
77	77		// Creates a new #GBytes from static data.
78	78		//
79	79		// @data must be static (ie: never modified or freed). It may be %NULL if @size
80	80		// is 0.
81		-	func NewStaticBytes(DataVar uintptr, SizeVar uint) *Bytes {
	81	+	func NewBytesStatic(DataVar uintptr, SizeVar uint) *Bytes {
82	82
83		-	cret := xNewStaticBytes(DataVar, SizeVar)
	83	+	cret := xNewBytesStatic(DataVar, SizeVar)
84	84		return cret
85	85		}
86	86
87		-	var xNewTakeBytes func(uintptr, uint) *Bytes
	87	+	var xNewBytesTake func(uintptr, uint) *Bytes
88	88
89	89		// Creates a new #GBytes from @data.
90	90		//

@@ -98,13 +98,13 @@ var xNewTakeBytes func(uintptr, uint) *Bytes
98	98		// g_bytes_new_with_free_func().
99	99		//
100	100		// @data may be %NULL if @size is 0.
101		-	func NewTakeBytes(DataVar uintptr, SizeVar uint) *Bytes {
	101	+	func NewBytesTake(DataVar uintptr, SizeVar uint) *Bytes {
102	102
103		-	cret := xNewTakeBytes(DataVar, SizeVar)
	103	+	cret := xNewBytesTake(DataVar, SizeVar)
104	104		return cret
105	105		}
106	106
107		-	var xNewWithFreeFuncBytes func(uintptr, uint, uintptr, uintptr) *Bytes
	107	+	var xNewBytesWithFreeFunc func(uintptr, uint, uintptr, uintptr) *Bytes
108	108
109	109		// Creates a #GBytes from @data.
110	110		//

@@ -115,9 +115,9 @@ var xNewWithFreeFuncBytes func(uintptr, uint, uintptr, uintptr) *Bytes
115	115		// been called to indicate that the bytes is no longer in use.
116	116		//
117	117		// @data may be %NULL if @size is 0.
118		-	func NewWithFreeFuncBytes(DataVar uintptr, SizeVar uint, FreeFuncVar DestroyNotify, UserDataVar uintptr) *Bytes {
	118	+	func NewBytesWithFreeFunc(DataVar uintptr, SizeVar uint, FreeFuncVar DestroyNotify, UserDataVar uintptr) *Bytes {
119	119
120		-	cret := xNewWithFreeFuncBytes(DataVar, SizeVar, purego.NewCallback(FreeFuncVar), UserDataVar)
	120	+	cret := xNewBytesWithFreeFunc(DataVar, SizeVar, purego.NewCallback(FreeFuncVar), UserDataVar)
121	121		return cret
122	122		}
123	123

@@ -421,9 +421,9 @@ func init() {
421	421		core.PuregoSafeRegister(&xPtrArrayFindWithEqualFunc, lib, "g_ptr_array_find_with_equal_func")
422	422
423	423		core.PuregoSafeRegister(&xNewBytes, lib, "g_bytes_new")
424		-	core.PuregoSafeRegister(&xNewStaticBytes, lib, "g_bytes_new_static")
425		-	core.PuregoSafeRegister(&xNewTakeBytes, lib, "g_bytes_new_take")
426		-	core.PuregoSafeRegister(&xNewWithFreeFuncBytes, lib, "g_bytes_new_with_free_func")
	424	+	core.PuregoSafeRegister(&xNewBytesStatic, lib, "g_bytes_new_static")
	425	+	core.PuregoSafeRegister(&xNewBytesTake, lib, "g_bytes_new_take")
	426	+	core.PuregoSafeRegister(&xNewBytesWithFreeFunc, lib, "g_bytes_new_with_free_func")
427	427
428	428		core.PuregoSafeRegister(&xBytesCompare, lib, "g_bytes_compare")
429	429		core.PuregoSafeRegister(&xBytesEqual, lib, "g_bytes_equal")

M v4/glib/gdate.go +8 -8


@@ -49,29 +49,29 @@ func NewDate() *Date {
49	49		return cret
50	50		}
51	51
52		-	var xNewDmyDate func(DateDay, DateMonth, DateYear) *Date
	52	+	var xNewDateDmy func(DateDay, DateMonth, DateYear) *Date
53	53
54	54		// Create a new #GDate representing the given day-month-year triplet.
55	55		//
56	56		// The triplet you pass in must represent a valid date. Use g_date_valid_dmy()
57	57		// if needed to validate it. The returned #GDate is guaranteed to be non-%NULL
58	58		// and valid.
59		-	func NewDmyDate(DayVar DateDay, MonthVar DateMonth, YearVar DateYear) *Date {
	59	+	func NewDateDmy(DayVar DateDay, MonthVar DateMonth, YearVar DateYear) *Date {
60	60
61		-	cret := xNewDmyDate(DayVar, MonthVar, YearVar)
	61	+	cret := xNewDateDmy(DayVar, MonthVar, YearVar)
62	62		return cret
63	63		}
64	64
65		-	var xNewJulianDate func(uint32) *Date
	65	+	var xNewDateJulian func(uint32) *Date
66	66
67	67		// Create a new #GDate representing the given Julian date.
68	68		//
69	69		// The @julian_day you pass in must be valid. Use g_date_valid_julian() if
70	70		// needed to validate it. The returned #GDate is guaranteed to be non-%NULL and
71	71		// valid.
72		-	func NewJulianDate(JulianDayVar uint32) *Date {
	72	+	func NewDateJulian(JulianDayVar uint32) *Date {
73	73
74		-	cret := xNewJulianDate(JulianDayVar)
	74	+	cret := xNewDateJulian(JulianDayVar)
75	75		return cret
76	76		}
77	77

@@ -740,8 +740,8 @@ func init() {
740	740		core.PuregoSafeRegister(&xDateValidYear, lib, "g_date_valid_year")
741	741
742	742		core.PuregoSafeRegister(&xNewDate, lib, "g_date_new")
743		-	core.PuregoSafeRegister(&xNewDmyDate, lib, "g_date_new_dmy")
744		-	core.PuregoSafeRegister(&xNewJulianDate, lib, "g_date_new_julian")
	743	+	core.PuregoSafeRegister(&xNewDateDmy, lib, "g_date_new_dmy")
	744	+	core.PuregoSafeRegister(&xNewDateJulian, lib, "g_date_new_julian")
745	745
746	746		core.PuregoSafeRegister(&xDateAddDays, lib, "g_date_add_days")
747	747		core.PuregoSafeRegister(&xDateAddMonths, lib, "g_date_add_months")

M v4/glib/gdatetime.go +40 -40


@@ -52,7 +52,7 @@ func NewDateTime(TzVar *TimeZone, YearVar int, MonthVar int, DayVar int, HourVar
52	52		return cret
53	53		}
54	54
55		-	var xNewFromIso8601DateTime func(string, TimeZone) DateTime
	55	+	var xNewDateTimeFromIso8601 func(string, TimeZone) DateTime
56	56
57	57		// Creates a #GDateTime corresponding to the given
58	58		// [ISO 8601 formatted string](https://en.wikipedia.org/wiki/ISO_8601)

@@ -97,13 +97,13 @@ var xNewFromIso8601DateTime func(string, TimeZone) DateTime
97	97		//
98	98		// You should release the return value by calling g_date_time_unref()
99	99		// when you are done with it.
100		-	func NewFromIso8601DateTime(TextVar string, DefaultTzVar TimeZone) DateTime {
	100	+	func NewDateTimeFromIso8601(TextVar string, DefaultTzVar TimeZone) DateTime {
101	101
102		-	cret := xNewFromIso8601DateTime(TextVar, DefaultTzVar)
	102	+	cret := xNewDateTimeFromIso8601(TextVar, DefaultTzVar)
103	103		return cret
104	104		}
105	105
106		-	var xNewFromTimevalLocalDateTime func(TimeVal) DateTime
	106	+	var xNewDateTimeFromTimevalLocal func(TimeVal) DateTime
107	107
108	108		// Creates a #GDateTime corresponding to the given #GTimeVal @tv in the
109	109		// local time zone.

@@ -117,13 +117,13 @@ var xNewFromTimevalLocalDateTime func(TimeVal) DateTime
117	117		//
118	118		// You should release the return value by calling g_date_time_unref()
119	119		// when you are done with it.
120		-	func NewFromTimevalLocalDateTime(TvVar TimeVal) DateTime {
	120	+	func NewDateTimeFromTimevalLocal(TvVar TimeVal) DateTime {
121	121
122		-	cret := xNewFromTimevalLocalDateTime(TvVar)
	122	+	cret := xNewDateTimeFromTimevalLocal(TvVar)
123	123		return cret
124	124		}
125	125
126		-	var xNewFromTimevalUtcDateTime func(TimeVal) DateTime
	126	+	var xNewDateTimeFromTimevalUtc func(TimeVal) DateTime
127	127
128	128		// Creates a #GDateTime corresponding to the given #GTimeVal @tv in UTC.
129	129		//

@@ -135,13 +135,13 @@ var xNewFromTimevalUtcDateTime func(TimeVal) DateTime
135	135		//
136	136		// You should release the return value by calling g_date_time_unref()
137	137		// when you are done with it.
138		-	func NewFromTimevalUtcDateTime(TvVar TimeVal) DateTime {
	138	+	func NewDateTimeFromTimevalUtc(TvVar TimeVal) DateTime {
139	139
140		-	cret := xNewFromTimevalUtcDateTime(TvVar)
	140	+	cret := xNewDateTimeFromTimevalUtc(TvVar)
141	141		return cret
142	142		}
143	143
144		-	var xNewFromUnixLocalDateTime func(int64) *DateTime
	144	+	var xNewDateTimeFromUnixLocal func(int64) *DateTime
145	145
146	146		// Creates a #GDateTime corresponding to the given Unix time @t in the
147	147		// local time zone.

@@ -154,13 +154,13 @@ var xNewFromUnixLocalDateTime func(int64) *DateTime
154	154		//
155	155		// You should release the return value by calling g_date_time_unref()
156	156		// when you are done with it.
157		-	func NewFromUnixLocalDateTime(TVar int64) *DateTime {
	157	+	func NewDateTimeFromUnixLocal(TVar int64) *DateTime {
158	158
159		-	cret := xNewFromUnixLocalDateTime(TVar)
	159	+	cret := xNewDateTimeFromUnixLocal(TVar)
160	160		return cret
161	161		}
162	162
163		-	var xNewFromUnixUtcDateTime func(int64) *DateTime
	163	+	var xNewDateTimeFromUnixUtc func(int64) *DateTime
164	164
165	165		// Creates a #GDateTime corresponding to the given Unix time @t in UTC.
166	166		//

@@ -172,26 +172,26 @@ var xNewFromUnixUtcDateTime func(int64) *DateTime
172	172		//
173	173		// You should release the return value by calling g_date_time_unref()
174	174		// when you are done with it.
175		-	func NewFromUnixUtcDateTime(TVar int64) *DateTime {
	175	+	func NewDateTimeFromUnixUtc(TVar int64) *DateTime {
176	176
177		-	cret := xNewFromUnixUtcDateTime(TVar)
	177	+	cret := xNewDateTimeFromUnixUtc(TVar)
178	178		return cret
179	179		}
180	180
181		-	var xNewLocalDateTime func(int, int, int, int, int, float64) *DateTime
	181	+	var xNewDateTimeLocal func(int, int, int, int, int, float64) *DateTime
182	182
183	183		// Creates a new #GDateTime corresponding to the given date and time in
184	184		// the local time zone.
185	185		//
186	186		// This call is equivalent to calling g_date_time_new() with the time
187	187		// zone returned by g_time_zone_new_local().
188		-	func NewLocalDateTime(YearVar int, MonthVar int, DayVar int, HourVar int, MinuteVar int, SecondsVar float64) *DateTime {
	188	+	func NewDateTimeLocal(YearVar int, MonthVar int, DayVar int, HourVar int, MinuteVar int, SecondsVar float64) *DateTime {
189	189
190		-	cret := xNewLocalDateTime(YearVar, MonthVar, DayVar, HourVar, MinuteVar, SecondsVar)
	190	+	cret := xNewDateTimeLocal(YearVar, MonthVar, DayVar, HourVar, MinuteVar, SecondsVar)
191	191		return cret
192	192		}
193	193
194		-	var xNewNowDateTime func(TimeZone) DateTime
	194	+	var xNewDateTimeNow func(TimeZone) DateTime
195	195
196	196		// Creates a #GDateTime corresponding to this exact instant in the given
197	197		// time zone @tz. The time is as accurate as the system allows, to a

@@ -202,47 +202,47 @@ var xNewNowDateTime func(TimeZone) DateTime
202	202		//
203	203		// You should release the return value by calling g_date_time_unref()
204	204		// when you are done with it.
205		-	func NewNowDateTime(TzVar TimeZone) DateTime {
	205	+	func NewDateTimeNow(TzVar TimeZone) DateTime {
206	206
207		-	cret := xNewNowDateTime(TzVar)
	207	+	cret := xNewDateTimeNow(TzVar)
208	208		return cret
209	209		}
210	210
211		-	var xNewNowLocalDateTime func() *DateTime
	211	+	var xNewDateTimeNowLocal func() *DateTime
212	212
213	213		// Creates a #GDateTime corresponding to this exact instant in the local
214	214		// time zone.
215	215		//
216	216		// This is equivalent to calling g_date_time_new_now() with the time
217	217		// zone returned by g_time_zone_new_local().
218		-	func NewNowLocalDateTime() *DateTime {
	218	+	func NewDateTimeNowLocal() *DateTime {
219	219
220		-	cret := xNewNowLocalDateTime()
	220	+	cret := xNewDateTimeNowLocal()
221	221		return cret
222	222		}
223	223
224		-	var xNewNowUtcDateTime func() *DateTime
	224	+	var xNewDateTimeNowUtc func() *DateTime
225	225
226	226		// Creates a #GDateTime corresponding to this exact instant in UTC.
227	227		//
228	228		// This is equivalent to calling g_date_time_new_now() with the time
229	229		// zone returned by g_time_zone_new_utc().
230		-	func NewNowUtcDateTime() *DateTime {
	230	+	func NewDateTimeNowUtc() *DateTime {
231	231
232		-	cret := xNewNowUtcDateTime()
	232	+	cret := xNewDateTimeNowUtc()
233	233		return cret
234	234		}
235	235
236		-	var xNewUtcDateTime func(int, int, int, int, int, float64) *DateTime
	236	+	var xNewDateTimeUtc func(int, int, int, int, int, float64) *DateTime
237	237
238	238		// Creates a new #GDateTime corresponding to the given date and time in
239	239		// UTC.
240	240		//
241	241		// This call is equivalent to calling g_date_time_new() with the time
242	242		// zone returned by g_time_zone_new_utc().
243		-	func NewUtcDateTime(YearVar int, MonthVar int, DayVar int, HourVar int, MinuteVar int, SecondsVar float64) *DateTime {
	243	+	func NewDateTimeUtc(YearVar int, MonthVar int, DayVar int, HourVar int, MinuteVar int, SecondsVar float64) *DateTime {
244	244
245		-	cret := xNewUtcDateTime(YearVar, MonthVar, DayVar, HourVar, MinuteVar, SecondsVar)
	245	+	cret := xNewDateTimeUtc(YearVar, MonthVar, DayVar, HourVar, MinuteVar, SecondsVar)
246	246		return cret
247	247		}
248	248

@@ -838,16 +838,16 @@ func init() {
838	838		}
839	839
840	840		core.PuregoSafeRegister(&xNewDateTime, lib, "g_date_time_new")
841		-	core.PuregoSafeRegister(&xNewFromIso8601DateTime, lib, "g_date_time_new_from_iso8601")
842		-	core.PuregoSafeRegister(&xNewFromTimevalLocalDateTime, lib, "g_date_time_new_from_timeval_local")
843		-	core.PuregoSafeRegister(&xNewFromTimevalUtcDateTime, lib, "g_date_time_new_from_timeval_utc")
844		-	core.PuregoSafeRegister(&xNewFromUnixLocalDateTime, lib, "g_date_time_new_from_unix_local")
845		-	core.PuregoSafeRegister(&xNewFromUnixUtcDateTime, lib, "g_date_time_new_from_unix_utc")
846		-	core.PuregoSafeRegister(&xNewLocalDateTime, lib, "g_date_time_new_local")
847		-	core.PuregoSafeRegister(&xNewNowDateTime, lib, "g_date_time_new_now")
848		-	core.PuregoSafeRegister(&xNewNowLocalDateTime, lib, "g_date_time_new_now_local")
849		-	core.PuregoSafeRegister(&xNewNowUtcDateTime, lib, "g_date_time_new_now_utc")
850		-	core.PuregoSafeRegister(&xNewUtcDateTime, lib, "g_date_time_new_utc")
	841	+	core.PuregoSafeRegister(&xNewDateTimeFromIso8601, lib, "g_date_time_new_from_iso8601")
	842	+	core.PuregoSafeRegister(&xNewDateTimeFromTimevalLocal, lib, "g_date_time_new_from_timeval_local")
	843	+	core.PuregoSafeRegister(&xNewDateTimeFromTimevalUtc, lib, "g_date_time_new_from_timeval_utc")
	844	+	core.PuregoSafeRegister(&xNewDateTimeFromUnixLocal, lib, "g_date_time_new_from_unix_local")
	845	+	core.PuregoSafeRegister(&xNewDateTimeFromUnixUtc, lib, "g_date_time_new_from_unix_utc")
	846	+	core.PuregoSafeRegister(&xNewDateTimeLocal, lib, "g_date_time_new_local")
	847	+	core.PuregoSafeRegister(&xNewDateTimeNow, lib, "g_date_time_new_now")
	848	+	core.PuregoSafeRegister(&xNewDateTimeNowLocal, lib, "g_date_time_new_now_local")
	849	+	core.PuregoSafeRegister(&xNewDateTimeNowUtc, lib, "g_date_time_new_now_utc")
	850	+	core.PuregoSafeRegister(&xNewDateTimeUtc, lib, "g_date_time_new_utc")
851	851
852	852		core.PuregoSafeRegister(&xDateTimeAdd, lib, "g_date_time_add")
853	853		core.PuregoSafeRegister(&xDateTimeAddDays, lib, "g_date_time_add_days")

M v4/glib/gerror.go +8 -8


@@ -59,25 +59,25 @@ func NewError(DomainVar Quark, CodeVar int, FormatVar string, varArgs ...interfa
59	59		return cret
60	60		}
61	61
62		-	var xNewLiteralError func(Quark, int, string) *Error
	62	+	var xNewErrorLiteral func(Quark, int, string) *Error
63	63
64	64		// Creates a new #GError; unlike g_error_new(), @message is
65	65		// not a printf()-style format string. Use this function if
66	66		// @message contains text you don't have control over,
67	67		// that could include printf() escape sequences.
68		-	func NewLiteralError(DomainVar Quark, CodeVar int, MessageVar string) *Error {
	68	+	func NewErrorLiteral(DomainVar Quark, CodeVar int, MessageVar string) *Error {
69	69
70		-	cret := xNewLiteralError(DomainVar, CodeVar, MessageVar)
	70	+	cret := xNewErrorLiteral(DomainVar, CodeVar, MessageVar)
71	71		return cret
72	72		}
73	73
74		-	var xNewValistError func(Quark, int, string, []interface{}) *Error
	74	+	var xNewErrorValist func(Quark, int, string, []interface{}) *Error
75	75
76	76		// Creates a new #GError with the given @domain and @code,
77	77		// and a message formatted with @format.
78		-	func NewValistError(DomainVar Quark, CodeVar int, FormatVar string, ArgsVar []interface{}) *Error {
	78	+	func NewErrorValist(DomainVar Quark, CodeVar int, FormatVar string, ArgsVar []interface{}) *Error {
79	79
80		-	cret := xNewValistError(DomainVar, CodeVar, FormatVar, ArgsVar)
	80	+	cret := xNewErrorValist(DomainVar, CodeVar, FormatVar, ArgsVar)
81	81		return cret
82	82		}
83	83

@@ -220,8 +220,8 @@ func init() {
220	220		core.PuregoSafeRegister(&xSetErrorLiteral, lib, "g_set_error_literal")
221	221
222	222		core.PuregoSafeRegister(&xNewError, lib, "g_error_new")
223		-	core.PuregoSafeRegister(&xNewLiteralError, lib, "g_error_new_literal")
224		-	core.PuregoSafeRegister(&xNewValistError, lib, "g_error_new_valist")
	223	+	core.PuregoSafeRegister(&xNewErrorLiteral, lib, "g_error_new_literal")
	224	+	core.PuregoSafeRegister(&xNewErrorValist, lib, "g_error_new_valist")
225	225
226	226		core.PuregoSafeRegister(&xErrorCopy, lib, "g_error_copy")
227	227		core.PuregoSafeRegister(&xErrorFree, lib, "g_error_free")

M v4/glib/giochannel.go +8 -8


@@ -62,17 +62,17 @@ func (x *IOChannel) GoPointer() uintptr {
62	62		return uintptr(unsafe.Pointer(x))
63	63		}
64	64
65		-	var xNewFileIOChannel func(string, string, *Error) IOChannel
	65	+	var xNewIOChannelFile func(string, string, *Error) IOChannel
66	66
67	67		// Open a file @filename as a #GIOChannel using mode @mode. This
68	68		// channel will be closed when the last reference to it is dropped,
69	69		// so there is no need to call g_io_channel_close() (though doing
70	70		// so will not cause problems, as long as no attempt is made to
71	71		// access the channel after it is closed).
72		-	func NewFileIOChannel(FilenameVar string, ModeVar string) (*IOChannel, error) {
	72	+	func NewIOChannelFile(FilenameVar string, ModeVar string) (*IOChannel, error) {
73	73		var cerr *Error
74	74
75		-	cret := xNewFileIOChannel(FilenameVar, ModeVar, &cerr)
	75	+	cret := xNewIOChannelFile(FilenameVar, ModeVar, &cerr)
76	76		if cerr == nil {
77	77		return cret, nil
78	78		}

@@ -80,7 +80,7 @@ func NewFileIOChannel(FilenameVar string, ModeVar string) (*IOChannel, error) {
80	80
81	81		}
82	82
83		-	var xUnixNewIOChannel func(int) *IOChannel
	83	+	var xIOChannelUnixNew func(int) *IOChannel
84	84
85	85		// Creates a new #GIOChannel given a file descriptor. On UNIX systems
86	86		// this works for plain files, pipes, and sockets.

@@ -104,9 +104,9 @@ var xUnixNewIOChannel func(int) *IOChannel
104	104		// in case the argument you pass to this function happens to be both a
105	105		// valid file descriptor and socket. If that happens a warning is
106	106		// issued, and GLib assumes that it is the file descriptor you mean.
107		-	func UnixNewIOChannel(FdVar int) *IOChannel {
	107	+	func IOChannelUnixNew(FdVar int) *IOChannel {
108	108
109		-	cret := xUnixNewIOChannel(FdVar)
	109	+	cret := xIOChannelUnixNew(FdVar)
110	110		return cret
111	111		}
112	112

@@ -731,8 +731,8 @@ func init() {
731	731		core.PuregoSafeRegister(&xIoChannelErrorFromErrno, lib, "g_io_channel_error_from_errno")
732	732		core.PuregoSafeRegister(&xIoCreateWatch, lib, "g_io_create_watch")
733	733
734		-	core.PuregoSafeRegister(&xNewFileIOChannel, lib, "g_io_channel_new_file")
735		-	core.PuregoSafeRegister(&xUnixNewIOChannel, lib, "g_io_channel_unix_new")
	734	+	core.PuregoSafeRegister(&xNewIOChannelFile, lib, "g_io_channel_new_file")
	735	+	core.PuregoSafeRegister(&xIOChannelUnixNew, lib, "g_io_channel_unix_new")
736	736
737	737		core.PuregoSafeRegister(&xIOChannelClose, lib, "g_io_channel_close")
738	738		core.PuregoSafeRegister(&xIOChannelFlush, lib, "g_io_channel_flush")

M v4/glib/gmain.go +4 -4


@@ -57,12 +57,12 @@ func NewMainContext() *MainContext {
57	57		return cret
58	58		}
59	59
60		-	var xNewWithFlagsMainContext func(MainContextFlags) *MainContext
	60	+	var xNewMainContextWithFlags func(MainContextFlags) *MainContext
61	61
62	62		// Creates a new #GMainContext structure.
63		-	func NewWithFlagsMainContext(FlagsVar MainContextFlags) *MainContext {
	63	+	func NewMainContextWithFlags(FlagsVar MainContextFlags) *MainContext {
64	64
65		-	cret := xNewWithFlagsMainContext(FlagsVar)
	65	+	cret := xNewMainContextWithFlags(FlagsVar)
66	66		return cret
67	67		}
68	68

@@ -1946,7 +1946,7 @@ func init() {
1946	1946		core.PuregoSafeRegister(&xTimeoutSourceNewSeconds, lib, "g_timeout_source_new_seconds")
1947	1947
1948	1948		core.PuregoSafeRegister(&xNewMainContext, lib, "g_main_context_new")
1949		-	core.PuregoSafeRegister(&xNewWithFlagsMainContext, lib, "g_main_context_new_with_flags")
	1949	+	core.PuregoSafeRegister(&xNewMainContextWithFlags, lib, "g_main_context_new_with_flags")
1950	1950
1951	1951		core.PuregoSafeRegister(&xMainContextAcquire, lib, "g_main_context_acquire")
1952	1952		core.PuregoSafeRegister(&xMainContextAddPoll, lib, "g_main_context_add_poll")

M v4/glib/gmappedfile.go +4 -4


@@ -47,7 +47,7 @@ func NewMappedFile(FilenameVar string, WritableVar bool) (*MappedFile, error) {
47	47
48	48		}
49	49
50		-	var xNewFromFdMappedFile func(int, bool, *Error) MappedFile
	50	+	var xNewMappedFileFromFd func(int, bool, *Error) MappedFile
51	51
52	52		// Maps a file into memory. On UNIX, this is using the mmap() function.
53	53		//

@@ -60,10 +60,10 @@ var xNewFromFdMappedFile func(int, bool, *Error) MappedFile
60	60		// of the #GMappedFile. Therefore, mapping should only be used if the file
61	61		// will not be modified, or if all modifications of the file are done
62	62		// atomically (e.g. using g_file_set_contents()).
63		-	func NewFromFdMappedFile(FdVar int, WritableVar bool) (*MappedFile, error) {
	63	+	func NewMappedFileFromFd(FdVar int, WritableVar bool) (*MappedFile, error) {
64	64		var cerr *Error
65	65
66		-	cret := xNewFromFdMappedFile(FdVar, WritableVar, &cerr)
	66	+	cret := xNewMappedFileFromFd(FdVar, WritableVar, &cerr)
67	67		if cerr == nil {
68	68		return cret, nil
69	69		}

@@ -146,7 +146,7 @@ func init() {
146	146		}
147	147
148	148		core.PuregoSafeRegister(&xNewMappedFile, lib, "g_mapped_file_new")
149		-	core.PuregoSafeRegister(&xNewFromFdMappedFile, lib, "g_mapped_file_new_from_fd")
	149	+	core.PuregoSafeRegister(&xNewMappedFileFromFd, lib, "g_mapped_file_new_from_fd")
150	150
151	151		core.PuregoSafeRegister(&xMappedFileFree, lib, "g_mapped_file_free")
152	152		core.PuregoSafeRegister(&xMappedFileGetBytes, lib, "g_mapped_file_get_bytes")

M v4/glib/gstring.go +8 -8


@@ -30,7 +30,7 @@ func NewString(InitVar string) *String {
30	30		return cret
31	31		}
32	32
33		-	var xNewLenString func(string, int) *String
	33	+	var xNewStringLen func(string, int) *String
34	34
35	35		// Creates a new #GString with @len bytes of the @init buffer.
36	36		// Because a length is provided, @init need not be nul-terminated,

@@ -39,21 +39,21 @@ var xNewLenString func(string, int) *String
39	39		// Since this function does not stop at nul bytes, it is the caller's
40	40		// responsibility to ensure that @init has at least @len addressable
41	41		// bytes.
42		-	func NewLenString(InitVar string, LenVar int) *String {
	42	+	func NewStringLen(InitVar string, LenVar int) *String {
43	43
44		-	cret := xNewLenString(InitVar, LenVar)
	44	+	cret := xNewStringLen(InitVar, LenVar)
45	45		return cret
46	46		}
47	47
48		-	var xSizedNewString func(uint) *String
	48	+	var xStringSizedNew func(uint) *String
49	49
50	50		// Creates a new #GString, with enough space for @dfl_size
51	51		// bytes. This is useful if you are going to add a lot of
52	52		// text to the string and don't want it to be reallocated
53	53		// too often.
54		-	func SizedNewString(DflSizeVar uint) *String {
	54	+	func StringSizedNew(DflSizeVar uint) *String {
55	55
56		-	cret := xSizedNewString(DflSizeVar)
	56	+	cret := xStringSizedNew(DflSizeVar)
57	57		return cret
58	58		}
59	59

@@ -425,8 +425,8 @@ func init() {
425	425		}
426	426
427	427		core.PuregoSafeRegister(&xNewString, lib, "g_string_new")
428		-	core.PuregoSafeRegister(&xNewLenString, lib, "g_string_new_len")
429		-	core.PuregoSafeRegister(&xSizedNewString, lib, "g_string_sized_new")
	428	+	core.PuregoSafeRegister(&xNewStringLen, lib, "g_string_new_len")
	429	+	core.PuregoSafeRegister(&xStringSizedNew, lib, "g_string_sized_new")
430	430
431	431		core.PuregoSafeRegister(&xStringAppend, lib, "g_string_append")
432	432		core.PuregoSafeRegister(&xStringAppendC, lib, "g_string_append_c")

M v4/glib/gthread.go +4 -4


@@ -695,17 +695,17 @@ func NewThread(NameVar string, FuncVar ThreadFunc, DataVar uintptr) *Thread {
695	695		return cret
696	696		}
697	697
698		-	var xTryNewThread func(string, uintptr, uintptr, *Error) Thread
	698	+	var xThreadTryNew func(string, uintptr, uintptr, *Error) Thread
699	699
700	700		// This function is the same as g_thread_new() except that
701	701		// it allows for the possibility of failure.
702	702		//
703	703		// If a thread can not be created (due to resource limits),
704	704		// @error is set and %NULL is returned.
705		-	func TryNewThread(NameVar string, FuncVar ThreadFunc, DataVar uintptr) (*Thread, error) {
	705	+	func ThreadTryNew(NameVar string, FuncVar ThreadFunc, DataVar uintptr) (*Thread, error) {
706	706		var cerr *Error
707	707
708		-	cret := xTryNewThread(NameVar, purego.NewCallback(FuncVar), DataVar, &cerr)
	708	+	cret := xThreadTryNew(NameVar, purego.NewCallback(FuncVar), DataVar, &cerr)
709	709		if cerr == nil {
710	710		return cret, nil
711	711		}

@@ -1000,7 +1000,7 @@ func init() {
1000	1000		core.PuregoSafeRegister(&xRecMutexUnlock, lib, "g_rec_mutex_unlock")
1001	1001
1002	1002		core.PuregoSafeRegister(&xNewThread, lib, "g_thread_new")
1003		-	core.PuregoSafeRegister(&xTryNewThread, lib, "g_thread_try_new")
	1003	+	core.PuregoSafeRegister(&xThreadTryNew, lib, "g_thread_try_new")
1004	1004
1005	1005		core.PuregoSafeRegister(&xThreadJoin, lib, "g_thread_join")
1006	1006		core.PuregoSafeRegister(&xThreadRef, lib, "g_thread_ref")

M v4/glib/gtimezone.go +16 -16


@@ -30,7 +30,7 @@ func NewTimeZone(IdentifierVar string) *TimeZone {
30	30		return cret
31	31		}
32	32
33		-	var xNewIdentifierTimeZone func(string) *TimeZone
	33	+	var xNewTimeZoneIdentifier func(string) *TimeZone
34	34
35	35		// Creates a #GTimeZone corresponding to @identifier. If @identifier cannot be
36	36		// parsed or loaded, %NULL is returned.

@@ -97,13 +97,13 @@ var xNewIdentifierTimeZone func(string) *TimeZone
97	97		//
98	98		// You should release the return value by calling g_time_zone_unref()
99	99		// when you are done with it.
100		-	func NewIdentifierTimeZone(IdentifierVar string) *TimeZone {
	100	+	func NewTimeZoneIdentifier(IdentifierVar string) *TimeZone {
101	101
102		-	cret := xNewIdentifierTimeZone(IdentifierVar)
	102	+	cret := xNewTimeZoneIdentifier(IdentifierVar)
103	103		return cret
104	104		}
105	105
106		-	var xNewLocalTimeZone func() *TimeZone
	106	+	var xNewTimeZoneLocal func() *TimeZone
107	107
108	108		// Creates a #GTimeZone corresponding to local time. The local time
109	109		// zone may change between invocations to this function; for example,

@@ -114,26 +114,26 @@ var xNewLocalTimeZone func() *TimeZone
114	114		//
115	115		// You should release the return value by calling g_time_zone_unref()
116	116		// when you are done with it.
117		-	func NewLocalTimeZone() *TimeZone {
	117	+	func NewTimeZoneLocal() *TimeZone {
118	118
119		-	cret := xNewLocalTimeZone()
	119	+	cret := xNewTimeZoneLocal()
120	120		return cret
121	121		}
122	122
123		-	var xNewOffsetTimeZone func(int32) *TimeZone
	123	+	var xNewTimeZoneOffset func(int32) *TimeZone
124	124
125	125		// Creates a #GTimeZone corresponding to the given constant offset from UTC,
126	126		// in seconds.
127	127		//
128	128		// This is equivalent to calling g_time_zone_new() with a string in the form
129	129		// `[+\|-]hh[:mm[:ss]]`.
130		-	func NewOffsetTimeZone(SecondsVar int32) *TimeZone {
	130	+	func NewTimeZoneOffset(SecondsVar int32) *TimeZone {
131	131
132		-	cret := xNewOffsetTimeZone(SecondsVar)
	132	+	cret := xNewTimeZoneOffset(SecondsVar)
133	133		return cret
134	134		}
135	135
136		-	var xNewUtcTimeZone func() *TimeZone
	136	+	var xNewTimeZoneUtc func() *TimeZone
137	137
138	138		// Creates a #GTimeZone corresponding to UTC.
139	139		//

@@ -142,9 +142,9 @@ var xNewUtcTimeZone func() *TimeZone
142	142		//
143	143		// You should release the return value by calling g_time_zone_unref()
144	144		// when you are done with it.
145		-	func NewUtcTimeZone() *TimeZone {
	145	+	func NewTimeZoneUtc() *TimeZone {
146	146
147		-	cret := xNewUtcTimeZone()
	147	+	cret := xNewTimeZoneUtc()
148	148		return cret
149	149		}
150	150

@@ -297,10 +297,10 @@ func init() {
297	297		}
298	298
299	299		core.PuregoSafeRegister(&xNewTimeZone, lib, "g_time_zone_new")
300		-	core.PuregoSafeRegister(&xNewIdentifierTimeZone, lib, "g_time_zone_new_identifier")
301		-	core.PuregoSafeRegister(&xNewLocalTimeZone, lib, "g_time_zone_new_local")
302		-	core.PuregoSafeRegister(&xNewOffsetTimeZone, lib, "g_time_zone_new_offset")
303		-	core.PuregoSafeRegister(&xNewUtcTimeZone, lib, "g_time_zone_new_utc")
	300	+	core.PuregoSafeRegister(&xNewTimeZoneIdentifier, lib, "g_time_zone_new_identifier")
	301	+	core.PuregoSafeRegister(&xNewTimeZoneLocal, lib, "g_time_zone_new_local")
	302	+	core.PuregoSafeRegister(&xNewTimeZoneOffset, lib, "g_time_zone_new_offset")
	303	+	core.PuregoSafeRegister(&xNewTimeZoneUtc, lib, "g_time_zone_new_utc")
304	304
305	305		core.PuregoSafeRegister(&xTimeZoneAdjustTime, lib, "g_time_zone_adjust_time")
306	306		core.PuregoSafeRegister(&xTimeZoneFindInterval, lib, "g_time_zone_find_interval")

M v4/glib/gtree.go +8 -8


@@ -39,24 +39,24 @@ func NewTree(KeyCompareFuncVar CompareFunc) *Tree {
39	39		return cret
40	40		}
41	41
42		-	var xNewFullTree func(uintptr, uintptr, uintptr, uintptr) *Tree
	42	+	var xNewTreeFull func(uintptr, uintptr, uintptr, uintptr) *Tree
43	43
44	44		// Creates a new #GTree like g_tree_new() and allows to specify functions
45	45		// to free the memory allocated for the key and value that get called when
46	46		// removing the entry from the #GTree.
47		-	func NewFullTree(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar DestroyNotify, ValueDestroyFuncVar DestroyNotify) *Tree {
	47	+	func NewTreeFull(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar DestroyNotify, ValueDestroyFuncVar DestroyNotify) *Tree {
48	48
49		-	cret := xNewFullTree(purego.NewCallback(KeyCompareFuncVar), KeyCompareDataVar, purego.NewCallback(KeyDestroyFuncVar), purego.NewCallback(ValueDestroyFuncVar))
	49	+	cret := xNewTreeFull(purego.NewCallback(KeyCompareFuncVar), KeyCompareDataVar, purego.NewCallback(KeyDestroyFuncVar), purego.NewCallback(ValueDestroyFuncVar))
50	50		return cret
51	51		}
52	52
53		-	var xNewWithDataTree func(uintptr, uintptr) *Tree
	53	+	var xNewTreeWithData func(uintptr, uintptr) *Tree
54	54
55	55		// Creates a new #GTree with a comparison function that accepts user data.
56	56		// See g_tree_new() for more details.
57		-	func NewWithDataTree(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr) *Tree {
	57	+	func NewTreeWithData(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr) *Tree {
58	58
59		-	cret := xNewWithDataTree(purego.NewCallback(KeyCompareFuncVar), KeyCompareDataVar)
	59	+	cret := xNewTreeWithData(purego.NewCallback(KeyCompareFuncVar), KeyCompareDataVar)
60	60		return cret
61	61		}
62	62

@@ -431,8 +431,8 @@ func init() {
431	431		}
432	432
433	433		core.PuregoSafeRegister(&xNewTree, lib, "g_tree_new")
434		-	core.PuregoSafeRegister(&xNewFullTree, lib, "g_tree_new_full")
435		-	core.PuregoSafeRegister(&xNewWithDataTree, lib, "g_tree_new_with_data")
	434	+	core.PuregoSafeRegister(&xNewTreeFull, lib, "g_tree_new_full")
	435	+	core.PuregoSafeRegister(&xNewTreeWithData, lib, "g_tree_new_with_data")
436	436
437	437		core.PuregoSafeRegister(&xTreeDestroy, lib, "g_tree_destroy")
438	438		core.PuregoSafeRegister(&xTreeForeach, lib, "g_tree_foreach")

M v4/glib/gvariant.go +116 -116


@@ -297,7 +297,7 @@ func NewVariant(FormatStringVar string, varArgs ...interface{}) *Variant {
297	297		return cret
298	298		}
299	299
300		-	var xNewArrayVariant func(VariantType, uintptr, uint) Variant
	300	+	var xNewVariantArray func(VariantType, uintptr, uint) Variant
301	301
302	302		// Creates a new #GVariant array from @children.
303	303		//

@@ -314,31 +314,31 @@ var xNewArrayVariant func(VariantType, uintptr, uint) Variant
314	314		//
315	315		// If the @children are floating references (see g_variant_ref_sink()), the
316	316		// new instance takes ownership of them as if via g_variant_ref_sink().
317		-	func NewArrayVariant(ChildTypeVar VariantType, ChildrenVar uintptr, NChildrenVar uint) Variant {
	317	+	func NewVariantArray(ChildTypeVar VariantType, ChildrenVar uintptr, NChildrenVar uint) Variant {
318	318
319		-	cret := xNewArrayVariant(ChildTypeVar, ChildrenVar, NChildrenVar)
	319	+	cret := xNewVariantArray(ChildTypeVar, ChildrenVar, NChildrenVar)
320	320		return cret
321	321		}
322	322
323		-	var xNewBooleanVariant func(bool) *Variant
	323	+	var xNewVariantBoolean func(bool) *Variant
324	324
325	325		// Creates a new boolean #GVariant instance -- either %TRUE or %FALSE.
326		-	func NewBooleanVariant(ValueVar bool) *Variant {
	326	+	func NewVariantBoolean(ValueVar bool) *Variant {
327	327
328		-	cret := xNewBooleanVariant(ValueVar)
	328	+	cret := xNewVariantBoolean(ValueVar)
329	329		return cret
330	330		}
331	331
332		-	var xNewByteVariant func(byte) *Variant
	332	+	var xNewVariantByte func(byte) *Variant
333	333
334	334		// Creates a new byte #GVariant instance.
335		-	func NewByteVariant(ValueVar byte) *Variant {
	335	+	func NewVariantByte(ValueVar byte) *Variant {
336	336
337		-	cret := xNewByteVariant(ValueVar)
	337	+	cret := xNewVariantByte(ValueVar)
338	338		return cret
339	339		}
340	340
341		-	var xNewBytestringVariant func(uintptr) *Variant
	341	+	var xNewVariantBytestring func(uintptr) *Variant
342	342
343	343		// Creates an array-of-bytes #GVariant with the contents of @string.
344	344		// This function is just like g_variant_new_string() except that the

@@ -346,47 +346,47 @@ var xNewBytestringVariant func(uintptr) *Variant
346	346		//
347	347		// The nul terminator character at the end of the string is stored in
348	348		// the array.
349		-	func NewBytestringVariant(StringVar uintptr) *Variant {
	349	+	func NewVariantBytestring(StringVar uintptr) *Variant {
350	350
351		-	cret := xNewBytestringVariant(StringVar)
	351	+	cret := xNewVariantBytestring(StringVar)
352	352		return cret
353	353		}
354	354
355		-	var xNewBytestringArrayVariant func(uintptr, int) *Variant
	355	+	var xNewVariantBytestringArray func(uintptr, int) *Variant
356	356
357	357		// Constructs an array of bytestring #GVariant from the given array of
358	358		// strings.
359	359		//
360	360		// If @length is -1 then @strv is %NULL-terminated.
361		-	func NewBytestringArrayVariant(StrvVar uintptr, LengthVar int) *Variant {
	361	+	func NewVariantBytestringArray(StrvVar uintptr, LengthVar int) *Variant {
362	362
363		-	cret := xNewBytestringArrayVariant(StrvVar, LengthVar)
	363	+	cret := xNewVariantBytestringArray(StrvVar, LengthVar)
364	364		return cret
365	365		}
366	366
367		-	var xNewDictEntryVariant func(Variant, Variant) *Variant
	367	+	var xNewVariantDictEntry func(Variant, Variant) *Variant
368	368
369	369		// Creates a new dictionary entry #GVariant. @key and @value must be
370	370		// non-%NULL. @key must be a value of a basic type (ie: not a container).
371	371		//
372	372		// If the @key or @value are floating references (see g_variant_ref_sink()),
373	373		// the new instance takes ownership of them as if via g_variant_ref_sink().
374		-	func NewDictEntryVariant(KeyVar Variant, ValueVar Variant) *Variant {
	374	+	func NewVariantDictEntry(KeyVar Variant, ValueVar Variant) *Variant {
375	375
376		-	cret := xNewDictEntryVariant(KeyVar, ValueVar)
	376	+	cret := xNewVariantDictEntry(KeyVar, ValueVar)
377	377		return cret
378	378		}
379	379
380		-	var xNewDoubleVariant func(float64) *Variant
	380	+	var xNewVariantDouble func(float64) *Variant
381	381
382	382		// Creates a new double #GVariant instance.
383		-	func NewDoubleVariant(ValueVar float64) *Variant {
	383	+	func NewVariantDouble(ValueVar float64) *Variant {
384	384
385		-	cret := xNewDoubleVariant(ValueVar)
	385	+	cret := xNewVariantDouble(ValueVar)
386	386		return cret
387	387		}
388	388
389		-	var xNewFixedArrayVariant func(VariantType, uintptr, uint, uint) Variant
	389	+	var xNewVariantFixedArray func(VariantType, uintptr, uint, uint) Variant
390	390
391	391		// Constructs a new array #GVariant instance, where the elements are
392	392		// of @element_type type.

@@ -401,13 +401,13 @@ var xNewFixedArrayVariant func(VariantType, uintptr, uint, uint) Variant
401	401		// expectation.
402	402		//
403	403		// @n_elements must be the length of the @elements array.
404		-	func NewFixedArrayVariant(ElementTypeVar VariantType, ElementsVar uintptr, NElementsVar uint, ElementSizeVar uint) Variant {
	404	+	func NewVariantFixedArray(ElementTypeVar VariantType, ElementsVar uintptr, NElementsVar uint, ElementSizeVar uint) Variant {
405	405
406		-	cret := xNewFixedArrayVariant(ElementTypeVar, ElementsVar, NElementsVar, ElementSizeVar)
	406	+	cret := xNewVariantFixedArray(ElementTypeVar, ElementsVar, NElementsVar, ElementSizeVar)
407	407		return cret
408	408		}
409	409
410		-	var xNewFromBytesVariant func(VariantType, Bytes, bool) *Variant
	410	+	var xNewVariantFromBytes func(VariantType, Bytes, bool) *Variant
411	411
412	412		// Constructs a new serialized-mode #GVariant instance. This is the
413	413		// inner interface for creation of new serialized values that gets

@@ -418,13 +418,13 @@ var xNewFromBytesVariant func(VariantType, Bytes, bool) *Variant
418	418		// The data in @bytes must be aligned appropriately for the @type being loaded.
419	419		// Otherwise this function will internally create a copy of the memory (since
420	420		// GLib 2.60) or (in older versions) fail and exit the process.
421		-	func NewFromBytesVariant(TypeVar VariantType, BytesVar Bytes, TrustedVar bool) *Variant {
	421	+	func NewVariantFromBytes(TypeVar VariantType, BytesVar Bytes, TrustedVar bool) *Variant {
422	422
423		-	cret := xNewFromBytesVariant(TypeVar, BytesVar, TrustedVar)
	423	+	cret := xNewVariantFromBytes(TypeVar, BytesVar, TrustedVar)
424	424		return cret
425	425		}
426	426
427		-	var xNewFromDataVariant func(VariantType, uintptr, uint, bool, uintptr, uintptr) Variant
	427	+	var xNewVariantFromData func(VariantType, uintptr, uint, bool, uintptr, uintptr) Variant
428	428
429	429		// Creates a new #GVariant instance from serialized data.
430	430		//

@@ -455,53 +455,53 @@ var xNewFromDataVariant func(*VariantType, uintptr, uint, bool, uintptr, uintptr
455	455		// @type being loaded. Otherwise this function will internally create a copy of
456	456		// the memory (since GLib 2.60) or (in older versions) fail and exit the
457	457		// process.
458		-	func NewFromDataVariant(TypeVar VariantType, DataVar uintptr, SizeVar uint, TrustedVar bool, NotifyVar DestroyNotify, UserDataVar uintptr) Variant {
	458	+	func NewVariantFromData(TypeVar VariantType, DataVar uintptr, SizeVar uint, TrustedVar bool, NotifyVar DestroyNotify, UserDataVar uintptr) Variant {
459	459
460		-	cret := xNewFromDataVariant(TypeVar, DataVar, SizeVar, TrustedVar, purego.NewCallback(NotifyVar), UserDataVar)
	460	+	cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, purego.NewCallback(NotifyVar), UserDataVar)
461	461		return cret
462	462		}
463	463
464		-	var xNewHandleVariant func(int32) *Variant
	464	+	var xNewVariantHandle func(int32) *Variant
465	465
466	466		// Creates a new handle #GVariant instance.
467	467		//
468	468		// By convention, handles are indexes into an array of file descriptors
469	469		// that are sent alongside a D-Bus message. If you're not interacting
470	470		// with D-Bus, you probably don't need them.
471		-	func NewHandleVariant(ValueVar int32) *Variant {
	471	+	func NewVariantHandle(ValueVar int32) *Variant {
472	472
473		-	cret := xNewHandleVariant(ValueVar)
	473	+	cret := xNewVariantHandle(ValueVar)
474	474		return cret
475	475		}
476	476
477		-	var xNewInt16Variant func(int16) *Variant
	477	+	var xNewVariantInt16 func(int16) *Variant
478	478
479	479		// Creates a new int16 #GVariant instance.
480		-	func NewInt16Variant(ValueVar int16) *Variant {
	480	+	func NewVariantInt16(ValueVar int16) *Variant {
481	481
482		-	cret := xNewInt16Variant(ValueVar)
	482	+	cret := xNewVariantInt16(ValueVar)
483	483		return cret
484	484		}
485	485
486		-	var xNewInt32Variant func(int32) *Variant
	486	+	var xNewVariantInt32 func(int32) *Variant
487	487
488	488		// Creates a new int32 #GVariant instance.
489		-	func NewInt32Variant(ValueVar int32) *Variant {
	489	+	func NewVariantInt32(ValueVar int32) *Variant {
490	490
491		-	cret := xNewInt32Variant(ValueVar)
	491	+	cret := xNewVariantInt32(ValueVar)
492	492		return cret
493	493		}
494	494
495		-	var xNewInt64Variant func(int64) *Variant
	495	+	var xNewVariantInt64 func(int64) *Variant
496	496
497	497		// Creates a new int64 #GVariant instance.
498		-	func NewInt64Variant(ValueVar int64) *Variant {
	498	+	func NewVariantInt64(ValueVar int64) *Variant {
499	499
500		-	cret := xNewInt64Variant(ValueVar)
	500	+	cret := xNewVariantInt64(ValueVar)
501	501		return cret
502	502		}
503	503
504		-	var xNewMaybeVariant func(VariantType, Variant) *Variant
	504	+	var xNewVariantMaybe func(VariantType, Variant) *Variant
505	505
506	506		// Depending on if @child is %NULL, either wraps @child inside of a
507	507		// maybe container or creates a Nothing instance for the given @type.

@@ -513,24 +513,24 @@ var xNewMaybeVariant func(VariantType, Variant) *Variant
513	513		//
514	514		// If @child is a floating reference (see g_variant_ref_sink()), the new
515	515		// instance takes ownership of @child.
516		-	func NewMaybeVariant(ChildTypeVar VariantType, ChildVar Variant) *Variant {
	516	+	func NewVariantMaybe(ChildTypeVar VariantType, ChildVar Variant) *Variant {
517	517
518		-	cret := xNewMaybeVariant(ChildTypeVar, ChildVar)
	518	+	cret := xNewVariantMaybe(ChildTypeVar, ChildVar)
519	519		return cret
520	520		}
521	521
522		-	var xNewObjectPathVariant func(string) *Variant
	522	+	var xNewVariantObjectPath func(string) *Variant
523	523
524	524		// Creates a D-Bus object path #GVariant with the contents of @string.
525	525		// @string must be a valid D-Bus object path. Use
526	526		// g_variant_is_object_path() if you're not sure.
527		-	func NewObjectPathVariant(ObjectPathVar string) *Variant {
	527	+	func NewVariantObjectPath(ObjectPathVar string) *Variant {
528	528
529		-	cret := xNewObjectPathVariant(ObjectPathVar)
	529	+	cret := xNewVariantObjectPath(ObjectPathVar)
530	530		return cret
531	531		}
532	532
533		-	var xNewObjvVariant func(uintptr, int) *Variant
	533	+	var xNewVariantObjv func(uintptr, int) *Variant
534	534
535	535		// Constructs an array of object paths #GVariant from the given array of
536	536		// strings.

@@ -539,13 +539,13 @@ var xNewObjvVariant func(uintptr, int) *Variant
539	539		// g_variant_is_object_path().
540	540		//
541	541		// If @length is -1 then @strv is %NULL-terminated.
542		-	func NewObjvVariant(StrvVar uintptr, LengthVar int) *Variant {
	542	+	func NewVariantObjv(StrvVar uintptr, LengthVar int) *Variant {
543	543
544		-	cret := xNewObjvVariant(StrvVar, LengthVar)
	544	+	cret := xNewVariantObjv(StrvVar, LengthVar)
545	545		return cret
546	546		}
547	547
548		-	var xNewParsedVariant func(string, ...interface{}) *Variant
	548	+	var xNewVariantParsed func(string, ...interface{}) *Variant
549	549
550	550		// Parses @format and returns the result.
551	551		//

@@ -581,13 +581,13 @@ var xNewParsedVariant func(string, ...interface{}) *Variant
581	581		// #GVariant pointer from the argument list. ie: @format may not solely
582	582		// be anything along the lines of "%*", "%?", "\%r", or anything starting
583	583		// with "%@".
584		-	func NewParsedVariant(FormatVar string, varArgs ...interface{}) *Variant {
	584	+	func NewVariantParsed(FormatVar string, varArgs ...interface{}) *Variant {
585	585
586		-	cret := xNewParsedVariant(FormatVar, varArgs...)
	586	+	cret := xNewVariantParsed(FormatVar, varArgs...)
587	587		return cret
588	588		}
589	589
590		-	var xNewParsedVaVariant func(string, []interface{}) *Variant
	590	+	var xNewVariantParsedVa func(string, []interface{}) *Variant
591	591
592	592		// Parses @format and returns the result.
593	593		//

@@ -610,62 +610,62 @@ var xNewParsedVaVariant func(string, []interface{}) *Variant
610	610		// At this point, the caller will have their own full reference to the
611	611		// result. This can also be done by adding the result to a container,
612	612		// or by passing it to another g_variant_new() call.
613		-	func NewParsedVaVariant(FormatVar string, AppVar []interface{}) *Variant {
	613	+	func NewVariantParsedVa(FormatVar string, AppVar []interface{}) *Variant {
614	614
615		-	cret := xNewParsedVaVariant(FormatVar, AppVar)
	615	+	cret := xNewVariantParsedVa(FormatVar, AppVar)
616	616		return cret
617	617		}
618	618
619		-	var xNewPrintfVariant func(string, ...interface{}) *Variant
	619	+	var xNewVariantPrintf func(string, ...interface{}) *Variant
620	620
621	621		// Creates a string-type GVariant using printf formatting.
622	622		//
623	623		// This is similar to calling g_strdup_printf() and then
624	624		// g_variant_new_string() but it saves a temporary variable and an
625	625		// unnecessary copy.
626		-	func NewPrintfVariant(FormatStringVar string, varArgs ...interface{}) *Variant {
	626	+	func NewVariantPrintf(FormatStringVar string, varArgs ...interface{}) *Variant {
627	627
628		-	cret := xNewPrintfVariant(FormatStringVar, varArgs...)
	628	+	cret := xNewVariantPrintf(FormatStringVar, varArgs...)
629	629		return cret
630	630		}
631	631
632		-	var xNewSignatureVariant func(string) *Variant
	632	+	var xNewVariantSignature func(string) *Variant
633	633
634	634		// Creates a D-Bus type signature #GVariant with the contents of
635	635		// @string. @string must be a valid D-Bus type signature. Use
636	636		// g_variant_is_signature() if you're not sure.
637		-	func NewSignatureVariant(SignatureVar string) *Variant {
	637	+	func NewVariantSignature(SignatureVar string) *Variant {
638	638
639		-	cret := xNewSignatureVariant(SignatureVar)
	639	+	cret := xNewVariantSignature(SignatureVar)
640	640		return cret
641	641		}
642	642
643		-	var xNewStringVariant func(string) *Variant
	643	+	var xNewVariantString func(string) *Variant
644	644
645	645		// Creates a string #GVariant with the contents of @string.
646	646		//
647	647		// @string must be valid UTF-8, and must not be %NULL. To encode
648	648		// potentially-%NULL strings, use g_variant_new() with `ms` as the
649	649		// [format string][gvariant-format-strings-maybe-types].
650		-	func NewStringVariant(StringVar string) *Variant {
	650	+	func NewVariantString(StringVar string) *Variant {
651	651
652		-	cret := xNewStringVariant(StringVar)
	652	+	cret := xNewVariantString(StringVar)
653	653		return cret
654	654		}
655	655
656		-	var xNewStrvVariant func(uintptr, int) *Variant
	656	+	var xNewVariantStrv func(uintptr, int) *Variant
657	657
658	658		// Constructs an array of strings #GVariant from the given array of
659	659		// strings.
660	660		//
661	661		// If @length is -1 then @strv is %NULL-terminated.
662		-	func NewStrvVariant(StrvVar uintptr, LengthVar int) *Variant {
	662	+	func NewVariantStrv(StrvVar uintptr, LengthVar int) *Variant {
663	663
664		-	cret := xNewStrvVariant(StrvVar, LengthVar)
	664	+	cret := xNewVariantStrv(StrvVar, LengthVar)
665	665		return cret
666	666		}
667	667
668		-	var xNewTakeStringVariant func(string) *Variant
	668	+	var xNewVariantTakeString func(string) *Variant
669	669
670	670		// Creates a string #GVariant with the contents of @string.
671	671		//

@@ -678,13 +678,13 @@ var xNewTakeStringVariant func(string) *Variant
678	678		// You must not modify or access @string in any other way after passing
679	679		// it to this function. It is even possible that @string is immediately
680	680		// freed.
681		-	func NewTakeStringVariant(StringVar string) *Variant {
	681	+	func NewVariantTakeString(StringVar string) *Variant {
682	682
683		-	cret := xNewTakeStringVariant(StringVar)
	683	+	cret := xNewVariantTakeString(StringVar)
684	684		return cret
685	685		}
686	686
687		-	var xNewTupleVariant func(uintptr, uint) *Variant
	687	+	var xNewVariantTuple func(uintptr, uint) *Variant
688	688
689	689		// Creates a new tuple #GVariant out of the items in @children. The
690	690		// type is determined from the types of @children. No entry in the

@@ -694,40 +694,40 @@ var xNewTupleVariant func(uintptr, uint) *Variant
694	694		//
695	695		// If the @children are floating references (see g_variant_ref_sink()), the
696	696		// new instance takes ownership of them as if via g_variant_ref_sink().
697		-	func NewTupleVariant(ChildrenVar uintptr, NChildrenVar uint) *Variant {
	697	+	func NewVariantTuple(ChildrenVar uintptr, NChildrenVar uint) *Variant {
698	698
699		-	cret := xNewTupleVariant(ChildrenVar, NChildrenVar)
	699	+	cret := xNewVariantTuple(ChildrenVar, NChildrenVar)
700	700		return cret
701	701		}
702	702
703		-	var xNewUint16Variant func(uint16) *Variant
	703	+	var xNewVariantUint16 func(uint16) *Variant
704	704
705	705		// Creates a new uint16 #GVariant instance.
706		-	func NewUint16Variant(ValueVar uint16) *Variant {
	706	+	func NewVariantUint16(ValueVar uint16) *Variant {
707	707
708		-	cret := xNewUint16Variant(ValueVar)
	708	+	cret := xNewVariantUint16(ValueVar)
709	709		return cret
710	710		}
711	711
712		-	var xNewUint32Variant func(uint32) *Variant
	712	+	var xNewVariantUint32 func(uint32) *Variant
713	713
714	714		// Creates a new uint32 #GVariant instance.
715		-	func NewUint32Variant(ValueVar uint32) *Variant {
	715	+	func NewVariantUint32(ValueVar uint32) *Variant {
716	716
717		-	cret := xNewUint32Variant(ValueVar)
	717	+	cret := xNewVariantUint32(ValueVar)
718	718		return cret
719	719		}
720	720
721		-	var xNewUint64Variant func(uint64) *Variant
	721	+	var xNewVariantUint64 func(uint64) *Variant
722	722
723	723		// Creates a new uint64 #GVariant instance.
724		-	func NewUint64Variant(ValueVar uint64) *Variant {
	724	+	func NewVariantUint64(ValueVar uint64) *Variant {
725	725
726		-	cret := xNewUint64Variant(ValueVar)
	726	+	cret := xNewVariantUint64(ValueVar)
727	727		return cret
728	728		}
729	729
730		-	var xNewVaVariant func(string, string, []interface{}) *Variant
	730	+	var xNewVariantVa func(string, string, []interface{}) *Variant
731	731
732	732		// This function is intended to be used by libraries based on
733	733		// #GVariant that want to provide g_variant_new()-like functionality

@@ -765,9 +765,9 @@ var xNewVaVariant func(string, string, []interface{}) *Variant
765	765		// At this point, the caller will have their own full reference to the
766	766		// result. This can also be done by adding the result to a container,
767	767		// or by passing it to another g_variant_new() call.
768		-	func NewVaVariant(FormatStringVar string, EndptrVar string, AppVar []interface{}) *Variant {
	768	+	func NewVariantVa(FormatStringVar string, EndptrVar string, AppVar []interface{}) *Variant {
769	769
770		-	cret := xNewVaVariant(FormatStringVar, EndptrVar, AppVar)
	770	+	cret := xNewVariantVa(FormatStringVar, EndptrVar, AppVar)
771	771		return cret
772	772		}
773	773

@@ -2778,35 +2778,35 @@ func init() {
2778	2778		core.PuregoSafeRegister(&xVariantParseErrorPrintContext, lib, "g_variant_parse_error_print_context")
2779	2779
2780	2780		core.PuregoSafeRegister(&xNewVariant, lib, "g_variant_new")
2781		-	core.PuregoSafeRegister(&xNewArrayVariant, lib, "g_variant_new_array")
2782		-	core.PuregoSafeRegister(&xNewBooleanVariant, lib, "g_variant_new_boolean")
2783		-	core.PuregoSafeRegister(&xNewByteVariant, lib, "g_variant_new_byte")
2784		-	core.PuregoSafeRegister(&xNewBytestringVariant, lib, "g_variant_new_bytestring")
2785		-	core.PuregoSafeRegister(&xNewBytestringArrayVariant, lib, "g_variant_new_bytestring_array")
2786		-	core.PuregoSafeRegister(&xNewDictEntryVariant, lib, "g_variant_new_dict_entry")
2787		-	core.PuregoSafeRegister(&xNewDoubleVariant, lib, "g_variant_new_double")
2788		-	core.PuregoSafeRegister(&xNewFixedArrayVariant, lib, "g_variant_new_fixed_array")
2789		-	core.PuregoSafeRegister(&xNewFromBytesVariant, lib, "g_variant_new_from_bytes")
2790		-	core.PuregoSafeRegister(&xNewFromDataVariant, lib, "g_variant_new_from_data")
2791		-	core.PuregoSafeRegister(&xNewHandleVariant, lib, "g_variant_new_handle")
2792		-	core.PuregoSafeRegister(&xNewInt16Variant, lib, "g_variant_new_int16")
2793		-	core.PuregoSafeRegister(&xNewInt32Variant, lib, "g_variant_new_int32")
2794		-	core.PuregoSafeRegister(&xNewInt64Variant, lib, "g_variant_new_int64")
2795		-	core.PuregoSafeRegister(&xNewMaybeVariant, lib, "g_variant_new_maybe")
2796		-	core.PuregoSafeRegister(&xNewObjectPathVariant, lib, "g_variant_new_object_path")
2797		-	core.PuregoSafeRegister(&xNewObjvVariant, lib, "g_variant_new_objv")
2798		-	core.PuregoSafeRegister(&xNewParsedVariant, lib, "g_variant_new_parsed")
2799		-	core.PuregoSafeRegister(&xNewParsedVaVariant, lib, "g_variant_new_parsed_va")
2800		-	core.PuregoSafeRegister(&xNewPrintfVariant, lib, "g_variant_new_printf")
2801		-	core.PuregoSafeRegister(&xNewSignatureVariant, lib, "g_variant_new_signature")
2802		-	core.PuregoSafeRegister(&xNewStringVariant, lib, "g_variant_new_string")
2803		-	core.PuregoSafeRegister(&xNewStrvVariant, lib, "g_variant_new_strv")
2804		-	core.PuregoSafeRegister(&xNewTakeStringVariant, lib, "g_variant_new_take_string")
2805		-	core.PuregoSafeRegister(&xNewTupleVariant, lib, "g_variant_new_tuple")
2806		-	core.PuregoSafeRegister(&xNewUint16Variant, lib, "g_variant_new_uint16")
2807		-	core.PuregoSafeRegister(&xNewUint32Variant, lib, "g_variant_new_uint32")
2808		-	core.PuregoSafeRegister(&xNewUint64Variant, lib, "g_variant_new_uint64")
2809		-	core.PuregoSafeRegister(&xNewVaVariant, lib, "g_variant_new_va")
	2781	+	core.PuregoSafeRegister(&xNewVariantArray, lib, "g_variant_new_array")
	2782	+	core.PuregoSafeRegister(&xNewVariantBoolean, lib, "g_variant_new_boolean")
	2783	+	core.PuregoSafeRegister(&xNewVariantByte, lib, "g_variant_new_byte")
	2784	+	core.PuregoSafeRegister(&xNewVariantBytestring, lib, "g_variant_new_bytestring")
	2785	+	core.PuregoSafeRegister(&xNewVariantBytestringArray, lib, "g_variant_new_bytestring_array")
	2786	+	core.PuregoSafeRegister(&xNewVariantDictEntry, lib, "g_variant_new_dict_entry")
	2787	+	core.PuregoSafeRegister(&xNewVariantDouble, lib, "g_variant_new_double")
	2788	+	core.PuregoSafeRegister(&xNewVariantFixedArray, lib, "g_variant_new_fixed_array")
	2789	+	core.PuregoSafeRegister(&xNewVariantFromBytes, lib, "g_variant_new_from_bytes")
	2790	+	core.PuregoSafeRegister(&xNewVariantFromData, lib, "g_variant_new_from_data")
	2791	+	core.PuregoSafeRegister(&xNewVariantHandle, lib, "g_variant_new_handle")
	2792	+	core.PuregoSafeRegister(&xNewVariantInt16, lib, "g_variant_new_int16")
	2793	+	core.PuregoSafeRegister(&xNewVariantInt32, lib, "g_variant_new_int32")
	2794	+	core.PuregoSafeRegister(&xNewVariantInt64, lib, "g_variant_new_int64")
	2795	+	core.PuregoSafeRegister(&xNewVariantMaybe, lib, "g_variant_new_maybe")
	2796	+	core.PuregoSafeRegister(&xNewVariantObjectPath, lib, "g_variant_new_object_path")
	2797	+	core.PuregoSafeRegister(&xNewVariantObjv, lib, "g_variant_new_objv")
	2798	+	core.PuregoSafeRegister(&xNewVariantParsed, lib, "g_variant_new_parsed")
	2799	+	core.PuregoSafeRegister(&xNewVariantParsedVa, lib, "g_variant_new_parsed_va")
	2800	+	core.PuregoSafeRegister(&xNewVariantPrintf, lib, "g_variant_new_printf")
	2801	+	core.PuregoSafeRegister(&xNewVariantSignature, lib, "g_variant_new_signature")
	2802	+	core.PuregoSafeRegister(&xNewVariantString, lib, "g_variant_new_string")
	2803	+	core.PuregoSafeRegister(&xNewVariantStrv, lib, "g_variant_new_strv")
	2804	+	core.PuregoSafeRegister(&xNewVariantTakeString, lib, "g_variant_new_take_string")
	2805	+	core.PuregoSafeRegister(&xNewVariantTuple, lib, "g_variant_new_tuple")
	2806	+	core.PuregoSafeRegister(&xNewVariantUint16, lib, "g_variant_new_uint16")
	2807	+	core.PuregoSafeRegister(&xNewVariantUint32, lib, "g_variant_new_uint32")
	2808	+	core.PuregoSafeRegister(&xNewVariantUint64, lib, "g_variant_new_uint64")
	2809	+	core.PuregoSafeRegister(&xNewVariantVa, lib, "g_variant_new_va")
2810	2810		core.PuregoSafeRegister(&xNewVariantVariant, lib, "g_variant_new_variant")
2811	2811
2812	2812		core.PuregoSafeRegister(&xVariantByteswap, lib, "g_variant_byteswap")

M v4/glib/gvarianttype.go +16 -16


@@ -197,43 +197,43 @@ func NewVariantType(TypeStringVar string) *VariantType {
197	197		return cret
198	198		}
199	199
200		-	var xNewArrayVariantType func(VariantType) VariantType
	200	+	var xNewVariantTypeArray func(VariantType) VariantType
201	201
202	202		// Constructs the type corresponding to an array of elements of the
203	203		// type @type.
204	204		//
205	205		// It is appropriate to call g_variant_type_free() on the return value.
206		-	func NewArrayVariantType(ElementVar VariantType) VariantType {
	206	+	func NewVariantTypeArray(ElementVar VariantType) VariantType {
207	207
208		-	cret := xNewArrayVariantType(ElementVar)
	208	+	cret := xNewVariantTypeArray(ElementVar)
209	209		return cret
210	210		}
211	211
212		-	var xNewDictEntryVariantType func(VariantType, VariantType) *VariantType
	212	+	var xNewVariantTypeDictEntry func(VariantType, VariantType) *VariantType
213	213
214	214		// Constructs the type corresponding to a dictionary entry with a key
215	215		// of type @key and a value of type @value.
216	216		//
217	217		// It is appropriate to call g_variant_type_free() on the return value.
218		-	func NewDictEntryVariantType(KeyVar VariantType, ValueVar VariantType) *VariantType {
	218	+	func NewVariantTypeDictEntry(KeyVar VariantType, ValueVar VariantType) *VariantType {
219	219
220		-	cret := xNewDictEntryVariantType(KeyVar, ValueVar)
	220	+	cret := xNewVariantTypeDictEntry(KeyVar, ValueVar)
221	221		return cret
222	222		}
223	223
224		-	var xNewMaybeVariantType func(VariantType) VariantType
	224	+	var xNewVariantTypeMaybe func(VariantType) VariantType
225	225
226	226		// Constructs the type corresponding to a maybe instance containing
227	227		// type @type or Nothing.
228	228		//
229	229		// It is appropriate to call g_variant_type_free() on the return value.
230		-	func NewMaybeVariantType(ElementVar VariantType) VariantType {
	230	+	func NewVariantTypeMaybe(ElementVar VariantType) VariantType {
231	231
232		-	cret := xNewMaybeVariantType(ElementVar)
	232	+	cret := xNewVariantTypeMaybe(ElementVar)
233	233		return cret
234	234		}
235	235
236		-	var xNewTupleVariantType func(uintptr, int) *VariantType
	236	+	var xNewVariantTypeTuple func(uintptr, int) *VariantType
237	237
238	238		// Constructs a new tuple type, from @items.
239	239		//

@@ -241,9 +241,9 @@ var xNewTupleVariantType func(uintptr, int) *VariantType
241	241		// @items is %NULL-terminated.
242	242		//
243	243		// It is appropriate to call g_variant_type_free() on the return value.
244		-	func NewTupleVariantType(ItemsVar uintptr, LengthVar int) *VariantType {
	244	+	func NewVariantTypeTuple(ItemsVar uintptr, LengthVar int) *VariantType {
245	245
246		-	cret := xNewTupleVariantType(ItemsVar, LengthVar)
	246	+	cret := xNewVariantTypeTuple(ItemsVar, LengthVar)
247	247		return cret
248	248		}
249	249

@@ -620,10 +620,10 @@ func init() {
620	620		core.PuregoSafeRegister(&xVariantTypeStringScan, lib, "g_variant_type_string_scan")
621	621
622	622		core.PuregoSafeRegister(&xNewVariantType, lib, "g_variant_type_new")
623		-	core.PuregoSafeRegister(&xNewArrayVariantType, lib, "g_variant_type_new_array")
624		-	core.PuregoSafeRegister(&xNewDictEntryVariantType, lib, "g_variant_type_new_dict_entry")
625		-	core.PuregoSafeRegister(&xNewMaybeVariantType, lib, "g_variant_type_new_maybe")
626		-	core.PuregoSafeRegister(&xNewTupleVariantType, lib, "g_variant_type_new_tuple")
	623	+	core.PuregoSafeRegister(&xNewVariantTypeArray, lib, "g_variant_type_new_array")
	624	+	core.PuregoSafeRegister(&xNewVariantTypeDictEntry, lib, "g_variant_type_new_dict_entry")
	625	+	core.PuregoSafeRegister(&xNewVariantTypeMaybe, lib, "g_variant_type_new_maybe")
	626	+	core.PuregoSafeRegister(&xNewVariantTypeTuple, lib, "g_variant_type_new_tuple")
627	627
628	628		core.PuregoSafeRegister(&xVariantTypeCopy, lib, "g_variant_type_copy")
629	629		core.PuregoSafeRegister(&xVariantTypeDupString, lib, "g_variant_type_dup_string")

M v4/gobject/gclosure.go +8 -8


@@ -115,19 +115,19 @@ func (x *Closure) GoPointer() uintptr {
115	115		return uintptr(unsafe.Pointer(x))
116	116		}
117	117
118		-	var xNewObjectClosure func(uint, uintptr) *Closure
	118	+	var xNewClosureObject func(uint, uintptr) *Closure
119	119
120	120		// A variant of g_closure_new_simple() which stores @object in the
121	121		// @data field of the closure and calls g_object_watch_closure() on
122	122		// @object and the created closure. This function is mainly useful
123	123		// when implementing new types of closures.
124		-	func NewObjectClosure(SizeofClosureVar uint, ObjectVar Object) Closure {
	124	+	func NewClosureObject(SizeofClosureVar uint, ObjectVar Object) Closure {
125	125
126		-	cret := xNewObjectClosure(SizeofClosureVar, ObjectVar.GoPointer())
	126	+	cret := xNewClosureObject(SizeofClosureVar, ObjectVar.GoPointer())
127	127		return cret
128	128		}
129	129
130		-	var xNewSimpleClosure func(uint, uintptr) *Closure
	130	+	var xNewClosureSimple func(uint, uintptr) *Closure
131	131
132	132		// Allocates a struct of the given size and initializes the initial
133	133		// part as a #GClosure.

@@ -171,9 +171,9 @@ var xNewSimpleClosure func(uint, uintptr) *Closure
171	171		// }
172	172		//
173	173		// ]\|
174		-	func NewSimpleClosure(SizeofClosureVar uint, DataVar uintptr) *Closure {
	174	+	func NewClosureSimple(SizeofClosureVar uint, DataVar uintptr) *Closure {
175	175
176		-	cret := xNewSimpleClosure(SizeofClosureVar, DataVar)
	176	+	cret := xNewClosureSimple(SizeofClosureVar, DataVar)
177	177		return cret
178	178		}
179	179

@@ -464,8 +464,8 @@ func init() {
464	464		core.PuregoSafeRegister(&xCclosureNewSwap, lib, "g_cclosure_new_swap")
465	465		core.PuregoSafeRegister(&xSignalTypeCclosureNew, lib, "g_signal_type_cclosure_new")
466	466
467		-	core.PuregoSafeRegister(&xNewObjectClosure, lib, "g_closure_new_object")
468		-	core.PuregoSafeRegister(&xNewSimpleClosure, lib, "g_closure_new_simple")
	467	+	core.PuregoSafeRegister(&xNewClosureObject, lib, "g_closure_new_object")
	468	+	core.PuregoSafeRegister(&xNewClosureSimple, lib, "g_closure_new_simple")
469	469
470	470		core.PuregoSafeRegister(&xClosureAddFinalizeNotifier, lib, "g_closure_add_finalize_notifier")
471	471		core.PuregoSafeRegister(&xClosureAddInvalidateNotifier, lib, "g_closure_add_invalidate_notifier")

M v4/gobject/gobject.go +12 -12


@@ -492,16 +492,16 @@ func NewObject(ObjectTypeVar []interface{}, FirstPropertyNameVar string, varArgs
492	492		return cls
493	493		}
494	494
495		-	var xNewValistObject func([]interface{}, string, []interface{}) uintptr
	495	+	var xNewObjectValist func([]interface{}, string, []interface{}) uintptr
496	496
497	497		// Creates a new instance of a #GObject subtype and sets its properties.
498	498		//
499	499		// Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY)
500	500		// which are not explicitly specified are set to their default values.
501		-	func NewValistObject(ObjectTypeVar []interface{}, FirstPropertyNameVar string, VarArgsVar []interface{}) *Object {
	501	+	func NewObjectValist(ObjectTypeVar []interface{}, FirstPropertyNameVar string, VarArgsVar []interface{}) *Object {
502	502		var cls *Object
503	503
504		-	cret := xNewValistObject(ObjectTypeVar, FirstPropertyNameVar, VarArgsVar)
	504	+	cret := xNewObjectValist(ObjectTypeVar, FirstPropertyNameVar, VarArgsVar)
505	505
506	506		if cret == 0 {
507	507		return nil

@@ -511,7 +511,7 @@ func NewValistObject(ObjectTypeVar []interface{}, FirstPropertyNameVar string, V
511	511		return cls
512	512		}
513	513
514		-	var xNewWithPropertiesObject func([]interface{}, uint, []string, uintptr) uintptr
	514	+	var xNewObjectWithProperties func([]interface{}, uint, []string, uintptr) uintptr
515	515
516	516		// Creates a new instance of a #GObject subtype and sets its properties using
517	517		// the provided arrays. Both arrays must have exactly @n_properties elements,

@@ -519,10 +519,10 @@ var xNewWithPropertiesObject func([]interface{}, uint, []string, uintptr) uintpt
519	519		//
520	520		// Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY)
521	521		// which are not explicitly specified are set to their default values.
522		-	func NewWithPropertiesObject(ObjectTypeVar []interface{}, NPropertiesVar uint, NamesVar []string, ValuesVar uintptr) *Object {
	522	+	func NewObjectWithProperties(ObjectTypeVar []interface{}, NPropertiesVar uint, NamesVar []string, ValuesVar uintptr) *Object {
523	523		var cls *Object
524	524
525		-	cret := xNewWithPropertiesObject(ObjectTypeVar, NPropertiesVar, NamesVar, ValuesVar)
	525	+	cret := xNewObjectWithProperties(ObjectTypeVar, NPropertiesVar, NamesVar, ValuesVar)
526	526
527	527		if cret == 0 {
528	528		return nil

@@ -532,16 +532,16 @@ func NewWithPropertiesObject(ObjectTypeVar []interface{}, NPropertiesVar uint, N
532	532		return cls
533	533		}
534	534
535		-	var xNewvObject func([]interface{}, uint, uintptr) uintptr
	535	+	var xNewObjectv func([]interface{}, uint, uintptr) uintptr
536	536
537	537		// Creates a new instance of a #GObject subtype and sets its properties.
538	538		//
539	539		// Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY)
540	540		// which are not explicitly specified are set to their default values.
541		-	func NewvObject(ObjectTypeVar []interface{}, NParametersVar uint, ParametersVar uintptr) *Object {
	541	+	func NewObjectv(ObjectTypeVar []interface{}, NParametersVar uint, ParametersVar uintptr) *Object {
542	542		var cls *Object
543	543
544		-	cret := xNewvObject(ObjectTypeVar, NParametersVar, ParametersVar)
	544	+	cret := xNewObjectv(ObjectTypeVar, NParametersVar, ParametersVar)
545	545
546	546		if cret == 0 {
547	547		return nil

@@ -1580,9 +1580,9 @@ func init() {
1580	1580		core.PuregoSafeRegister(&xWeakRefSet, lib, "g_weak_ref_set")
1581	1581
1582	1582		core.PuregoSafeRegister(&xNewObject, lib, "g_object_new")
1583		-	core.PuregoSafeRegister(&xNewValistObject, lib, "g_object_new_valist")
1584		-	core.PuregoSafeRegister(&xNewWithPropertiesObject, lib, "g_object_new_with_properties")
1585		-	core.PuregoSafeRegister(&xNewvObject, lib, "g_object_newv")
	1583	+	core.PuregoSafeRegister(&xNewObjectValist, lib, "g_object_new_valist")
	1584	+	core.PuregoSafeRegister(&xNewObjectWithProperties, lib, "g_object_new_with_properties")
	1585	+	core.PuregoSafeRegister(&xNewObjectv, lib, "g_object_newv")
1586	1586
1587	1587		core.PuregoSafeRegister(&xObjectAddToggleRef, lib, "g_object_add_toggle_ref")
1588	1588		core.PuregoSafeRegister(&xObjectAddWeakPointer, lib, "g_object_add_weak_pointer")

M v4/graphene/graphene-box.go +4 -4


@@ -20,14 +20,14 @@ func (x *Box) GoPointer() uintptr {
20	20		return uintptr(unsafe.Pointer(x))
21	21		}
22	22
23		-	var xAllocBox func() *Box
	23	+	var xBoxAlloc func() *Box
24	24
25	25		// Allocates a new #graphene_box_t.
26	26		//
27	27		// The contents of the returned structure are undefined.
28		-	func AllocBox() *Box {
	28	+	func BoxAlloc() *Box {
29	29
30		-	cret := xAllocBox()
	30	+	cret := xBoxAlloc()
31	31		return cret
32	32		}
33	33

@@ -341,7 +341,7 @@ func init() {
341	341		core.PuregoSafeRegister(&xBoxOneMinusOne, lib, "graphene_box_one_minus_one")
342	342		core.PuregoSafeRegister(&xBoxZero, lib, "graphene_box_zero")
343	343
344		-	core.PuregoSafeRegister(&xAllocBox, lib, "graphene_box_alloc")
	344	+	core.PuregoSafeRegister(&xBoxAlloc, lib, "graphene_box_alloc")
345	345
346	346		core.PuregoSafeRegister(&xBoxContainsBox, lib, "graphene_box_contains_box")
347	347		core.PuregoSafeRegister(&xBoxContainsPoint, lib, "graphene_box_contains_point")

M v4/graphene/graphene-euler.go +4 -4


@@ -22,14 +22,14 @@ func (x *Euler) GoPointer() uintptr {
22	22		return uintptr(unsafe.Pointer(x))
23	23		}
24	24
25		-	var xAllocEuler func() *Euler
	25	+	var xEulerAlloc func() *Euler
26	26
27	27		// Allocates a new #graphene_euler_t.
28	28		//
29	29		// The contents of the returned structure are undefined.
30		-	func AllocEuler() *Euler {
	30	+	func EulerAlloc() *Euler {
31	31
32		-	cret := xAllocEuler()
	32	+	cret := xEulerAlloc()
33	33		return cret
34	34		}
35	35

@@ -350,7 +350,7 @@ func init() {
350	350		panic(err)
351	351		}
352	352
353		-	core.PuregoSafeRegister(&xAllocEuler, lib, "graphene_euler_alloc")
	353	+	core.PuregoSafeRegister(&xEulerAlloc, lib, "graphene_euler_alloc")
354	354
355	355		core.PuregoSafeRegister(&xEulerEqual, lib, "graphene_euler_equal")
356	356		core.PuregoSafeRegister(&xEulerFree, lib, "graphene_euler_free")

M v4/graphene/graphene-frustum.go +4 -4


@@ -20,14 +20,14 @@ func (x *Frustum) GoPointer() uintptr {
20	20		return uintptr(unsafe.Pointer(x))
21	21		}
22	22
23		-	var xAllocFrustum func() *Frustum
	23	+	var xFrustumAlloc func() *Frustum
24	24
25	25		// Allocates a new #graphene_frustum_t structure.
26	26		//
27	27		// The contents of the returned structure are undefined.
28		-	func AllocFrustum() *Frustum {
	28	+	func FrustumAlloc() *Frustum {
29	29
30		-	cret := xAllocFrustum()
	30	+	cret := xFrustumAlloc()
31	31		return cret
32	32		}
33	33

@@ -123,7 +123,7 @@ func init() {
123	123		panic(err)
124	124		}
125	125
126		-	core.PuregoSafeRegister(&xAllocFrustum, lib, "graphene_frustum_alloc")
	126	+	core.PuregoSafeRegister(&xFrustumAlloc, lib, "graphene_frustum_alloc")
127	127
128	128		core.PuregoSafeRegister(&xFrustumContainsPoint, lib, "graphene_frustum_contains_point")
129	129		core.PuregoSafeRegister(&xFrustumEqual, lib, "graphene_frustum_equal")

M v4/graphene/graphene-matrix.go +4 -4


@@ -20,12 +20,12 @@ func (x *Matrix) GoPointer() uintptr {
20	20		return uintptr(unsafe.Pointer(x))
21	21		}
22	22
23		-	var xAllocMatrix func() *Matrix
	23	+	var xMatrixAlloc func() *Matrix
24	24
25	25		// Allocates a new #graphene_matrix_t.
26		-	func AllocMatrix() *Matrix {
	26	+	func MatrixAlloc() *Matrix {
27	27
28		-	cret := xAllocMatrix()
	28	+	cret := xMatrixAlloc()
29	29		return cret
30	30		}
31	31

@@ -792,7 +792,7 @@ func init() {
792	792		panic(err)
793	793		}
794	794
795		-	core.PuregoSafeRegister(&xAllocMatrix, lib, "graphene_matrix_alloc")
	795	+	core.PuregoSafeRegister(&xMatrixAlloc, lib, "graphene_matrix_alloc")
796	796
797	797		core.PuregoSafeRegister(&xMatrixDecompose, lib, "graphene_matrix_decompose")
798	798		core.PuregoSafeRegister(&xMatrixDeterminant, lib, "graphene_matrix_determinant")

M v4/graphene/graphene-plane.go +4 -4


@@ -22,14 +22,14 @@ func (x *Plane) GoPointer() uintptr {
22	22		return uintptr(unsafe.Pointer(x))
23	23		}
24	24
25		-	var xAllocPlane func() *Plane
	25	+	var xPlaneAlloc func() *Plane
26	26
27	27		// Allocates a new #graphene_plane_t structure.
28	28		//
29	29		// The contents of the returned structure are undefined.
30		-	func AllocPlane() *Plane {
	30	+	func PlaneAlloc() *Plane {
31	31
32		-	cret := xAllocPlane()
	32	+	cret := xPlaneAlloc()
33	33		return cret
34	34		}
35	35

@@ -175,7 +175,7 @@ func init() {
175	175		panic(err)
176	176		}
177	177
178		-	core.PuregoSafeRegister(&xAllocPlane, lib, "graphene_plane_alloc")
	178	+	core.PuregoSafeRegister(&xPlaneAlloc, lib, "graphene_plane_alloc")
179	179
180	180		core.PuregoSafeRegister(&xPlaneDistance, lib, "graphene_plane_distance")
181	181		core.PuregoSafeRegister(&xPlaneEqual, lib, "graphene_plane_equal")

M v4/graphene/graphene-point.go +4 -4


@@ -19,7 +19,7 @@ func (x *Point) GoPointer() uintptr {
19	19		return uintptr(unsafe.Pointer(x))
20	20		}
21	21
22		-	var xAllocPoint func() *Point
	22	+	var xPointAlloc func() *Point
23	23
24	24		// Allocates a new #graphene_point_t structure.
25	25		//

@@ -43,9 +43,9 @@ var xAllocPoint func() *Point
43	43		// }
44	44		//
45	45		// ]\|
46		-	func AllocPoint() *Point {
	46	+	func PointAlloc() *Point {
47	47
48		-	cret := xAllocPoint()
	48	+	cret := xPointAlloc()
49	49		return cret
50	50		}
51	51

@@ -156,7 +156,7 @@ func init() {
156	156		}
157	157		core.PuregoSafeRegister(&xPointZero, lib, "graphene_point_zero")
158	158
159		-	core.PuregoSafeRegister(&xAllocPoint, lib, "graphene_point_alloc")
	159	+	core.PuregoSafeRegister(&xPointAlloc, lib, "graphene_point_alloc")
160	160
161	161		core.PuregoSafeRegister(&xPointDistance, lib, "graphene_point_distance")
162	162		core.PuregoSafeRegister(&xPointEqual, lib, "graphene_point_equal")

M v4/graphene/graphene-point3d.go +4 -4


@@ -21,12 +21,12 @@ func (x *Point3D) GoPointer() uintptr {
21	21		return uintptr(unsafe.Pointer(x))
22	22		}
23	23
24		-	var xAllocPoint3D func() *Point3D
	24	+	var xPoint3DAlloc func() *Point3D
25	25
26	26		// Allocates a #graphene_point3d_t structure.
27		-	func AllocPoint3D() *Point3D {
	27	+	func Point3DAlloc() *Point3D {
28	28
29		-	cret := xAllocPoint3D()
	29	+	cret := xPoint3DAlloc()
30	30		return cret
31	31		}
32	32

@@ -193,7 +193,7 @@ func init() {
193	193		}
194	194		core.PuregoSafeRegister(&xPoint3dZero, lib, "graphene_point3d_zero")
195	195
196		-	core.PuregoSafeRegister(&xAllocPoint3D, lib, "graphene_point3d_alloc")
	196	+	core.PuregoSafeRegister(&xPoint3DAlloc, lib, "graphene_point3d_alloc")
197	197
198	198		core.PuregoSafeRegister(&xPoint3DCross, lib, "graphene_point3d_cross")
199	199		core.PuregoSafeRegister(&xPoint3DDistance, lib, "graphene_point3d_distance")

M v4/graphene/graphene-quad.go +4 -4


@@ -20,14 +20,14 @@ func (x *Quad) GoPointer() uintptr {
20	20		return uintptr(unsafe.Pointer(x))
21	21		}
22	22
23		-	var xAllocQuad func() *Quad
	23	+	var xQuadAlloc func() *Quad
24	24
25	25		// Allocates a new #graphene_quad_t instance.
26	26		//
27	27		// The contents of the returned instance are undefined.
28		-	func AllocQuad() *Quad {
	28	+	func QuadAlloc() *Quad {
29	29
30		-	cret := xAllocQuad()
	30	+	cret := xQuadAlloc()
31	31		return cret
32	32		}
33	33

@@ -101,7 +101,7 @@ func init() {
101	101		panic(err)
102	102		}
103	103
104		-	core.PuregoSafeRegister(&xAllocQuad, lib, "graphene_quad_alloc")
	104	+	core.PuregoSafeRegister(&xQuadAlloc, lib, "graphene_quad_alloc")
105	105
106	106		core.PuregoSafeRegister(&xQuadBounds, lib, "graphene_quad_bounds")
107	107		core.PuregoSafeRegister(&xQuadContains, lib, "graphene_quad_contains")

M v4/graphene/graphene-quaternion.go +4 -4


@@ -26,14 +26,14 @@ func (x *Quaternion) GoPointer() uintptr {
26	26		return uintptr(unsafe.Pointer(x))
27	27		}
28	28
29		-	var xAllocQuaternion func() *Quaternion
	29	+	var xQuaternionAlloc func() *Quaternion
30	30
31	31		// Allocates a new #graphene_quaternion_t.
32	32		//
33	33		// The contents of the returned value are undefined.
34		-	func AllocQuaternion() *Quaternion {
	34	+	func QuaternionAlloc() *Quaternion {
35	35
36		-	cret := xAllocQuaternion()
	36	+	cret := xQuaternionAlloc()
37	37		return cret
38	38		}
39	39

@@ -271,7 +271,7 @@ func init() {
271	271		panic(err)
272	272		}
273	273
274		-	core.PuregoSafeRegister(&xAllocQuaternion, lib, "graphene_quaternion_alloc")
	274	+	core.PuregoSafeRegister(&xQuaternionAlloc, lib, "graphene_quaternion_alloc")
275	275
276	276		core.PuregoSafeRegister(&xQuaternionAdd, lib, "graphene_quaternion_add")
277	277		core.PuregoSafeRegister(&xQuaternionDot, lib, "graphene_quaternion_dot")

M v4/graphene/graphene-ray.go +4 -4


@@ -22,14 +22,14 @@ func (x *Ray) GoPointer() uintptr {
22	22		return uintptr(unsafe.Pointer(x))
23	23		}
24	24
25		-	var xAllocRay func() *Ray
	25	+	var xRayAlloc func() *Ray
26	26
27	27		// Allocates a new #graphene_ray_t structure.
28	28		//
29	29		// The contents of the returned structure are undefined.
30		-	func AllocRay() *Ray {
	30	+	func RayAlloc() *Ray {
31	31
32		-	cret := xAllocRay()
	32	+	cret := xRayAlloc()
33	33		return cret
34	34		}
35	35

@@ -231,7 +231,7 @@ func init() {
231	231		panic(err)
232	232		}
233	233
234		-	core.PuregoSafeRegister(&xAllocRay, lib, "graphene_ray_alloc")
	234	+	core.PuregoSafeRegister(&xRayAlloc, lib, "graphene_ray_alloc")
235	235
236	236		core.PuregoSafeRegister(&xRayEqual, lib, "graphene_ray_equal")
237	237		core.PuregoSafeRegister(&xRayFree, lib, "graphene_ray_free")

M v4/graphene/graphene-size.go +4 -4


@@ -19,14 +19,14 @@ func (x *Size) GoPointer() uintptr {
19	19		return uintptr(unsafe.Pointer(x))
20	20		}
21	21
22		-	var xAllocSize func() *Size
	22	+	var xSizeAlloc func() *Size
23	23
24	24		// Allocates a new #graphene_size_t.
25	25		//
26	26		// The contents of the returned value are undefined.
27		-	func AllocSize() *Size {
	27	+	func SizeAlloc() *Size {
28	28
29		-	cret := xAllocSize()
	29	+	cret := xSizeAlloc()
30	30		return cret
31	31		}
32	32

@@ -103,7 +103,7 @@ func init() {
103	103		}
104	104		core.PuregoSafeRegister(&xSizeZero, lib, "graphene_size_zero")
105	105
106		-	core.PuregoSafeRegister(&xAllocSize, lib, "graphene_size_alloc")
	106	+	core.PuregoSafeRegister(&xSizeAlloc, lib, "graphene_size_alloc")
107	107
108	108		core.PuregoSafeRegister(&xSizeEqual, lib, "graphene_size_equal")
109	109		core.PuregoSafeRegister(&xSizeFree, lib, "graphene_size_free")

M v4/graphene/graphene-sphere.go +4 -4


@@ -19,14 +19,14 @@ func (x *Sphere) GoPointer() uintptr {
19	19		return uintptr(unsafe.Pointer(x))
20	20		}
21	21
22		-	var xAllocSphere func() *Sphere
	22	+	var xSphereAlloc func() *Sphere
23	23
24	24		// Allocates a new #graphene_sphere_t.
25	25		//
26	26		// The contents of the newly allocated structure are undefined.
27		-	func AllocSphere() *Sphere {
	27	+	func SphereAlloc() *Sphere {
28	28
29		-	cret := xAllocSphere()
	29	+	cret := xSphereAlloc()
30	30		return cret
31	31		}
32	32

@@ -156,7 +156,7 @@ func init() {
156	156		panic(err)
157	157		}
158	158
159		-	core.PuregoSafeRegister(&xAllocSphere, lib, "graphene_sphere_alloc")
	159	+	core.PuregoSafeRegister(&xSphereAlloc, lib, "graphene_sphere_alloc")
160	160
161	161		core.PuregoSafeRegister(&xSphereContainsPoint, lib, "graphene_sphere_contains_point")
162	162		core.PuregoSafeRegister(&xSphereDistance, lib, "graphene_sphere_distance")

M v4/graphene/graphene-triangle.go +4 -4


@@ -21,14 +21,14 @@ func (x *Triangle) GoPointer() uintptr {
21	21		return uintptr(unsafe.Pointer(x))
22	22		}
23	23
24		-	var xAllocTriangle func() *Triangle
	24	+	var xTriangleAlloc func() *Triangle
25	25
26	26		// Allocates a new #graphene_triangle_t.
27	27		//
28	28		// The contents of the returned structure are undefined.
29		-	func AllocTriangle() *Triangle {
	29	+	func TriangleAlloc() *Triangle {
30	30
31		-	cret := xAllocTriangle()
	31	+	cret := xTriangleAlloc()
32	32		return cret
33	33		}
34	34

@@ -205,7 +205,7 @@ func init() {
205	205		panic(err)
206	206		}
207	207
208		-	core.PuregoSafeRegister(&xAllocTriangle, lib, "graphene_triangle_alloc")
	208	+	core.PuregoSafeRegister(&xTriangleAlloc, lib, "graphene_triangle_alloc")
209	209
210	210		core.PuregoSafeRegister(&xTriangleContainsPoint, lib, "graphene_triangle_contains_point")
211	211		core.PuregoSafeRegister(&xTriangleEqual, lib, "graphene_triangle_equal")

M v4/graphene/graphene-vec2.go +4 -4


@@ -20,16 +20,16 @@ func (x *Vec2) GoPointer() uintptr {
20	20		return uintptr(unsafe.Pointer(x))
21	21		}
22	22
23		-	var xAllocVec2 func() *Vec2
	23	+	var xVec2Alloc func() *Vec2
24	24
25	25		// Allocates a new #graphene_vec2_t structure.
26	26		//
27	27		// The contents of the returned structure are undefined.
28	28		//
29	29		// Use graphene_vec2_init() to initialize the vector.
30		-	func AllocVec2() *Vec2 {
	30	+	func Vec2Alloc() *Vec2 {
31	31
32		-	cret := xAllocVec2()
	32	+	cret := xVec2Alloc()
33	33		return cret
34	34		}
35	35

@@ -279,7 +279,7 @@ func init() {
279	279		core.PuregoSafeRegister(&xVec2YAxis, lib, "graphene_vec2_y_axis")
280	280		core.PuregoSafeRegister(&xVec2Zero, lib, "graphene_vec2_zero")
281	281
282		-	core.PuregoSafeRegister(&xAllocVec2, lib, "graphene_vec2_alloc")
	282	+	core.PuregoSafeRegister(&xVec2Alloc, lib, "graphene_vec2_alloc")
283	283
284	284		core.PuregoSafeRegister(&xVec2Add, lib, "graphene_vec2_add")
285	285		core.PuregoSafeRegister(&xVec2Divide, lib, "graphene_vec2_divide")

M v4/graphene/graphene-vec3.go +4 -4


@@ -20,16 +20,16 @@ func (x *Vec3) GoPointer() uintptr {
20	20		return uintptr(unsafe.Pointer(x))
21	21		}
22	22
23		-	var xAllocVec3 func() *Vec3
	23	+	var xVec3Alloc func() *Vec3
24	24
25	25		// Allocates a new #graphene_vec3_t structure.
26	26		//
27	27		// The contents of the returned structure are undefined.
28	28		//
29	29		// Use graphene_vec3_init() to initialize the vector.
30		-	func AllocVec3() *Vec3 {
	30	+	func Vec3Alloc() *Vec3 {
31	31
32		-	cret := xAllocVec3()
	32	+	cret := xVec3Alloc()
33	33		return cret
34	34		}
35	35

@@ -361,7 +361,7 @@ func init() {
361	361		core.PuregoSafeRegister(&xVec3ZAxis, lib, "graphene_vec3_z_axis")
362	362		core.PuregoSafeRegister(&xVec3Zero, lib, "graphene_vec3_zero")
363	363
364		-	core.PuregoSafeRegister(&xAllocVec3, lib, "graphene_vec3_alloc")
	364	+	core.PuregoSafeRegister(&xVec3Alloc, lib, "graphene_vec3_alloc")
365	365
366	366		core.PuregoSafeRegister(&xVec3Add, lib, "graphene_vec3_add")
367	367		core.PuregoSafeRegister(&xVec3Cross, lib, "graphene_vec3_cross")

M v4/graphene/graphene-vec4.go +4 -4


@@ -20,16 +20,16 @@ func (x *Vec4) GoPointer() uintptr {
20	20		return uintptr(unsafe.Pointer(x))
21	21		}
22	22
23		-	var xAllocVec4 func() *Vec4
	23	+	var xVec4Alloc func() *Vec4
24	24
25	25		// Allocates a new #graphene_vec4_t structure.
26	26		//
27	27		// The contents of the returned structure are undefined.
28	28		//
29	29		// Use graphene_vec4_init() to initialize the vector.
30		-	func AllocVec4() *Vec4 {
	30	+	func Vec4Alloc() *Vec4 {
31	31
32		-	cret := xAllocVec4()
	32	+	cret := xVec4Alloc()
33	33		return cret
34	34		}
35	35

@@ -363,7 +363,7 @@ func init() {
363	363		core.PuregoSafeRegister(&xVec4ZAxis, lib, "graphene_vec4_z_axis")
364	364		core.PuregoSafeRegister(&xVec4Zero, lib, "graphene_vec4_zero")
365	365
366		-	core.PuregoSafeRegister(&xAllocVec4, lib, "graphene_vec4_alloc")
	366	+	core.PuregoSafeRegister(&xVec4Alloc, lib, "graphene_vec4_alloc")
367	367
368	368		core.PuregoSafeRegister(&xVec4Add, lib, "graphene_vec4_add")
369	369		core.PuregoSafeRegister(&xVec4Divide, lib, "graphene_vec4_divide")

M v4/gsk/gskglshader.go +8 -8


@@ -293,13 +293,13 @@ func GLShaderNewFromInternalPtr(ptr uintptr) *GLShader {
293	293		return cls
294	294		}
295	295
296		-	var xNewFromBytesGLShader func(*glib.Bytes) uintptr
	296	+	var xNewGLShaderFromBytes func(*glib.Bytes) uintptr
297	297
298	298		// Creates a `GskGLShader` that will render pixels using the specified code.
299		-	func NewFromBytesGLShader(SourcecodeVar glib.Bytes) GLShader {
	299	+	func NewGLShaderFromBytes(SourcecodeVar glib.Bytes) GLShader {
300	300		var cls *GLShader
301	301
302		-	cret := xNewFromBytesGLShader(SourcecodeVar)
	302	+	cret := xNewGLShaderFromBytes(SourcecodeVar)
303	303
304	304		if cret == 0 {
305	305		return nil

@@ -309,13 +309,13 @@ func NewFromBytesGLShader(SourcecodeVar glib.Bytes) GLShader {
309	309		return cls
310	310		}
311	311
312		-	var xNewFromResourceGLShader func(string) uintptr
	312	+	var xNewGLShaderFromResource func(string) uintptr
313	313
314	314		// Creates a `GskGLShader` that will render pixels using the specified code.
315		-	func NewFromResourceGLShader(ResourcePathVar string) *GLShader {
	315	+	func NewGLShaderFromResource(ResourcePathVar string) *GLShader {
316	316		var cls *GLShader
317	317
318		-	cret := xNewFromResourceGLShader(ResourcePathVar)
	318	+	cret := xNewGLShaderFromResource(ResourcePathVar)
319	319
320	320		if cret == 0 {
321	321		return nil

@@ -578,8 +578,8 @@ func init() {
578	578		core.PuregoSafeRegister(&xShaderArgsBuilderToArgs, lib, "gsk_shader_args_builder_to_args")
579	579		core.PuregoSafeRegister(&xShaderArgsBuilderUnref, lib, "gsk_shader_args_builder_unref")
580	580
581		-	core.PuregoSafeRegister(&xNewFromBytesGLShader, lib, "gsk_gl_shader_new_from_bytes")
582		-	core.PuregoSafeRegister(&xNewFromResourceGLShader, lib, "gsk_gl_shader_new_from_resource")
	581	+	core.PuregoSafeRegister(&xNewGLShaderFromBytes, lib, "gsk_gl_shader_new_from_bytes")
	582	+	core.PuregoSafeRegister(&xNewGLShaderFromResource, lib, "gsk_gl_shader_new_from_resource")
583	583
584	584		core.PuregoSafeRegister(&xGLShaderCompile, lib, "gsk_gl_shader_compile")
585	585		core.PuregoSafeRegister(&xGLShaderFindUniformByName, lib, "gsk_gl_shader_find_uniform_by_name")

M v4/gsk/gskrenderer.go +4 -4


@@ -41,7 +41,7 @@ func RendererNewFromInternalPtr(ptr uintptr) *Renderer {
41	41		return cls
42	42		}
43	43
44		-	var xNewForSurfaceRenderer func(uintptr) uintptr
	44	+	var xNewRendererForSurface func(uintptr) uintptr
45	45
46	46		// Creates an appropriate `GskRenderer` instance for the given @surface.
47	47		//

@@ -50,10 +50,10 @@ var xNewForSurfaceRenderer func(uintptr) uintptr
50	50		// default. The ultimate fallback is the cairo renderer.
51	51		//
52	52		// The renderer will be realized before it is returned.
53		-	func NewForSurfaceRenderer(SurfaceVar gdk.Surface) Renderer {
	53	+	func NewRendererForSurface(SurfaceVar gdk.Surface) Renderer {
54	54		var cls *Renderer
55	55
56		-	cret := xNewForSurfaceRenderer(SurfaceVar.GoPointer())
	56	+	cret := xNewRendererForSurface(SurfaceVar.GoPointer())
57	57
58	58		if cret == 0 {
59	59		return nil

@@ -178,7 +178,7 @@ func init() {
178	178		panic(err)
179	179		}
180	180
181		-	core.PuregoSafeRegister(&xNewForSurfaceRenderer, lib, "gsk_renderer_new_for_surface")
	181	+	core.PuregoSafeRegister(&xNewRendererForSurface, lib, "gsk_renderer_new_for_surface")
182	182
183	183		core.PuregoSafeRegister(&xRendererGetSurface, lib, "gsk_renderer_get_surface")
184	184		core.PuregoSafeRegister(&xRendererIsRealized, lib, "gsk_renderer_is_realized")

M v4/gtk/gtkappchooserdialog.go +4 -4


@@ -51,15 +51,15 @@ func NewAppChooserDialog(ParentVar *Window, FlagsVar DialogFlags, FileVar gio.Fi
51	51		return cls
52	52		}
53	53
54		-	var xNewForContentTypeAppChooserDialog func(uintptr, DialogFlags, string) uintptr
	54	+	var xNewAppChooserDialogForContentType func(uintptr, DialogFlags, string) uintptr
55	55
56	56		// Creates a new `GtkAppChooserDialog` for the provided content type.
57	57		//
58	58		// The dialog will show applications that can open the content type.
59		-	func NewForContentTypeAppChooserDialog(ParentVar Window, FlagsVar DialogFlags, ContentTypeVar string) AppChooserDialog {
	59	+	func NewAppChooserDialogForContentType(ParentVar Window, FlagsVar DialogFlags, ContentTypeVar string) AppChooserDialog {
60	60		var cls *AppChooserDialog
61	61
62		-	cret := xNewForContentTypeAppChooserDialog(ParentVar.GoPointer(), FlagsVar, ContentTypeVar)
	62	+	cret := xNewAppChooserDialogForContentType(ParentVar.GoPointer(), FlagsVar, ContentTypeVar)
63	63
64	64		if cret == 0 {
65	65		return nil

@@ -401,7 +401,7 @@ func init() {
401	401		}
402	402
403	403		core.PuregoSafeRegister(&xNewAppChooserDialog, lib, "gtk_app_chooser_dialog_new")
404		-	core.PuregoSafeRegister(&xNewForContentTypeAppChooserDialog, lib, "gtk_app_chooser_dialog_new_for_content_type")
	404	+	core.PuregoSafeRegister(&xNewAppChooserDialogForContentType, lib, "gtk_app_chooser_dialog_new_for_content_type")
405	405
406	406		core.PuregoSafeRegister(&xAppChooserDialogGetHeading, lib, "gtk_app_chooser_dialog_get_heading")
407	407		core.PuregoSafeRegister(&xAppChooserDialogGetWidget, lib, "gtk_app_chooser_dialog_get_widget")

M v4/gtk/gtkatcontext.go +4 -4


@@ -33,17 +33,17 @@ func ATContextNewFromInternalPtr(ptr uintptr) *ATContext {
33	33		return cls
34	34		}
35	35
36		-	var xCreateATContext func(AccessibleRole, uintptr, uintptr) uintptr
	36	+	var xATContextCreate func(AccessibleRole, uintptr, uintptr) uintptr
37	37
38	38		// Creates a new `GtkATContext` instance for the given accessible role,
39	39		// accessible instance, and display connection.
40	40		//
41	41		// The `GtkATContext` implementation being instantiated will depend on the
42	42		// platform.
43		-	func CreateATContext(AccessibleRoleVar AccessibleRole, AccessibleVar Accessible, DisplayVar gdk.Display) ATContext {
	43	+	func ATContextCreate(AccessibleRoleVar AccessibleRole, AccessibleVar Accessible, DisplayVar gdk.Display) ATContext {
44	44		var cls *ATContext
45	45
46		-	cret := xCreateATContext(AccessibleRoleVar, AccessibleVar.GoPointer(), DisplayVar.GoPointer())
	46	+	cret := xATContextCreate(AccessibleRoleVar, AccessibleVar.GoPointer(), DisplayVar.GoPointer())
47	47
48	48		if cret == 0 {
49	49		return nil

@@ -106,7 +106,7 @@ func init() {
106	106		panic(err)
107	107		}
108	108
109		-	core.PuregoSafeRegister(&xCreateATContext, lib, "gtk_at_context_create")
	109	+	core.PuregoSafeRegister(&xATContextCreate, lib, "gtk_at_context_create")
110	110
111	111		core.PuregoSafeRegister(&xATContextGetAccessible, lib, "gtk_at_context_get_accessible")
112	112		core.PuregoSafeRegister(&xATContextGetAccessibleRole, lib, "gtk_at_context_get_accessible_role")

M v4/gtk/gtkbuilder.go +12 -12


@@ -279,17 +279,17 @@ func NewBuilder() *Builder {
279	279		return cls
280	280		}
281	281
282		-	var xNewFromFileBuilder func(string) uintptr
	282	+	var xNewBuilderFromFile func(string) uintptr
283	283
284	284		// Parses the UI definition in the file @filename.
285	285		//
286	286		// If there is an error opening the file or parsing the description then
287	287		// the program will be aborted. You should only ever attempt to parse
288	288		// user interface descriptions that are shipped as part of your program.
289		-	func NewFromFileBuilder(FilenameVar string) *Builder {
	289	+	func NewBuilderFromFile(FilenameVar string) *Builder {
290	290		var cls *Builder
291	291
292		-	cret := xNewFromFileBuilder(FilenameVar)
	292	+	cret := xNewBuilderFromFile(FilenameVar)
293	293
294	294		if cret == 0 {
295	295		return nil

@@ -299,16 +299,16 @@ func NewFromFileBuilder(FilenameVar string) *Builder {
299	299		return cls
300	300		}
301	301
302		-	var xNewFromResourceBuilder func(string) uintptr
	302	+	var xNewBuilderFromResource func(string) uintptr
303	303
304	304		// Parses the UI definition at @resource_path.
305	305		//
306	306		// If there is an error locating the resource or parsing the
307	307		// description, then the program will be aborted.
308		-	func NewFromResourceBuilder(ResourcePathVar string) *Builder {
	308	+	func NewBuilderFromResource(ResourcePathVar string) *Builder {
309	309		var cls *Builder
310	310
311		-	cret := xNewFromResourceBuilder(ResourcePathVar)
	311	+	cret := xNewBuilderFromResource(ResourcePathVar)
312	312
313	313		if cret == 0 {
314	314		return nil

@@ -318,7 +318,7 @@ func NewFromResourceBuilder(ResourcePathVar string) *Builder {
318	318		return cls
319	319		}
320	320
321		-	var xNewFromStringBuilder func(string, int) uintptr
	321	+	var xNewBuilderFromString func(string, int) uintptr
322	322
323	323		// Parses the UI definition in @string.
324	324		//

@@ -328,10 +328,10 @@ var xNewFromStringBuilder func(string, int) uintptr
328	328		// If there is an error parsing @string then the program will be
329	329		// aborted. You should not attempt to parse user interface description
330	330		// from untrusted sources.
331		-	func NewFromStringBuilder(StringVar string, LengthVar int) *Builder {
	331	+	func NewBuilderFromString(StringVar string, LengthVar int) *Builder {
332	332		var cls *Builder
333	333
334		-	cret := xNewFromStringBuilder(StringVar, LengthVar)
	334	+	cret := xNewBuilderFromString(StringVar, LengthVar)
335	335
336	336		if cret == 0 {
337	337		return nil

@@ -739,9 +739,9 @@ func init() {
739	739		}
740	740
741	741		core.PuregoSafeRegister(&xNewBuilder, lib, "gtk_builder_new")
742		-	core.PuregoSafeRegister(&xNewFromFileBuilder, lib, "gtk_builder_new_from_file")
743		-	core.PuregoSafeRegister(&xNewFromResourceBuilder, lib, "gtk_builder_new_from_resource")
744		-	core.PuregoSafeRegister(&xNewFromStringBuilder, lib, "gtk_builder_new_from_string")
	742	+	core.PuregoSafeRegister(&xNewBuilderFromFile, lib, "gtk_builder_new_from_file")
	743	+	core.PuregoSafeRegister(&xNewBuilderFromResource, lib, "gtk_builder_new_from_resource")
	744	+	core.PuregoSafeRegister(&xNewBuilderFromString, lib, "gtk_builder_new_from_string")
745	745
746	746		core.PuregoSafeRegister(&xBuilderAddFromFile, lib, "gtk_builder_add_from_file")
747	747		core.PuregoSafeRegister(&xBuilderAddFromResource, lib, "gtk_builder_add_from_resource")

M v4/gtk/gtkbuilderlistitemfactory.go +8 -8


@@ -52,14 +52,14 @@ func BuilderListItemFactoryNewFromInternalPtr(ptr uintptr) *BuilderListItemFacto
52	52		return cls
53	53		}
54	54
55		-	var xNewFromBytesBuilderListItemFactory func(uintptr, *glib.Bytes) uintptr
	55	+	var xNewBuilderListItemFactoryFromBytes func(uintptr, *glib.Bytes) uintptr
56	56
57	57		// Creates a new `GtkBuilderListItemFactory` that instantiates widgets
58	58		// using @bytes as the data to pass to `GtkBuilder`.
59		-	func NewFromBytesBuilderListItemFactory(ScopeVar BuilderScope, BytesVar glib.Bytes) BuilderListItemFactory {
	59	+	func NewBuilderListItemFactoryFromBytes(ScopeVar BuilderScope, BytesVar glib.Bytes) BuilderListItemFactory {
60	60		var cls *BuilderListItemFactory
61	61
62		-	cret := xNewFromBytesBuilderListItemFactory(ScopeVar.GoPointer(), BytesVar)
	62	+	cret := xNewBuilderListItemFactoryFromBytes(ScopeVar.GoPointer(), BytesVar)
63	63
64	64		if cret == 0 {
65	65		return nil

@@ -69,14 +69,14 @@ func NewFromBytesBuilderListItemFactory(ScopeVar BuilderScope, BytesVar *glib.By
69	69		return cls
70	70		}
71	71
72		-	var xNewFromResourceBuilderListItemFactory func(uintptr, string) uintptr
	72	+	var xNewBuilderListItemFactoryFromResource func(uintptr, string) uintptr
73	73
74	74		// Creates a new `GtkBuilderListItemFactory` that instantiates widgets
75	75		// using data read from the given @resource_path to pass to `GtkBuilder`.
76		-	func NewFromResourceBuilderListItemFactory(ScopeVar BuilderScope, ResourcePathVar string) *BuilderListItemFactory {
	76	+	func NewBuilderListItemFactoryFromResource(ScopeVar BuilderScope, ResourcePathVar string) *BuilderListItemFactory {
77	77		var cls *BuilderListItemFactory
78	78
79		-	cret := xNewFromResourceBuilderListItemFactory(ScopeVar.GoPointer(), ResourcePathVar)
	79	+	cret := xNewBuilderListItemFactoryFromResource(ScopeVar.GoPointer(), ResourcePathVar)
80	80
81	81		if cret == 0 {
82	82		return nil

@@ -136,8 +136,8 @@ func init() {
136	136		panic(err)
137	137		}
138	138
139		-	core.PuregoSafeRegister(&xNewFromBytesBuilderListItemFactory, lib, "gtk_builder_list_item_factory_new_from_bytes")
140		-	core.PuregoSafeRegister(&xNewFromResourceBuilderListItemFactory, lib, "gtk_builder_list_item_factory_new_from_resource")
	139	+	core.PuregoSafeRegister(&xNewBuilderListItemFactoryFromBytes, lib, "gtk_builder_list_item_factory_new_from_bytes")
	140	+	core.PuregoSafeRegister(&xNewBuilderListItemFactoryFromResource, lib, "gtk_builder_list_item_factory_new_from_resource")
141	141
142	142		core.PuregoSafeRegister(&xBuilderListItemFactoryGetBytes, lib, "gtk_builder_list_item_factory_get_bytes")
143	143		core.PuregoSafeRegister(&xBuilderListItemFactoryGetResource, lib, "gtk_builder_list_item_factory_get_resource")

M v4/gtk/gtkbutton.go +12 -12


@@ -86,17 +86,17 @@ func NewButton() *Button {
86	86		return cls
87	87		}
88	88
89		-	var xNewFromIconNameButton func(string) uintptr
	89	+	var xNewButtonFromIconName func(string) uintptr
90	90
91	91		// Creates a new button containing an icon from the current icon theme.
92	92		//
93	93		// If the icon name isn’t known, a “broken image” icon will be
94	94		// displayed instead. If the current icon theme is changed, the icon
95	95		// will be updated appropriately.
96		-	func NewFromIconNameButton(IconNameVar string) *Button {
	96	+	func NewButtonFromIconName(IconNameVar string) *Button {
97	97		var cls *Button
98	98
99		-	cret := xNewFromIconNameButton(IconNameVar)
	99	+	cret := xNewButtonFromIconName(IconNameVar)
100	100
101	101		if cret == 0 {
102	102		return nil

@@ -107,13 +107,13 @@ func NewFromIconNameButton(IconNameVar string) *Button {
107	107		return cls
108	108		}
109	109
110		-	var xNewWithLabelButton func(string) uintptr
	110	+	var xNewButtonWithLabel func(string) uintptr
111	111
112	112		// Creates a `GtkButton` widget with a `GtkLabel` child.
113		-	func NewWithLabelButton(LabelVar string) *Button {
	113	+	func NewButtonWithLabel(LabelVar string) *Button {
114	114		var cls *Button
115	115
116		-	cret := xNewWithLabelButton(LabelVar)
	116	+	cret := xNewButtonWithLabel(LabelVar)
117	117
118	118		if cret == 0 {
119	119		return nil

@@ -124,7 +124,7 @@ func NewWithLabelButton(LabelVar string) *Button {
124	124		return cls
125	125		}
126	126
127		-	var xNewWithMnemonicButton func(string) uintptr
	127	+	var xNewButtonWithMnemonic func(string) uintptr
128	128
129	129		// Creates a new `GtkButton` containing a label.
130	130		//

@@ -132,10 +132,10 @@ var xNewWithMnemonicButton func(string) uintptr
132	132		// If you need a literal underscore character in a label, use “__” (two
133	133		// underscores). The first underlined character represents a keyboard
134	134		// accelerator called a mnemonic. Pressing Alt and that key activates the button.
135		-	func NewWithMnemonicButton(LabelVar string) *Button {
	135	+	func NewButtonWithMnemonic(LabelVar string) *Button {
136	136		var cls *Button
137	137
138		-	cret := xNewWithMnemonicButton(LabelVar)
	138	+	cret := xNewButtonWithMnemonic(LabelVar)
139	139
140	140		if cret == 0 {
141	141		return nil

@@ -538,9 +538,9 @@ func init() {
538	538		}
539	539
540	540		core.PuregoSafeRegister(&xNewButton, lib, "gtk_button_new")
541		-	core.PuregoSafeRegister(&xNewFromIconNameButton, lib, "gtk_button_new_from_icon_name")
542		-	core.PuregoSafeRegister(&xNewWithLabelButton, lib, "gtk_button_new_with_label")
543		-	core.PuregoSafeRegister(&xNewWithMnemonicButton, lib, "gtk_button_new_with_mnemonic")
	541	+	core.PuregoSafeRegister(&xNewButtonFromIconName, lib, "gtk_button_new_from_icon_name")
	542	+	core.PuregoSafeRegister(&xNewButtonWithLabel, lib, "gtk_button_new_with_label")
	543	+	core.PuregoSafeRegister(&xNewButtonWithMnemonic, lib, "gtk_button_new_with_mnemonic")
544	544
545	545		core.PuregoSafeRegister(&xButtonGetChild, lib, "gtk_button_get_child")
546	546		core.PuregoSafeRegister(&xButtonGetHasFrame, lib, "gtk_button_get_has_frame")

M v4/gtk/gtkcellview.go +16 -16


@@ -55,7 +55,7 @@ func NewCellView() *CellView {
55	55		return cls
56	56		}
57	57
58		-	var xNewWithContextCellView func(uintptr, uintptr) uintptr
	58	+	var xNewCellViewWithContext func(uintptr, uintptr) uintptr
59	59
60	60		// Creates a new `GtkCellView` widget with a specific `GtkCellArea`
61	61		// to layout cells and a specific `GtkCellAreaContext`.

@@ -64,10 +64,10 @@ var xNewWithContextCellView func(uintptr, uintptr) uintptr
64	64		// the underlying area synchronize the geometry for those cells,
65	65		// in this way alignments with cellviews for other rows are
66	66		// possible.
67		-	func NewWithContextCellView(AreaVar CellArea, ContextVar CellAreaContext) *CellView {
	67	+	func NewCellViewWithContext(AreaVar CellArea, ContextVar CellAreaContext) *CellView {
68	68		var cls *CellView
69	69
70		-	cret := xNewWithContextCellView(AreaVar.GoPointer(), ContextVar.GoPointer())
	70	+	cret := xNewCellViewWithContext(AreaVar.GoPointer(), ContextVar.GoPointer())
71	71
72	72		if cret == 0 {
73	73		return nil

@@ -78,15 +78,15 @@ func NewWithContextCellView(AreaVar CellArea, ContextVar CellAreaContext) *Cel
78	78		return cls
79	79		}
80	80
81		-	var xNewWithMarkupCellView func(string) uintptr
	81	+	var xNewCellViewWithMarkup func(string) uintptr
82	82
83	83		// Creates a new `GtkCellView` widget, adds a `GtkCellRendererText`
84	84		// to it, and makes it show @markup. The text can be marked up with
85	85		// the [Pango text markup language](https://docs.gtk.org/Pango/pango_markup.html).
86		-	func NewWithMarkupCellView(MarkupVar string) *CellView {
	86	+	func NewCellViewWithMarkup(MarkupVar string) *CellView {
87	87		var cls *CellView
88	88
89		-	cret := xNewWithMarkupCellView(MarkupVar)
	89	+	cret := xNewCellViewWithMarkup(MarkupVar)
90	90
91	91		if cret == 0 {
92	92		return nil

@@ -97,14 +97,14 @@ func NewWithMarkupCellView(MarkupVar string) *CellView {
97	97		return cls
98	98		}
99	99
100		-	var xNewWithTextCellView func(string) uintptr
	100	+	var xNewCellViewWithText func(string) uintptr
101	101
102	102		// Creates a new `GtkCellView` widget, adds a `GtkCellRendererText`
103	103		// to it, and makes it show @text.
104		-	func NewWithTextCellView(TextVar string) *CellView {
	104	+	func NewCellViewWithText(TextVar string) *CellView {
105	105		var cls *CellView
106	106
107		-	cret := xNewWithTextCellView(TextVar)
	107	+	cret := xNewCellViewWithText(TextVar)
108	108
109	109		if cret == 0 {
110	110		return nil

@@ -115,14 +115,14 @@ func NewWithTextCellView(TextVar string) *CellView {
115	115		return cls
116	116		}
117	117
118		-	var xNewWithTextureCellView func(uintptr) uintptr
	118	+	var xNewCellViewWithTexture func(uintptr) uintptr
119	119
120	120		// Creates a new `GtkCellView` widget, adds a `GtkCellRendererPixbuf`
121	121		// to it, and makes it show @texture.
122		-	func NewWithTextureCellView(TextureVar gdk.Texture) CellView {
	122	+	func NewCellViewWithTexture(TextureVar gdk.Texture) CellView {
123	123		var cls *CellView
124	124
125		-	cret := xNewWithTextureCellView(TextureVar.GoPointer())
	125	+	cret := xNewCellViewWithTexture(TextureVar.GoPointer())
126	126
127	127		if cret == 0 {
128	128		return nil

@@ -516,10 +516,10 @@ func init() {
516	516		}
517	517
518	518		core.PuregoSafeRegister(&xNewCellView, lib, "gtk_cell_view_new")
519		-	core.PuregoSafeRegister(&xNewWithContextCellView, lib, "gtk_cell_view_new_with_context")
520		-	core.PuregoSafeRegister(&xNewWithMarkupCellView, lib, "gtk_cell_view_new_with_markup")
521		-	core.PuregoSafeRegister(&xNewWithTextCellView, lib, "gtk_cell_view_new_with_text")
522		-	core.PuregoSafeRegister(&xNewWithTextureCellView, lib, "gtk_cell_view_new_with_texture")
	519	+	core.PuregoSafeRegister(&xNewCellViewWithContext, lib, "gtk_cell_view_new_with_context")
	520	+	core.PuregoSafeRegister(&xNewCellViewWithMarkup, lib, "gtk_cell_view_new_with_markup")
	521	+	core.PuregoSafeRegister(&xNewCellViewWithText, lib, "gtk_cell_view_new_with_text")
	522	+	core.PuregoSafeRegister(&xNewCellViewWithTexture, lib, "gtk_cell_view_new_with_texture")
523	523
524	524		core.PuregoSafeRegister(&xCellViewGetDisplayedRow, lib, "gtk_cell_view_get_displayed_row")
525	525		core.PuregoSafeRegister(&xCellViewGetDrawSensitive, lib, "gtk_cell_view_get_draw_sensitive")

M v4/gtk/gtkcheckbutton.go +8 -8


@@ -99,13 +99,13 @@ func NewCheckButton() *CheckButton {
99	99		return cls
100	100		}
101	101
102		-	var xNewWithLabelCheckButton func(string) uintptr
	102	+	var xNewCheckButtonWithLabel func(string) uintptr
103	103
104	104		// Creates a new `GtkCheckButton` with the given text.
105		-	func NewWithLabelCheckButton(LabelVar string) *CheckButton {
	105	+	func NewCheckButtonWithLabel(LabelVar string) *CheckButton {
106	106		var cls *CheckButton
107	107
108		-	cret := xNewWithLabelCheckButton(LabelVar)
	108	+	cret := xNewCheckButtonWithLabel(LabelVar)
109	109
110	110		if cret == 0 {
111	111		return nil

@@ -116,13 +116,13 @@ func NewWithLabelCheckButton(LabelVar string) *CheckButton {
116	116		return cls
117	117		}
118	118
119		-	var xNewWithMnemonicCheckButton func(string) uintptr
	119	+	var xNewCheckButtonWithMnemonic func(string) uintptr
120	120
121	121		// Creates a new `GtkCheckButton` with the given text and a mnemonic.
122		-	func NewWithMnemonicCheckButton(LabelVar string) *CheckButton {
	122	+	func NewCheckButtonWithMnemonic(LabelVar string) *CheckButton {
123	123		var cls *CheckButton
124	124
125		-	cret := xNewWithMnemonicCheckButton(LabelVar)
	125	+	cret := xNewCheckButtonWithMnemonic(LabelVar)
126	126
127	127		if cret == 0 {
128	128		return nil

@@ -543,8 +543,8 @@ func init() {
543	543		}
544	544
545	545		core.PuregoSafeRegister(&xNewCheckButton, lib, "gtk_check_button_new")
546		-	core.PuregoSafeRegister(&xNewWithLabelCheckButton, lib, "gtk_check_button_new_with_label")
547		-	core.PuregoSafeRegister(&xNewWithMnemonicCheckButton, lib, "gtk_check_button_new_with_mnemonic")
	546	+	core.PuregoSafeRegister(&xNewCheckButtonWithLabel, lib, "gtk_check_button_new_with_label")
	547	+	core.PuregoSafeRegister(&xNewCheckButtonWithMnemonic, lib, "gtk_check_button_new_with_mnemonic")
548	548
549	549		core.PuregoSafeRegister(&xCheckButtonGetActive, lib, "gtk_check_button_get_active")
550	550		core.PuregoSafeRegister(&xCheckButtonGetChild, lib, "gtk_check_button_get_child")

M v4/gtk/gtkcolorbutton.go +4 -4


@@ -61,13 +61,13 @@ func NewColorButton() *ColorButton {
61	61		return cls
62	62		}
63	63
64		-	var xNewWithRgbaColorButton func(*gdk.RGBA) uintptr
	64	+	var xNewColorButtonWithRgba func(*gdk.RGBA) uintptr
65	65
66	66		// Creates a new color button showing the given color.
67		-	func NewWithRgbaColorButton(RgbaVar gdk.RGBA) ColorButton {
	67	+	func NewColorButtonWithRgba(RgbaVar gdk.RGBA) ColorButton {
68	68		var cls *ColorButton
69	69
70		-	cret := xNewWithRgbaColorButton(RgbaVar)
	70	+	cret := xNewColorButtonWithRgba(RgbaVar)
71	71
72	72		if cret == 0 {
73	73		return nil

@@ -357,7 +357,7 @@ func init() {
357	357		}
358	358
359	359		core.PuregoSafeRegister(&xNewColorButton, lib, "gtk_color_button_new")
360		-	core.PuregoSafeRegister(&xNewWithRgbaColorButton, lib, "gtk_color_button_new_with_rgba")
	360	+	core.PuregoSafeRegister(&xNewColorButtonWithRgba, lib, "gtk_color_button_new_with_rgba")
361	361
362	362		core.PuregoSafeRegister(&xColorButtonGetModal, lib, "gtk_color_button_get_modal")
363	363		core.PuregoSafeRegister(&xColorButtonGetTitle, lib, "gtk_color_button_get_title")

M v4/gtk/gtkcombobox.go +12 -12


@@ -108,17 +108,17 @@ func NewComboBox() *ComboBox {
108	108		return cls
109	109		}
110	110
111		-	var xNewWithEntryComboBox func() uintptr
	111	+	var xNewComboBoxWithEntry func() uintptr
112	112
113	113		// Creates a new empty `GtkComboBox` with an entry.
114	114		//
115	115		// In order to use a combo box with entry, you need to tell it
116	116		// which column of the model contains the text for the entry
117	117		// by calling [method@Gtk.ComboBox.set_entry_text_column].
118		-	func NewWithEntryComboBox() *ComboBox {
	118	+	func NewComboBoxWithEntry() *ComboBox {
119	119		var cls *ComboBox
120	120
121		-	cret := xNewWithEntryComboBox()
	121	+	cret := xNewComboBoxWithEntry()
122	122
123	123		if cret == 0 {
124	124		return nil

@@ -129,13 +129,13 @@ func NewWithEntryComboBox() *ComboBox {
129	129		return cls
130	130		}
131	131
132		-	var xNewWithModelComboBox func(uintptr) uintptr
	132	+	var xNewComboBoxWithModel func(uintptr) uintptr
133	133
134	134		// Creates a new `GtkComboBox` with a model.
135		-	func NewWithModelComboBox(ModelVar TreeModel) *ComboBox {
	135	+	func NewComboBoxWithModel(ModelVar TreeModel) *ComboBox {
136	136		var cls *ComboBox
137	137
138		-	cret := xNewWithModelComboBox(ModelVar.GoPointer())
	138	+	cret := xNewComboBoxWithModel(ModelVar.GoPointer())
139	139
140	140		if cret == 0 {
141	141		return nil

@@ -146,15 +146,15 @@ func NewWithModelComboBox(ModelVar TreeModel) *ComboBox {
146	146		return cls
147	147		}
148	148
149		-	var xNewWithModelAndEntryComboBox func(uintptr) uintptr
	149	+	var xNewComboBoxWithModelAndEntry func(uintptr) uintptr
150	150
151	151		// Creates a new empty `GtkComboBox` with an entry and a model.
152	152		//
153	153		// See also [ctor@Gtk.ComboBox.new_with_entry].
154		-	func NewWithModelAndEntryComboBox(ModelVar TreeModel) *ComboBox {
	154	+	func NewComboBoxWithModelAndEntry(ModelVar TreeModel) *ComboBox {
155	155		var cls *ComboBox
156	156
157		-	cret := xNewWithModelAndEntryComboBox(ModelVar.GoPointer())
	157	+	cret := xNewComboBoxWithModelAndEntry(ModelVar.GoPointer())
158	158
159	159		if cret == 0 {
160	160		return nil

@@ -893,9 +893,9 @@ func init() {
893	893		}
894	894
895	895		core.PuregoSafeRegister(&xNewComboBox, lib, "gtk_combo_box_new")
896		-	core.PuregoSafeRegister(&xNewWithEntryComboBox, lib, "gtk_combo_box_new_with_entry")
897		-	core.PuregoSafeRegister(&xNewWithModelComboBox, lib, "gtk_combo_box_new_with_model")
898		-	core.PuregoSafeRegister(&xNewWithModelAndEntryComboBox, lib, "gtk_combo_box_new_with_model_and_entry")
	896	+	core.PuregoSafeRegister(&xNewComboBoxWithEntry, lib, "gtk_combo_box_new_with_entry")
	897	+	core.PuregoSafeRegister(&xNewComboBoxWithModel, lib, "gtk_combo_box_new_with_model")
	898	+	core.PuregoSafeRegister(&xNewComboBoxWithModelAndEntry, lib, "gtk_combo_box_new_with_model_and_entry")
899	899
900	900		core.PuregoSafeRegister(&xComboBoxGetActive, lib, "gtk_combo_box_get_active")
901	901		core.PuregoSafeRegister(&xComboBoxGetActiveId, lib, "gtk_combo_box_get_active_id")

M v4/gtk/gtkcomboboxtext.go +4 -4


@@ -95,13 +95,13 @@ func NewComboBoxText() *ComboBoxText {
95	95		return cls
96	96		}
97	97
98		-	var xNewWithEntryComboBoxText func() uintptr
	98	+	var xNewComboBoxTextWithEntry func() uintptr
99	99
100	100		// Creates a new `GtkComboBoxText` with an entry.
101		-	func NewWithEntryComboBoxText() *ComboBoxText {
	101	+	func NewComboBoxTextWithEntry() *ComboBoxText {
102	102		var cls *ComboBoxText
103	103
104		-	cret := xNewWithEntryComboBoxText()
	104	+	cret := xNewComboBoxTextWithEntry()
105	105
106	106		if cret == 0 {
107	107		return nil

@@ -524,7 +524,7 @@ func init() {
524	524		}
525	525
526	526		core.PuregoSafeRegister(&xNewComboBoxText, lib, "gtk_combo_box_text_new")
527		-	core.PuregoSafeRegister(&xNewWithEntryComboBoxText, lib, "gtk_combo_box_text_new_with_entry")
	527	+	core.PuregoSafeRegister(&xNewComboBoxTextWithEntry, lib, "gtk_combo_box_text_new_with_entry")
528	528
529	529		core.PuregoSafeRegister(&xComboBoxTextAppend, lib, "gtk_combo_box_text_append")
530	530		core.PuregoSafeRegister(&xComboBoxTextAppendText, lib, "gtk_combo_box_text_append_text")

M v4/gtk/gtkconstraint.go +4 -4


@@ -89,14 +89,14 @@ func NewConstraint(TargetVar ConstraintTarget, TargetAttributeVar ConstraintAttr
89	89		return cls
90	90		}
91	91
92		-	var xNewConstantConstraint func(uintptr, ConstraintAttribute, ConstraintRelation, float64, int) uintptr
	92	+	var xNewConstraintConstant func(uintptr, ConstraintAttribute, ConstraintRelation, float64, int) uintptr
93	93
94	94		// Creates a new constraint representing a relation between a layout
95	95		// attribute on a target and a constant value.
96		-	func NewConstantConstraint(TargetVar ConstraintTarget, TargetAttributeVar ConstraintAttribute, RelationVar ConstraintRelation, ConstantVar float64, StrengthVar int) *Constraint {
	96	+	func NewConstraintConstant(TargetVar ConstraintTarget, TargetAttributeVar ConstraintAttribute, RelationVar ConstraintRelation, ConstantVar float64, StrengthVar int) *Constraint {
97	97		var cls *Constraint
98	98
99		-	cret := xNewConstantConstraint(TargetVar.GoPointer(), TargetAttributeVar, RelationVar, ConstantVar, StrengthVar)
	99	+	cret := xNewConstraintConstant(TargetVar.GoPointer(), TargetAttributeVar, RelationVar, ConstantVar, StrengthVar)
100	100
101	101		if cret == 0 {
102	102		return nil

@@ -248,7 +248,7 @@ func init() {
248	248		}
249	249
250	250		core.PuregoSafeRegister(&xNewConstraint, lib, "gtk_constraint_new")
251		-	core.PuregoSafeRegister(&xNewConstantConstraint, lib, "gtk_constraint_new_constant")
	251	+	core.PuregoSafeRegister(&xNewConstraintConstant, lib, "gtk_constraint_new_constant")
252	252
253	253		core.PuregoSafeRegister(&xConstraintGetConstant, lib, "gtk_constraint_get_constant")
254	254		core.PuregoSafeRegister(&xConstraintGetMultiplier, lib, "gtk_constraint_get_multiplier")

M v4/gtk/gtkdialog.go +4 -4


@@ -224,7 +224,7 @@ func NewDialog() *Dialog {
224	224		return cls
225	225		}
226	226
227		-	var xNewWithButtonsDialog func(string, uintptr, DialogFlags, string, ...interface{}) uintptr
	227	+	var xNewDialogWithButtons func(string, uintptr, DialogFlags, string, ...interface{}) uintptr
228	228
229	229		// Creates a new `GtkDialog` with the given title and transient parent.
230	230		//

@@ -261,10 +261,10 @@ var xNewWithButtonsDialog func(string, uintptr, DialogFlags, string, ...interfac
261	261		// NULL);
262	262		//
263	263		// ```
264		-	func NewWithButtonsDialog(TitleVar string, ParentVar Window, FlagsVar DialogFlags, FirstButtonTextVar string, varArgs ...interface{}) Dialog {
	264	+	func NewDialogWithButtons(TitleVar string, ParentVar Window, FlagsVar DialogFlags, FirstButtonTextVar string, varArgs ...interface{}) Dialog {
265	265		var cls *Dialog
266	266
267		-	cret := xNewWithButtonsDialog(TitleVar, ParentVar.GoPointer(), FlagsVar, FirstButtonTextVar, varArgs...)
	267	+	cret := xNewDialogWithButtons(TitleVar, ParentVar.GoPointer(), FlagsVar, FirstButtonTextVar, varArgs...)
268	268
269	269		if cret == 0 {
270	270		return nil

@@ -725,7 +725,7 @@ func init() {
725	725		}
726	726
727	727		core.PuregoSafeRegister(&xNewDialog, lib, "gtk_dialog_new")
728		-	core.PuregoSafeRegister(&xNewWithButtonsDialog, lib, "gtk_dialog_new_with_buttons")
	728	+	core.PuregoSafeRegister(&xNewDialogWithButtons, lib, "gtk_dialog_new_with_buttons")
729	729
730	730		core.PuregoSafeRegister(&xDialogAddActionWidget, lib, "gtk_dialog_add_action_widget")
731	731		core.PuregoSafeRegister(&xDialogAddButton, lib, "gtk_dialog_add_button")

M v4/gtk/gtkdropdown.go +4 -4


@@ -92,14 +92,14 @@ func NewDropDown(ModelVar gio.ListModel, ExpressionVar Expression) DropDown {
92	92		return cls
93	93		}
94	94
95		-	var xNewFromStringsDropDown func(uintptr) uintptr
	95	+	var xNewDropDownFromStrings func(uintptr) uintptr
96	96
97	97		// Creates a new `GtkDropDown` that is populated with
98	98		// the strings.
99		-	func NewFromStringsDropDown(StringsVar uintptr) *DropDown {
	99	+	func NewDropDownFromStrings(StringsVar uintptr) *DropDown {
100	100		var cls *DropDown
101	101
102		-	cret := xNewFromStringsDropDown(StringsVar)
	102	+	cret := xNewDropDownFromStrings(StringsVar)
103	103
104	104		if cret == 0 {
105	105		return nil

@@ -471,7 +471,7 @@ func init() {
471	471		}
472	472
473	473		core.PuregoSafeRegister(&xNewDropDown, lib, "gtk_drop_down_new")
474		-	core.PuregoSafeRegister(&xNewFromStringsDropDown, lib, "gtk_drop_down_new_from_strings")
	474	+	core.PuregoSafeRegister(&xNewDropDownFromStrings, lib, "gtk_drop_down_new_from_strings")
475	475
476	476		core.PuregoSafeRegister(&xDropDownGetEnableSearch, lib, "gtk_drop_down_get_enable_search")
477	477		core.PuregoSafeRegister(&xDropDownGetExpression, lib, "gtk_drop_down_get_expression")

M v4/gtk/gtkentry.go +4 -4


@@ -154,13 +154,13 @@ func NewEntry() *Entry {
154	154		return cls
155	155		}
156	156
157		-	var xNewWithBufferEntry func(uintptr) uintptr
	157	+	var xNewEntryWithBuffer func(uintptr) uintptr
158	158
159	159		// Creates a new entry with the specified text buffer.
160		-	func NewWithBufferEntry(BufferVar EntryBuffer) Entry {
	160	+	func NewEntryWithBuffer(BufferVar EntryBuffer) Entry {
161	161		var cls *Entry
162	162
163		-	cret := xNewWithBufferEntry(BufferVar.GoPointer())
	163	+	cret := xNewEntryWithBuffer(BufferVar.GoPointer())
164	164
165	165		if cret == 0 {
166	166		return nil

@@ -1357,7 +1357,7 @@ func init() {
1357	1357		}
1358	1358
1359	1359		core.PuregoSafeRegister(&xNewEntry, lib, "gtk_entry_new")
1360		-	core.PuregoSafeRegister(&xNewWithBufferEntry, lib, "gtk_entry_new_with_buffer")
	1360	+	core.PuregoSafeRegister(&xNewEntryWithBuffer, lib, "gtk_entry_new_with_buffer")
1361	1361
1362	1362		core.PuregoSafeRegister(&xEntryGetActivatesDefault, lib, "gtk_entry_get_activates_default")
1363	1363		core.PuregoSafeRegister(&xEntryGetAlignment, lib, "gtk_entry_get_alignment")

M v4/gtk/gtkentrycompletion.go +4 -4


@@ -81,17 +81,17 @@ func NewEntryCompletion() *EntryCompletion {
81	81		return cls
82	82		}
83	83
84		-	var xNewWithAreaEntryCompletion func(uintptr) uintptr
	84	+	var xNewEntryCompletionWithArea func(uintptr) uintptr
85	85
86	86		// Creates a new `GtkEntryCompletion` object using the
87	87		// specified @area.
88	88		//
89	89		// The `GtkCellArea` is used to layout cells in the underlying
90	90		// `GtkTreeViewColumn` for the drop-down menu.
91		-	func NewWithAreaEntryCompletion(AreaVar CellArea) EntryCompletion {
	91	+	func NewEntryCompletionWithArea(AreaVar CellArea) EntryCompletion {
92	92		var cls *EntryCompletion
93	93
94		-	cret := xNewWithAreaEntryCompletion(AreaVar.GoPointer())
	94	+	cret := xNewEntryCompletionWithArea(AreaVar.GoPointer())
95	95
96	96		if cret == 0 {
97	97		return nil

@@ -568,7 +568,7 @@ func init() {
568	568		}
569	569
570	570		core.PuregoSafeRegister(&xNewEntryCompletion, lib, "gtk_entry_completion_new")
571		-	core.PuregoSafeRegister(&xNewWithAreaEntryCompletion, lib, "gtk_entry_completion_new_with_area")
	571	+	core.PuregoSafeRegister(&xNewEntryCompletionWithArea, lib, "gtk_entry_completion_new_with_area")
572	572
573	573		core.PuregoSafeRegister(&xEntryCompletionComplete, lib, "gtk_entry_completion_complete")
574	574		core.PuregoSafeRegister(&xEntryCompletionComputePrefix, lib, "gtk_entry_completion_compute_prefix")

M v4/gtk/gtkexpander.go +4 -4


@@ -133,7 +133,7 @@ func NewExpander(LabelVar string) *Expander {
133	133		return cls
134	134		}
135	135
136		-	var xNewWithMnemonicExpander func(string) uintptr
	136	+	var xNewExpanderWithMnemonic func(string) uintptr
137	137
138	138		// Creates a new expander using @label as the text of the label.
139	139		//

@@ -143,10 +143,10 @@ var xNewWithMnemonicExpander func(string) uintptr
143	143		// a keyboard accelerator called a mnemonic.
144	144		//
145	145		// Pressing Alt and that key activates the button.
146		-	func NewWithMnemonicExpander(LabelVar string) *Expander {
	146	+	func NewExpanderWithMnemonic(LabelVar string) *Expander {
147	147		var cls *Expander
148	148
149		-	cret := xNewWithMnemonicExpander(LabelVar)
	149	+	cret := xNewExpanderWithMnemonic(LabelVar)
150	150
151	151		if cret == 0 {
152	152		return nil

@@ -487,7 +487,7 @@ func init() {
487	487		}
488	488
489	489		core.PuregoSafeRegister(&xNewExpander, lib, "gtk_expander_new")
490		-	core.PuregoSafeRegister(&xNewWithMnemonicExpander, lib, "gtk_expander_new_with_mnemonic")
	490	+	core.PuregoSafeRegister(&xNewExpanderWithMnemonic, lib, "gtk_expander_new_with_mnemonic")
491	491
492	492		core.PuregoSafeRegister(&xExpanderGetChild, lib, "gtk_expander_get_child")
493	493		core.PuregoSafeRegister(&xExpanderGetExpanded, lib, "gtk_expander_get_expanded")

M v4/gtk/gtkexpression.go +8 -8


@@ -251,13 +251,13 @@ func NewConstantExpression(ValueTypeVar []interface{}, varArgs ...interface{}) *
251	251		return cls
252	252		}
253	253
254		-	var xNewForValueConstantExpression func(*gobject.Value) uintptr
	254	+	var xNewConstantExpressionForValue func(*gobject.Value) uintptr
255	255
256	256		// Creates an expression that always evaluates to the given `value`.
257		-	func NewForValueConstantExpression(ValueVar gobject.Value) ConstantExpression {
	257	+	func NewConstantExpressionForValue(ValueVar gobject.Value) ConstantExpression {
258	258		var cls *ConstantExpression
259	259
260		-	cret := xNewForValueConstantExpression(ValueVar)
	260	+	cret := xNewConstantExpressionForValue(ValueVar)
261	261
262	262		if cret == 0 {
263	263		return nil

@@ -665,7 +665,7 @@ func NewPropertyExpression(ThisTypeVar []interface{}, ExpressionVar *Expression,
665	665		return cls
666	666		}
667	667
668		-	var xNewForPspecPropertyExpression func(uintptr, uintptr) uintptr
	668	+	var xNewPropertyExpressionForPspec func(uintptr, uintptr) uintptr
669	669
670	670		// Creates an expression that looks up a property.
671	671		//

@@ -675,10 +675,10 @@ var xNewForPspecPropertyExpression func(uintptr, uintptr) uintptr
675	675		// If the resulting object conforms to `this_type`, its
676	676		// property specified by `pspec` will be queried.
677	677		// Otherwise, this expression's evaluation will fail.
678		-	func NewForPspecPropertyExpression(ExpressionVar Expression, PspecVar gobject.ParamSpec) *PropertyExpression {
	678	+	func NewPropertyExpressionForPspec(ExpressionVar Expression, PspecVar gobject.ParamSpec) *PropertyExpression {
679	679		var cls *PropertyExpression
680	680
681		-	cret := xNewForPspecPropertyExpression(ExpressionVar.GoPointer(), PspecVar.GoPointer())
	681	+	cret := xNewPropertyExpressionForPspec(ExpressionVar.GoPointer(), PspecVar.GoPointer())
682	682
683	683		if cret == 0 {
684	684		return nil

@@ -753,7 +753,7 @@ func init() {
753	753		core.PuregoSafeRegister(&xNewClosureExpression, lib, "gtk_closure_expression_new")
754	754
755	755		core.PuregoSafeRegister(&xNewConstantExpression, lib, "gtk_constant_expression_new")
756		-	core.PuregoSafeRegister(&xNewForValueConstantExpression, lib, "gtk_constant_expression_new_for_value")
	756	+	core.PuregoSafeRegister(&xNewConstantExpressionForValue, lib, "gtk_constant_expression_new_for_value")
757	757
758	758		core.PuregoSafeRegister(&xConstantExpressionGetValue, lib, "gtk_constant_expression_get_value")
759	759

@@ -770,7 +770,7 @@ func init() {
770	770		core.PuregoSafeRegister(&xObjectExpressionGetObject, lib, "gtk_object_expression_get_object")
771	771
772	772		core.PuregoSafeRegister(&xNewPropertyExpression, lib, "gtk_property_expression_new")
773		-	core.PuregoSafeRegister(&xNewForPspecPropertyExpression, lib, "gtk_property_expression_new_for_pspec")
	773	+	core.PuregoSafeRegister(&xNewPropertyExpressionForPspec, lib, "gtk_property_expression_new_for_pspec")
774	774
775	775		core.PuregoSafeRegister(&xPropertyExpressionGetExpression, lib, "gtk_property_expression_get_expression")
776	776		core.PuregoSafeRegister(&xPropertyExpressionGetPspec, lib, "gtk_property_expression_get_pspec")

M v4/gtk/gtkfilefilter.go +4 -4


@@ -94,16 +94,16 @@ func NewFileFilter() *FileFilter {
94	94		return cls
95	95		}
96	96
97		-	var xNewFromGvariantFileFilter func(*glib.Variant) uintptr
	97	+	var xNewFileFilterFromGvariant func(*glib.Variant) uintptr
98	98
99	99		// Deserialize a file filter from a `GVariant`.
100	100		//
101	101		// The variant must be in the format produced by
102	102		// [method@Gtk.FileFilter.to_gvariant].
103		-	func NewFromGvariantFileFilter(VariantVar glib.Variant) FileFilter {
	103	+	func NewFileFilterFromGvariant(VariantVar glib.Variant) FileFilter {
104	104		var cls *FileFilter
105	105
106		-	cret := xNewFromGvariantFileFilter(VariantVar)
	106	+	cret := xNewFileFilterFromGvariant(VariantVar)
107	107
108	108		if cret == 0 {
109	109		return nil

@@ -234,7 +234,7 @@ func init() {
234	234		}
235	235
236	236		core.PuregoSafeRegister(&xNewFileFilter, lib, "gtk_file_filter_new")
237		-	core.PuregoSafeRegister(&xNewFromGvariantFileFilter, lib, "gtk_file_filter_new_from_gvariant")
	237	+	core.PuregoSafeRegister(&xNewFileFilterFromGvariant, lib, "gtk_file_filter_new_from_gvariant")
238	238
239	239		core.PuregoSafeRegister(&xFileFilterAddMimeType, lib, "gtk_file_filter_add_mime_type")
240	240		core.PuregoSafeRegister(&xFileFilterAddPattern, lib, "gtk_file_filter_add_pattern")

M v4/gtk/gtkfontbutton.go +4 -4


@@ -55,13 +55,13 @@ func NewFontButton() *FontButton {
55	55		return cls
56	56		}
57	57
58		-	var xNewWithFontFontButton func(string) uintptr
	58	+	var xNewFontButtonWithFont func(string) uintptr
59	59
60	60		// Creates a new font picker widget showing the given font.
61		-	func NewWithFontFontButton(FontnameVar string) *FontButton {
	61	+	func NewFontButtonWithFont(FontnameVar string) *FontButton {
62	62		var cls *FontButton
63	63
64		-	cret := xNewWithFontFontButton(FontnameVar)
	64	+	cret := xNewFontButtonWithFont(FontnameVar)
65	65
66	66		if cret == 0 {
67	67		return nil

@@ -551,7 +551,7 @@ func init() {
551	551		}
552	552
553	553		core.PuregoSafeRegister(&xNewFontButton, lib, "gtk_font_button_new")
554		-	core.PuregoSafeRegister(&xNewWithFontFontButton, lib, "gtk_font_button_new_with_font")
	554	+	core.PuregoSafeRegister(&xNewFontButtonWithFont, lib, "gtk_font_button_new_with_font")
555	555
556	556		core.PuregoSafeRegister(&xFontButtonGetModal, lib, "gtk_font_button_get_modal")
557	557		core.PuregoSafeRegister(&xFontButtonGetTitle, lib, "gtk_font_button_get_title")

M v4/gtk/gtkicontheme.go +4 -4


@@ -49,15 +49,15 @@ func IconPaintableNewFromInternalPtr(ptr uintptr) *IconPaintable {
49	49		return cls
50	50		}
51	51
52		-	var xNewForFileIconPaintable func(uintptr, int, int) uintptr
	52	+	var xNewIconPaintableForFile func(uintptr, int, int) uintptr
53	53
54	54		// Creates a `GtkIconPaintable` for a file with a given size and scale.
55	55		//
56	56		// The icon can then be rendered by using it as a `GdkPaintable`.
57		-	func NewForFileIconPaintable(FileVar gio.File, SizeVar int, ScaleVar int) *IconPaintable {
	57	+	func NewIconPaintableForFile(FileVar gio.File, SizeVar int, ScaleVar int) *IconPaintable {
58	58		var cls *IconPaintable
59	59
60		-	cret := xNewForFileIconPaintable(FileVar.GoPointer(), SizeVar, ScaleVar)
	60	+	cret := xNewIconPaintableForFile(FileVar.GoPointer(), SizeVar, ScaleVar)
61	61
62	62		if cret == 0 {
63	63		return nil

@@ -622,7 +622,7 @@ func init() {
622	622		panic(err)
623	623		}
624	624
625		-	core.PuregoSafeRegister(&xNewForFileIconPaintable, lib, "gtk_icon_paintable_new_for_file")
	625	+	core.PuregoSafeRegister(&xNewIconPaintableForFile, lib, "gtk_icon_paintable_new_for_file")
626	626
627	627		core.PuregoSafeRegister(&xIconPaintableGetFile, lib, "gtk_icon_paintable_get_file")
628	628		core.PuregoSafeRegister(&xIconPaintableGetIconName, lib, "gtk_icon_paintable_get_icon_name")

M v4/gtk/gtkiconview.go +8 -8


@@ -84,14 +84,14 @@ func NewIconView() *IconView {
84	84		return cls
85	85		}
86	86
87		-	var xNewWithAreaIconView func(uintptr) uintptr
	87	+	var xNewIconViewWithArea func(uintptr) uintptr
88	88
89	89		// Creates a new `GtkIconView` widget using the
90	90		// specified @area to layout cells inside the icons.
91		-	func NewWithAreaIconView(AreaVar CellArea) IconView {
	91	+	func NewIconViewWithArea(AreaVar CellArea) IconView {
92	92		var cls *IconView
93	93
94		-	cret := xNewWithAreaIconView(AreaVar.GoPointer())
	94	+	cret := xNewIconViewWithArea(AreaVar.GoPointer())
95	95
96	96		if cret == 0 {
97	97		return nil

@@ -102,13 +102,13 @@ func NewWithAreaIconView(AreaVar CellArea) IconView {
102	102		return cls
103	103		}
104	104
105		-	var xNewWithModelIconView func(uintptr) uintptr
	105	+	var xNewIconViewWithModel func(uintptr) uintptr
106	106
107	107		// Creates a new `GtkIconView` widget with the model @model.
108		-	func NewWithModelIconView(ModelVar TreeModel) *IconView {
	108	+	func NewIconViewWithModel(ModelVar TreeModel) *IconView {
109	109		var cls *IconView
110	110
111		-	cret := xNewWithModelIconView(ModelVar.GoPointer())
	111	+	cret := xNewIconViewWithModel(ModelVar.GoPointer())
112	112
113	113		if cret == 0 {
114	114		return nil

@@ -1305,8 +1305,8 @@ func init() {
1305	1305		}
1306	1306
1307	1307		core.PuregoSafeRegister(&xNewIconView, lib, "gtk_icon_view_new")
1308		-	core.PuregoSafeRegister(&xNewWithAreaIconView, lib, "gtk_icon_view_new_with_area")
1309		-	core.PuregoSafeRegister(&xNewWithModelIconView, lib, "gtk_icon_view_new_with_model")
	1308	+	core.PuregoSafeRegister(&xNewIconViewWithArea, lib, "gtk_icon_view_new_with_area")
	1309	+	core.PuregoSafeRegister(&xNewIconViewWithModel, lib, "gtk_icon_view_new_with_model")
1310	1310
1311	1311		core.PuregoSafeRegister(&xIconViewCreateDragIcon, lib, "gtk_icon_view_create_drag_icon")
1312	1312		core.PuregoSafeRegister(&xIconViewEnableModelDragDest, lib, "gtk_icon_view_enable_model_drag_dest")

M v4/gtk/gtkimage.go +24 -24


@@ -98,7 +98,7 @@ func NewImage() *Image {
98	98		return cls
99	99		}
100	100
101		-	var xNewFromFileImage func(string) uintptr
	101	+	var xNewImageFromFile func(string) uintptr
102	102
103	103		// Creates a new `GtkImage` displaying the file @filename.
104	104		//

@@ -113,10 +113,10 @@ var xNewFromFileImage func(string) uintptr
113	113		// The storage type (see [method@Gtk.Image.get_storage_type])
114	114		// of the returned image is not defined, it will be whatever
115	115		// is appropriate for displaying the file.
116		-	func NewFromFileImage(FilenameVar string) *Image {
	116	+	func NewImageFromFile(FilenameVar string) *Image {
117	117		var cls *Image
118	118
119		-	cret := xNewFromFileImage(FilenameVar)
	119	+	cret := xNewImageFromFile(FilenameVar)
120	120
121	121		if cret == 0 {
122	122		return nil

@@ -127,17 +127,17 @@ func NewFromFileImage(FilenameVar string) *Image {
127	127		return cls
128	128		}
129	129
130		-	var xNewFromGiconImage func(uintptr) uintptr
	130	+	var xNewImageFromGicon func(uintptr) uintptr
131	131
132	132		// Creates a `GtkImage` displaying an icon from the current icon theme.
133	133		//
134	134		// If the icon name isn’t known, a “broken image” icon will be
135	135		// displayed instead. If the current icon theme is changed, the icon
136	136		// will be updated appropriately.
137		-	func NewFromGiconImage(IconVar gio.Icon) *Image {
	137	+	func NewImageFromGicon(IconVar gio.Icon) *Image {
138	138		var cls *Image
139	139
140		-	cret := xNewFromGiconImage(IconVar.GoPointer())
	140	+	cret := xNewImageFromGicon(IconVar.GoPointer())
141	141
142	142		if cret == 0 {
143	143		return nil

@@ -148,17 +148,17 @@ func NewFromGiconImage(IconVar gio.Icon) *Image {
148	148		return cls
149	149		}
150	150
151		-	var xNewFromIconNameImage func(string) uintptr
	151	+	var xNewImageFromIconName func(string) uintptr
152	152
153	153		// Creates a `GtkImage` displaying an icon from the current icon theme.
154	154		//
155	155		// If the icon name isn’t known, a “broken image” icon will be
156	156		// displayed instead. If the current icon theme is changed, the icon
157	157		// will be updated appropriately.
158		-	func NewFromIconNameImage(IconNameVar string) *Image {
	158	+	func NewImageFromIconName(IconNameVar string) *Image {
159	159		var cls *Image
160	160
161		-	cret := xNewFromIconNameImage(IconNameVar)
	161	+	cret := xNewImageFromIconName(IconNameVar)
162	162
163	163		if cret == 0 {
164	164		return nil

@@ -169,7 +169,7 @@ func NewFromIconNameImage(IconNameVar string) *Image {
169	169		return cls
170	170		}
171	171
172		-	var xNewFromPaintableImage func(uintptr) uintptr
	172	+	var xNewImageFromPaintable func(uintptr) uintptr
173	173
174	174		// Creates a new `GtkImage` displaying @paintable.
175	175		//

@@ -179,10 +179,10 @@ var xNewFromPaintableImage func(uintptr) uintptr
179	179		//
180	180		// The `GtkImage` will track changes to the @paintable and update
181	181		// its size and contents in response to it.
182		-	func NewFromPaintableImage(PaintableVar gdk.Paintable) *Image {
	182	+	func NewImageFromPaintable(PaintableVar gdk.Paintable) *Image {
183	183		var cls *Image
184	184
185		-	cret := xNewFromPaintableImage(PaintableVar.GoPointer())
	185	+	cret := xNewImageFromPaintable(PaintableVar.GoPointer())
186	186
187	187		if cret == 0 {
188	188		return nil

@@ -193,7 +193,7 @@ func NewFromPaintableImage(PaintableVar gdk.Paintable) *Image {
193	193		return cls
194	194		}
195	195
196		-	var xNewFromPixbufImage func(uintptr) uintptr
	196	+	var xNewImageFromPixbuf func(uintptr) uintptr
197	197
198	198		// Creates a new `GtkImage` displaying @pixbuf.
199	199		//

@@ -207,10 +207,10 @@ var xNewFromPixbufImage func(uintptr) uintptr
207	207		// Note that this function just creates an `GtkImage` from the pixbuf.
208	208		// The `GtkImage` created will not react to state changes. Should you
209	209		// want that, you should use [ctor@Gtk.Image.new_from_icon_name].
210		-	func NewFromPixbufImage(PixbufVar gdkpixbuf.Pixbuf) Image {
	210	+	func NewImageFromPixbuf(PixbufVar gdkpixbuf.Pixbuf) Image {
211	211		var cls *Image
212	212
213		-	cret := xNewFromPixbufImage(PixbufVar.GoPointer())
	213	+	cret := xNewImageFromPixbuf(PixbufVar.GoPointer())
214	214
215	215		if cret == 0 {
216	216		return nil

@@ -221,7 +221,7 @@ func NewFromPixbufImage(PixbufVar gdkpixbuf.Pixbuf) Image {
221	221		return cls
222	222		}
223	223
224		-	var xNewFromResourceImage func(string) uintptr
	224	+	var xNewImageFromResource func(string) uintptr
225	225
226	226		// Creates a new `GtkImage` displaying the resource file @resource_path.
227	227		//

@@ -236,10 +236,10 @@ var xNewFromResourceImage func(string) uintptr
236	236		// The storage type (see [method@Gtk.Image.get_storage_type]) of
237	237		// the returned image is not defined, it will be whatever is
238	238		// appropriate for displaying the file.
239		-	func NewFromResourceImage(ResourcePathVar string) *Image {
	239	+	func NewImageFromResource(ResourcePathVar string) *Image {
240	240		var cls *Image
241	241
242		-	cret := xNewFromResourceImage(ResourcePathVar)
	242	+	cret := xNewImageFromResource(ResourcePathVar)
243	243
244	244		if cret == 0 {
245	245		return nil

@@ -597,12 +597,12 @@ func init() {
597	597		}
598	598
599	599		core.PuregoSafeRegister(&xNewImage, lib, "gtk_image_new")
600		-	core.PuregoSafeRegister(&xNewFromFileImage, lib, "gtk_image_new_from_file")
601		-	core.PuregoSafeRegister(&xNewFromGiconImage, lib, "gtk_image_new_from_gicon")
602		-	core.PuregoSafeRegister(&xNewFromIconNameImage, lib, "gtk_image_new_from_icon_name")
603		-	core.PuregoSafeRegister(&xNewFromPaintableImage, lib, "gtk_image_new_from_paintable")
604		-	core.PuregoSafeRegister(&xNewFromPixbufImage, lib, "gtk_image_new_from_pixbuf")
605		-	core.PuregoSafeRegister(&xNewFromResourceImage, lib, "gtk_image_new_from_resource")
	600	+	core.PuregoSafeRegister(&xNewImageFromFile, lib, "gtk_image_new_from_file")
	601	+	core.PuregoSafeRegister(&xNewImageFromGicon, lib, "gtk_image_new_from_gicon")
	602	+	core.PuregoSafeRegister(&xNewImageFromIconName, lib, "gtk_image_new_from_icon_name")
	603	+	core.PuregoSafeRegister(&xNewImageFromPaintable, lib, "gtk_image_new_from_paintable")
	604	+	core.PuregoSafeRegister(&xNewImageFromPixbuf, lib, "gtk_image_new_from_pixbuf")
	605	+	core.PuregoSafeRegister(&xNewImageFromResource, lib, "gtk_image_new_from_resource")
606	606
607	607		core.PuregoSafeRegister(&xImageClear, lib, "gtk_image_clear")
608	608		core.PuregoSafeRegister(&xImageGetGicon, lib, "gtk_image_get_gicon")

M v4/gtk/gtkinfobar.go +4 -4


@@ -112,7 +112,7 @@ func NewInfoBar() *InfoBar {
112	112		return cls
113	113		}
114	114
115		-	var xNewWithButtonsInfoBar func(string, ...interface{}) uintptr
	115	+	var xNewInfoBarWithButtons func(string, ...interface{}) uintptr
116	116
117	117		// Creates a new `GtkInfoBar` with buttons.
118	118		//

@@ -122,10 +122,10 @@ var xNewWithButtonsInfoBar func(string, ...interface{}) uintptr
122	122		// user clicks one of these dialog buttons, GtkInfoBar will emit
123	123		// the [signal@Gtk.InfoBar::response] signal with the corresponding
124	124		// response ID.
125		-	func NewWithButtonsInfoBar(FirstButtonTextVar string, varArgs ...interface{}) *InfoBar {
	125	+	func NewInfoBarWithButtons(FirstButtonTextVar string, varArgs ...interface{}) *InfoBar {
126	126		var cls *InfoBar
127	127
128		-	cret := xNewWithButtonsInfoBar(FirstButtonTextVar, varArgs...)
	128	+	cret := xNewInfoBarWithButtons(FirstButtonTextVar, varArgs...)
129	129
130	130		if cret == 0 {
131	131		return nil

@@ -508,7 +508,7 @@ func init() {
508	508		}
509	509
510	510		core.PuregoSafeRegister(&xNewInfoBar, lib, "gtk_info_bar_new")
511		-	core.PuregoSafeRegister(&xNewWithButtonsInfoBar, lib, "gtk_info_bar_new_with_buttons")
	511	+	core.PuregoSafeRegister(&xNewInfoBarWithButtons, lib, "gtk_info_bar_new_with_buttons")
512	512
513	513		core.PuregoSafeRegister(&xInfoBarAddActionWidget, lib, "gtk_info_bar_add_action_widget")
514	514		core.PuregoSafeRegister(&xInfoBarAddButton, lib, "gtk_info_bar_add_button")

M v4/gtk/gtklabel.go +4 -4


@@ -219,7 +219,7 @@ func NewLabel(StrVar string) *Label {
219	219		return cls
220	220		}
221	221
222		-	var xNewWithMnemonicLabel func(string) uintptr
	222	+	var xNewLabelWithMnemonic func(string) uintptr
223	223
224	224		// Creates a new `GtkLabel`, containing the text in @str.
225	225		//

@@ -235,10 +235,10 @@ var xNewWithMnemonicLabel func(string) uintptr
235	235		// widget. For instance, if the label is inside a button or menu item,
236	236		// the button or menu item will automatically become the mnemonic widget
237	237		// and be activated by the mnemonic.
238		-	func NewWithMnemonicLabel(StrVar string) *Label {
	238	+	func NewLabelWithMnemonic(StrVar string) *Label {
239	239		var cls *Label
240	240
241		-	cret := xNewWithMnemonicLabel(StrVar)
	241	+	cret := xNewLabelWithMnemonic(StrVar)
242	242
243	243		if cret == 0 {
244	244		return nil

@@ -1145,7 +1145,7 @@ func init() {
1145	1145		}
1146	1146
1147	1147		core.PuregoSafeRegister(&xNewLabel, lib, "gtk_label_new")
1148		-	core.PuregoSafeRegister(&xNewWithMnemonicLabel, lib, "gtk_label_new_with_mnemonic")
	1148	+	core.PuregoSafeRegister(&xNewLabelWithMnemonic, lib, "gtk_label_new_with_mnemonic")
1149	1149
1150	1150		core.PuregoSafeRegister(&xLabelGetAttributes, lib, "gtk_label_get_attributes")
1151	1151		core.PuregoSafeRegister(&xLabelGetCurrentUri, lib, "gtk_label_get_current_uri")

M v4/gtk/gtklevelbar.go +4 -4


@@ -144,13 +144,13 @@ func NewLevelBar() *LevelBar {
144	144		return cls
145	145		}
146	146
147		-	var xNewForIntervalLevelBar func(float64, float64) uintptr
	147	+	var xNewLevelBarForInterval func(float64, float64) uintptr
148	148
149	149		// Creates a new `GtkLevelBar` for the specified interval.
150		-	func NewForIntervalLevelBar(MinValueVar float64, MaxValueVar float64) *LevelBar {
	150	+	func NewLevelBarForInterval(MinValueVar float64, MaxValueVar float64) *LevelBar {
151	151		var cls *LevelBar
152	152
153		-	cret := xNewForIntervalLevelBar(MinValueVar, MaxValueVar)
	153	+	cret := xNewLevelBarForInterval(MinValueVar, MaxValueVar)
154	154
155	155		if cret == 0 {
156	156		return nil

@@ -486,7 +486,7 @@ func init() {
486	486		}
487	487
488	488		core.PuregoSafeRegister(&xNewLevelBar, lib, "gtk_level_bar_new")
489		-	core.PuregoSafeRegister(&xNewForIntervalLevelBar, lib, "gtk_level_bar_new_for_interval")
	489	+	core.PuregoSafeRegister(&xNewLevelBarForInterval, lib, "gtk_level_bar_new_for_interval")
490	490
491	491		core.PuregoSafeRegister(&xLevelBarAddOffsetValue, lib, "gtk_level_bar_add_offset_value")
492	492		core.PuregoSafeRegister(&xLevelBarGetInverted, lib, "gtk_level_bar_get_inverted")

M v4/gtk/gtklinkbutton.go +4 -4


@@ -61,13 +61,13 @@ func NewLinkButton(UriVar string) *LinkButton {
61	61		return cls
62	62		}
63	63
64		-	var xNewWithLabelLinkButton func(string, string) uintptr
	64	+	var xNewLinkButtonWithLabel func(string, string) uintptr
65	65
66	66		// Creates a new `GtkLinkButton` containing a label.
67		-	func NewWithLabelLinkButton(UriVar string, LabelVar string) *LinkButton {
	67	+	func NewLinkButtonWithLabel(UriVar string, LabelVar string) *LinkButton {
68	68		var cls *LinkButton
69	69
70		-	cret := xNewWithLabelLinkButton(UriVar, LabelVar)
	70	+	cret := xNewLinkButtonWithLabel(UriVar, LabelVar)
71	71
72	72		if cret == 0 {
73	73		return nil

@@ -383,7 +383,7 @@ func init() {
383	383		}
384	384
385	385		core.PuregoSafeRegister(&xNewLinkButton, lib, "gtk_link_button_new")
386		-	core.PuregoSafeRegister(&xNewWithLabelLinkButton, lib, "gtk_link_button_new_with_label")
	386	+	core.PuregoSafeRegister(&xNewLinkButtonWithLabel, lib, "gtk_link_button_new_with_label")
387	387
388	388		core.PuregoSafeRegister(&xLinkButtonGetUri, lib, "gtk_link_button_get_uri")
389	389		core.PuregoSafeRegister(&xLinkButtonGetVisited, lib, "gtk_link_button_get_visited")

M v4/gtk/gtkliststore.go +4 -4


@@ -203,13 +203,13 @@ func NewListStore(NColumnsVar int, varArgs ...interface{}) *ListStore {
203	203		return cls
204	204		}
205	205
206		-	var xNewvListStore func(int, uintptr) uintptr
	206	+	var xNewListStorev func(int, uintptr) uintptr
207	207
208	208		// Non-vararg creation function. Used primarily by language bindings.
209		-	func NewvListStore(NColumnsVar int, TypesVar uintptr) *ListStore {
	209	+	func NewListStorev(NColumnsVar int, TypesVar uintptr) *ListStore {
210	210		var cls *ListStore
211	211
212		-	cret := xNewvListStore(NColumnsVar, TypesVar)
	212	+	cret := xNewListStorev(NColumnsVar, TypesVar)
213	213
214	214		if cret == 0 {
215	215		return nil

@@ -944,7 +944,7 @@ func init() {
944	944		}
945	945
946	946		core.PuregoSafeRegister(&xNewListStore, lib, "gtk_list_store_new")
947		-	core.PuregoSafeRegister(&xNewvListStore, lib, "gtk_list_store_newv")
	947	+	core.PuregoSafeRegister(&xNewListStorev, lib, "gtk_list_store_newv")
948	948
949	949		core.PuregoSafeRegister(&xListStoreAppend, lib, "gtk_list_store_append")
950	950		core.PuregoSafeRegister(&xListStoreClear, lib, "gtk_list_store_clear")

M v4/gtk/gtkmediafile.go +16 -16


@@ -57,13 +57,13 @@ func NewMediaFile() *MediaFile {
57	57		return cls
58	58		}
59	59
60		-	var xNewForFileMediaFile func(uintptr) uintptr
	60	+	var xNewMediaFileForFile func(uintptr) uintptr
61	61
62	62		// Creates a new media file to play @file.
63		-	func NewForFileMediaFile(FileVar gio.File) *MediaFile {
	63	+	func NewMediaFileForFile(FileVar gio.File) *MediaFile {
64	64		var cls *MediaFile
65	65
66		-	cret := xNewForFileMediaFile(FileVar.GoPointer())
	66	+	cret := xNewMediaFileForFile(FileVar.GoPointer())
67	67
68	68		if cret == 0 {
69	69		return nil

@@ -73,16 +73,16 @@ func NewForFileMediaFile(FileVar gio.File) *MediaFile {
73	73		return cls
74	74		}
75	75
76		-	var xNewForFilenameMediaFile func(string) uintptr
	76	+	var xNewMediaFileForFilename func(string) uintptr
77	77
78	78		// Creates a new media file for the given filename.
79	79		//
80	80		// This is a utility function that converts the given @filename
81	81		// to a `GFile` and calls [ctor@Gtk.MediaFile.new_for_file].
82		-	func NewForFilenameMediaFile(FilenameVar string) *MediaFile {
	82	+	func NewMediaFileForFilename(FilenameVar string) *MediaFile {
83	83		var cls *MediaFile
84	84
85		-	cret := xNewForFilenameMediaFile(FilenameVar)
	85	+	cret := xNewMediaFileForFilename(FilenameVar)
86	86
87	87		if cret == 0 {
88	88		return nil

@@ -92,16 +92,16 @@ func NewForFilenameMediaFile(FilenameVar string) *MediaFile {
92	92		return cls
93	93		}
94	94
95		-	var xNewForInputStreamMediaFile func(uintptr) uintptr
	95	+	var xNewMediaFileForInputStream func(uintptr) uintptr
96	96
97	97		// Creates a new media file to play @stream.
98	98		//
99	99		// If you want the resulting media to be seekable,
100	100		// the stream should implement the `GSeekable` interface.
101		-	func NewForInputStreamMediaFile(StreamVar gio.InputStream) MediaFile {
	101	+	func NewMediaFileForInputStream(StreamVar gio.InputStream) MediaFile {
102	102		var cls *MediaFile
103	103
104		-	cret := xNewForInputStreamMediaFile(StreamVar.GoPointer())
	104	+	cret := xNewMediaFileForInputStream(StreamVar.GoPointer())
105	105
106	106		if cret == 0 {
107	107		return nil

@@ -111,16 +111,16 @@ func NewForInputStreamMediaFile(StreamVar gio.InputStream) MediaFile {
111	111		return cls
112	112		}
113	113
114		-	var xNewForResourceMediaFile func(string) uintptr
	114	+	var xNewMediaFileForResource func(string) uintptr
115	115
116	116		// Creates a new new media file for the given resource.
117	117		//
118	118		// This is a utility function that converts the given @resource
119	119		// to a `GFile` and calls [ctor@Gtk.MediaFile.new_for_file].
120		-	func NewForResourceMediaFile(ResourcePathVar string) *MediaFile {
	120	+	func NewMediaFileForResource(ResourcePathVar string) *MediaFile {
121	121		var cls *MediaFile
122	122
123		-	cret := xNewForResourceMediaFile(ResourcePathVar)
	123	+	cret := xNewMediaFileForResource(ResourcePathVar)
124	124
125	125		if cret == 0 {
126	126		return nil

@@ -387,10 +387,10 @@ func init() {
387	387		}
388	388
389	389		core.PuregoSafeRegister(&xNewMediaFile, lib, "gtk_media_file_new")
390		-	core.PuregoSafeRegister(&xNewForFileMediaFile, lib, "gtk_media_file_new_for_file")
391		-	core.PuregoSafeRegister(&xNewForFilenameMediaFile, lib, "gtk_media_file_new_for_filename")
392		-	core.PuregoSafeRegister(&xNewForInputStreamMediaFile, lib, "gtk_media_file_new_for_input_stream")
393		-	core.PuregoSafeRegister(&xNewForResourceMediaFile, lib, "gtk_media_file_new_for_resource")
	390	+	core.PuregoSafeRegister(&xNewMediaFileForFile, lib, "gtk_media_file_new_for_file")
	391	+	core.PuregoSafeRegister(&xNewMediaFileForFilename, lib, "gtk_media_file_new_for_filename")
	392	+	core.PuregoSafeRegister(&xNewMediaFileForInputStream, lib, "gtk_media_file_new_for_input_stream")
	393	+	core.PuregoSafeRegister(&xNewMediaFileForResource, lib, "gtk_media_file_new_for_resource")
394	394
395	395		core.PuregoSafeRegister(&xMediaFileClear, lib, "gtk_media_file_clear")
396	396		core.PuregoSafeRegister(&xMediaFileGetFile, lib, "gtk_media_file_get_file")

M v4/gtk/gtkmessagedialog.go +4 -4


@@ -139,7 +139,7 @@ func NewMessageDialog(ParentVar *Window, FlagsVar DialogFlags, TypeVar MessageTy
139	139		return cls
140	140		}
141	141
142		-	var xNewWithMarkupMessageDialog func(uintptr, DialogFlags, MessageType, ButtonsType, string, ...interface{}) uintptr
	142	+	var xNewMessageDialogWithMarkup func(uintptr, DialogFlags, MessageType, ButtonsType, string, ...interface{}) uintptr
143	143
144	144		// Creates a new message dialog.
145	145		//

@@ -173,10 +173,10 @@ var xNewWithMarkupMessageDialog func(uintptr, DialogFlags, MessageType, ButtonsT
173	173		// markup);
174	174		//
175	175		// ```
176		-	func NewWithMarkupMessageDialog(ParentVar Window, FlagsVar DialogFlags, TypeVar MessageType, ButtonsVar ButtonsType, MessageFormatVar string, varArgs ...interface{}) MessageDialog {
	176	+	func NewMessageDialogWithMarkup(ParentVar Window, FlagsVar DialogFlags, TypeVar MessageType, ButtonsVar ButtonsType, MessageFormatVar string, varArgs ...interface{}) MessageDialog {
177	177		var cls *MessageDialog
178	178
179		-	cret := xNewWithMarkupMessageDialog(ParentVar.GoPointer(), FlagsVar, TypeVar, ButtonsVar, MessageFormatVar, varArgs...)
	179	+	cret := xNewMessageDialogWithMarkup(ParentVar.GoPointer(), FlagsVar, TypeVar, ButtonsVar, MessageFormatVar, varArgs...)
180	180
181	181		if cret == 0 {
182	182		return nil

@@ -519,7 +519,7 @@ func init() {
519	519		}
520	520
521	521		core.PuregoSafeRegister(&xNewMessageDialog, lib, "gtk_message_dialog_new")
522		-	core.PuregoSafeRegister(&xNewWithMarkupMessageDialog, lib, "gtk_message_dialog_new_with_markup")
	522	+	core.PuregoSafeRegister(&xNewMessageDialogWithMarkup, lib, "gtk_message_dialog_new_with_markup")
523	523
524	524		core.PuregoSafeRegister(&xMessageDialogFormatSecondaryMarkup, lib, "gtk_message_dialog_format_secondary_markup")
525	525		core.PuregoSafeRegister(&xMessageDialogFormatSecondaryText, lib, "gtk_message_dialog_format_secondary_text")

M v4/gtk/gtkpagesetup.go +12 -12


@@ -78,18 +78,18 @@ func NewPageSetup() *PageSetup {
78	78		return cls
79	79		}
80	80
81		-	var xNewFromFilePageSetup func(string, **glib.Error) uintptr
	81	+	var xNewPageSetupFromFile func(string, **glib.Error) uintptr
82	82
83	83		// Reads the page setup from the file @file_name.
84	84		//
85	85		// Returns a new `GtkPageSetup` object with the restored
86	86		// page setup, or %NULL if an error occurred.
87	87		// See [method@Gtk.PageSetup.to_file].
88		-	func NewFromFilePageSetup(FileNameVar string) (*PageSetup, error) {
	88	+	func NewPageSetupFromFile(FileNameVar string) (*PageSetup, error) {
89	89		var cls *PageSetup
90	90		var cerr *glib.Error
91	91
92		-	cret := xNewFromFilePageSetup(FileNameVar, &cerr)
	92	+	cret := xNewPageSetupFromFile(FileNameVar, &cerr)
93	93
94	94		if cret == 0 {
95	95		return nil, cerr

@@ -103,16 +103,16 @@ func NewFromFilePageSetup(FileNameVar string) (*PageSetup, error) {
103	103
104	104		}
105	105
106		-	var xNewFromGvariantPageSetup func(*glib.Variant) uintptr
	106	+	var xNewPageSetupFromGvariant func(*glib.Variant) uintptr
107	107
108	108		// Desrialize a page setup from an a{sv} variant.
109	109		//
110	110		// The variant must be in the format produced by
111	111		// [method@Gtk.PageSetup.to_gvariant].
112		-	func NewFromGvariantPageSetup(VariantVar glib.Variant) PageSetup {
	112	+	func NewPageSetupFromGvariant(VariantVar glib.Variant) PageSetup {
113	113		var cls *PageSetup
114	114
115		-	cret := xNewFromGvariantPageSetup(VariantVar)
	115	+	cret := xNewPageSetupFromGvariant(VariantVar)
116	116
117	117		if cret == 0 {
118	118		return nil

@@ -122,18 +122,18 @@ func NewFromGvariantPageSetup(VariantVar glib.Variant) PageSetup {
122	122		return cls
123	123		}
124	124
125		-	var xNewFromKeyFilePageSetup func(glib.KeyFile, string, *glib.Error) uintptr
	125	+	var xNewPageSetupFromKeyFile func(glib.KeyFile, string, *glib.Error) uintptr
126	126
127	127		// Reads the page setup from the group @group_name in the key file
128	128		// @key_file.
129	129		//
130	130		// Returns a new `GtkPageSetup` object with the restored
131	131		// page setup, or %NULL if an error occurred.
132		-	func NewFromKeyFilePageSetup(KeyFileVar glib.KeyFile, GroupNameVar string) (PageSetup, error) {
	132	+	func NewPageSetupFromKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) (PageSetup, error) {
133	133		var cls *PageSetup
134	134		var cerr *glib.Error
135	135
136		-	cret := xNewFromKeyFilePageSetup(KeyFileVar, GroupNameVar, &cerr)
	136	+	cret := xNewPageSetupFromKeyFile(KeyFileVar, GroupNameVar, &cerr)
137	137
138	138		if cret == 0 {
139	139		return nil, cerr

@@ -414,9 +414,9 @@ func init() {
414	414		}
415	415
416	416		core.PuregoSafeRegister(&xNewPageSetup, lib, "gtk_page_setup_new")
417		-	core.PuregoSafeRegister(&xNewFromFilePageSetup, lib, "gtk_page_setup_new_from_file")
418		-	core.PuregoSafeRegister(&xNewFromGvariantPageSetup, lib, "gtk_page_setup_new_from_gvariant")
419		-	core.PuregoSafeRegister(&xNewFromKeyFilePageSetup, lib, "gtk_page_setup_new_from_key_file")
	417	+	core.PuregoSafeRegister(&xNewPageSetupFromFile, lib, "gtk_page_setup_new_from_file")
	418	+	core.PuregoSafeRegister(&xNewPageSetupFromGvariant, lib, "gtk_page_setup_new_from_gvariant")
	419	+	core.PuregoSafeRegister(&xNewPageSetupFromKeyFile, lib, "gtk_page_setup_new_from_key_file")
420	420
421	421		core.PuregoSafeRegister(&xPageSetupCopy, lib, "gtk_page_setup_copy")
422	422		core.PuregoSafeRegister(&xPageSetupGetBottomMargin, lib, "gtk_page_setup_get_bottom_margin")

M v4/gtk/gtkpapersize.go +20 -20


@@ -41,29 +41,29 @@ func NewPaperSize(NameVar string) *PaperSize {
41	41		return cret
42	42		}
43	43
44		-	var xNewCustomPaperSize func(string, string, float64, float64, Unit) *PaperSize
	44	+	var xNewPaperSizeCustom func(string, string, float64, float64, Unit) *PaperSize
45	45
46	46		// Creates a new `GtkPaperSize` object with the
47	47		// given parameters.
48		-	func NewCustomPaperSize(NameVar string, DisplayNameVar string, WidthVar float64, HeightVar float64, UnitVar Unit) *PaperSize {
	48	+	func NewPaperSizeCustom(NameVar string, DisplayNameVar string, WidthVar float64, HeightVar float64, UnitVar Unit) *PaperSize {
49	49
50		-	cret := xNewCustomPaperSize(NameVar, DisplayNameVar, WidthVar, HeightVar, UnitVar)
	50	+	cret := xNewPaperSizeCustom(NameVar, DisplayNameVar, WidthVar, HeightVar, UnitVar)
51	51		return cret
52	52		}
53	53
54		-	var xNewFromGvariantPaperSize func(glib.Variant) PaperSize
	54	+	var xNewPaperSizeFromGvariant func(glib.Variant) PaperSize
55	55
56	56		// Deserialize a paper size from a `GVariant`.
57	57		//
58	58		// The `GVariant must be in the format produced by
59	59		// [method@Gtk.PaperSize.to_gvariant].
60		-	func NewFromGvariantPaperSize(VariantVar glib.Variant) PaperSize {
	60	+	func NewPaperSizeFromGvariant(VariantVar glib.Variant) PaperSize {
61	61
62		-	cret := xNewFromGvariantPaperSize(VariantVar)
	62	+	cret := xNewPaperSizeFromGvariant(VariantVar)
63	63		return cret
64	64		}
65	65
66		-	var xNewFromIppPaperSize func(string, float64, float64) *PaperSize
	66	+	var xNewPaperSizeFromIpp func(string, float64, float64) *PaperSize
67	67
68	68		// Creates a new `GtkPaperSize` object by using
69	69		// IPP information.

@@ -71,20 +71,20 @@ var xNewFromIppPaperSize func(string, float64, float64) *PaperSize
71	71		// If @ipp_name is not a recognized paper name,
72	72		// @width and @height are used to
73	73		// construct a custom `GtkPaperSize` object.
74		-	func NewFromIppPaperSize(IppNameVar string, WidthVar float64, HeightVar float64) *PaperSize {
	74	+	func NewPaperSizeFromIpp(IppNameVar string, WidthVar float64, HeightVar float64) *PaperSize {
75	75
76		-	cret := xNewFromIppPaperSize(IppNameVar, WidthVar, HeightVar)
	76	+	cret := xNewPaperSizeFromIpp(IppNameVar, WidthVar, HeightVar)
77	77		return cret
78	78		}
79	79
80		-	var xNewFromKeyFilePaperSize func(glib.KeyFile, string, glib.Error) PaperSize
	80	+	var xNewPaperSizeFromKeyFile func(glib.KeyFile, string, glib.Error) PaperSize
81	81
82	82		// Reads a paper size from the group @group_name in the key file
83	83		// @key_file.
84		-	func NewFromKeyFilePaperSize(KeyFileVar glib.KeyFile, GroupNameVar string) (PaperSize, error) {
	84	+	func NewPaperSizeFromKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) (PaperSize, error) {
85	85		var cerr *glib.Error
86	86
87		-	cret := xNewFromKeyFilePaperSize(KeyFileVar, GroupNameVar, &cerr)
	87	+	cret := xNewPaperSizeFromKeyFile(KeyFileVar, GroupNameVar, &cerr)
88	88		if cerr == nil {
89	89		return cret, nil
90	90		}

@@ -92,7 +92,7 @@ func NewFromKeyFilePaperSize(KeyFileVar glib.KeyFile, GroupNameVar string) (Pa
92	92
93	93		}
94	94
95		-	var xNewFromPpdPaperSize func(string, string, float64, float64) *PaperSize
	95	+	var xNewPaperSizeFromPpd func(string, string, float64, float64) *PaperSize
96	96
97	97		// Creates a new `GtkPaperSize` object by using
98	98		// PPD information.

@@ -100,9 +100,9 @@ var xNewFromPpdPaperSize func(string, string, float64, float64) *PaperSize
100	100		// If @ppd_name is not a recognized PPD paper name,
101	101		// @ppd_display_name, @width and @height are used to
102	102		// construct a custom `GtkPaperSize` object.
103		-	func NewFromPpdPaperSize(PpdNameVar string, PpdDisplayNameVar string, WidthVar float64, HeightVar float64) *PaperSize {
	103	+	func NewPaperSizeFromPpd(PpdNameVar string, PpdDisplayNameVar string, WidthVar float64, HeightVar float64) *PaperSize {
104	104
105		-	cret := xNewFromPpdPaperSize(PpdNameVar, PpdDisplayNameVar, WidthVar, HeightVar)
	105	+	cret := xNewPaperSizeFromPpd(PpdNameVar, PpdDisplayNameVar, WidthVar, HeightVar)
106	106		return cret
107	107		}
108	108

@@ -307,11 +307,11 @@ func init() {
307	307		core.PuregoSafeRegister(&xPaperSizeGetPaperSizes, lib, "gtk_paper_size_get_paper_sizes")
308	308
309	309		core.PuregoSafeRegister(&xNewPaperSize, lib, "gtk_paper_size_new")
310		-	core.PuregoSafeRegister(&xNewCustomPaperSize, lib, "gtk_paper_size_new_custom")
311		-	core.PuregoSafeRegister(&xNewFromGvariantPaperSize, lib, "gtk_paper_size_new_from_gvariant")
312		-	core.PuregoSafeRegister(&xNewFromIppPaperSize, lib, "gtk_paper_size_new_from_ipp")
313		-	core.PuregoSafeRegister(&xNewFromKeyFilePaperSize, lib, "gtk_paper_size_new_from_key_file")
314		-	core.PuregoSafeRegister(&xNewFromPpdPaperSize, lib, "gtk_paper_size_new_from_ppd")
	310	+	core.PuregoSafeRegister(&xNewPaperSizeCustom, lib, "gtk_paper_size_new_custom")
	311	+	core.PuregoSafeRegister(&xNewPaperSizeFromGvariant, lib, "gtk_paper_size_new_from_gvariant")
	312	+	core.PuregoSafeRegister(&xNewPaperSizeFromIpp, lib, "gtk_paper_size_new_from_ipp")
	313	+	core.PuregoSafeRegister(&xNewPaperSizeFromKeyFile, lib, "gtk_paper_size_new_from_key_file")
	314	+	core.PuregoSafeRegister(&xNewPaperSizeFromPpd, lib, "gtk_paper_size_new_from_ppd")
315	315
316	316		core.PuregoSafeRegister(&xPaperSizeCopy, lib, "gtk_paper_size_copy")
317	317		core.PuregoSafeRegister(&xPaperSizeFree, lib, "gtk_paper_size_free")

M v4/gtk/gtkpicture.go +20 -20


@@ -93,7 +93,7 @@ func NewPicture() *Picture {
93	93		return cls
94	94		}
95	95
96		-	var xNewForFilePicture func(uintptr) uintptr
	96	+	var xNewPictureForFile func(uintptr) uintptr
97	97
98	98		// Creates a new `GtkPicture` displaying the given @file.
99	99		//

@@ -103,10 +103,10 @@ var xNewForFilePicture func(uintptr) uintptr
103	103		// If you need to detect failures to load the file, use
104	104		// [ctor@Gdk.Texture.new_from_file] to load the file yourself,
105	105		// then create the `GtkPicture` from the texture.
106		-	func NewForFilePicture(FileVar gio.File) *Picture {
	106	+	func NewPictureForFile(FileVar gio.File) *Picture {
107	107		var cls *Picture
108	108
109		-	cret := xNewForFilePicture(FileVar.GoPointer())
	109	+	cret := xNewPictureForFile(FileVar.GoPointer())
110	110
111	111		if cret == 0 {
112	112		return nil

@@ -117,16 +117,16 @@ func NewForFilePicture(FileVar gio.File) *Picture {
117	117		return cls
118	118		}
119	119
120		-	var xNewForFilenamePicture func(string) uintptr
	120	+	var xNewPictureForFilename func(string) uintptr
121	121
122	122		// Creates a new `GtkPicture` displaying the file @filename.
123	123		//
124	124		// This is a utility function that calls [ctor@Gtk.Picture.new_for_file].
125	125		// See that function for details.
126		-	func NewForFilenamePicture(FilenameVar string) *Picture {
	126	+	func NewPictureForFilename(FilenameVar string) *Picture {
127	127		var cls *Picture
128	128
129		-	cret := xNewForFilenamePicture(FilenameVar)
	129	+	cret := xNewPictureForFilename(FilenameVar)
130	130
131	131		if cret == 0 {
132	132		return nil

@@ -137,16 +137,16 @@ func NewForFilenamePicture(FilenameVar string) *Picture {
137	137		return cls
138	138		}
139	139
140		-	var xNewForPaintablePicture func(uintptr) uintptr
	140	+	var xNewPictureForPaintable func(uintptr) uintptr
141	141
142	142		// Creates a new `GtkPicture` displaying @paintable.
143	143		//
144	144		// The `GtkPicture` will track changes to the @paintable and update
145	145		// its size and contents in response to it.
146		-	func NewForPaintablePicture(PaintableVar gdk.Paintable) *Picture {
	146	+	func NewPictureForPaintable(PaintableVar gdk.Paintable) *Picture {
147	147		var cls *Picture
148	148
149		-	cret := xNewForPaintablePicture(PaintableVar.GoPointer())
	149	+	cret := xNewPictureForPaintable(PaintableVar.GoPointer())
150	150
151	151		if cret == 0 {
152	152		return nil

@@ -157,7 +157,7 @@ func NewForPaintablePicture(PaintableVar gdk.Paintable) *Picture {
157	157		return cls
158	158		}
159	159
160		-	var xNewForPixbufPicture func(uintptr) uintptr
	160	+	var xNewPictureForPixbuf func(uintptr) uintptr
161	161
162	162		// Creates a new `GtkPicture` displaying @pixbuf.
163	163		//

@@ -165,10 +165,10 @@ var xNewForPixbufPicture func(uintptr) uintptr
165	165		// See that function for details.
166	166		//
167	167		// The pixbuf must not be modified after passing it to this function.
168		-	func NewForPixbufPicture(PixbufVar gdkpixbuf.Pixbuf) Picture {
	168	+	func NewPictureForPixbuf(PixbufVar gdkpixbuf.Pixbuf) Picture {
169	169		var cls *Picture
170	170
171		-	cret := xNewForPixbufPicture(PixbufVar.GoPointer())
	171	+	cret := xNewPictureForPixbuf(PixbufVar.GoPointer())
172	172
173	173		if cret == 0 {
174	174		return nil

@@ -179,16 +179,16 @@ func NewForPixbufPicture(PixbufVar gdkpixbuf.Pixbuf) Picture {
179	179		return cls
180	180		}
181	181
182		-	var xNewForResourcePicture func(string) uintptr
	182	+	var xNewPictureForResource func(string) uintptr
183	183
184	184		// Creates a new `GtkPicture` displaying the resource at @resource_path.
185	185		//
186	186		// This is a utility function that calls [ctor@Gtk.Picture.new_for_file].
187	187		// See that function for details.
188		-	func NewForResourcePicture(ResourcePathVar string) *Picture {
	188	+	func NewPictureForResource(ResourcePathVar string) *Picture {
189	189		var cls *Picture
190	190
191		-	cret := xNewForResourcePicture(ResourcePathVar)
	191	+	cret := xNewPictureForResource(ResourcePathVar)
192	192
193	193		if cret == 0 {
194	194		return nil

@@ -554,11 +554,11 @@ func init() {
554	554		}
555	555
556	556		core.PuregoSafeRegister(&xNewPicture, lib, "gtk_picture_new")
557		-	core.PuregoSafeRegister(&xNewForFilePicture, lib, "gtk_picture_new_for_file")
558		-	core.PuregoSafeRegister(&xNewForFilenamePicture, lib, "gtk_picture_new_for_filename")
559		-	core.PuregoSafeRegister(&xNewForPaintablePicture, lib, "gtk_picture_new_for_paintable")
560		-	core.PuregoSafeRegister(&xNewForPixbufPicture, lib, "gtk_picture_new_for_pixbuf")
561		-	core.PuregoSafeRegister(&xNewForResourcePicture, lib, "gtk_picture_new_for_resource")
	557	+	core.PuregoSafeRegister(&xNewPictureForFile, lib, "gtk_picture_new_for_file")
	558	+	core.PuregoSafeRegister(&xNewPictureForFilename, lib, "gtk_picture_new_for_filename")
	559	+	core.PuregoSafeRegister(&xNewPictureForPaintable, lib, "gtk_picture_new_for_paintable")
	560	+	core.PuregoSafeRegister(&xNewPictureForPixbuf, lib, "gtk_picture_new_for_pixbuf")
	561	+	core.PuregoSafeRegister(&xNewPictureForResource, lib, "gtk_picture_new_for_resource")
562	562
563	563		core.PuregoSafeRegister(&xPictureGetAlternativeText, lib, "gtk_picture_get_alternative_text")
564	564		core.PuregoSafeRegister(&xPictureGetCanShrink, lib, "gtk_picture_get_can_shrink")

M v4/gtk/gtkpopovermenu.go +8 -8


@@ -136,7 +136,7 @@ func PopoverMenuNewFromInternalPtr(ptr uintptr) *PopoverMenu {
136	136		return cls
137	137		}
138	138
139		-	var xNewFromModelPopoverMenu func(uintptr) uintptr
	139	+	var xNewPopoverMenuFromModel func(uintptr) uintptr
140	140
141	141		// Creates a `GtkPopoverMenu` and populates it according to @model.
142	142		//

@@ -151,10 +151,10 @@ var xNewFromModelPopoverMenu func(uintptr) uintptr
151	151		// This function creates menus with sliding submenus.
152	152		// See [ctor@Gtk.PopoverMenu.new_from_model_full] for a way
153	153		// to control this.
154		-	func NewFromModelPopoverMenu(ModelVar gio.MenuModel) PopoverMenu {
	154	+	func NewPopoverMenuFromModel(ModelVar gio.MenuModel) PopoverMenu {
155	155		var cls *PopoverMenu
156	156
157		-	cret := xNewFromModelPopoverMenu(ModelVar.GoPointer())
	157	+	cret := xNewPopoverMenuFromModel(ModelVar.GoPointer())
158	158
159	159		if cret == 0 {
160	160		return nil

@@ -165,7 +165,7 @@ func NewFromModelPopoverMenu(ModelVar gio.MenuModel) PopoverMenu {
165	165		return cls
166	166		}
167	167
168		-	var xNewFromModelFullPopoverMenu func(uintptr, PopoverMenuFlags) uintptr
	168	+	var xNewPopoverMenuFromModelFull func(uintptr, PopoverMenuFlags) uintptr
169	169
170	170		// Creates a `GtkPopoverMenu` and populates it according to @model.
171	171		//

@@ -178,10 +178,10 @@ var xNewFromModelFullPopoverMenu func(uintptr, PopoverMenuFlags) uintptr
178	178		// The only flag that is supported currently is
179	179		// %GTK_POPOVER_MENU_NESTED, which makes GTK create traditional,
180	180		// nested submenus instead of the default sliding submenus.
181		-	func NewFromModelFullPopoverMenu(ModelVar gio.MenuModel, FlagsVar PopoverMenuFlags) PopoverMenu {
	181	+	func NewPopoverMenuFromModelFull(ModelVar gio.MenuModel, FlagsVar PopoverMenuFlags) PopoverMenu {
182	182		var cls *PopoverMenu
183	183
184		-	cret := xNewFromModelFullPopoverMenu(ModelVar.GoPointer(), FlagsVar)
	184	+	cret := xNewPopoverMenuFromModelFull(ModelVar.GoPointer(), FlagsVar)
185	185
186	186		if cret == 0 {
187	187		return nil

@@ -459,8 +459,8 @@ func init() {
459	459		panic(err)
460	460		}
461	461
462		-	core.PuregoSafeRegister(&xNewFromModelPopoverMenu, lib, "gtk_popover_menu_new_from_model")
463		-	core.PuregoSafeRegister(&xNewFromModelFullPopoverMenu, lib, "gtk_popover_menu_new_from_model_full")
	462	+	core.PuregoSafeRegister(&xNewPopoverMenuFromModel, lib, "gtk_popover_menu_new_from_model")
	463	+	core.PuregoSafeRegister(&xNewPopoverMenuFromModelFull, lib, "gtk_popover_menu_new_from_model_full")
464	464
465	465		core.PuregoSafeRegister(&xPopoverMenuAddChild, lib, "gtk_popover_menu_add_child")
466	466		core.PuregoSafeRegister(&xPopoverMenuGetMenuModel, lib, "gtk_popover_menu_get_menu_model")

M v4/gtk/gtkpopovermenubar.go +4 -4


@@ -49,13 +49,13 @@ func PopoverMenuBarNewFromInternalPtr(ptr uintptr) *PopoverMenuBar {
49	49		return cls
50	50		}
51	51
52		-	var xNewFromModelPopoverMenuBar func(uintptr) uintptr
	52	+	var xNewPopoverMenuBarFromModel func(uintptr) uintptr
53	53
54	54		// Creates a `GtkPopoverMenuBar` from a `GMenuModel`.
55		-	func NewFromModelPopoverMenuBar(ModelVar gio.MenuModel) PopoverMenuBar {
	55	+	func NewPopoverMenuBarFromModel(ModelVar gio.MenuModel) PopoverMenuBar {
56	56		var cls *PopoverMenuBar
57	57
58		-	cret := xNewFromModelPopoverMenuBar(ModelVar.GoPointer())
	58	+	cret := xNewPopoverMenuBarFromModel(ModelVar.GoPointer())
59	59
60	60		if cret == 0 {
61	61		return nil

@@ -272,7 +272,7 @@ func init() {
272	272		panic(err)
273	273		}
274	274
275		-	core.PuregoSafeRegister(&xNewFromModelPopoverMenuBar, lib, "gtk_popover_menu_bar_new_from_model")
	275	+	core.PuregoSafeRegister(&xNewPopoverMenuBarFromModel, lib, "gtk_popover_menu_bar_new_from_model")
276	276
277	277		core.PuregoSafeRegister(&xPopoverMenuBarAddChild, lib, "gtk_popover_menu_bar_add_child")
278	278		core.PuregoSafeRegister(&xPopoverMenuBarGetMenuModel, lib, "gtk_popover_menu_bar_get_menu_model")

M v4/gtk/gtkprintsettings.go +12 -12


@@ -135,7 +135,7 @@ func NewPrintSettings() *PrintSettings {
135	135		return cls
136	136		}
137	137
138		-	var xNewFromFilePrintSettings func(string, **glib.Error) uintptr
	138	+	var xNewPrintSettingsFromFile func(string, **glib.Error) uintptr
139	139
140	140		// Reads the print settings from @file_name.
141	141		//

@@ -144,11 +144,11 @@ var xNewFromFilePrintSettings func(string, **glib.Error) uintptr
144	144		// error is set to either a `GFileError` or `GKeyFileError`.
145	145		//
146	146		// See [method@Gtk.PrintSettings.to_file].
147		-	func NewFromFilePrintSettings(FileNameVar string) (*PrintSettings, error) {
	147	+	func NewPrintSettingsFromFile(FileNameVar string) (*PrintSettings, error) {
148	148		var cls *PrintSettings
149	149		var cerr *glib.Error
150	150
151		-	cret := xNewFromFilePrintSettings(FileNameVar, &cerr)
	151	+	cret := xNewPrintSettingsFromFile(FileNameVar, &cerr)
152	152
153	153		if cret == 0 {
154	154		return nil, cerr

@@ -162,16 +162,16 @@ func NewFromFilePrintSettings(FileNameVar string) (*PrintSettings, error) {
162	162
163	163		}
164	164
165		-	var xNewFromGvariantPrintSettings func(*glib.Variant) uintptr
	165	+	var xNewPrintSettingsFromGvariant func(*glib.Variant) uintptr
166	166
167	167		// Deserialize print settings from an a{sv} variant.
168	168		//
169	169		// The variant must be in the format produced by
170	170		// [method@Gtk.PrintSettings.to_gvariant].
171		-	func NewFromGvariantPrintSettings(VariantVar glib.Variant) PrintSettings {
	171	+	func NewPrintSettingsFromGvariant(VariantVar glib.Variant) PrintSettings {
172	172		var cls *PrintSettings
173	173
174		-	cret := xNewFromGvariantPrintSettings(VariantVar)
	174	+	cret := xNewPrintSettingsFromGvariant(VariantVar)
175	175
176	176		if cret == 0 {
177	177		return nil

@@ -181,18 +181,18 @@ func NewFromGvariantPrintSettings(VariantVar glib.Variant) PrintSettings {
181	181		return cls
182	182		}
183	183
184		-	var xNewFromKeyFilePrintSettings func(glib.KeyFile, string, *glib.Error) uintptr
	184	+	var xNewPrintSettingsFromKeyFile func(glib.KeyFile, string, *glib.Error) uintptr
185	185
186	186		// Reads the print settings from the group @group_name in @key_file.
187	187		//
188	188		// Returns a new `GtkPrintSettings` object with the restored settings,
189	189		// or %NULL if an error occurred. If the file could not be loaded then
190	190		// error is set to either `GFileError` or `GKeyFileError`.
191		-	func NewFromKeyFilePrintSettings(KeyFileVar glib.KeyFile, GroupNameVar string) (PrintSettings, error) {
	191	+	func NewPrintSettingsFromKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) (PrintSettings, error) {
192	192		var cls *PrintSettings
193	193		var cerr *glib.Error
194	194
195		-	cret := xNewFromKeyFilePrintSettings(KeyFileVar, GroupNameVar, &cerr)
	195	+	cret := xNewPrintSettingsFromKeyFile(KeyFileVar, GroupNameVar, &cerr)
196	196
197	197		if cret == 0 {
198	198		return nil, cerr

@@ -932,9 +932,9 @@ func init() {
932	932		}
933	933
934	934		core.PuregoSafeRegister(&xNewPrintSettings, lib, "gtk_print_settings_new")
935		-	core.PuregoSafeRegister(&xNewFromFilePrintSettings, lib, "gtk_print_settings_new_from_file")
936		-	core.PuregoSafeRegister(&xNewFromGvariantPrintSettings, lib, "gtk_print_settings_new_from_gvariant")
937		-	core.PuregoSafeRegister(&xNewFromKeyFilePrintSettings, lib, "gtk_print_settings_new_from_key_file")
	935	+	core.PuregoSafeRegister(&xNewPrintSettingsFromFile, lib, "gtk_print_settings_new_from_file")
	936	+	core.PuregoSafeRegister(&xNewPrintSettingsFromGvariant, lib, "gtk_print_settings_new_from_gvariant")
	937	+	core.PuregoSafeRegister(&xNewPrintSettingsFromKeyFile, lib, "gtk_print_settings_new_from_key_file")
938	938
939	939		core.PuregoSafeRegister(&xPrintSettingsCopy, lib, "gtk_print_settings_copy")
940	940		core.PuregoSafeRegister(&xPrintSettingsForeach, lib, "gtk_print_settings_foreach")

M v4/gtk/gtkscale.go +4 -4


@@ -132,7 +132,7 @@ func NewScale(OrientationVar Orientation, AdjustmentVar Adjustment) Scale {
132	132		return cls
133	133		}
134	134
135		-	var xNewWithRangeScale func(Orientation, float64, float64, float64) uintptr
	135	+	var xNewScaleWithRange func(Orientation, float64, float64, float64) uintptr
136	136
137	137		// Creates a new scale widget with a range from @min to @max.
138	138		//

@@ -145,10 +145,10 @@ var xNewWithRangeScale func(Orientation, float64, float64, float64) uintptr
145	145		// Note that the way in which the precision is derived works best if
146	146		// @step is a power of ten. If the resulting precision is not suitable
147	147		// for your needs, use [method@Gtk.Scale.set_digits] to correct it.
148		-	func NewWithRangeScale(OrientationVar Orientation, MinVar float64, MaxVar float64, StepVar float64) *Scale {
	148	+	func NewScaleWithRange(OrientationVar Orientation, MinVar float64, MaxVar float64, StepVar float64) *Scale {
149	149		var cls *Scale
150	150
151		-	cret := xNewWithRangeScale(OrientationVar, MinVar, MaxVar, StepVar)
	151	+	cret := xNewScaleWithRange(OrientationVar, MinVar, MaxVar, StepVar)
152	152
153	153		if cret == 0 {
154	154		return nil

@@ -498,7 +498,7 @@ func init() {
498	498		}
499	499
500	500		core.PuregoSafeRegister(&xNewScale, lib, "gtk_scale_new")
501		-	core.PuregoSafeRegister(&xNewWithRangeScale, lib, "gtk_scale_new_with_range")
	501	+	core.PuregoSafeRegister(&xNewScaleWithRange, lib, "gtk_scale_new_with_range")
502	502
503	503		core.PuregoSafeRegister(&xScaleAddMark, lib, "gtk_scale_add_mark")
504	504		core.PuregoSafeRegister(&xScaleClearMarks, lib, "gtk_scale_clear_marks")

M v4/gtk/gtkshortcut.go +4 -4


@@ -60,14 +60,14 @@ func NewShortcut(TriggerVar ShortcutTrigger, ActionVar ShortcutAction) *Shortc
60	60		return cls
61	61		}
62	62
63		-	var xNewWithArgumentsShortcut func(uintptr, uintptr, string, ...interface{}) uintptr
	63	+	var xNewShortcutWithArguments func(uintptr, uintptr, string, ...interface{}) uintptr
64	64
65	65		// Creates a new `GtkShortcut` that is triggered by @trigger and then activates
66	66		// @action with arguments given by @format_string.
67		-	func NewWithArgumentsShortcut(TriggerVar ShortcutTrigger, ActionVar ShortcutAction, FormatStringVar string, varArgs ...interface{}) *Shortcut {
	67	+	func NewShortcutWithArguments(TriggerVar ShortcutTrigger, ActionVar ShortcutAction, FormatStringVar string, varArgs ...interface{}) *Shortcut {
68	68		var cls *Shortcut
69	69
70		-	cret := xNewWithArgumentsShortcut(TriggerVar.GoPointer(), ActionVar.GoPointer(), FormatStringVar, varArgs...)
	70	+	cret := xNewShortcutWithArguments(TriggerVar.GoPointer(), ActionVar.GoPointer(), FormatStringVar, varArgs...)
71	71
72	72		if cret == 0 {
73	73		return nil

@@ -162,7 +162,7 @@ func init() {
162	162		}
163	163
164	164		core.PuregoSafeRegister(&xNewShortcut, lib, "gtk_shortcut_new")
165		-	core.PuregoSafeRegister(&xNewWithArgumentsShortcut, lib, "gtk_shortcut_new_with_arguments")
	165	+	core.PuregoSafeRegister(&xNewShortcutWithArguments, lib, "gtk_shortcut_new_with_arguments")
166	166
167	167		core.PuregoSafeRegister(&xShortcutGetAction, lib, "gtk_shortcut_get_action")
168	168		core.PuregoSafeRegister(&xShortcutGetArguments, lib, "gtk_shortcut_get_arguments")

M v4/gtk/gtkshortcutaction.go +4 -4


@@ -315,7 +315,7 @@ func ShortcutActionNewFromInternalPtr(ptr uintptr) *ShortcutAction {
315	315		return cls
316	316		}
317	317
318		-	var xParseStringShortcutAction func(string) uintptr
	318	+	var xShortcutActionParseString func(string) uintptr
319	319
320	320		// Tries to parse the given string into an action.
321	321		//

@@ -329,10 +329,10 @@ var xParseStringShortcutAction func(string) uintptr
329	329		// - `mnemonic-activate`, for `GtkMnemonicAction`
330	330		// - `action(NAME)`, for a `GtkNamedAction` for the action named `NAME`
331	331		// - `signal(NAME)`, for a `GtkSignalAction` for the signal `NAME`
332		-	func ParseStringShortcutAction(StringVar string) *ShortcutAction {
	332	+	func ShortcutActionParseString(StringVar string) *ShortcutAction {
333	333		var cls *ShortcutAction
334	334
335		-	cret := xParseStringShortcutAction(StringVar)
	335	+	cret := xShortcutActionParseString(StringVar)
336	336
337	337		if cret == 0 {
338	338		return nil

@@ -459,7 +459,7 @@ func init() {
459	459
460	460		core.PuregoSafeRegister(&xNothingActionGet, lib, "gtk_nothing_action_get")
461	461
462		-	core.PuregoSafeRegister(&xParseStringShortcutAction, lib, "gtk_shortcut_action_parse_string")
	462	+	core.PuregoSafeRegister(&xShortcutActionParseString, lib, "gtk_shortcut_action_parse_string")
463	463
464	464		core.PuregoSafeRegister(&xShortcutActionActivate, lib, "gtk_shortcut_action_activate")
465	465		core.PuregoSafeRegister(&xShortcutActionPrint, lib, "gtk_shortcut_action_print")

M v4/gtk/gtkshortcutcontroller.go +4 -4


@@ -86,7 +86,7 @@ func NewShortcutController() *ShortcutController {
86	86		return cls
87	87		}
88	88
89		-	var xNewForModelShortcutController func(uintptr) uintptr
	89	+	var xNewShortcutControllerForModel func(uintptr) uintptr
90	90
91	91		// Creates a new shortcut controller that takes its shortcuts from
92	92		// the given list model.

@@ -94,10 +94,10 @@ var xNewForModelShortcutController func(uintptr) uintptr
94	94		// A controller created by this function does not let you add or
95	95		// remove individual shortcuts using the shortcut controller api,
96	96		// but you can change the contents of the model.
97		-	func NewForModelShortcutController(ModelVar gio.ListModel) *ShortcutController {
	97	+	func NewShortcutControllerForModel(ModelVar gio.ListModel) *ShortcutController {
98	98		var cls *ShortcutController
99	99
100		-	cret := xNewForModelShortcutController(ModelVar.GoPointer())
	100	+	cret := xNewShortcutControllerForModel(ModelVar.GoPointer())
101	101
102	102		if cret == 0 {
103	103		return nil

@@ -305,7 +305,7 @@ func init() {
305	305		}
306	306
307	307		core.PuregoSafeRegister(&xNewShortcutController, lib, "gtk_shortcut_controller_new")
308		-	core.PuregoSafeRegister(&xNewForModelShortcutController, lib, "gtk_shortcut_controller_new_for_model")
	308	+	core.PuregoSafeRegister(&xNewShortcutControllerForModel, lib, "gtk_shortcut_controller_new_for_model")
309	309
310	310		core.PuregoSafeRegister(&xShortcutControllerAddShortcut, lib, "gtk_shortcut_controller_add_shortcut")
311	311		core.PuregoSafeRegister(&xShortcutControllerGetMnemonicsModifiers, lib, "gtk_shortcut_controller_get_mnemonics_modifiers")

M v4/gtk/gtkshortcuttrigger.go +4 -4


@@ -299,7 +299,7 @@ func ShortcutTriggerNewFromInternalPtr(ptr uintptr) *ShortcutTrigger {
299	299		return cls
300	300		}
301	301
302		-	var xParseStringShortcutTrigger func(string) uintptr
	302	+	var xShortcutTriggerParseString func(string) uintptr
303	303
304	304		// Tries to parse the given string into a trigger.
305	305		//

@@ -317,10 +317,10 @@ var xParseStringShortcutTrigger func(string) uintptr
317	317		// Note that you will have to escape the `<` and `>` characters when specifying
318	318		// triggers in XML files, such as GtkBuilder ui files. Use `&lt;` instead of
319	319		// `<` and `&gt;` instead of `>`.
320		-	func ParseStringShortcutTrigger(StringVar string) *ShortcutTrigger {
	320	+	func ShortcutTriggerParseString(StringVar string) *ShortcutTrigger {
321	321		var cls *ShortcutTrigger
322	322
323		-	cret := xParseStringShortcutTrigger(StringVar)
	323	+	cret := xShortcutTriggerParseString(StringVar)
324	324
325	325		if cret == 0 {
326	326		return nil

@@ -474,7 +474,7 @@ func init() {
474	474
475	475		core.PuregoSafeRegister(&xNeverTriggerGet, lib, "gtk_never_trigger_get")
476	476
477		-	core.PuregoSafeRegister(&xParseStringShortcutTrigger, lib, "gtk_shortcut_trigger_parse_string")
	477	+	core.PuregoSafeRegister(&xShortcutTriggerParseString, lib, "gtk_shortcut_trigger_parse_string")
478	478
479	479		core.PuregoSafeRegister(&xShortcutTriggerCompare, lib, "gtk_shortcut_trigger_compare")
480	480		core.PuregoSafeRegister(&xShortcutTriggerEqual, lib, "gtk_shortcut_trigger_equal")

M v4/gtk/gtkspinbutton.go +4 -4


@@ -201,7 +201,7 @@ func NewSpinButton(AdjustmentVar *Adjustment, ClimbRateVar float64, DigitsVar ui
201	201		return cls
202	202		}
203	203
204		-	var xNewWithRangeSpinButton func(float64, float64, float64) uintptr
	204	+	var xNewSpinButtonWithRange func(float64, float64, float64) uintptr
205	205
206	206		// Creates a new `GtkSpinButton` with the given properties.
207	207		//

@@ -216,10 +216,10 @@ var xNewWithRangeSpinButton func(float64, float64, float64) uintptr
216	216		// best if @step is a power of ten. If the resulting precision
217	217		// is not suitable for your needs, use
218	218		// [method@Gtk.SpinButton.set_digits] to correct it.
219		-	func NewWithRangeSpinButton(MinVar float64, MaxVar float64, StepVar float64) *SpinButton {
	219	+	func NewSpinButtonWithRange(MinVar float64, MaxVar float64, StepVar float64) *SpinButton {
220	220		var cls *SpinButton
221	221
222		-	cret := xNewWithRangeSpinButton(MinVar, MaxVar, StepVar)
	222	+	cret := xNewSpinButtonWithRange(MinVar, MaxVar, StepVar)
223	223
224	224		if cret == 0 {
225	225		return nil

@@ -1028,7 +1028,7 @@ func init() {
1028	1028		}
1029	1029
1030	1030		core.PuregoSafeRegister(&xNewSpinButton, lib, "gtk_spin_button_new")
1031		-	core.PuregoSafeRegister(&xNewWithRangeSpinButton, lib, "gtk_spin_button_new_with_range")
	1031	+	core.PuregoSafeRegister(&xNewSpinButtonWithRange, lib, "gtk_spin_button_new_with_range")
1032	1032
1033	1033		core.PuregoSafeRegister(&xSpinButtonConfigure, lib, "gtk_spin_button_configure")
1034	1034		core.PuregoSafeRegister(&xSpinButtonGetAdjustment, lib, "gtk_spin_button_get_adjustment")

M v4/gtk/gtktext.go +4 -4


@@ -99,13 +99,13 @@ func NewText() *Text {
99	99		return cls
100	100		}
101	101
102		-	var xNewWithBufferText func(uintptr) uintptr
	102	+	var xNewTextWithBuffer func(uintptr) uintptr
103	103
104	104		// Creates a new `GtkText` with the specified text buffer.
105		-	func NewWithBufferText(BufferVar EntryBuffer) Text {
	105	+	func NewTextWithBuffer(BufferVar EntryBuffer) Text {
106	106		var cls *Text
107	107
108		-	cret := xNewWithBufferText(BufferVar.GoPointer())
	108	+	cret := xNewTextWithBuffer(BufferVar.GoPointer())
109	109
110	110		if cret == 0 {
111	111		return nil

@@ -1135,7 +1135,7 @@ func init() {
1135	1135		}
1136	1136
1137	1137		core.PuregoSafeRegister(&xNewText, lib, "gtk_text_new")
1138		-	core.PuregoSafeRegister(&xNewWithBufferText, lib, "gtk_text_new_with_buffer")
	1138	+	core.PuregoSafeRegister(&xNewTextWithBuffer, lib, "gtk_text_new_with_buffer")
1139	1139
1140	1140		core.PuregoSafeRegister(&xTextComputeCursorExtents, lib, "gtk_text_compute_cursor_extents")
1141	1141		core.PuregoSafeRegister(&xTextGetActivatesDefault, lib, "gtk_text_get_activates_default")

M v4/gtk/gtktextchild.go +4 -4


@@ -52,16 +52,16 @@ func NewTextChildAnchor() *TextChildAnchor {
52	52		return cls
53	53		}
54	54
55		-	var xNewWithReplacementTextChildAnchor func(string) uintptr
	55	+	var xNewTextChildAnchorWithReplacement func(string) uintptr
56	56
57	57		// Creates a new `GtkTextChildAnchor` with the given replacement character.
58	58		//
59	59		// Usually you would then insert it into a `GtkTextBuffer` with
60	60		// [method@Gtk.TextBuffer.insert_child_anchor].
61		-	func NewWithReplacementTextChildAnchor(CharacterVar string) *TextChildAnchor {
	61	+	func NewTextChildAnchorWithReplacement(CharacterVar string) *TextChildAnchor {
62	62		var cls *TextChildAnchor
63	63
64		-	cret := xNewWithReplacementTextChildAnchor(CharacterVar)
	64	+	cret := xNewTextChildAnchorWithReplacement(CharacterVar)
65	65
66	66		if cret == 0 {
67	67		return nil

@@ -113,7 +113,7 @@ func init() {
113	113		}
114	114
115	115		core.PuregoSafeRegister(&xNewTextChildAnchor, lib, "gtk_text_child_anchor_new")
116		-	core.PuregoSafeRegister(&xNewWithReplacementTextChildAnchor, lib, "gtk_text_child_anchor_new_with_replacement")
	116	+	core.PuregoSafeRegister(&xNewTextChildAnchorWithReplacement, lib, "gtk_text_child_anchor_new_with_replacement")
117	117
118	118		core.PuregoSafeRegister(&xTextChildAnchorGetDeleted, lib, "gtk_text_child_anchor_get_deleted")
119	119		core.PuregoSafeRegister(&xTextChildAnchorGetWidgets, lib, "gtk_text_child_anchor_get_widgets")

M v4/gtk/gtktextview.go +4 -4


@@ -146,7 +146,7 @@ func NewTextView() *TextView {
146	146		return cls
147	147		}
148	148
149		-	var xNewWithBufferTextView func(uintptr) uintptr
	149	+	var xNewTextViewWithBuffer func(uintptr) uintptr
150	150
151	151		// Creates a new `GtkTextView` widget displaying the buffer @buffer.
152	152		//

@@ -154,10 +154,10 @@ var xNewWithBufferTextView func(uintptr) uintptr
154	154		// to create a default buffer, in which case this function is equivalent
155	155		// to [ctor@Gtk.TextView.new]. The text view adds its own reference count
156	156		// to the buffer; it does not take over an existing reference.
157		-	func NewWithBufferTextView(BufferVar TextBuffer) TextView {
	157	+	func NewTextViewWithBuffer(BufferVar TextBuffer) TextView {
158	158		var cls *TextView
159	159
160		-	cret := xNewWithBufferTextView(BufferVar.GoPointer())
	160	+	cret := xNewTextViewWithBuffer(BufferVar.GoPointer())
161	161
162	162		if cret == 0 {
163	163		return nil

@@ -1656,7 +1656,7 @@ func init() {
1656	1656		}
1657	1657
1658	1658		core.PuregoSafeRegister(&xNewTextView, lib, "gtk_text_view_new")
1659		-	core.PuregoSafeRegister(&xNewWithBufferTextView, lib, "gtk_text_view_new_with_buffer")
	1659	+	core.PuregoSafeRegister(&xNewTextViewWithBuffer, lib, "gtk_text_view_new_with_buffer")
1660	1660
1661	1661		core.PuregoSafeRegister(&xTextViewAddChildAtAnchor, lib, "gtk_text_view_add_child_at_anchor")
1662	1662		core.PuregoSafeRegister(&xTextViewAddOverlay, lib, "gtk_text_view_add_overlay")

M v4/gtk/gtktogglebutton.go +8 -8


@@ -124,13 +124,13 @@ func NewToggleButton() *ToggleButton {
124	124		return cls
125	125		}
126	126
127		-	var xNewWithLabelToggleButton func(string) uintptr
	127	+	var xNewToggleButtonWithLabel func(string) uintptr
128	128
129	129		// Creates a new toggle button with a text label.
130		-	func NewWithLabelToggleButton(LabelVar string) *ToggleButton {
	130	+	func NewToggleButtonWithLabel(LabelVar string) *ToggleButton {
131	131		var cls *ToggleButton
132	132
133		-	cret := xNewWithLabelToggleButton(LabelVar)
	133	+	cret := xNewToggleButtonWithLabel(LabelVar)
134	134
135	135		if cret == 0 {
136	136		return nil

@@ -141,16 +141,16 @@ func NewWithLabelToggleButton(LabelVar string) *ToggleButton {
141	141		return cls
142	142		}
143	143
144		-	var xNewWithMnemonicToggleButton func(string) uintptr
	144	+	var xNewToggleButtonWithMnemonic func(string) uintptr
145	145
146	146		// Creates a new `GtkToggleButton` containing a label.
147	147		//
148	148		// The label will be created using [ctor@Gtk.Label.new_with_mnemonic],
149	149		// so underscores in @label indicate the mnemonic for the button.
150		-	func NewWithMnemonicToggleButton(LabelVar string) *ToggleButton {
	150	+	func NewToggleButtonWithMnemonic(LabelVar string) *ToggleButton {
151	151		var cls *ToggleButton
152	152
153		-	cret := xNewWithMnemonicToggleButton(LabelVar)
	153	+	cret := xNewToggleButtonWithMnemonic(LabelVar)
154	154
155	155		if cret == 0 {
156	156		return nil

@@ -471,8 +471,8 @@ func init() {
471	471		}
472	472
473	473		core.PuregoSafeRegister(&xNewToggleButton, lib, "gtk_toggle_button_new")
474		-	core.PuregoSafeRegister(&xNewWithLabelToggleButton, lib, "gtk_toggle_button_new_with_label")
475		-	core.PuregoSafeRegister(&xNewWithMnemonicToggleButton, lib, "gtk_toggle_button_new_with_mnemonic")
	474	+	core.PuregoSafeRegister(&xNewToggleButtonWithLabel, lib, "gtk_toggle_button_new_with_label")
	475	+	core.PuregoSafeRegister(&xNewToggleButtonWithMnemonic, lib, "gtk_toggle_button_new_with_mnemonic")
476	476
477	477		core.PuregoSafeRegister(&xToggleButtonGetActive, lib, "gtk_toggle_button_get_active")
478	478		core.PuregoSafeRegister(&xToggleButtonSetActive, lib, "gtk_toggle_button_set_active")

M v4/gtk/gtktreemodel.go +20 -20


@@ -83,36 +83,36 @@ func NewTreePath() *TreePath {
83	83		return cret
84	84		}
85	85
86		-	var xNewFirstTreePath func() *TreePath
	86	+	var xNewTreePathFirst func() *TreePath
87	87
88	88		// Creates a new `GtkTreePath`.
89	89		//
90	90		// The string representation of this path is “0”.
91		-	func NewFirstTreePath() *TreePath {
	91	+	func NewTreePathFirst() *TreePath {
92	92
93		-	cret := xNewFirstTreePath()
	93	+	cret := xNewTreePathFirst()
94	94		return cret
95	95		}
96	96
97		-	var xNewFromIndicesTreePath func(int, ...interface{}) *TreePath
	97	+	var xNewTreePathFromIndices func(int, ...interface{}) *TreePath
98	98
99	99		// Creates a new path with @first_index and @varargs as indices.
100		-	func NewFromIndicesTreePath(FirstIndexVar int, varArgs ...interface{}) *TreePath {
	100	+	func NewTreePathFromIndices(FirstIndexVar int, varArgs ...interface{}) *TreePath {
101	101
102		-	cret := xNewFromIndicesTreePath(FirstIndexVar, varArgs...)
	102	+	cret := xNewTreePathFromIndices(FirstIndexVar, varArgs...)
103	103		return cret
104	104		}
105	105
106		-	var xNewFromIndicesvTreePath func(uintptr, uint) *TreePath
	106	+	var xNewTreePathFromIndicesv func(uintptr, uint) *TreePath
107	107
108	108		// Creates a new path with the given @indices array of @length.
109		-	func NewFromIndicesvTreePath(IndicesVar uintptr, LengthVar uint) *TreePath {
	109	+	func NewTreePathFromIndicesv(IndicesVar uintptr, LengthVar uint) *TreePath {
110	110
111		-	cret := xNewFromIndicesvTreePath(IndicesVar, LengthVar)
	111	+	cret := xNewTreePathFromIndicesv(IndicesVar, LengthVar)
112	112		return cret
113	113		}
114	114
115		-	var xNewFromStringTreePath func(string) *TreePath
	115	+	var xNewTreePathFromString func(string) *TreePath
116	116
117	117		// Creates a new `GtkTreePath` initialized to @path.
118	118		//

@@ -121,9 +121,9 @@ var xNewFromStringTreePath func(string) *TreePath
121	121		// 3 pointing to the 11th child of the root node, the 5th
122	122		// child of that 11th child, and the 1st child of that 5th child.
123	123		// If an invalid path string is passed in, %NULL is returned.
124		-	func NewFromStringTreePath(PathVar string) *TreePath {
	124	+	func NewTreePathFromString(PathVar string) *TreePath {
125	125
126		-	cret := xNewFromStringTreePath(PathVar)
	126	+	cret := xNewTreePathFromString(PathVar)
127	127		return cret
128	128		}
129	129

@@ -309,7 +309,7 @@ func NewTreeRowReference(ModelVar TreeModel, PathVar TreePath) TreeRowReferenc
309	309		return cret
310	310		}
311	311
312		-	var xNewProxyTreeRowReference func(uintptr, uintptr, TreePath) TreeRowReference
	312	+	var xNewTreeRowReferenceProxy func(uintptr, uintptr, TreePath) TreeRowReference
313	313
314	314		// You do not need to use this function.
315	315		//

@@ -335,9 +335,9 @@ var xNewProxyTreeRowReference func(uintptr, uintptr, TreePath) TreeRowReferenc
335	335		// This type of row reference is primarily meant by structures that
336	336		// need to carefully monitor exactly when a row reference updates
337	337		// itself, and is not generally needed by most applications.
338		-	func NewProxyTreeRowReference(ProxyVar gobject.Object, ModelVar TreeModel, PathVar TreePath) *TreeRowReference {
	338	+	func NewTreeRowReferenceProxy(ProxyVar gobject.Object, ModelVar TreeModel, PathVar TreePath) *TreeRowReference {
339	339
340		-	cret := xNewProxyTreeRowReference(ProxyVar.GoPointer(), ModelVar.GoPointer(), PathVar)
	340	+	cret := xNewTreeRowReferenceProxy(ProxyVar.GoPointer(), ModelVar.GoPointer(), PathVar)
341	341		return cret
342	342		}
343	343

@@ -1067,10 +1067,10 @@ func init() {
1067	1067		core.PuregoSafeRegister(&xTreeIterFree, lib, "gtk_tree_iter_free")
1068	1068
1069	1069		core.PuregoSafeRegister(&xNewTreePath, lib, "gtk_tree_path_new")
1070		-	core.PuregoSafeRegister(&xNewFirstTreePath, lib, "gtk_tree_path_new_first")
1071		-	core.PuregoSafeRegister(&xNewFromIndicesTreePath, lib, "gtk_tree_path_new_from_indices")
1072		-	core.PuregoSafeRegister(&xNewFromIndicesvTreePath, lib, "gtk_tree_path_new_from_indicesv")
1073		-	core.PuregoSafeRegister(&xNewFromStringTreePath, lib, "gtk_tree_path_new_from_string")
	1070	+	core.PuregoSafeRegister(&xNewTreePathFirst, lib, "gtk_tree_path_new_first")
	1071	+	core.PuregoSafeRegister(&xNewTreePathFromIndices, lib, "gtk_tree_path_new_from_indices")
	1072	+	core.PuregoSafeRegister(&xNewTreePathFromIndicesv, lib, "gtk_tree_path_new_from_indicesv")
	1073	+	core.PuregoSafeRegister(&xNewTreePathFromString, lib, "gtk_tree_path_new_from_string")
1074	1074
1075	1075		core.PuregoSafeRegister(&xTreePathAppendIndex, lib, "gtk_tree_path_append_index")
1076	1076		core.PuregoSafeRegister(&xTreePathCompare, lib, "gtk_tree_path_compare")

@@ -1089,7 +1089,7 @@ func init() {
1089	1089		core.PuregoSafeRegister(&xTreePathUp, lib, "gtk_tree_path_up")
1090	1090
1091	1091		core.PuregoSafeRegister(&xNewTreeRowReference, lib, "gtk_tree_row_reference_new")
1092		-	core.PuregoSafeRegister(&xNewProxyTreeRowReference, lib, "gtk_tree_row_reference_new_proxy")
	1092	+	core.PuregoSafeRegister(&xNewTreeRowReferenceProxy, lib, "gtk_tree_row_reference_new_proxy")
1093	1093
1094	1094		core.PuregoSafeRegister(&xTreeRowReferenceCopy, lib, "gtk_tree_row_reference_copy")
1095	1095		core.PuregoSafeRegister(&xTreeRowReferenceFree, lib, "gtk_tree_row_reference_free")

M v4/gtk/gtktreemodelsort.go +4 -4


@@ -138,13 +138,13 @@ func TreeModelSortNewFromInternalPtr(ptr uintptr) *TreeModelSort {
138	138		return cls
139	139		}
140	140
141		-	var xNewWithModelTreeModelSort func(uintptr) uintptr
	141	+	var xNewTreeModelSortWithModel func(uintptr) uintptr
142	142
143	143		// Creates a new `GtkTreeModelSort`, with @child_model as the child model.
144		-	func NewWithModelTreeModelSort(ChildModelVar TreeModel) *TreeModelSort {
	144	+	func NewTreeModelSortWithModel(ChildModelVar TreeModel) *TreeModelSort {
145	145		var cls *TreeModelSort
146	146
147		-	cret := xNewWithModelTreeModelSort(ChildModelVar.GoPointer())
	147	+	cret := xNewTreeModelSortWithModel(ChildModelVar.GoPointer())
148	148
149	149		if cret == 0 {
150	150		return nil

@@ -694,7 +694,7 @@ func init() {
694	694		panic(err)
695	695		}
696	696
697		-	core.PuregoSafeRegister(&xNewWithModelTreeModelSort, lib, "gtk_tree_model_sort_new_with_model")
	697	+	core.PuregoSafeRegister(&xNewTreeModelSortWithModel, lib, "gtk_tree_model_sort_new_with_model")
698	698
699	699		core.PuregoSafeRegister(&xTreeModelSortClearCache, lib, "gtk_tree_model_sort_clear_cache")
700	700		core.PuregoSafeRegister(&xTreeModelSortConvertChildIterToIter, lib, "gtk_tree_model_sort_convert_child_iter_to_iter")

M v4/gtk/gtktreestore.go +4 -4


@@ -94,13 +94,13 @@ func NewTreeStore(NColumnsVar int, varArgs ...interface{}) *TreeStore {
94	94		return cls
95	95		}
96	96
97		-	var xNewvTreeStore func(int, uintptr) uintptr
	97	+	var xNewTreeStorev func(int, uintptr) uintptr
98	98
99	99		// Non vararg creation function. Used primarily by language bindings.
100		-	func NewvTreeStore(NColumnsVar int, TypesVar uintptr) *TreeStore {
	100	+	func NewTreeStorev(NColumnsVar int, TypesVar uintptr) *TreeStore {
101	101		var cls *TreeStore
102	102
103		-	cret := xNewvTreeStore(NColumnsVar, TypesVar)
	103	+	cret := xNewTreeStorev(NColumnsVar, TypesVar)
104	104
105	105		if cret == 0 {
106	106		return nil

@@ -855,7 +855,7 @@ func init() {
855	855		}
856	856
857	857		core.PuregoSafeRegister(&xNewTreeStore, lib, "gtk_tree_store_new")
858		-	core.PuregoSafeRegister(&xNewvTreeStore, lib, "gtk_tree_store_newv")
	858	+	core.PuregoSafeRegister(&xNewTreeStorev, lib, "gtk_tree_store_newv")
859	859
860	860		core.PuregoSafeRegister(&xTreeStoreAppend, lib, "gtk_tree_store_append")
861	861		core.PuregoSafeRegister(&xTreeStoreClear, lib, "gtk_tree_store_clear")

M v4/gtk/gtktreeview.go +4 -4


@@ -176,13 +176,13 @@ func NewTreeView() *TreeView {
176	176		return cls
177	177		}
178	178
179		-	var xNewWithModelTreeView func(uintptr) uintptr
	179	+	var xNewTreeViewWithModel func(uintptr) uintptr
180	180
181	181		// Creates a new `GtkTreeView` widget with the model initialized to @model.
182		-	func NewWithModelTreeView(ModelVar TreeModel) *TreeView {
	182	+	func NewTreeViewWithModel(ModelVar TreeModel) *TreeView {
183	183		var cls *TreeView
184	184
185		-	cret := xNewWithModelTreeView(ModelVar.GoPointer())
	185	+	cret := xNewTreeViewWithModel(ModelVar.GoPointer())
186	186
187	187		if cret == 0 {
188	188		return nil

@@ -1735,7 +1735,7 @@ func init() {
1735	1735		}
1736	1736
1737	1737		core.PuregoSafeRegister(&xNewTreeView, lib, "gtk_tree_view_new")
1738		-	core.PuregoSafeRegister(&xNewWithModelTreeView, lib, "gtk_tree_view_new_with_model")
	1738	+	core.PuregoSafeRegister(&xNewTreeViewWithModel, lib, "gtk_tree_view_new_with_model")
1739	1739
1740	1740		core.PuregoSafeRegister(&xTreeViewAppendColumn, lib, "gtk_tree_view_append_column")
1741	1741		core.PuregoSafeRegister(&xTreeViewCollapseAll, lib, "gtk_tree_view_collapse_all")

M v4/gtk/gtktreeviewcolumn.go +8 -8


@@ -70,13 +70,13 @@ func NewTreeViewColumn() *TreeViewColumn {
70	70		return cls
71	71		}
72	72
73		-	var xNewWithAreaTreeViewColumn func(uintptr) uintptr
	73	+	var xNewTreeViewColumnWithArea func(uintptr) uintptr
74	74
75	75		// Creates a new `GtkTreeViewColumn` using @area to render its cells.
76		-	func NewWithAreaTreeViewColumn(AreaVar CellArea) TreeViewColumn {
	76	+	func NewTreeViewColumnWithArea(AreaVar CellArea) TreeViewColumn {
77	77		var cls *TreeViewColumn
78	78
79		-	cret := xNewWithAreaTreeViewColumn(AreaVar.GoPointer())
	79	+	cret := xNewTreeViewColumnWithArea(AreaVar.GoPointer())
80	80
81	81		if cret == 0 {
82	82		return nil

@@ -87,7 +87,7 @@ func NewWithAreaTreeViewColumn(AreaVar CellArea) TreeViewColumn {
87	87		return cls
88	88		}
89	89
90		-	var xNewWithAttributesTreeViewColumn func(string, uintptr, ...interface{}) uintptr
	90	+	var xNewTreeViewColumnWithAttributes func(string, uintptr, ...interface{}) uintptr
91	91
92	92		// Creates a new `GtkTreeViewColumn` with a number of default values.
93	93		// This is equivalent to calling gtk_tree_view_column_set_title(),

@@ -111,10 +111,10 @@ var xNewWithAttributesTreeViewColumn func(string, uintptr, ...interface{}) uintp
111	111		// }
112	112		//
113	113		// ]\|
114		-	func NewWithAttributesTreeViewColumn(TitleVar string, CellVar CellRenderer, varArgs ...interface{}) TreeViewColumn {
	114	+	func NewTreeViewColumnWithAttributes(TitleVar string, CellVar CellRenderer, varArgs ...interface{}) TreeViewColumn {
115	115		var cls *TreeViewColumn
116	116
117		-	cret := xNewWithAttributesTreeViewColumn(TitleVar, CellVar.GoPointer(), varArgs...)
	117	+	cret := xNewTreeViewColumnWithAttributes(TitleVar, CellVar.GoPointer(), varArgs...)
118	118
119	119		if cret == 0 {
120	120		return nil

@@ -761,8 +761,8 @@ func init() {
761	761		}
762	762
763	763		core.PuregoSafeRegister(&xNewTreeViewColumn, lib, "gtk_tree_view_column_new")
764		-	core.PuregoSafeRegister(&xNewWithAreaTreeViewColumn, lib, "gtk_tree_view_column_new_with_area")
765		-	core.PuregoSafeRegister(&xNewWithAttributesTreeViewColumn, lib, "gtk_tree_view_column_new_with_attributes")
	764	+	core.PuregoSafeRegister(&xNewTreeViewColumnWithArea, lib, "gtk_tree_view_column_new_with_area")
	765	+	core.PuregoSafeRegister(&xNewTreeViewColumnWithAttributes, lib, "gtk_tree_view_column_new_with_attributes")
766	766
767	767		core.PuregoSafeRegister(&xTreeViewColumnAddAttribute, lib, "gtk_tree_view_column_add_attribute")
768	768		core.PuregoSafeRegister(&xTreeViewColumnCellGetPosition, lib, "gtk_tree_view_column_cell_get_position")

M v4/gtk/gtktypes.go +8 -8


@@ -30,21 +30,21 @@ func (x *Bitset) GoPointer() uintptr {
30	30		return uintptr(unsafe.Pointer(x))
31	31		}
32	32
33		-	var xNewEmptyBitset func() *Bitset
	33	+	var xNewBitsetEmpty func() *Bitset
34	34
35	35		// Creates a new empty bitset.
36		-	func NewEmptyBitset() *Bitset {
	36	+	func NewBitsetEmpty() *Bitset {
37	37
38		-	cret := xNewEmptyBitset()
	38	+	cret := xNewBitsetEmpty()
39	39		return cret
40	40		}
41	41
42		-	var xNewRangeBitset func(uint, uint) *Bitset
	42	+	var xNewBitsetRange func(uint, uint) *Bitset
43	43
44	44		// Creates a bitset with the given range set.
45		-	func NewRangeBitset(StartVar uint, NItemsVar uint) *Bitset {
	45	+	func NewBitsetRange(StartVar uint, NItemsVar uint) *Bitset {
46	46
47		-	cret := xNewRangeBitset(StartVar, NItemsVar)
	47	+	cret := xNewBitsetRange(StartVar, NItemsVar)
48	48		return cret
49	49		}
50	50

@@ -379,8 +379,8 @@ func init() {
379	379		panic(err)
380	380		}
381	381
382		-	core.PuregoSafeRegister(&xNewEmptyBitset, lib, "gtk_bitset_new_empty")
383		-	core.PuregoSafeRegister(&xNewRangeBitset, lib, "gtk_bitset_new_range")
	382	+	core.PuregoSafeRegister(&xNewBitsetEmpty, lib, "gtk_bitset_new_empty")
	383	+	core.PuregoSafeRegister(&xNewBitsetRange, lib, "gtk_bitset_new_range")
384	384
385	385		core.PuregoSafeRegister(&xBitsetAdd, lib, "gtk_bitset_add")
386	386		core.PuregoSafeRegister(&xBitsetAddRange, lib, "gtk_bitset_add_range")

M v4/gtk/gtkvideo.go +16 -16


@@ -59,13 +59,13 @@ func NewVideo() *Video {
59	59		return cls
60	60		}
61	61
62		-	var xNewForFileVideo func(uintptr) uintptr
	62	+	var xNewVideoForFile func(uintptr) uintptr
63	63
64	64		// Creates a `GtkVideo` to play back the given @file.
65		-	func NewForFileVideo(FileVar gio.File) *Video {
	65	+	func NewVideoForFile(FileVar gio.File) *Video {
66	66		var cls *Video
67	67
68		-	cret := xNewForFileVideo(FileVar.GoPointer())
	68	+	cret := xNewVideoForFile(FileVar.GoPointer())
69	69
70	70		if cret == 0 {
71	71		return nil

@@ -76,16 +76,16 @@ func NewForFileVideo(FileVar gio.File) *Video {
76	76		return cls
77	77		}
78	78
79		-	var xNewForFilenameVideo func(string) uintptr
	79	+	var xNewVideoForFilename func(string) uintptr
80	80
81	81		// Creates a `GtkVideo` to play back the given @filename.
82	82		//
83	83		// This is a utility function that calls [ctor@Gtk.Video.new_for_file],
84	84		// See that function for details.
85		-	func NewForFilenameVideo(FilenameVar string) *Video {
	85	+	func NewVideoForFilename(FilenameVar string) *Video {
86	86		var cls *Video
87	87
88		-	cret := xNewForFilenameVideo(FilenameVar)
	88	+	cret := xNewVideoForFilename(FilenameVar)
89	89
90	90		if cret == 0 {
91	91		return nil

@@ -96,13 +96,13 @@ func NewForFilenameVideo(FilenameVar string) *Video {
96	96		return cls
97	97		}
98	98
99		-	var xNewForMediaStreamVideo func(uintptr) uintptr
	99	+	var xNewVideoForMediaStream func(uintptr) uintptr
100	100
101	101		// Creates a `GtkVideo` to play back the given @stream.
102		-	func NewForMediaStreamVideo(StreamVar MediaStream) Video {
	102	+	func NewVideoForMediaStream(StreamVar MediaStream) Video {
103	103		var cls *Video
104	104
105		-	cret := xNewForMediaStreamVideo(StreamVar.GoPointer())
	105	+	cret := xNewVideoForMediaStream(StreamVar.GoPointer())
106	106
107	107		if cret == 0 {
108	108		return nil

@@ -113,16 +113,16 @@ func NewForMediaStreamVideo(StreamVar MediaStream) Video {
113	113		return cls
114	114		}
115	115
116		-	var xNewForResourceVideo func(string) uintptr
	116	+	var xNewVideoForResource func(string) uintptr
117	117
118	118		// Creates a `GtkVideo` to play back the resource at the
119	119		// given @resource_path.
120	120		//
121	121		// This is a utility function that calls [ctor@Gtk.Video.new_for_file].
122		-	func NewForResourceVideo(ResourcePathVar string) *Video {
	122	+	func NewVideoForResource(ResourcePathVar string) *Video {
123	123		var cls *Video
124	124
125		-	cret := xNewForResourceVideo(ResourcePathVar)
	125	+	cret := xNewVideoForResource(ResourcePathVar)
126	126
127	127		if cret == 0 {
128	128		return nil

@@ -410,10 +410,10 @@ func init() {
410	410		}
411	411
412	412		core.PuregoSafeRegister(&xNewVideo, lib, "gtk_video_new")
413		-	core.PuregoSafeRegister(&xNewForFileVideo, lib, "gtk_video_new_for_file")
414		-	core.PuregoSafeRegister(&xNewForFilenameVideo, lib, "gtk_video_new_for_filename")
415		-	core.PuregoSafeRegister(&xNewForMediaStreamVideo, lib, "gtk_video_new_for_media_stream")
416		-	core.PuregoSafeRegister(&xNewForResourceVideo, lib, "gtk_video_new_for_resource")
	413	+	core.PuregoSafeRegister(&xNewVideoForFile, lib, "gtk_video_new_for_file")
	414	+	core.PuregoSafeRegister(&xNewVideoForFilename, lib, "gtk_video_new_for_filename")
	415	+	core.PuregoSafeRegister(&xNewVideoForMediaStream, lib, "gtk_video_new_for_media_stream")
	416	+	core.PuregoSafeRegister(&xNewVideoForResource, lib, "gtk_video_new_for_resource")
417	417
418	418		core.PuregoSafeRegister(&xVideoGetAutoplay, lib, "gtk_video_get_autoplay")
419	419		core.PuregoSafeRegister(&xVideoGetFile, lib, "gtk_video_get_file")

M v4/pango/pango-tabs.go +4 -4


@@ -32,15 +32,15 @@ func NewTabArray(InitialSizeVar int, PositionsInPixelsVar bool) *TabArray {
32	32		return cret
33	33		}
34	34
35		-	var xNewWithPositionsTabArray func(int, bool, TabAlign, int, ...interface{}) *TabArray
	35	+	var xNewTabArrayWithPositions func(int, bool, TabAlign, int, ...interface{}) *TabArray
36	36
37	37		// Creates a `PangoTabArray` and allows you to specify the alignment
38	38		// and position of each tab stop.
39	39		//
40	40		// You must provide an alignment and position for @size tab stops.
41		-	func NewWithPositionsTabArray(SizeVar int, PositionsInPixelsVar bool, FirstAlignmentVar TabAlign, FirstPositionVar int, varArgs ...interface{}) *TabArray {
	41	+	func NewTabArrayWithPositions(SizeVar int, PositionsInPixelsVar bool, FirstAlignmentVar TabAlign, FirstPositionVar int, varArgs ...interface{}) *TabArray {
42	42
43		-	cret := xNewWithPositionsTabArray(SizeVar, PositionsInPixelsVar, FirstAlignmentVar, FirstPositionVar, varArgs...)
	43	+	cret := xNewTabArrayWithPositions(SizeVar, PositionsInPixelsVar, FirstAlignmentVar, FirstPositionVar, varArgs...)
44	44		return cret
45	45		}
46	46

@@ -234,7 +234,7 @@ func init() {
234	234		core.PuregoSafeRegister(&xTabArrayFromString, lib, "pango_tab_array_from_string")
235	235
236	236		core.PuregoSafeRegister(&xNewTabArray, lib, "pango_tab_array_new")
237		-	core.PuregoSafeRegister(&xNewWithPositionsTabArray, lib, "pango_tab_array_new_with_positions")
	237	+	core.PuregoSafeRegister(&xNewTabArrayWithPositions, lib, "pango_tab_array_new_with_positions")
238	238
239	239		core.PuregoSafeRegister(&xTabArrayCopy, lib, "pango_tab_array_copy")
240	240		core.PuregoSafeRegister(&xTabArrayFree, lib, "pango_tab_array_free")