28ec147 Gen: Re-run script · purego

M v4/adw/adw-about-dialog.go +678 -1


@@ -995,6 +995,683 @@ func (c *AboutDialog) SetGoPointer(ptr uintptr) {
995		c.Ptr = ptr	995		c.Ptr = ptr
996		}	996		}
997			997
			998	+	// SetPropertyApplicationIcon sets the "application-icon" property.
			999	+	// The name of the application icon.
			1000	+	//
			1001	+	// The icon is displayed at the top of the main page.
			1002	+	func (x *AboutDialog) SetPropertyApplicationIcon(value string) {
			1003	+	var v gobject.Value
			1004	+	v.Init(gobject.TypeStringVal)
			1005	+	v.SetString(value)
			1006	+	x.SetProperty("application-icon", &v)
			1007	+	}
			1008	+
			1009	+	// GetPropertyApplicationIcon gets the "application-icon" property.
			1010	+	// The name of the application icon.
			1011	+	//
			1012	+	// The icon is displayed at the top of the main page.
			1013	+	func (x *AboutDialog) GetPropertyApplicationIcon() string {
			1014	+	var v gobject.Value
			1015	+	x.GetProperty("application-icon", &v)
			1016	+	return v.GetString()
			1017	+	}
			1018	+
			1019	+	// SetPropertyApplicationName sets the "application-name" property.
			1020	+	// The name of the application.
			1021	+	//
			1022	+	// The name is displayed at the top of the main page.
			1023	+	func (x *AboutDialog) SetPropertyApplicationName(value string) {
			1024	+	var v gobject.Value
			1025	+	v.Init(gobject.TypeStringVal)
			1026	+	v.SetString(value)
			1027	+	x.SetProperty("application-name", &v)
			1028	+	}
			1029	+
			1030	+	// GetPropertyApplicationName gets the "application-name" property.
			1031	+	// The name of the application.
			1032	+	//
			1033	+	// The name is displayed at the top of the main page.
			1034	+	func (x *AboutDialog) GetPropertyApplicationName() string {
			1035	+	var v gobject.Value
			1036	+	x.GetProperty("application-name", &v)
			1037	+	return v.GetString()
			1038	+	}
			1039	+
			1040	+	// SetPropertyArtists sets the "artists" property.
			1041	+	// The list of artists of the application.
			1042	+	//
			1043	+	// It will be displayed on the Credits page.
			1044	+	//
			1045	+	// Each name may contain email addresses and URLs, see the introduction for
			1046	+	// more details.
			1047	+	//
			1048	+	// See also:
			1049	+	//
			1050	+	// * [property@AboutDialog:developers]
			1051	+	// * [property@AboutDialog:designers]
			1052	+	// * [property@AboutDialog:documenters]
			1053	+	// * [property@AboutDialog:translator-credits]
			1054	+	// * [method@AboutDialog.add_credit_section]
			1055	+	// * [method@AboutDialog.add_acknowledgement_section]
			1056	+	func (x *AboutDialog) SetPropertyArtists(value []string) {
			1057	+	var v gobject.Value
			1058	+	v.Init(glib.StrvGetType())
			1059	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			1060	+	x.SetProperty("artists", &v)
			1061	+	}
			1062	+
			1063	+	// GetPropertyArtists gets the "artists" property.
			1064	+	// The list of artists of the application.
			1065	+	//
			1066	+	// It will be displayed on the Credits page.
			1067	+	//
			1068	+	// Each name may contain email addresses and URLs, see the introduction for
			1069	+	// more details.
			1070	+	//
			1071	+	// See also:
			1072	+	//
			1073	+	// * [property@AboutDialog:developers]
			1074	+	// * [property@AboutDialog:designers]
			1075	+	// * [property@AboutDialog:documenters]
			1076	+	// * [property@AboutDialog:translator-credits]
			1077	+	// * [method@AboutDialog.add_credit_section]
			1078	+	// * [method@AboutDialog.add_acknowledgement_section]
			1079	+	func (x *AboutDialog) GetPropertyArtists() []string {
			1080	+	var v gobject.Value
			1081	+	x.GetProperty("artists", &v)
			1082	+	return core.GoStringSlice(v.GetBoxed())
			1083	+	}
			1084	+
			1085	+	// SetPropertyComments sets the "comments" property.
			1086	+	// The comments about the application.
			1087	+	//
			1088	+	// Comments will be shown on the Details page, above links.
			1089	+	//
			1090	+	// Unlike [property@Gtk.AboutDialog:comments], this string can be long and
			1091	+	// detailed. It can also contain links and Pango markup.
			1092	+	func (x *AboutDialog) SetPropertyComments(value string) {
			1093	+	var v gobject.Value
			1094	+	v.Init(gobject.TypeStringVal)
			1095	+	v.SetString(value)
			1096	+	x.SetProperty("comments", &v)
			1097	+	}
			1098	+
			1099	+	// GetPropertyComments gets the "comments" property.
			1100	+	// The comments about the application.
			1101	+	//
			1102	+	// Comments will be shown on the Details page, above links.
			1103	+	//
			1104	+	// Unlike [property@Gtk.AboutDialog:comments], this string can be long and
			1105	+	// detailed. It can also contain links and Pango markup.
			1106	+	func (x *AboutDialog) GetPropertyComments() string {
			1107	+	var v gobject.Value
			1108	+	x.GetProperty("comments", &v)
			1109	+	return v.GetString()
			1110	+	}
			1111	+
			1112	+	// SetPropertyCopyright sets the "copyright" property.
			1113	+	// The copyright information.
			1114	+	//
			1115	+	// This should be a short string of one or two lines, for example:
			1116	+	// `© 2022 Example`.
			1117	+	//
			1118	+	// The copyright information will be displayed on the Legal page, above the
			1119	+	// application license.
			1120	+	//
			1121	+	// [method@AboutDialog.add_legal_section] can be used to add copyright
			1122	+	// information for the application dependencies or other components.
			1123	+	func (x *AboutDialog) SetPropertyCopyright(value string) {
			1124	+	var v gobject.Value
			1125	+	v.Init(gobject.TypeStringVal)
			1126	+	v.SetString(value)
			1127	+	x.SetProperty("copyright", &v)
			1128	+	}
			1129	+
			1130	+	// GetPropertyCopyright gets the "copyright" property.
			1131	+	// The copyright information.
			1132	+	//
			1133	+	// This should be a short string of one or two lines, for example:
			1134	+	// `© 2022 Example`.
			1135	+	//
			1136	+	// The copyright information will be displayed on the Legal page, above the
			1137	+	// application license.
			1138	+	//
			1139	+	// [method@AboutDialog.add_legal_section] can be used to add copyright
			1140	+	// information for the application dependencies or other components.
			1141	+	func (x *AboutDialog) GetPropertyCopyright() string {
			1142	+	var v gobject.Value
			1143	+	x.GetProperty("copyright", &v)
			1144	+	return v.GetString()
			1145	+	}
			1146	+
			1147	+	// SetPropertyDebugInfo sets the "debug-info" property.
			1148	+	// The debug information.
			1149	+	//
			1150	+	// Debug information will be shown on the Troubleshooting page. It's intended
			1151	+	// to be attached to issue reports when reporting issues against the
			1152	+	// application.
			1153	+	//
			1154	+	// `AdwAboutDialog` provides a quick way to save debug information to a file.
			1155	+	// When saving, [property@AboutDialog:debug-info-filename] would be used as
			1156	+	// the suggested filename.
			1157	+	//
			1158	+	// Debug information cannot contain markup or links.
			1159	+	func (x *AboutDialog) SetPropertyDebugInfo(value string) {
			1160	+	var v gobject.Value
			1161	+	v.Init(gobject.TypeStringVal)
			1162	+	v.SetString(value)
			1163	+	x.SetProperty("debug-info", &v)
			1164	+	}
			1165	+
			1166	+	// GetPropertyDebugInfo gets the "debug-info" property.
			1167	+	// The debug information.
			1168	+	//
			1169	+	// Debug information will be shown on the Troubleshooting page. It's intended
			1170	+	// to be attached to issue reports when reporting issues against the
			1171	+	// application.
			1172	+	//
			1173	+	// `AdwAboutDialog` provides a quick way to save debug information to a file.
			1174	+	// When saving, [property@AboutDialog:debug-info-filename] would be used as
			1175	+	// the suggested filename.
			1176	+	//
			1177	+	// Debug information cannot contain markup or links.
			1178	+	func (x *AboutDialog) GetPropertyDebugInfo() string {
			1179	+	var v gobject.Value
			1180	+	x.GetProperty("debug-info", &v)
			1181	+	return v.GetString()
			1182	+	}
			1183	+
			1184	+	// SetPropertyDebugInfoFilename sets the "debug-info-filename" property.
			1185	+	// The debug information filename.
			1186	+	//
			1187	+	// It will be used as the suggested filename when saving debug information to
			1188	+	// a file.
			1189	+	//
			1190	+	// See [property@AboutDialog:debug-info].
			1191	+	func (x *AboutDialog) SetPropertyDebugInfoFilename(value string) {
			1192	+	var v gobject.Value
			1193	+	v.Init(gobject.TypeStringVal)
			1194	+	v.SetString(value)
			1195	+	x.SetProperty("debug-info-filename", &v)
			1196	+	}
			1197	+
			1198	+	// GetPropertyDebugInfoFilename gets the "debug-info-filename" property.
			1199	+	// The debug information filename.
			1200	+	//
			1201	+	// It will be used as the suggested filename when saving debug information to
			1202	+	// a file.
			1203	+	//
			1204	+	// See [property@AboutDialog:debug-info].
			1205	+	func (x *AboutDialog) GetPropertyDebugInfoFilename() string {
			1206	+	var v gobject.Value
			1207	+	x.GetProperty("debug-info-filename", &v)
			1208	+	return v.GetString()
			1209	+	}
			1210	+
			1211	+	// SetPropertyDesigners sets the "designers" property.
			1212	+	// The list of designers of the application.
			1213	+	//
			1214	+	// It will be displayed on the Credits page.
			1215	+	//
			1216	+	// Each name may contain email addresses and URLs, see the introduction for
			1217	+	// more details.
			1218	+	//
			1219	+	// See also:
			1220	+	//
			1221	+	// * [property@AboutDialog:developers]
			1222	+	// * [property@AboutDialog:artists]
			1223	+	// * [property@AboutDialog:documenters]
			1224	+	// * [property@AboutDialog:translator-credits]
			1225	+	// * [method@AboutDialog.add_credit_section]
			1226	+	// * [method@AboutDialog.add_acknowledgement_section]
			1227	+	func (x *AboutDialog) SetPropertyDesigners(value []string) {
			1228	+	var v gobject.Value
			1229	+	v.Init(glib.StrvGetType())
			1230	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			1231	+	x.SetProperty("designers", &v)
			1232	+	}
			1233	+
			1234	+	// GetPropertyDesigners gets the "designers" property.
			1235	+	// The list of designers of the application.
			1236	+	//
			1237	+	// It will be displayed on the Credits page.
			1238	+	//
			1239	+	// Each name may contain email addresses and URLs, see the introduction for
			1240	+	// more details.
			1241	+	//
			1242	+	// See also:
			1243	+	//
			1244	+	// * [property@AboutDialog:developers]
			1245	+	// * [property@AboutDialog:artists]
			1246	+	// * [property@AboutDialog:documenters]
			1247	+	// * [property@AboutDialog:translator-credits]
			1248	+	// * [method@AboutDialog.add_credit_section]
			1249	+	// * [method@AboutDialog.add_acknowledgement_section]
			1250	+	func (x *AboutDialog) GetPropertyDesigners() []string {
			1251	+	var v gobject.Value
			1252	+	x.GetProperty("designers", &v)
			1253	+	return core.GoStringSlice(v.GetBoxed())
			1254	+	}
			1255	+
			1256	+	// SetPropertyDeveloperName sets the "developer-name" property.
			1257	+	// The developer name.
			1258	+	//
			1259	+	// The developer name is displayed on the main page, under the application
			1260	+	// name.
			1261	+	//
			1262	+	// If the application is developed by multiple people, the developer name can
			1263	+	// be set to values like "AppName team", "AppName developers" or
			1264	+	// "The AppName project", and the individual contributors can be listed on the
			1265	+	// Credits page, with [property@AboutDialog:developers] and related
			1266	+	// properties.
			1267	+	func (x *AboutDialog) SetPropertyDeveloperName(value string) {
			1268	+	var v gobject.Value
			1269	+	v.Init(gobject.TypeStringVal)
			1270	+	v.SetString(value)
			1271	+	x.SetProperty("developer-name", &v)
			1272	+	}
			1273	+
			1274	+	// GetPropertyDeveloperName gets the "developer-name" property.
			1275	+	// The developer name.
			1276	+	//
			1277	+	// The developer name is displayed on the main page, under the application
			1278	+	// name.
			1279	+	//
			1280	+	// If the application is developed by multiple people, the developer name can
			1281	+	// be set to values like "AppName team", "AppName developers" or
			1282	+	// "The AppName project", and the individual contributors can be listed on the
			1283	+	// Credits page, with [property@AboutDialog:developers] and related
			1284	+	// properties.
			1285	+	func (x *AboutDialog) GetPropertyDeveloperName() string {
			1286	+	var v gobject.Value
			1287	+	x.GetProperty("developer-name", &v)
			1288	+	return v.GetString()
			1289	+	}
			1290	+
			1291	+	// SetPropertyDevelopers sets the "developers" property.
			1292	+	// The list of developers of the application.
			1293	+	//
			1294	+	// It will be displayed on the Credits page.
			1295	+	//
			1296	+	// Each name may contain email addresses and URLs, see the introduction for
			1297	+	// more details.
			1298	+	//
			1299	+	// See also:
			1300	+	//
			1301	+	// * [property@AboutDialog:designers]
			1302	+	// * [property@AboutDialog:artists]
			1303	+	// * [property@AboutDialog:documenters]
			1304	+	// * [property@AboutDialog:translator-credits]
			1305	+	// * [method@AboutDialog.add_credit_section]
			1306	+	// * [method@AboutDialog.add_acknowledgement_section]
			1307	+	func (x *AboutDialog) SetPropertyDevelopers(value []string) {
			1308	+	var v gobject.Value
			1309	+	v.Init(glib.StrvGetType())
			1310	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			1311	+	x.SetProperty("developers", &v)
			1312	+	}
			1313	+
			1314	+	// GetPropertyDevelopers gets the "developers" property.
			1315	+	// The list of developers of the application.
			1316	+	//
			1317	+	// It will be displayed on the Credits page.
			1318	+	//
			1319	+	// Each name may contain email addresses and URLs, see the introduction for
			1320	+	// more details.
			1321	+	//
			1322	+	// See also:
			1323	+	//
			1324	+	// * [property@AboutDialog:designers]
			1325	+	// * [property@AboutDialog:artists]
			1326	+	// * [property@AboutDialog:documenters]
			1327	+	// * [property@AboutDialog:translator-credits]
			1328	+	// * [method@AboutDialog.add_credit_section]
			1329	+	// * [method@AboutDialog.add_acknowledgement_section]
			1330	+	func (x *AboutDialog) GetPropertyDevelopers() []string {
			1331	+	var v gobject.Value
			1332	+	x.GetProperty("developers", &v)
			1333	+	return core.GoStringSlice(v.GetBoxed())
			1334	+	}
			1335	+
			1336	+	// SetPropertyDocumenters sets the "documenters" property.
			1337	+	// The list of documenters of the application.
			1338	+	//
			1339	+	// It will be displayed on the Credits page.
			1340	+	//
			1341	+	// Each name may contain email addresses and URLs, see the introduction for
			1342	+	// more details.
			1343	+	//
			1344	+	// See also:
			1345	+	//
			1346	+	// * [property@AboutDialog:developers]
			1347	+	// * [property@AboutDialog:designers]
			1348	+	// * [property@AboutDialog:artists]
			1349	+	// * [property@AboutDialog:translator-credits]
			1350	+	// * [method@AboutDialog.add_credit_section]
			1351	+	// * [method@AboutDialog.add_acknowledgement_section]
			1352	+	func (x *AboutDialog) SetPropertyDocumenters(value []string) {
			1353	+	var v gobject.Value
			1354	+	v.Init(glib.StrvGetType())
			1355	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			1356	+	x.SetProperty("documenters", &v)
			1357	+	}
			1358	+
			1359	+	// GetPropertyDocumenters gets the "documenters" property.
			1360	+	// The list of documenters of the application.
			1361	+	//
			1362	+	// It will be displayed on the Credits page.
			1363	+	//
			1364	+	// Each name may contain email addresses and URLs, see the introduction for
			1365	+	// more details.
			1366	+	//
			1367	+	// See also:
			1368	+	//
			1369	+	// * [property@AboutDialog:developers]
			1370	+	// * [property@AboutDialog:designers]
			1371	+	// * [property@AboutDialog:artists]
			1372	+	// * [property@AboutDialog:translator-credits]
			1373	+	// * [method@AboutDialog.add_credit_section]
			1374	+	// * [method@AboutDialog.add_acknowledgement_section]
			1375	+	func (x *AboutDialog) GetPropertyDocumenters() []string {
			1376	+	var v gobject.Value
			1377	+	x.GetProperty("documenters", &v)
			1378	+	return core.GoStringSlice(v.GetBoxed())
			1379	+	}
			1380	+
			1381	+	// SetPropertyIssueUrl sets the "issue-url" property.
			1382	+	// The URL for the application's issue tracker.
			1383	+	//
			1384	+	// The issue tracker link is displayed on the main page.
			1385	+	func (x *AboutDialog) SetPropertyIssueUrl(value string) {
			1386	+	var v gobject.Value
			1387	+	v.Init(gobject.TypeStringVal)
			1388	+	v.SetString(value)
			1389	+	x.SetProperty("issue-url", &v)
			1390	+	}
			1391	+
			1392	+	// GetPropertyIssueUrl gets the "issue-url" property.
			1393	+	// The URL for the application's issue tracker.
			1394	+	//
			1395	+	// The issue tracker link is displayed on the main page.
			1396	+	func (x *AboutDialog) GetPropertyIssueUrl() string {
			1397	+	var v gobject.Value
			1398	+	x.GetProperty("issue-url", &v)
			1399	+	return v.GetString()
			1400	+	}
			1401	+
			1402	+	// SetPropertyLicense sets the "license" property.
			1403	+	// The license text.
			1404	+	//
			1405	+	// This can be used to set a custom text for the license if it can't be set
			1406	+	// via [property@AboutDialog:license-type].
			1407	+	//
			1408	+	// When set, [property@AboutDialog:license-type] will be set to
			1409	+	// `GTK_LICENSE_CUSTOM`.
			1410	+	//
			1411	+	// The license text will be displayed on the Legal page, below the copyright
			1412	+	// information.
			1413	+	//
			1414	+	// License text can contain Pango markup and links.
			1415	+	//
			1416	+	// [method@AboutDialog.add_legal_section] can be used to add license
			1417	+	// information for the application dependencies or other components.
			1418	+	func (x *AboutDialog) SetPropertyLicense(value string) {
			1419	+	var v gobject.Value
			1420	+	v.Init(gobject.TypeStringVal)
			1421	+	v.SetString(value)
			1422	+	x.SetProperty("license", &v)
			1423	+	}
			1424	+
			1425	+	// GetPropertyLicense gets the "license" property.
			1426	+	// The license text.
			1427	+	//
			1428	+	// This can be used to set a custom text for the license if it can't be set
			1429	+	// via [property@AboutDialog:license-type].
			1430	+	//
			1431	+	// When set, [property@AboutDialog:license-type] will be set to
			1432	+	// `GTK_LICENSE_CUSTOM`.
			1433	+	//
			1434	+	// The license text will be displayed on the Legal page, below the copyright
			1435	+	// information.
			1436	+	//
			1437	+	// License text can contain Pango markup and links.
			1438	+	//
			1439	+	// [method@AboutDialog.add_legal_section] can be used to add license
			1440	+	// information for the application dependencies or other components.
			1441	+	func (x *AboutDialog) GetPropertyLicense() string {
			1442	+	var v gobject.Value
			1443	+	x.GetProperty("license", &v)
			1444	+	return v.GetString()
			1445	+	}
			1446	+
			1447	+	// SetPropertyReleaseNotes sets the "release-notes" property.
			1448	+	// The release notes of the application.
			1449	+	//
			1450	+	// Release notes are displayed on the the What's New page.
			1451	+	//
			1452	+	// Release notes are formatted the same way as
			1453	+	// [AppStream descriptions](https://freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-description).
			1454	+	//
			1455	+	// The supported formatting options are:
			1456	+	//
			1457	+	// * Paragraph (`<p>`)
			1458	+	// * Ordered list (`<ol>`), with list items (`<li>`)
			1459	+	// * Unordered list (`<ul>`), with list items (`<li>`)
			1460	+	//
			1461	+	// Within paragraphs and list items, emphasis (`<em>`) and inline code
			1462	+	// (`<code>`) text styles are supported. The emphasis is rendered in italic,
			1463	+	// while inline code is shown in a monospaced font.
			1464	+	//
			1465	+	// Any text outside paragraphs or list items is ignored.
			1466	+	//
			1467	+	// Nested lists are not supported.
			1468	+	//
			1469	+	// `AdwAboutDialog` displays the version above the release notes. If set, the
			1470	+	// [property@AboutDialog:release-notes-version] of the property will be used
			1471	+	// as the version; otherwise, [property@AboutDialog:version] is used.
			1472	+	func (x *AboutDialog) SetPropertyReleaseNotes(value string) {
			1473	+	var v gobject.Value
			1474	+	v.Init(gobject.TypeStringVal)
			1475	+	v.SetString(value)
			1476	+	x.SetProperty("release-notes", &v)
			1477	+	}
			1478	+
			1479	+	// GetPropertyReleaseNotes gets the "release-notes" property.
			1480	+	// The release notes of the application.
			1481	+	//
			1482	+	// Release notes are displayed on the the What's New page.
			1483	+	//
			1484	+	// Release notes are formatted the same way as
			1485	+	// [AppStream descriptions](https://freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-description).
			1486	+	//
			1487	+	// The supported formatting options are:
			1488	+	//
			1489	+	// * Paragraph (`<p>`)
			1490	+	// * Ordered list (`<ol>`), with list items (`<li>`)
			1491	+	// * Unordered list (`<ul>`), with list items (`<li>`)
			1492	+	//
			1493	+	// Within paragraphs and list items, emphasis (`<em>`) and inline code
			1494	+	// (`<code>`) text styles are supported. The emphasis is rendered in italic,
			1495	+	// while inline code is shown in a monospaced font.
			1496	+	//
			1497	+	// Any text outside paragraphs or list items is ignored.
			1498	+	//
			1499	+	// Nested lists are not supported.
			1500	+	//
			1501	+	// `AdwAboutDialog` displays the version above the release notes. If set, the
			1502	+	// [property@AboutDialog:release-notes-version] of the property will be used
			1503	+	// as the version; otherwise, [property@AboutDialog:version] is used.
			1504	+	func (x *AboutDialog) GetPropertyReleaseNotes() string {
			1505	+	var v gobject.Value
			1506	+	x.GetProperty("release-notes", &v)
			1507	+	return v.GetString()
			1508	+	}
			1509	+
			1510	+	// SetPropertyReleaseNotesVersion sets the "release-notes-version" property.
			1511	+	// The version described by the application's release notes.
			1512	+	//
			1513	+	// The release notes version is displayed on the What's New page, above the
			1514	+	// release notes.
			1515	+	//
			1516	+	// If not set, [property@AboutDialog:version] will be used instead.
			1517	+	//
			1518	+	// For example, an application with the current version 2.0.2 might want to
			1519	+	// keep the release notes from 2.0.0, and set the release notes version
			1520	+	// accordingly.
			1521	+	//
			1522	+	// See [property@AboutDialog:release-notes].
			1523	+	func (x *AboutDialog) SetPropertyReleaseNotesVersion(value string) {
			1524	+	var v gobject.Value
			1525	+	v.Init(gobject.TypeStringVal)
			1526	+	v.SetString(value)
			1527	+	x.SetProperty("release-notes-version", &v)
			1528	+	}
			1529	+
			1530	+	// GetPropertyReleaseNotesVersion gets the "release-notes-version" property.
			1531	+	// The version described by the application's release notes.
			1532	+	//
			1533	+	// The release notes version is displayed on the What's New page, above the
			1534	+	// release notes.
			1535	+	//
			1536	+	// If not set, [property@AboutDialog:version] will be used instead.
			1537	+	//
			1538	+	// For example, an application with the current version 2.0.2 might want to
			1539	+	// keep the release notes from 2.0.0, and set the release notes version
			1540	+	// accordingly.
			1541	+	//
			1542	+	// See [property@AboutDialog:release-notes].
			1543	+	func (x *AboutDialog) GetPropertyReleaseNotesVersion() string {
			1544	+	var v gobject.Value
			1545	+	x.GetProperty("release-notes-version", &v)
			1546	+	return v.GetString()
			1547	+	}
			1548	+
			1549	+	// SetPropertySupportUrl sets the "support-url" property.
			1550	+	// The URL of the application's support page.
			1551	+	//
			1552	+	// The support page link is displayed on the main page.
			1553	+	func (x *AboutDialog) SetPropertySupportUrl(value string) {
			1554	+	var v gobject.Value
			1555	+	v.Init(gobject.TypeStringVal)
			1556	+	v.SetString(value)
			1557	+	x.SetProperty("support-url", &v)
			1558	+	}
			1559	+
			1560	+	// GetPropertySupportUrl gets the "support-url" property.
			1561	+	// The URL of the application's support page.
			1562	+	//
			1563	+	// The support page link is displayed on the main page.
			1564	+	func (x *AboutDialog) GetPropertySupportUrl() string {
			1565	+	var v gobject.Value
			1566	+	x.GetProperty("support-url", &v)
			1567	+	return v.GetString()
			1568	+	}
			1569	+
			1570	+	// SetPropertyTranslatorCredits sets the "translator-credits" property.
			1571	+	// The translator credits string.
			1572	+	//
			1573	+	// It will be displayed on the Credits page.
			1574	+	//
			1575	+	// This string should be `"translator-credits"` or `"translator_credits"` and
			1576	+	// should be marked as translatable.
			1577	+	//
			1578	+	// The string may contain email addresses and URLs, see the introduction for
			1579	+	// more details.
			1580	+	//
			1581	+	// See also:
			1582	+	//
			1583	+	// * [property@AboutDialog:developers]
			1584	+	// * [property@AboutDialog:designers]
			1585	+	// * [property@AboutDialog:artists]
			1586	+	// * [property@AboutDialog:documenters]
			1587	+	// * [method@AboutDialog.add_credit_section]
			1588	+	// * [method@AboutDialog.add_acknowledgement_section]
			1589	+	func (x *AboutDialog) SetPropertyTranslatorCredits(value string) {
			1590	+	var v gobject.Value
			1591	+	v.Init(gobject.TypeStringVal)
			1592	+	v.SetString(value)
			1593	+	x.SetProperty("translator-credits", &v)
			1594	+	}
			1595	+
			1596	+	// GetPropertyTranslatorCredits gets the "translator-credits" property.
			1597	+	// The translator credits string.
			1598	+	//
			1599	+	// It will be displayed on the Credits page.
			1600	+	//
			1601	+	// This string should be `"translator-credits"` or `"translator_credits"` and
			1602	+	// should be marked as translatable.
			1603	+	//
			1604	+	// The string may contain email addresses and URLs, see the introduction for
			1605	+	// more details.
			1606	+	//
			1607	+	// See also:
			1608	+	//
			1609	+	// * [property@AboutDialog:developers]
			1610	+	// * [property@AboutDialog:designers]
			1611	+	// * [property@AboutDialog:artists]
			1612	+	// * [property@AboutDialog:documenters]
			1613	+	// * [method@AboutDialog.add_credit_section]
			1614	+	// * [method@AboutDialog.add_acknowledgement_section]
			1615	+	func (x *AboutDialog) GetPropertyTranslatorCredits() string {
			1616	+	var v gobject.Value
			1617	+	x.GetProperty("translator-credits", &v)
			1618	+	return v.GetString()
			1619	+	}
			1620	+
			1621	+	// SetPropertyVersion sets the "version" property.
			1622	+	// The version of the application.
			1623	+	//
			1624	+	// The version is displayed on the main page.
			1625	+	//
			1626	+	// If [property@AboutDialog:release-notes-version] is not set, the version
			1627	+	// will also be displayed above the release notes on the What's New page.
			1628	+	func (x *AboutDialog) SetPropertyVersion(value string) {
			1629	+	var v gobject.Value
			1630	+	v.Init(gobject.TypeStringVal)
			1631	+	v.SetString(value)
			1632	+	x.SetProperty("version", &v)
			1633	+	}
			1634	+
			1635	+	// GetPropertyVersion gets the "version" property.
			1636	+	// The version of the application.
			1637	+	//
			1638	+	// The version is displayed on the main page.
			1639	+	//
			1640	+	// If [property@AboutDialog:release-notes-version] is not set, the version
			1641	+	// will also be displayed above the release notes on the What's New page.
			1642	+	func (x *AboutDialog) GetPropertyVersion() string {
			1643	+	var v gobject.Value
			1644	+	x.GetProperty("version", &v)
			1645	+	return v.GetString()
			1646	+	}
			1647	+
			1648	+	// SetPropertyWebsite sets the "website" property.
			1649	+	// The URL of the application's website.
			1650	+	//
			1651	+	// Website is displayed on the Details page, below comments, or on the main
			1652	+	// page if the Details page doesn't have any other content.
			1653	+	//
			1654	+	// Applications can add other links below, see [method@AboutDialog.add_link].
			1655	+	func (x *AboutDialog) SetPropertyWebsite(value string) {
			1656	+	var v gobject.Value
			1657	+	v.Init(gobject.TypeStringVal)
			1658	+	v.SetString(value)
			1659	+	x.SetProperty("website", &v)
			1660	+	}
			1661	+
			1662	+	// GetPropertyWebsite gets the "website" property.
			1663	+	// The URL of the application's website.
			1664	+	//
			1665	+	// Website is displayed on the Details page, below comments, or on the main
			1666	+	// page if the Details page doesn't have any other content.
			1667	+	//
			1668	+	// Applications can add other links below, see [method@AboutDialog.add_link].
			1669	+	func (x *AboutDialog) GetPropertyWebsite() string {
			1670	+	var v gobject.Value
			1671	+	x.GetProperty("website", &v)
			1672	+	return v.GetString()
			1673	+	}
			1674	+
998		// Emitted when a URL is activated.	1675		// Emitted when a URL is activated.
999		//	1676		//
1000		// Applications may connect to it to override the default behavior, which is	1677		// Applications may connect to it to override the default behavior, which is

@@ -1075,7 +1752,7 @@ func (x AboutDialog) GetAtContext() gtk.ATContext {
1075		// This functionality can be overridden by `GtkAccessible`	1752		// This functionality can be overridden by `GtkAccessible`
1076		// implementations, e.g. to get the bounds from an ignored	1753		// implementations, e.g. to get the bounds from an ignored
1077		// child widget.	1754		// child widget.
1078	-	func (x *AboutDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	1755	+	func (x AboutDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
1079			1756
1080		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	1757		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
1081		return cret	1758		return cret

M v4/adw/adw-about-window.go +679 -2


@@ -965,6 +965,683 @@ func (c *AboutWindow) SetGoPointer(ptr uintptr) {
965		c.Ptr = ptr	965		c.Ptr = ptr
966		}	966		}
967			967
			968	+	// SetPropertyApplicationIcon sets the "application-icon" property.
			969	+	// The name of the application icon.
			970	+	//
			971	+	// The icon is displayed at the top of the main page.
			972	+	func (x *AboutWindow) SetPropertyApplicationIcon(value string) {
			973	+	var v gobject.Value
			974	+	v.Init(gobject.TypeStringVal)
			975	+	v.SetString(value)
			976	+	x.SetProperty("application-icon", &v)
			977	+	}
			978	+
			979	+	// GetPropertyApplicationIcon gets the "application-icon" property.
			980	+	// The name of the application icon.
			981	+	//
			982	+	// The icon is displayed at the top of the main page.
			983	+	func (x *AboutWindow) GetPropertyApplicationIcon() string {
			984	+	var v gobject.Value
			985	+	x.GetProperty("application-icon", &v)
			986	+	return v.GetString()
			987	+	}
			988	+
			989	+	// SetPropertyApplicationName sets the "application-name" property.
			990	+	// The name of the application.
			991	+	//
			992	+	// The name is displayed at the top of the main page.
			993	+	func (x *AboutWindow) SetPropertyApplicationName(value string) {
			994	+	var v gobject.Value
			995	+	v.Init(gobject.TypeStringVal)
			996	+	v.SetString(value)
			997	+	x.SetProperty("application-name", &v)
			998	+	}
			999	+
			1000	+	// GetPropertyApplicationName gets the "application-name" property.
			1001	+	// The name of the application.
			1002	+	//
			1003	+	// The name is displayed at the top of the main page.
			1004	+	func (x *AboutWindow) GetPropertyApplicationName() string {
			1005	+	var v gobject.Value
			1006	+	x.GetProperty("application-name", &v)
			1007	+	return v.GetString()
			1008	+	}
			1009	+
			1010	+	// SetPropertyArtists sets the "artists" property.
			1011	+	// The list of artists of the application.
			1012	+	//
			1013	+	// It will be displayed on the Credits page.
			1014	+	//
			1015	+	// Each name may contain email addresses and URLs, see the introduction for
			1016	+	// more details.
			1017	+	//
			1018	+	// See also:
			1019	+	//
			1020	+	// * [property@AboutWindow:developers]
			1021	+	// * [property@AboutWindow:designers]
			1022	+	// * [property@AboutWindow:documenters]
			1023	+	// * [property@AboutWindow:translator-credits]
			1024	+	// * [method@AboutWindow.add_credit_section]
			1025	+	// * [method@AboutWindow.add_acknowledgement_section]
			1026	+	func (x *AboutWindow) SetPropertyArtists(value []string) {
			1027	+	var v gobject.Value
			1028	+	v.Init(glib.StrvGetType())
			1029	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			1030	+	x.SetProperty("artists", &v)
			1031	+	}
			1032	+
			1033	+	// GetPropertyArtists gets the "artists" property.
			1034	+	// The list of artists of the application.
			1035	+	//
			1036	+	// It will be displayed on the Credits page.
			1037	+	//
			1038	+	// Each name may contain email addresses and URLs, see the introduction for
			1039	+	// more details.
			1040	+	//
			1041	+	// See also:
			1042	+	//
			1043	+	// * [property@AboutWindow:developers]
			1044	+	// * [property@AboutWindow:designers]
			1045	+	// * [property@AboutWindow:documenters]
			1046	+	// * [property@AboutWindow:translator-credits]
			1047	+	// * [method@AboutWindow.add_credit_section]
			1048	+	// * [method@AboutWindow.add_acknowledgement_section]
			1049	+	func (x *AboutWindow) GetPropertyArtists() []string {
			1050	+	var v gobject.Value
			1051	+	x.GetProperty("artists", &v)
			1052	+	return core.GoStringSlice(v.GetBoxed())
			1053	+	}
			1054	+
			1055	+	// SetPropertyComments sets the "comments" property.
			1056	+	// The comments about the application.
			1057	+	//
			1058	+	// Comments will be shown on the Details page, above links.
			1059	+	//
			1060	+	// Unlike [property@Gtk.AboutDialog:comments], this string can be long and
			1061	+	// detailed. It can also contain links and Pango markup.
			1062	+	func (x *AboutWindow) SetPropertyComments(value string) {
			1063	+	var v gobject.Value
			1064	+	v.Init(gobject.TypeStringVal)
			1065	+	v.SetString(value)
			1066	+	x.SetProperty("comments", &v)
			1067	+	}
			1068	+
			1069	+	// GetPropertyComments gets the "comments" property.
			1070	+	// The comments about the application.
			1071	+	//
			1072	+	// Comments will be shown on the Details page, above links.
			1073	+	//
			1074	+	// Unlike [property@Gtk.AboutDialog:comments], this string can be long and
			1075	+	// detailed. It can also contain links and Pango markup.
			1076	+	func (x *AboutWindow) GetPropertyComments() string {
			1077	+	var v gobject.Value
			1078	+	x.GetProperty("comments", &v)
			1079	+	return v.GetString()
			1080	+	}
			1081	+
			1082	+	// SetPropertyCopyright sets the "copyright" property.
			1083	+	// The copyright information.
			1084	+	//
			1085	+	// This should be a short string of one or two lines, for example:
			1086	+	// `© 2022 Example`.
			1087	+	//
			1088	+	// The copyright information will be displayed on the Legal page, above the
			1089	+	// application license.
			1090	+	//
			1091	+	// [method@AboutWindow.add_legal_section] can be used to add copyright
			1092	+	// information for the application dependencies or other components.
			1093	+	func (x *AboutWindow) SetPropertyCopyright(value string) {
			1094	+	var v gobject.Value
			1095	+	v.Init(gobject.TypeStringVal)
			1096	+	v.SetString(value)
			1097	+	x.SetProperty("copyright", &v)
			1098	+	}
			1099	+
			1100	+	// GetPropertyCopyright gets the "copyright" property.
			1101	+	// The copyright information.
			1102	+	//
			1103	+	// This should be a short string of one or two lines, for example:
			1104	+	// `© 2022 Example`.
			1105	+	//
			1106	+	// The copyright information will be displayed on the Legal page, above the
			1107	+	// application license.
			1108	+	//
			1109	+	// [method@AboutWindow.add_legal_section] can be used to add copyright
			1110	+	// information for the application dependencies or other components.
			1111	+	func (x *AboutWindow) GetPropertyCopyright() string {
			1112	+	var v gobject.Value
			1113	+	x.GetProperty("copyright", &v)
			1114	+	return v.GetString()
			1115	+	}
			1116	+
			1117	+	// SetPropertyDebugInfo sets the "debug-info" property.
			1118	+	// The debug information.
			1119	+	//
			1120	+	// Debug information will be shown on the Troubleshooting page. It's intended
			1121	+	// to be attached to issue reports when reporting issues against the
			1122	+	// application.
			1123	+	//
			1124	+	// `AdwAboutWindow` provides a quick way to save debug information to a file.
			1125	+	// When saving, [property@AboutWindow:debug-info-filename] would be used as
			1126	+	// the suggested filename.
			1127	+	//
			1128	+	// Debug information cannot contain markup or links.
			1129	+	func (x *AboutWindow) SetPropertyDebugInfo(value string) {
			1130	+	var v gobject.Value
			1131	+	v.Init(gobject.TypeStringVal)
			1132	+	v.SetString(value)
			1133	+	x.SetProperty("debug-info", &v)
			1134	+	}
			1135	+
			1136	+	// GetPropertyDebugInfo gets the "debug-info" property.
			1137	+	// The debug information.
			1138	+	//
			1139	+	// Debug information will be shown on the Troubleshooting page. It's intended
			1140	+	// to be attached to issue reports when reporting issues against the
			1141	+	// application.
			1142	+	//
			1143	+	// `AdwAboutWindow` provides a quick way to save debug information to a file.
			1144	+	// When saving, [property@AboutWindow:debug-info-filename] would be used as
			1145	+	// the suggested filename.
			1146	+	//
			1147	+	// Debug information cannot contain markup or links.
			1148	+	func (x *AboutWindow) GetPropertyDebugInfo() string {
			1149	+	var v gobject.Value
			1150	+	x.GetProperty("debug-info", &v)
			1151	+	return v.GetString()
			1152	+	}
			1153	+
			1154	+	// SetPropertyDebugInfoFilename sets the "debug-info-filename" property.
			1155	+	// The debug information filename.
			1156	+	//
			1157	+	// It will be used as the suggested filename when saving debug information to
			1158	+	// a file.
			1159	+	//
			1160	+	// See [property@AboutWindow:debug-info].
			1161	+	func (x *AboutWindow) SetPropertyDebugInfoFilename(value string) {
			1162	+	var v gobject.Value
			1163	+	v.Init(gobject.TypeStringVal)
			1164	+	v.SetString(value)
			1165	+	x.SetProperty("debug-info-filename", &v)
			1166	+	}
			1167	+
			1168	+	// GetPropertyDebugInfoFilename gets the "debug-info-filename" property.
			1169	+	// The debug information filename.
			1170	+	//
			1171	+	// It will be used as the suggested filename when saving debug information to
			1172	+	// a file.
			1173	+	//
			1174	+	// See [property@AboutWindow:debug-info].
			1175	+	func (x *AboutWindow) GetPropertyDebugInfoFilename() string {
			1176	+	var v gobject.Value
			1177	+	x.GetProperty("debug-info-filename", &v)
			1178	+	return v.GetString()
			1179	+	}
			1180	+
			1181	+	// SetPropertyDesigners sets the "designers" property.
			1182	+	// The list of designers of the application.
			1183	+	//
			1184	+	// It will be displayed on the Credits page.
			1185	+	//
			1186	+	// Each name may contain email addresses and URLs, see the introduction for
			1187	+	// more details.
			1188	+	//
			1189	+	// See also:
			1190	+	//
			1191	+	// * [property@AboutWindow:developers]
			1192	+	// * [property@AboutWindow:artists]
			1193	+	// * [property@AboutWindow:documenters]
			1194	+	// * [property@AboutWindow:translator-credits]
			1195	+	// * [method@AboutWindow.add_credit_section]
			1196	+	// * [method@AboutWindow.add_acknowledgement_section]
			1197	+	func (x *AboutWindow) SetPropertyDesigners(value []string) {
			1198	+	var v gobject.Value
			1199	+	v.Init(glib.StrvGetType())
			1200	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			1201	+	x.SetProperty("designers", &v)
			1202	+	}
			1203	+
			1204	+	// GetPropertyDesigners gets the "designers" property.
			1205	+	// The list of designers of the application.
			1206	+	//
			1207	+	// It will be displayed on the Credits page.
			1208	+	//
			1209	+	// Each name may contain email addresses and URLs, see the introduction for
			1210	+	// more details.
			1211	+	//
			1212	+	// See also:
			1213	+	//
			1214	+	// * [property@AboutWindow:developers]
			1215	+	// * [property@AboutWindow:artists]
			1216	+	// * [property@AboutWindow:documenters]
			1217	+	// * [property@AboutWindow:translator-credits]
			1218	+	// * [method@AboutWindow.add_credit_section]
			1219	+	// * [method@AboutWindow.add_acknowledgement_section]
			1220	+	func (x *AboutWindow) GetPropertyDesigners() []string {
			1221	+	var v gobject.Value
			1222	+	x.GetProperty("designers", &v)
			1223	+	return core.GoStringSlice(v.GetBoxed())
			1224	+	}
			1225	+
			1226	+	// SetPropertyDeveloperName sets the "developer-name" property.
			1227	+	// The developer name.
			1228	+	//
			1229	+	// The developer name is displayed on the main page, under the application
			1230	+	// name.
			1231	+	//
			1232	+	// If the application is developed by multiple people, the developer name can
			1233	+	// be set to values like "AppName team", "AppName developers" or
			1234	+	// "The AppName project", and the individual contributors can be listed on the
			1235	+	// Credits page, with [property@AboutWindow:developers] and related
			1236	+	// properties.
			1237	+	func (x *AboutWindow) SetPropertyDeveloperName(value string) {
			1238	+	var v gobject.Value
			1239	+	v.Init(gobject.TypeStringVal)
			1240	+	v.SetString(value)
			1241	+	x.SetProperty("developer-name", &v)
			1242	+	}
			1243	+
			1244	+	// GetPropertyDeveloperName gets the "developer-name" property.
			1245	+	// The developer name.
			1246	+	//
			1247	+	// The developer name is displayed on the main page, under the application
			1248	+	// name.
			1249	+	//
			1250	+	// If the application is developed by multiple people, the developer name can
			1251	+	// be set to values like "AppName team", "AppName developers" or
			1252	+	// "The AppName project", and the individual contributors can be listed on the
			1253	+	// Credits page, with [property@AboutWindow:developers] and related
			1254	+	// properties.
			1255	+	func (x *AboutWindow) GetPropertyDeveloperName() string {
			1256	+	var v gobject.Value
			1257	+	x.GetProperty("developer-name", &v)
			1258	+	return v.GetString()
			1259	+	}
			1260	+
			1261	+	// SetPropertyDevelopers sets the "developers" property.
			1262	+	// The list of developers of the application.
			1263	+	//
			1264	+	// It will be displayed on the Credits page.
			1265	+	//
			1266	+	// Each name may contain email addresses and URLs, see the introduction for
			1267	+	// more details.
			1268	+	//
			1269	+	// See also:
			1270	+	//
			1271	+	// * [property@AboutWindow:designers]
			1272	+	// * [property@AboutWindow:artists]
			1273	+	// * [property@AboutWindow:documenters]
			1274	+	// * [property@AboutWindow:translator-credits]
			1275	+	// * [method@AboutWindow.add_credit_section]
			1276	+	// * [method@AboutWindow.add_acknowledgement_section]
			1277	+	func (x *AboutWindow) SetPropertyDevelopers(value []string) {
			1278	+	var v gobject.Value
			1279	+	v.Init(glib.StrvGetType())
			1280	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			1281	+	x.SetProperty("developers", &v)
			1282	+	}
			1283	+
			1284	+	// GetPropertyDevelopers gets the "developers" property.
			1285	+	// The list of developers of the application.
			1286	+	//
			1287	+	// It will be displayed on the Credits page.
			1288	+	//
			1289	+	// Each name may contain email addresses and URLs, see the introduction for
			1290	+	// more details.
			1291	+	//
			1292	+	// See also:
			1293	+	//
			1294	+	// * [property@AboutWindow:designers]
			1295	+	// * [property@AboutWindow:artists]
			1296	+	// * [property@AboutWindow:documenters]
			1297	+	// * [property@AboutWindow:translator-credits]
			1298	+	// * [method@AboutWindow.add_credit_section]
			1299	+	// * [method@AboutWindow.add_acknowledgement_section]
			1300	+	func (x *AboutWindow) GetPropertyDevelopers() []string {
			1301	+	var v gobject.Value
			1302	+	x.GetProperty("developers", &v)
			1303	+	return core.GoStringSlice(v.GetBoxed())
			1304	+	}
			1305	+
			1306	+	// SetPropertyDocumenters sets the "documenters" property.
			1307	+	// The list of documenters of the application.
			1308	+	//
			1309	+	// It will be displayed on the Credits page.
			1310	+	//
			1311	+	// Each name may contain email addresses and URLs, see the introduction for
			1312	+	// more details.
			1313	+	//
			1314	+	// See also:
			1315	+	//
			1316	+	// * [property@AboutWindow:developers]
			1317	+	// * [property@AboutWindow:designers]
			1318	+	// * [property@AboutWindow:artists]
			1319	+	// * [property@AboutWindow:translator-credits]
			1320	+	// * [method@AboutWindow.add_credit_section]
			1321	+	// * [method@AboutWindow.add_acknowledgement_section]
			1322	+	func (x *AboutWindow) SetPropertyDocumenters(value []string) {
			1323	+	var v gobject.Value
			1324	+	v.Init(glib.StrvGetType())
			1325	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			1326	+	x.SetProperty("documenters", &v)
			1327	+	}
			1328	+
			1329	+	// GetPropertyDocumenters gets the "documenters" property.
			1330	+	// The list of documenters of the application.
			1331	+	//
			1332	+	// It will be displayed on the Credits page.
			1333	+	//
			1334	+	// Each name may contain email addresses and URLs, see the introduction for
			1335	+	// more details.
			1336	+	//
			1337	+	// See also:
			1338	+	//
			1339	+	// * [property@AboutWindow:developers]
			1340	+	// * [property@AboutWindow:designers]
			1341	+	// * [property@AboutWindow:artists]
			1342	+	// * [property@AboutWindow:translator-credits]
			1343	+	// * [method@AboutWindow.add_credit_section]
			1344	+	// * [method@AboutWindow.add_acknowledgement_section]
			1345	+	func (x *AboutWindow) GetPropertyDocumenters() []string {
			1346	+	var v gobject.Value
			1347	+	x.GetProperty("documenters", &v)
			1348	+	return core.GoStringSlice(v.GetBoxed())
			1349	+	}
			1350	+
			1351	+	// SetPropertyIssueUrl sets the "issue-url" property.
			1352	+	// The URL for the application's issue tracker.
			1353	+	//
			1354	+	// The issue tracker link is displayed on the main page.
			1355	+	func (x *AboutWindow) SetPropertyIssueUrl(value string) {
			1356	+	var v gobject.Value
			1357	+	v.Init(gobject.TypeStringVal)
			1358	+	v.SetString(value)
			1359	+	x.SetProperty("issue-url", &v)
			1360	+	}
			1361	+
			1362	+	// GetPropertyIssueUrl gets the "issue-url" property.
			1363	+	// The URL for the application's issue tracker.
			1364	+	//
			1365	+	// The issue tracker link is displayed on the main page.
			1366	+	func (x *AboutWindow) GetPropertyIssueUrl() string {
			1367	+	var v gobject.Value
			1368	+	x.GetProperty("issue-url", &v)
			1369	+	return v.GetString()
			1370	+	}
			1371	+
			1372	+	// SetPropertyLicense sets the "license" property.
			1373	+	// The license text.
			1374	+	//
			1375	+	// This can be used to set a custom text for the license if it can't be set
			1376	+	// via [property@AboutWindow:license-type].
			1377	+	//
			1378	+	// When set, [property@AboutWindow:license-type] will be set to
			1379	+	// `GTK_LICENSE_CUSTOM`.
			1380	+	//
			1381	+	// The license text will be displayed on the Legal page, below the copyright
			1382	+	// information.
			1383	+	//
			1384	+	// License text can contain Pango markup and links.
			1385	+	//
			1386	+	// [method@AboutWindow.add_legal_section] can be used to add license
			1387	+	// information for the application dependencies or other components.
			1388	+	func (x *AboutWindow) SetPropertyLicense(value string) {
			1389	+	var v gobject.Value
			1390	+	v.Init(gobject.TypeStringVal)
			1391	+	v.SetString(value)
			1392	+	x.SetProperty("license", &v)
			1393	+	}
			1394	+
			1395	+	// GetPropertyLicense gets the "license" property.
			1396	+	// The license text.
			1397	+	//
			1398	+	// This can be used to set a custom text for the license if it can't be set
			1399	+	// via [property@AboutWindow:license-type].
			1400	+	//
			1401	+	// When set, [property@AboutWindow:license-type] will be set to
			1402	+	// `GTK_LICENSE_CUSTOM`.
			1403	+	//
			1404	+	// The license text will be displayed on the Legal page, below the copyright
			1405	+	// information.
			1406	+	//
			1407	+	// License text can contain Pango markup and links.
			1408	+	//
			1409	+	// [method@AboutWindow.add_legal_section] can be used to add license
			1410	+	// information for the application dependencies or other components.
			1411	+	func (x *AboutWindow) GetPropertyLicense() string {
			1412	+	var v gobject.Value
			1413	+	x.GetProperty("license", &v)
			1414	+	return v.GetString()
			1415	+	}
			1416	+
			1417	+	// SetPropertyReleaseNotes sets the "release-notes" property.
			1418	+	// The release notes of the application.
			1419	+	//
			1420	+	// Release notes are displayed on the the What's New page.
			1421	+	//
			1422	+	// Release notes are formatted the same way as
			1423	+	// [AppStream descriptions](https://freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-description).
			1424	+	//
			1425	+	// The supported formatting options are:
			1426	+	//
			1427	+	// * Paragraph (`<p>`)
			1428	+	// * Ordered list (`<ol>`), with list items (`<li>`)
			1429	+	// * Unordered list (`<ul>`), with list items (`<li>`)
			1430	+	//
			1431	+	// Within paragraphs and list items, emphasis (`<em>`) and inline code
			1432	+	// (`<code>`) text styles are supported. The emphasis is rendered in italic,
			1433	+	// while inline code is shown in a monospaced font.
			1434	+	//
			1435	+	// Any text outside paragraphs or list items is ignored.
			1436	+	//
			1437	+	// Nested lists are not supported.
			1438	+	//
			1439	+	// `AdwAboutWindow` displays the version above the release notes. If set, the
			1440	+	// [property@AboutWindow:release-notes-version] of the property will be used
			1441	+	// as the version; otherwise, [property@AboutWindow:version] is used.
			1442	+	func (x *AboutWindow) SetPropertyReleaseNotes(value string) {
			1443	+	var v gobject.Value
			1444	+	v.Init(gobject.TypeStringVal)
			1445	+	v.SetString(value)
			1446	+	x.SetProperty("release-notes", &v)
			1447	+	}
			1448	+
			1449	+	// GetPropertyReleaseNotes gets the "release-notes" property.
			1450	+	// The release notes of the application.
			1451	+	//
			1452	+	// Release notes are displayed on the the What's New page.
			1453	+	//
			1454	+	// Release notes are formatted the same way as
			1455	+	// [AppStream descriptions](https://freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-description).
			1456	+	//
			1457	+	// The supported formatting options are:
			1458	+	//
			1459	+	// * Paragraph (`<p>`)
			1460	+	// * Ordered list (`<ol>`), with list items (`<li>`)
			1461	+	// * Unordered list (`<ul>`), with list items (`<li>`)
			1462	+	//
			1463	+	// Within paragraphs and list items, emphasis (`<em>`) and inline code
			1464	+	// (`<code>`) text styles are supported. The emphasis is rendered in italic,
			1465	+	// while inline code is shown in a monospaced font.
			1466	+	//
			1467	+	// Any text outside paragraphs or list items is ignored.
			1468	+	//
			1469	+	// Nested lists are not supported.
			1470	+	//
			1471	+	// `AdwAboutWindow` displays the version above the release notes. If set, the
			1472	+	// [property@AboutWindow:release-notes-version] of the property will be used
			1473	+	// as the version; otherwise, [property@AboutWindow:version] is used.
			1474	+	func (x *AboutWindow) GetPropertyReleaseNotes() string {
			1475	+	var v gobject.Value
			1476	+	x.GetProperty("release-notes", &v)
			1477	+	return v.GetString()
			1478	+	}
			1479	+
			1480	+	// SetPropertyReleaseNotesVersion sets the "release-notes-version" property.
			1481	+	// The version described by the application's release notes.
			1482	+	//
			1483	+	// The release notes version is displayed on the What's New page, above the
			1484	+	// release notes.
			1485	+	//
			1486	+	// If not set, [property@AboutWindow:version] will be used instead.
			1487	+	//
			1488	+	// For example, an application with the current version 2.0.2 might want to
			1489	+	// keep the release notes from 2.0.0, and set the release notes version
			1490	+	// accordingly.
			1491	+	//
			1492	+	// See [property@AboutWindow:release-notes].
			1493	+	func (x *AboutWindow) SetPropertyReleaseNotesVersion(value string) {
			1494	+	var v gobject.Value
			1495	+	v.Init(gobject.TypeStringVal)
			1496	+	v.SetString(value)
			1497	+	x.SetProperty("release-notes-version", &v)
			1498	+	}
			1499	+
			1500	+	// GetPropertyReleaseNotesVersion gets the "release-notes-version" property.
			1501	+	// The version described by the application's release notes.
			1502	+	//
			1503	+	// The release notes version is displayed on the What's New page, above the
			1504	+	// release notes.
			1505	+	//
			1506	+	// If not set, [property@AboutWindow:version] will be used instead.
			1507	+	//
			1508	+	// For example, an application with the current version 2.0.2 might want to
			1509	+	// keep the release notes from 2.0.0, and set the release notes version
			1510	+	// accordingly.
			1511	+	//
			1512	+	// See [property@AboutWindow:release-notes].
			1513	+	func (x *AboutWindow) GetPropertyReleaseNotesVersion() string {
			1514	+	var v gobject.Value
			1515	+	x.GetProperty("release-notes-version", &v)
			1516	+	return v.GetString()
			1517	+	}
			1518	+
			1519	+	// SetPropertySupportUrl sets the "support-url" property.
			1520	+	// The URL of the application's support page.
			1521	+	//
			1522	+	// The support page link is displayed on the main page.
			1523	+	func (x *AboutWindow) SetPropertySupportUrl(value string) {
			1524	+	var v gobject.Value
			1525	+	v.Init(gobject.TypeStringVal)
			1526	+	v.SetString(value)
			1527	+	x.SetProperty("support-url", &v)
			1528	+	}
			1529	+
			1530	+	// GetPropertySupportUrl gets the "support-url" property.
			1531	+	// The URL of the application's support page.
			1532	+	//
			1533	+	// The support page link is displayed on the main page.
			1534	+	func (x *AboutWindow) GetPropertySupportUrl() string {
			1535	+	var v gobject.Value
			1536	+	x.GetProperty("support-url", &v)
			1537	+	return v.GetString()
			1538	+	}
			1539	+
			1540	+	// SetPropertyTranslatorCredits sets the "translator-credits" property.
			1541	+	// The translator credits string.
			1542	+	//
			1543	+	// It will be displayed on the Credits page.
			1544	+	//
			1545	+	// This string should be `"translator-credits"` or `"translator_credits"` and
			1546	+	// should be marked as translatable.
			1547	+	//
			1548	+	// The string may contain email addresses and URLs, see the introduction for
			1549	+	// more details.
			1550	+	//
			1551	+	// See also:
			1552	+	//
			1553	+	// * [property@AboutWindow:developers]
			1554	+	// * [property@AboutWindow:designers]
			1555	+	// * [property@AboutWindow:artists]
			1556	+	// * [property@AboutWindow:documenters]
			1557	+	// * [method@AboutWindow.add_credit_section]
			1558	+	// * [method@AboutWindow.add_acknowledgement_section]
			1559	+	func (x *AboutWindow) SetPropertyTranslatorCredits(value string) {
			1560	+	var v gobject.Value
			1561	+	v.Init(gobject.TypeStringVal)
			1562	+	v.SetString(value)
			1563	+	x.SetProperty("translator-credits", &v)
			1564	+	}
			1565	+
			1566	+	// GetPropertyTranslatorCredits gets the "translator-credits" property.
			1567	+	// The translator credits string.
			1568	+	//
			1569	+	// It will be displayed on the Credits page.
			1570	+	//
			1571	+	// This string should be `"translator-credits"` or `"translator_credits"` and
			1572	+	// should be marked as translatable.
			1573	+	//
			1574	+	// The string may contain email addresses and URLs, see the introduction for
			1575	+	// more details.
			1576	+	//
			1577	+	// See also:
			1578	+	//
			1579	+	// * [property@AboutWindow:developers]
			1580	+	// * [property@AboutWindow:designers]
			1581	+	// * [property@AboutWindow:artists]
			1582	+	// * [property@AboutWindow:documenters]
			1583	+	// * [method@AboutWindow.add_credit_section]
			1584	+	// * [method@AboutWindow.add_acknowledgement_section]
			1585	+	func (x *AboutWindow) GetPropertyTranslatorCredits() string {
			1586	+	var v gobject.Value
			1587	+	x.GetProperty("translator-credits", &v)
			1588	+	return v.GetString()
			1589	+	}
			1590	+
			1591	+	// SetPropertyVersion sets the "version" property.
			1592	+	// The version of the application.
			1593	+	//
			1594	+	// The version is displayed on the main page.
			1595	+	//
			1596	+	// If [property@AboutWindow:release-notes-version] is not set, the version
			1597	+	// will also be displayed above the release notes on the What's New page.
			1598	+	func (x *AboutWindow) SetPropertyVersion(value string) {
			1599	+	var v gobject.Value
			1600	+	v.Init(gobject.TypeStringVal)
			1601	+	v.SetString(value)
			1602	+	x.SetProperty("version", &v)
			1603	+	}
			1604	+
			1605	+	// GetPropertyVersion gets the "version" property.
			1606	+	// The version of the application.
			1607	+	//
			1608	+	// The version is displayed on the main page.
			1609	+	//
			1610	+	// If [property@AboutWindow:release-notes-version] is not set, the version
			1611	+	// will also be displayed above the release notes on the What's New page.
			1612	+	func (x *AboutWindow) GetPropertyVersion() string {
			1613	+	var v gobject.Value
			1614	+	x.GetProperty("version", &v)
			1615	+	return v.GetString()
			1616	+	}
			1617	+
			1618	+	// SetPropertyWebsite sets the "website" property.
			1619	+	// The URL of the application's website.
			1620	+	//
			1621	+	// Website is displayed on the Details page, below comments, or on the main
			1622	+	// page if the Details page doesn't have any other content.
			1623	+	//
			1624	+	// Applications can add other links below, see [method@AboutWindow.add_link].
			1625	+	func (x *AboutWindow) SetPropertyWebsite(value string) {
			1626	+	var v gobject.Value
			1627	+	v.Init(gobject.TypeStringVal)
			1628	+	v.SetString(value)
			1629	+	x.SetProperty("website", &v)
			1630	+	}
			1631	+
			1632	+	// GetPropertyWebsite gets the "website" property.
			1633	+	// The URL of the application's website.
			1634	+	//
			1635	+	// Website is displayed on the Details page, below comments, or on the main
			1636	+	// page if the Details page doesn't have any other content.
			1637	+	//
			1638	+	// Applications can add other links below, see [method@AboutWindow.add_link].
			1639	+	func (x *AboutWindow) GetPropertyWebsite() string {
			1640	+	var v gobject.Value
			1641	+	x.GetProperty("website", &v)
			1642	+	return v.GetString()
			1643	+	}
			1644	+
968		// Emitted when a URL is activated.	1645		// Emitted when a URL is activated.
969		//	1646		//
970		// Applications may connect to it to override the default behavior, which is	1647		// Applications may connect to it to override the default behavior, which is

@@ -1045,7 +1722,7 @@ func (x AboutWindow) GetAtContext() gtk.ATContext {
1045		// This functionality can be overridden by `GtkAccessible`	1722		// This functionality can be overridden by `GtkAccessible`
1046		// implementations, e.g. to get the bounds from an ignored	1723		// implementations, e.g. to get the bounds from an ignored
1047		// child widget.	1724		// child widget.
1048	-	func (x *AboutWindow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	1725	+	func (x AboutWindow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
1049			1726
1050		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	1727		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
1051		return cret	1728		return cret

@@ -1300,7 +1977,7 @@ func (x AboutWindow) GetSurface() gdk.Surface {
1300		//	1977		//
1301		// This is the translation from @self's surface coordinates into	1978		// This is the translation from @self's surface coordinates into
1302		// @self's widget coordinates.	1979		// @self's widget coordinates.
1303	-	func (x *AboutWindow) GetSurfaceTransform(XVar float64, YVar float64) {	1980	+	func (x AboutWindow) GetSurfaceTransform(XVar float64, YVar *float64) {
1304			1981
1305		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	1982		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
1306			1983

M v4/adw/adw-action-row.go +108 -3


@@ -27,7 +27,7 @@ func (x *ActionRowClass) GoPointer() uintptr {
27		return uintptr(unsafe.Pointer(x))	27		return uintptr(unsafe.Pointer(x))
28		}	28		}
29			29
30	-	// OverrideActivate sets the callback function.	30	+	// OverrideActivate sets the "activate" callback function.
31		// Activates the row to trigger its main action.	31		// Activates the row to trigger its main action.
32		func (x ActionRowClass) OverrideActivate(cb func(ActionRow)) {	32		func (x ActionRowClass) OverrideActivate(cb func(ActionRow)) {
33		if cb == nil {	33		if cb == nil {

@@ -39,7 +39,7 @@ func (x ActionRowClass) OverrideActivate(cb func(ActionRow)) {
39		}	39		}
40		}	40		}
41			41
42	-	// GetActivate gets the callback function.	42	+	// GetActivate gets the "activate" callback function.
43		// Activates the row to trigger its main action.	43		// Activates the row to trigger its main action.
44		func (x ActionRowClass) GetActivate() func(ActionRow) {	44		func (x ActionRowClass) GetActivate() func(ActionRow) {
45		if x.xActivate == 0 {	45		if x.xActivate == 0 {

@@ -320,6 +320,111 @@ func (c *ActionRow) SetGoPointer(ptr uintptr) {
320		c.Ptr = ptr	320		c.Ptr = ptr
321		}	321		}
322			322
			323	+	// SetPropertyIconName sets the "icon-name" property.
			324	+	// The icon name for this row.
			325	+	func (x *ActionRow) SetPropertyIconName(value string) {
			326	+	var v gobject.Value
			327	+	v.Init(gobject.TypeStringVal)
			328	+	v.SetString(value)
			329	+	x.SetProperty("icon-name", &v)
			330	+	}
			331	+
			332	+	// GetPropertyIconName gets the "icon-name" property.
			333	+	// The icon name for this row.
			334	+	func (x *ActionRow) GetPropertyIconName() string {
			335	+	var v gobject.Value
			336	+	x.GetProperty("icon-name", &v)
			337	+	return v.GetString()
			338	+	}
			339	+
			340	+	// SetPropertySubtitle sets the "subtitle" property.
			341	+	// The subtitle for this row.
			342	+	//
			343	+	// The subtitle is interpreted as Pango markup unless
			344	+	// [property@PreferencesRow:use-markup] is set to `FALSE`.
			345	+	func (x *ActionRow) SetPropertySubtitle(value string) {
			346	+	var v gobject.Value
			347	+	v.Init(gobject.TypeStringVal)
			348	+	v.SetString(value)
			349	+	x.SetProperty("subtitle", &v)
			350	+	}
			351	+
			352	+	// GetPropertySubtitle gets the "subtitle" property.
			353	+	// The subtitle for this row.
			354	+	//
			355	+	// The subtitle is interpreted as Pango markup unless
			356	+	// [property@PreferencesRow:use-markup] is set to `FALSE`.
			357	+	func (x *ActionRow) GetPropertySubtitle() string {
			358	+	var v gobject.Value
			359	+	x.GetProperty("subtitle", &v)
			360	+	return v.GetString()
			361	+	}
			362	+
			363	+	// SetPropertySubtitleLines sets the "subtitle-lines" property.
			364	+	// The number of lines at the end of which the subtitle label will be
			365	+	// ellipsized.
			366	+	//
			367	+	// If the value is 0, the number of lines won't be limited.
			368	+	func (x *ActionRow) SetPropertySubtitleLines(value int) {
			369	+	var v gobject.Value
			370	+	v.Init(gobject.TypeIntVal)
			371	+	v.SetInt(value)
			372	+	x.SetProperty("subtitle-lines", &v)
			373	+	}
			374	+
			375	+	// GetPropertySubtitleLines gets the "subtitle-lines" property.
			376	+	// The number of lines at the end of which the subtitle label will be
			377	+	// ellipsized.
			378	+	//
			379	+	// If the value is 0, the number of lines won't be limited.
			380	+	func (x *ActionRow) GetPropertySubtitleLines() int {
			381	+	var v gobject.Value
			382	+	x.GetProperty("subtitle-lines", &v)
			383	+	return v.GetInt()
			384	+	}
			385	+
			386	+	// SetPropertySubtitleSelectable sets the "subtitle-selectable" property.
			387	+	// Whether the user can copy the subtitle from the label.
			388	+	//
			389	+	// See also [property@Gtk.Label:selectable].
			390	+	func (x *ActionRow) SetPropertySubtitleSelectable(value bool) {
			391	+	var v gobject.Value
			392	+	v.Init(gobject.TypeBooleanVal)
			393	+	v.SetBoolean(value)
			394	+	x.SetProperty("subtitle-selectable", &v)
			395	+	}
			396	+
			397	+	// GetPropertySubtitleSelectable gets the "subtitle-selectable" property.
			398	+	// Whether the user can copy the subtitle from the label.
			399	+	//
			400	+	// See also [property@Gtk.Label:selectable].
			401	+	func (x *ActionRow) GetPropertySubtitleSelectable() bool {
			402	+	var v gobject.Value
			403	+	x.GetProperty("subtitle-selectable", &v)
			404	+	return v.GetBoolean()
			405	+	}
			406	+
			407	+	// SetPropertyTitleLines sets the "title-lines" property.
			408	+	// The number of lines at the end of which the title label will be ellipsized.
			409	+	//
			410	+	// If the value is 0, the number of lines won't be limited.
			411	+	func (x *ActionRow) SetPropertyTitleLines(value int) {
			412	+	var v gobject.Value
			413	+	v.Init(gobject.TypeIntVal)
			414	+	v.SetInt(value)
			415	+	x.SetProperty("title-lines", &v)
			416	+	}
			417	+
			418	+	// GetPropertyTitleLines gets the "title-lines" property.
			419	+	// The number of lines at the end of which the title label will be ellipsized.
			420	+	//
			421	+	// If the value is 0, the number of lines won't be limited.
			422	+	func (x *ActionRow) GetPropertyTitleLines() int {
			423	+	var v gobject.Value
			424	+	x.GetProperty("title-lines", &v)
			425	+	return v.GetInt()
			426	+	}
			427	+
323		// This signal is emitted after the row has been activated.	428		// This signal is emitted after the row has been activated.
324		func (x ActionRow) ConnectActivated(cb func(ActionRow)) uint32 {	429		func (x ActionRow) ConnectActivated(cb func(ActionRow)) uint32 {
325		cbPtr := uintptr(unsafe.Pointer(cb))	430		cbPtr := uintptr(unsafe.Pointer(cb))

@@ -397,7 +502,7 @@ func (x ActionRow) GetAtContext() gtk.ATContext {
397		// This functionality can be overridden by `GtkAccessible`	502		// This functionality can be overridden by `GtkAccessible`
398		// implementations, e.g. to get the bounds from an ignored	503		// implementations, e.g. to get the bounds from an ignored
399		// child widget.	504		// child widget.
400	-	func (x *ActionRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	505	+	func (x ActionRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
401			506
402		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	507		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
403		return cret	508		return cret

M v4/adw/adw-alert-dialog.go +166 -3


@@ -28,7 +28,7 @@ func (x *AlertDialogClass) GoPointer() uintptr {
28		return uintptr(unsafe.Pointer(x))	28		return uintptr(unsafe.Pointer(x))
29		}	29		}
30			30
31	-	// OverrideResponse sets the callback function.	31	+	// OverrideResponse sets the "response" callback function.
32		func (x AlertDialogClass) OverrideResponse(cb func(AlertDialog, string)) {	32		func (x AlertDialogClass) OverrideResponse(cb func(AlertDialog, string)) {
33		if cb == nil {	33		if cb == nil {
34		x.xResponse = 0	34		x.xResponse = 0

@@ -39,7 +39,7 @@ func (x AlertDialogClass) OverrideResponse(cb func(AlertDialog, string)) {
39		}	39		}
40		}	40		}
41			41
42	-	// GetResponse gets the callback function.	42	+	// GetResponse gets the "response" callback function.
43		func (x AlertDialogClass) GetResponse() func(AlertDialog, string) {	43		func (x AlertDialogClass) GetResponse() func(AlertDialog, string) {
44		if x.xResponse == 0 {	44		if x.xResponse == 0 {
45		return nil	45		return nil

@@ -685,6 +685,169 @@ func (c *AlertDialog) SetGoPointer(ptr uintptr) {
685		c.Ptr = ptr	685		c.Ptr = ptr
686		}	686		}
687			687
			688	+	// SetPropertyBody sets the "body" property.
			689	+	// The body text of the dialog.
			690	+	func (x *AlertDialog) SetPropertyBody(value string) {
			691	+	var v gobject.Value
			692	+	v.Init(gobject.TypeStringVal)
			693	+	v.SetString(value)
			694	+	x.SetProperty("body", &v)
			695	+	}
			696	+
			697	+	// GetPropertyBody gets the "body" property.
			698	+	// The body text of the dialog.
			699	+	func (x *AlertDialog) GetPropertyBody() string {
			700	+	var v gobject.Value
			701	+	x.GetProperty("body", &v)
			702	+	return v.GetString()
			703	+	}
			704	+
			705	+	// SetPropertyBodyUseMarkup sets the "body-use-markup" property.
			706	+	// Whether the body text includes Pango markup.
			707	+	//
			708	+	// See [func@Pango.parse_markup].
			709	+	func (x *AlertDialog) SetPropertyBodyUseMarkup(value bool) {
			710	+	var v gobject.Value
			711	+	v.Init(gobject.TypeBooleanVal)
			712	+	v.SetBoolean(value)
			713	+	x.SetProperty("body-use-markup", &v)
			714	+	}
			715	+
			716	+	// GetPropertyBodyUseMarkup gets the "body-use-markup" property.
			717	+	// Whether the body text includes Pango markup.
			718	+	//
			719	+	// See [func@Pango.parse_markup].
			720	+	func (x *AlertDialog) GetPropertyBodyUseMarkup() bool {
			721	+	var v gobject.Value
			722	+	x.GetProperty("body-use-markup", &v)
			723	+	return v.GetBoolean()
			724	+	}
			725	+
			726	+	// SetPropertyCloseResponse sets the "close-response" property.
			727	+	// The ID of the close response.
			728	+	//
			729	+	// It will be passed to [signal@AlertDialog::response] if the dialog is
			730	+	// closed by pressing <kbd>Escape</kbd> or with a system action.
			731	+	//
			732	+	// It doesn't have to correspond to any of the responses in the dialog.
			733	+	//
			734	+	// The default close response is `close`.
			735	+	func (x *AlertDialog) SetPropertyCloseResponse(value string) {
			736	+	var v gobject.Value
			737	+	v.Init(gobject.TypeStringVal)
			738	+	v.SetString(value)
			739	+	x.SetProperty("close-response", &v)
			740	+	}
			741	+
			742	+	// GetPropertyCloseResponse gets the "close-response" property.
			743	+	// The ID of the close response.
			744	+	//
			745	+	// It will be passed to [signal@AlertDialog::response] if the dialog is
			746	+	// closed by pressing <kbd>Escape</kbd> or with a system action.
			747	+	//
			748	+	// It doesn't have to correspond to any of the responses in the dialog.
			749	+	//
			750	+	// The default close response is `close`.
			751	+	func (x *AlertDialog) GetPropertyCloseResponse() string {
			752	+	var v gobject.Value
			753	+	x.GetProperty("close-response", &v)
			754	+	return v.GetString()
			755	+	}
			756	+
			757	+	// SetPropertyDefaultResponse sets the "default-response" property.
			758	+	// The response ID of the default response.
			759	+	//
			760	+	// The button corresponding to this response will be set as the default widget
			761	+	// of the dialog.
			762	+	//
			763	+	// If not set, the default widget will not be set, and the last added response
			764	+	// will be focused by default.
			765	+	//
			766	+	// See [property@Dialog:default-widget].
			767	+	func (x *AlertDialog) SetPropertyDefaultResponse(value string) {
			768	+	var v gobject.Value
			769	+	v.Init(gobject.TypeStringVal)
			770	+	v.SetString(value)
			771	+	x.SetProperty("default-response", &v)
			772	+	}
			773	+
			774	+	// GetPropertyDefaultResponse gets the "default-response" property.
			775	+	// The response ID of the default response.
			776	+	//
			777	+	// The button corresponding to this response will be set as the default widget
			778	+	// of the dialog.
			779	+	//
			780	+	// If not set, the default widget will not be set, and the last added response
			781	+	// will be focused by default.
			782	+	//
			783	+	// See [property@Dialog:default-widget].
			784	+	func (x *AlertDialog) GetPropertyDefaultResponse() string {
			785	+	var v gobject.Value
			786	+	x.GetProperty("default-response", &v)
			787	+	return v.GetString()
			788	+	}
			789	+
			790	+	// SetPropertyHeading sets the "heading" property.
			791	+	// The heading of the dialog.
			792	+	func (x *AlertDialog) SetPropertyHeading(value string) {
			793	+	var v gobject.Value
			794	+	v.Init(gobject.TypeStringVal)
			795	+	v.SetString(value)
			796	+	x.SetProperty("heading", &v)
			797	+	}
			798	+
			799	+	// GetPropertyHeading gets the "heading" property.
			800	+	// The heading of the dialog.
			801	+	func (x *AlertDialog) GetPropertyHeading() string {
			802	+	var v gobject.Value
			803	+	x.GetProperty("heading", &v)
			804	+	return v.GetString()
			805	+	}
			806	+
			807	+	// SetPropertyHeadingUseMarkup sets the "heading-use-markup" property.
			808	+	// Whether the heading includes Pango markup.
			809	+	//
			810	+	// See [func@Pango.parse_markup].
			811	+	func (x *AlertDialog) SetPropertyHeadingUseMarkup(value bool) {
			812	+	var v gobject.Value
			813	+	v.Init(gobject.TypeBooleanVal)
			814	+	v.SetBoolean(value)
			815	+	x.SetProperty("heading-use-markup", &v)
			816	+	}
			817	+
			818	+	// GetPropertyHeadingUseMarkup gets the "heading-use-markup" property.
			819	+	// Whether the heading includes Pango markup.
			820	+	//
			821	+	// See [func@Pango.parse_markup].
			822	+	func (x *AlertDialog) GetPropertyHeadingUseMarkup() bool {
			823	+	var v gobject.Value
			824	+	x.GetProperty("heading-use-markup", &v)
			825	+	return v.GetBoolean()
			826	+	}
			827	+
			828	+	// SetPropertyPreferWideLayout sets the "prefer-wide-layout" property.
			829	+	// Whether to prefer wide layout.
			830	+	//
			831	+	// Prefer horizontal button layout when possible, and wider dialog width
			832	+	// otherwise.
			833	+	func (x *AlertDialog) SetPropertyPreferWideLayout(value bool) {
			834	+	var v gobject.Value
			835	+	v.Init(gobject.TypeBooleanVal)
			836	+	v.SetBoolean(value)
			837	+	x.SetProperty("prefer-wide-layout", &v)
			838	+	}
			839	+
			840	+	// GetPropertyPreferWideLayout gets the "prefer-wide-layout" property.
			841	+	// Whether to prefer wide layout.
			842	+	//
			843	+	// Prefer horizontal button layout when possible, and wider dialog width
			844	+	// otherwise.
			845	+	func (x *AlertDialog) GetPropertyPreferWideLayout() bool {
			846	+	var v gobject.Value
			847	+	x.GetProperty("prefer-wide-layout", &v)
			848	+	return v.GetBoolean()
			849	+	}
			850	+
688		// This signal is emitted when the dialog is closed.	851		// This signal is emitted when the dialog is closed.
689		//	852		//
690		// @response will be set to the response ID of the button that had been	853		// @response will be set to the response ID of the button that had been

@@ -769,7 +932,7 @@ func (x AlertDialog) GetAtContext() gtk.ATContext {
769		// This functionality can be overridden by `GtkAccessible`	932		// This functionality can be overridden by `GtkAccessible`
770		// implementations, e.g. to get the bounds from an ignored	933		// implementations, e.g. to get the bounds from an ignored
771		// child widget.	934		// child widget.
772	-	func (x *AlertDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	935	+	func (x AlertDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
773			936
774		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	937		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
775		return cret	938		return cret

M v4/adw/adw-animation.go +41 -0


@@ -302,6 +302,47 @@ func (c *Animation) SetGoPointer(ptr uintptr) {
302	c.Ptr = ptr	302		c.Ptr = ptr
303	}	303		}
304		304
		305	+	// SetPropertyFollowEnableAnimationsSetting sets the "follow-enable-animations-setting" property.
		306	+	// Whether to skip the animation when animations are globally disabled.
		307	+	//
		308	+	// The default behavior is to skip the animation. Set to `FALSE` to disable
		309	+	// this behavior.
		310	+	//
		311	+	// This can be useful for cases where animation is essential, like spinners,
		312	+	// or in demo applications. Most other animations should keep it enabled.
		313	+	//
		314	+	// See [property@Gtk.Settings:gtk-enable-animations].
		315	+	func (x *Animation) SetPropertyFollowEnableAnimationsSetting(value bool) {
		316	+	var v gobject.Value
		317	+	v.Init(gobject.TypeBooleanVal)
		318	+	v.SetBoolean(value)
		319	+	x.SetProperty("follow-enable-animations-setting", &v)
		320	+	}
		321	+
		322	+	// GetPropertyFollowEnableAnimationsSetting gets the "follow-enable-animations-setting" property.
		323	+	// Whether to skip the animation when animations are globally disabled.
		324	+	//
		325	+	// The default behavior is to skip the animation. Set to `FALSE` to disable
		326	+	// this behavior.
		327	+	//
		328	+	// This can be useful for cases where animation is essential, like spinners,
		329	+	// or in demo applications. Most other animations should keep it enabled.
		330	+	//
		331	+	// See [property@Gtk.Settings:gtk-enable-animations].
		332	+	func (x *Animation) GetPropertyFollowEnableAnimationsSetting() bool {
		333	+	var v gobject.Value
		334	+	x.GetProperty("follow-enable-animations-setting", &v)
		335	+	return v.GetBoolean()
		336	+	}
		337	+
		338	+	// GetPropertyValue gets the "value" property.
		339	+	// The current value of the animation.
		340	+	func (x *Animation) GetPropertyValue() float64 {
		341	+	var v gobject.Value
		342	+	x.GetProperty("value", &v)
		343	+	return v.GetDouble()
		344	+	}
		345	+
305	// This signal is emitted when the animation has been completed, either on its	346		// This signal is emitted when the animation has been completed, either on its
306	// own or via calling [method@Animation.skip].	347		// own or via calling [method@Animation.skip].
307	func (x Animation) ConnectDone(cb func(Animation)) uint32 {	348		func (x Animation) ConnectDone(cb func(Animation)) uint32 {

M v4/adw/adw-application-window.go +36 -3


@@ -224,6 +224,39 @@ func (c *ApplicationWindow) SetGoPointer(ptr uintptr) {
224		c.Ptr = ptr	224		c.Ptr = ptr
225		}	225		}
226			226
			227	+	// SetPropertyAdaptivePreview sets the "adaptive-preview" property.
			228	+	// Whether adaptive preview is currently open.
			229	+	//
			230	+	// Adaptive preview is a debugging tool used for testing the window
			231	+	// contents at specific screen sizes, simulating mobile environment.
			232	+	//
			233	+	// Adaptive preview can always be accessed from inspector. This function
			234	+	// allows applications to open it manually.
			235	+	//
			236	+	// Most applications should not use this property.
			237	+	func (x *ApplicationWindow) SetPropertyAdaptivePreview(value bool) {
			238	+	var v gobject.Value
			239	+	v.Init(gobject.TypeBooleanVal)
			240	+	v.SetBoolean(value)
			241	+	x.SetProperty("adaptive-preview", &v)
			242	+	}
			243	+
			244	+	// GetPropertyAdaptivePreview gets the "adaptive-preview" property.
			245	+	// Whether adaptive preview is currently open.
			246	+	//
			247	+	// Adaptive preview is a debugging tool used for testing the window
			248	+	// contents at specific screen sizes, simulating mobile environment.
			249	+	//
			250	+	// Adaptive preview can always be accessed from inspector. This function
			251	+	// allows applications to open it manually.
			252	+	//
			253	+	// Most applications should not use this property.
			254	+	func (x *ApplicationWindow) GetPropertyAdaptivePreview() bool {
			255	+	var v gobject.Value
			256	+	x.GetProperty("adaptive-preview", &v)
			257	+	return v.GetBoolean()
			258	+	}
			259	+
227		// Emits the [signal@Gio.ActionGroup::action-added] signal on @action_group.	260		// Emits the [signal@Gio.ActionGroup::action-added] signal on @action_group.
228		//	261		//
229		// This function should only be called by [type@Gio.ActionGroup] implementations.	262		// This function should only be called by [type@Gio.ActionGroup] implementations.

@@ -449,7 +482,7 @@ func (x *ApplicationWindow) ListActions() []string {
449		// fields (as indicated by having a non-`NULL` reference passed in) are	482		// fields (as indicated by having a non-`NULL` reference passed in) are
450		// filled. If the action doesn’t exist, `FALSE` is returned and the	483		// filled. If the action doesn’t exist, `FALSE` is returned and the
451		// fields may or may not have been modified.	484		// fields may or may not have been modified.
452	-	func (x ApplicationWindow) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar *glib.Variant) bool {	485	+	func (x ApplicationWindow) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar glib.Variant) bool {
453			486
454		cret := gio.XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)	487		cret := gio.XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
455		return cret	488		return cret

@@ -630,7 +663,7 @@ func (x ApplicationWindow) GetAtContext() gtk.ATContext {
630		// This functionality can be overridden by `GtkAccessible`	663		// This functionality can be overridden by `GtkAccessible`
631		// implementations, e.g. to get the bounds from an ignored	664		// implementations, e.g. to get the bounds from an ignored
632		// child widget.	665		// child widget.
633	-	func (x *ApplicationWindow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	666	+	func (x ApplicationWindow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
634			667
635		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	668		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
636		return cret	669		return cret

@@ -885,7 +918,7 @@ func (x ApplicationWindow) GetSurface() gdk.Surface {
885		//	918		//
886		// This is the translation from @self's surface coordinates into	919		// This is the translation from @self's surface coordinates into
887		// @self's widget coordinates.	920		// @self's widget coordinates.
888	-	func (x *ApplicationWindow) GetSurfaceTransform(XVar float64, YVar float64) {	921	+	func (x ApplicationWindow) GetSurfaceTransform(XVar float64, YVar *float64) {
889			922
890		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	923		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
891			924

M v4/adw/adw-application.go +1 -1


@@ -364,7 +364,7 @@ func (x *Application) ListActions() []string {
364		// fields (as indicated by having a non-`NULL` reference passed in) are	364		// fields (as indicated by having a non-`NULL` reference passed in) are
365		// filled. If the action doesn’t exist, `FALSE` is returned and the	365		// filled. If the action doesn’t exist, `FALSE` is returned and the
366		// fields may or may not have been modified.	366		// fields may or may not have been modified.
367	-	func (x Application) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar *glib.Variant) bool {	367	+	func (x Application) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar glib.Variant) bool {
368			368
369		cret := gio.XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)	369		cret := gio.XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
370		return cret	370		return cret

M v4/adw/adw-avatar.go +83 -1


@@ -221,6 +221,88 @@ func (c *Avatar) SetGoPointer(ptr uintptr) {
221		c.Ptr = ptr	221		c.Ptr = ptr
222		}	222		}
223			223
			224	+	// SetPropertyIconName sets the "icon-name" property.
			225	+	// The name of an icon to use as a fallback.
			226	+	//
			227	+	// If no name is set, `avatar-default-symbolic` will be used.
			228	+	func (x *Avatar) SetPropertyIconName(value string) {
			229	+	var v gobject.Value
			230	+	v.Init(gobject.TypeStringVal)
			231	+	v.SetString(value)
			232	+	x.SetProperty("icon-name", &v)
			233	+	}
			234	+
			235	+	// GetPropertyIconName gets the "icon-name" property.
			236	+	// The name of an icon to use as a fallback.
			237	+	//
			238	+	// If no name is set, `avatar-default-symbolic` will be used.
			239	+	func (x *Avatar) GetPropertyIconName() string {
			240	+	var v gobject.Value
			241	+	x.GetProperty("icon-name", &v)
			242	+	return v.GetString()
			243	+	}
			244	+
			245	+	// SetPropertyShowInitials sets the "show-initials" property.
			246	+	// Whether initials are used instead of an icon on the fallback avatar.
			247	+	//
			248	+	// See [property@Avatar:icon-name] for how to change the fallback icon.
			249	+	func (x *Avatar) SetPropertyShowInitials(value bool) {
			250	+	var v gobject.Value
			251	+	v.Init(gobject.TypeBooleanVal)
			252	+	v.SetBoolean(value)
			253	+	x.SetProperty("show-initials", &v)
			254	+	}
			255	+
			256	+	// GetPropertyShowInitials gets the "show-initials" property.
			257	+	// Whether initials are used instead of an icon on the fallback avatar.
			258	+	//
			259	+	// See [property@Avatar:icon-name] for how to change the fallback icon.
			260	+	func (x *Avatar) GetPropertyShowInitials() bool {
			261	+	var v gobject.Value
			262	+	x.GetProperty("show-initials", &v)
			263	+	return v.GetBoolean()
			264	+	}
			265	+
			266	+	// SetPropertySize sets the "size" property.
			267	+	// The size of the avatar.
			268	+	func (x *Avatar) SetPropertySize(value int) {
			269	+	var v gobject.Value
			270	+	v.Init(gobject.TypeIntVal)
			271	+	v.SetInt(value)
			272	+	x.SetProperty("size", &v)
			273	+	}
			274	+
			275	+	// GetPropertySize gets the "size" property.
			276	+	// The size of the avatar.
			277	+	func (x *Avatar) GetPropertySize() int {
			278	+	var v gobject.Value
			279	+	x.GetProperty("size", &v)
			280	+	return v.GetInt()
			281	+	}
			282	+
			283	+	// SetPropertyText sets the "text" property.
			284	+	// Sets the text used to generate the fallback initials and color.
			285	+	//
			286	+	// It's only used to generate the color if [property@Avatar:show-initials] is
			287	+	// `FALSE`.
			288	+	func (x *Avatar) SetPropertyText(value string) {
			289	+	var v gobject.Value
			290	+	v.Init(gobject.TypeStringVal)
			291	+	v.SetString(value)
			292	+	x.SetProperty("text", &v)
			293	+	}
			294	+
			295	+	// GetPropertyText gets the "text" property.
			296	+	// Sets the text used to generate the fallback initials and color.
			297	+	//
			298	+	// It's only used to generate the color if [property@Avatar:show-initials] is
			299	+	// `FALSE`.
			300	+	func (x *Avatar) GetPropertyText() string {
			301	+	var v gobject.Value
			302	+	x.GetProperty("text", &v)
			303	+	return v.GetString()
			304	+	}
			305	+
224		// Requests the user's screen reader to announce the given message.	306		// Requests the user's screen reader to announce the given message.
225		//	307		//
226		// This kind of notification is useful for messages that	308		// This kind of notification is useful for messages that

@@ -278,7 +360,7 @@ func (x Avatar) GetAtContext() gtk.ATContext {
278		// This functionality can be overridden by `GtkAccessible`	360		// This functionality can be overridden by `GtkAccessible`
279		// implementations, e.g. to get the bounds from an ignored	361		// implementations, e.g. to get the bounds from an ignored
280		// child widget.	362		// child widget.
281	-	func (x *Avatar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	363	+	func (x Avatar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
282			364
283		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	365		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
284		return cret	366		return cret

M v4/adw/adw-banner.go +87 -1


@@ -229,6 +229,92 @@ func (c *Banner) SetGoPointer(ptr uintptr) {
229		c.Ptr = ptr	229		c.Ptr = ptr
230		}	230		}
231			231
			232	+	// SetPropertyButtonLabel sets the "button-label" property.
			233	+	// The label to show on the button.
			234	+	//
			235	+	// If set to `""` or `NULL`, the button won't be shown.
			236	+	//
			237	+	// The button can be used with a `GAction`, or with the
			238	+	// [signal@Banner::button-clicked] signal.
			239	+	func (x *Banner) SetPropertyButtonLabel(value string) {
			240	+	var v gobject.Value
			241	+	v.Init(gobject.TypeStringVal)
			242	+	v.SetString(value)
			243	+	x.SetProperty("button-label", &v)
			244	+	}
			245	+
			246	+	// GetPropertyButtonLabel gets the "button-label" property.
			247	+	// The label to show on the button.
			248	+	//
			249	+	// If set to `""` or `NULL`, the button won't be shown.
			250	+	//
			251	+	// The button can be used with a `GAction`, or with the
			252	+	// [signal@Banner::button-clicked] signal.
			253	+	func (x *Banner) GetPropertyButtonLabel() string {
			254	+	var v gobject.Value
			255	+	x.GetProperty("button-label", &v)
			256	+	return v.GetString()
			257	+	}
			258	+
			259	+	// SetPropertyRevealed sets the "revealed" property.
			260	+	// Whether the banner is currently revealed.
			261	+	func (x *Banner) SetPropertyRevealed(value bool) {
			262	+	var v gobject.Value
			263	+	v.Init(gobject.TypeBooleanVal)
			264	+	v.SetBoolean(value)
			265	+	x.SetProperty("revealed", &v)
			266	+	}
			267	+
			268	+	// GetPropertyRevealed gets the "revealed" property.
			269	+	// Whether the banner is currently revealed.
			270	+	func (x *Banner) GetPropertyRevealed() bool {
			271	+	var v gobject.Value
			272	+	x.GetProperty("revealed", &v)
			273	+	return v.GetBoolean()
			274	+	}
			275	+
			276	+	// SetPropertyTitle sets the "title" property.
			277	+	// The title for this banner.
			278	+	//
			279	+	// See also: [property@Banner:use-markup].
			280	+	func (x *Banner) SetPropertyTitle(value string) {
			281	+	var v gobject.Value
			282	+	v.Init(gobject.TypeStringVal)
			283	+	v.SetString(value)
			284	+	x.SetProperty("title", &v)
			285	+	}
			286	+
			287	+	// GetPropertyTitle gets the "title" property.
			288	+	// The title for this banner.
			289	+	//
			290	+	// See also: [property@Banner:use-markup].
			291	+	func (x *Banner) GetPropertyTitle() string {
			292	+	var v gobject.Value
			293	+	x.GetProperty("title", &v)
			294	+	return v.GetString()
			295	+	}
			296	+
			297	+	// SetPropertyUseMarkup sets the "use-markup" property.
			298	+	// Whether to use Pango markup for the banner title.
			299	+	//
			300	+	// See also [func@Pango.parse_markup].
			301	+	func (x *Banner) SetPropertyUseMarkup(value bool) {
			302	+	var v gobject.Value
			303	+	v.Init(gobject.TypeBooleanVal)
			304	+	v.SetBoolean(value)
			305	+	x.SetProperty("use-markup", &v)
			306	+	}
			307	+
			308	+	// GetPropertyUseMarkup gets the "use-markup" property.
			309	+	// Whether to use Pango markup for the banner title.
			310	+	//
			311	+	// See also [func@Pango.parse_markup].
			312	+	func (x *Banner) GetPropertyUseMarkup() bool {
			313	+	var v gobject.Value
			314	+	x.GetProperty("use-markup", &v)
			315	+	return v.GetBoolean()
			316	+	}
			317	+
232		// This signal is emitted after the action button has been clicked.	318		// This signal is emitted after the action button has been clicked.
233		//	319		//
234		// It can be used as an alternative to setting an action.	320		// It can be used as an alternative to setting an action.

@@ -308,7 +394,7 @@ func (x Banner) GetAtContext() gtk.ATContext {
308		// This functionality can be overridden by `GtkAccessible`	394		// This functionality can be overridden by `GtkAccessible`
309		// implementations, e.g. to get the bounds from an ignored	395		// implementations, e.g. to get the bounds from an ignored
310		// child widget.	396		// child widget.
311	-	func (x *Banner) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	397	+	func (x Banner) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
312			398
313		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	399		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
314		return cret	400		return cret

M v4/adw/adw-bin.go +1 -1


@@ -163,7 +163,7 @@ func (x Bin) GetAtContext() gtk.ATContext {
163		// This functionality can be overridden by `GtkAccessible`	163		// This functionality can be overridden by `GtkAccessible`
164		// implementations, e.g. to get the bounds from an ignored	164		// implementations, e.g. to get the bounds from an ignored
165		// child widget.	165		// child widget.
166	-	func (x *Bin) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	166	+	func (x Bin) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
167			167
168		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	168		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
169		return cret	169		return cret

M v4/adw/adw-bottom-sheet.go +233 -2


@@ -434,6 +434,237 @@ func (c *BottomSheet) SetGoPointer(ptr uintptr) {
434		c.Ptr = ptr	434		c.Ptr = ptr
435		}	435		}
436			436
			437	+	// SetPropertyAlign sets the "align" property.
			438	+	// Horizontal alignment of the bottom sheet.
			439	+	//
			440	+	// 0 means the bottom sheet is flush with the start edge, 1 means it's flush
			441	+	// with the end edge. 0.5 means it's centered.
			442	+	//
			443	+	// Only used when [property@BottomSheet:full-width] is set to `FALSE`.
			444	+	func (x *BottomSheet) SetPropertyAlign(value float32) {
			445	+	var v gobject.Value
			446	+	v.Init(gobject.TypeFloatVal)
			447	+	v.SetFloat(value)
			448	+	x.SetProperty("align", &v)
			449	+	}
			450	+
			451	+	// GetPropertyAlign gets the "align" property.
			452	+	// Horizontal alignment of the bottom sheet.
			453	+	//
			454	+	// 0 means the bottom sheet is flush with the start edge, 1 means it's flush
			455	+	// with the end edge. 0.5 means it's centered.
			456	+	//
			457	+	// Only used when [property@BottomSheet:full-width] is set to `FALSE`.
			458	+	func (x *BottomSheet) GetPropertyAlign() float32 {
			459	+	var v gobject.Value
			460	+	x.GetProperty("align", &v)
			461	+	return v.GetFloat()
			462	+	}
			463	+
			464	+	// GetPropertyBottomBarHeight gets the "bottom-bar-height" property.
			465	+	// The current bottom bar height.
			466	+	//
			467	+	// It can be used to shift the content upwards permanently to accommodate for
			468	+	// the bottom bar.
			469	+	func (x *BottomSheet) GetPropertyBottomBarHeight() int {
			470	+	var v gobject.Value
			471	+	x.GetProperty("bottom-bar-height", &v)
			472	+	return v.GetInt()
			473	+	}
			474	+
			475	+	// SetPropertyCanClose sets the "can-close" property.
			476	+	// Whether the bottom sheet can be closed by user.
			477	+	//
			478	+	// It can be closed via the close button, swiping down, pressing
			479	+	// <kbd>Escape</kbd> or clicking the content dimming (when modal).
			480	+	//
			481	+	// Bottom sheet can still be closed using [property@BottomSheet:open].
			482	+	func (x *BottomSheet) SetPropertyCanClose(value bool) {
			483	+	var v gobject.Value
			484	+	v.Init(gobject.TypeBooleanVal)
			485	+	v.SetBoolean(value)
			486	+	x.SetProperty("can-close", &v)
			487	+	}
			488	+
			489	+	// GetPropertyCanClose gets the "can-close" property.
			490	+	// Whether the bottom sheet can be closed by user.
			491	+	//
			492	+	// It can be closed via the close button, swiping down, pressing
			493	+	// <kbd>Escape</kbd> or clicking the content dimming (when modal).
			494	+	//
			495	+	// Bottom sheet can still be closed using [property@BottomSheet:open].
			496	+	func (x *BottomSheet) GetPropertyCanClose() bool {
			497	+	var v gobject.Value
			498	+	x.GetProperty("can-close", &v)
			499	+	return v.GetBoolean()
			500	+	}
			501	+
			502	+	// SetPropertyCanOpen sets the "can-open" property.
			503	+	// Whether the bottom sheet can be opened by user.
			504	+	//
			505	+	// It can be opened via clicking or swiping up from the bottom bar.
			506	+	//
			507	+	// Does nothing if [property@BottomSheet:bottom-bar] is not set.
			508	+	//
			509	+	// Bottom sheet can still be opened using [property@BottomSheet:open].
			510	+	func (x *BottomSheet) SetPropertyCanOpen(value bool) {
			511	+	var v gobject.Value
			512	+	v.Init(gobject.TypeBooleanVal)
			513	+	v.SetBoolean(value)
			514	+	x.SetProperty("can-open", &v)
			515	+	}
			516	+
			517	+	// GetPropertyCanOpen gets the "can-open" property.
			518	+	// Whether the bottom sheet can be opened by user.
			519	+	//
			520	+	// It can be opened via clicking or swiping up from the bottom bar.
			521	+	//
			522	+	// Does nothing if [property@BottomSheet:bottom-bar] is not set.
			523	+	//
			524	+	// Bottom sheet can still be opened using [property@BottomSheet:open].
			525	+	func (x *BottomSheet) GetPropertyCanOpen() bool {
			526	+	var v gobject.Value
			527	+	x.GetProperty("can-open", &v)
			528	+	return v.GetBoolean()
			529	+	}
			530	+
			531	+	// SetPropertyFullWidth sets the "full-width" property.
			532	+	// Whether the bottom sheet takes the full width.
			533	+	//
			534	+	// When full width, [property@BottomSheet:align] is ignored.
			535	+	func (x *BottomSheet) SetPropertyFullWidth(value bool) {
			536	+	var v gobject.Value
			537	+	v.Init(gobject.TypeBooleanVal)
			538	+	v.SetBoolean(value)
			539	+	x.SetProperty("full-width", &v)
			540	+	}
			541	+
			542	+	// GetPropertyFullWidth gets the "full-width" property.
			543	+	// Whether the bottom sheet takes the full width.
			544	+	//
			545	+	// When full width, [property@BottomSheet:align] is ignored.
			546	+	func (x *BottomSheet) GetPropertyFullWidth() bool {
			547	+	var v gobject.Value
			548	+	x.GetProperty("full-width", &v)
			549	+	return v.GetBoolean()
			550	+	}
			551	+
			552	+	// SetPropertyModal sets the "modal" property.
			553	+	// Whether the bottom sheet is modal.
			554	+	//
			555	+	// When modal, [property@BottomSheet:content] will be dimmed when the bottom
			556	+	// sheet is open, and clicking it will close the bottom sheet. It also cannot
			557	+	// be focused with keyboard.
			558	+	//
			559	+	// Otherwise, the content is accessible even when the bottom sheet is open.
			560	+	func (x *BottomSheet) SetPropertyModal(value bool) {
			561	+	var v gobject.Value
			562	+	v.Init(gobject.TypeBooleanVal)
			563	+	v.SetBoolean(value)
			564	+	x.SetProperty("modal", &v)
			565	+	}
			566	+
			567	+	// GetPropertyModal gets the "modal" property.
			568	+	// Whether the bottom sheet is modal.
			569	+	//
			570	+	// When modal, [property@BottomSheet:content] will be dimmed when the bottom
			571	+	// sheet is open, and clicking it will close the bottom sheet. It also cannot
			572	+	// be focused with keyboard.
			573	+	//
			574	+	// Otherwise, the content is accessible even when the bottom sheet is open.
			575	+	func (x *BottomSheet) GetPropertyModal() bool {
			576	+	var v gobject.Value
			577	+	x.GetProperty("modal", &v)
			578	+	return v.GetBoolean()
			579	+	}
			580	+
			581	+	// SetPropertyOpen sets the "open" property.
			582	+	// Whether the bottom sheet is open.
			583	+	func (x *BottomSheet) SetPropertyOpen(value bool) {
			584	+	var v gobject.Value
			585	+	v.Init(gobject.TypeBooleanVal)
			586	+	v.SetBoolean(value)
			587	+	x.SetProperty("open", &v)
			588	+	}
			589	+
			590	+	// GetPropertyOpen gets the "open" property.
			591	+	// Whether the bottom sheet is open.
			592	+	func (x *BottomSheet) GetPropertyOpen() bool {
			593	+	var v gobject.Value
			594	+	x.GetProperty("open", &v)
			595	+	return v.GetBoolean()
			596	+	}
			597	+
			598	+	// SetPropertyRevealBottomBar sets the "reveal-bottom-bar" property.
			599	+	// Whether to reveal the bottom bar.
			600	+	//
			601	+	// The transition will be animated.
			602	+	//
			603	+	// See [property@BottomSheet:bottom-bar] and
			604	+	// [property@BottomSheet:bottom-bar-height].
			605	+	func (x *BottomSheet) SetPropertyRevealBottomBar(value bool) {
			606	+	var v gobject.Value
			607	+	v.Init(gobject.TypeBooleanVal)
			608	+	v.SetBoolean(value)
			609	+	x.SetProperty("reveal-bottom-bar", &v)
			610	+	}
			611	+
			612	+	// GetPropertyRevealBottomBar gets the "reveal-bottom-bar" property.
			613	+	// Whether to reveal the bottom bar.
			614	+	//
			615	+	// The transition will be animated.
			616	+	//
			617	+	// See [property@BottomSheet:bottom-bar] and
			618	+	// [property@BottomSheet:bottom-bar-height].
			619	+	func (x *BottomSheet) GetPropertyRevealBottomBar() bool {
			620	+	var v gobject.Value
			621	+	x.GetProperty("reveal-bottom-bar", &v)
			622	+	return v.GetBoolean()
			623	+	}
			624	+
			625	+	// GetPropertySheetHeight gets the "sheet-height" property.
			626	+	// The current bottom sheet height.
			627	+	//
			628	+	// It can be used to shift the content upwards when the bottom sheet is open.
			629	+	func (x *BottomSheet) GetPropertySheetHeight() int {
			630	+	var v gobject.Value
			631	+	x.GetProperty("sheet-height", &v)
			632	+	return v.GetInt()
			633	+	}
			634	+
			635	+	// SetPropertyShowDragHandle sets the "show-drag-handle" property.
			636	+	// Whether to overlay a drag handle in the bottom sheet.
			637	+	//
			638	+	// The handle will be overlaid over [property@BottomSheet:sheet].
			639	+	//
			640	+	// When the handle is shown, [class@HeaderBar] will hide its default title,
			641	+	// and [class@ToolbarView] will reserve space if there are no top bars.
			642	+	//
			643	+	// Showing drag handle also allows to swipe the bottom sheet down (and to
			644	+	// swipe the bottom bar up) with a pointer, instead of just touchscreen.
			645	+	func (x *BottomSheet) SetPropertyShowDragHandle(value bool) {
			646	+	var v gobject.Value
			647	+	v.Init(gobject.TypeBooleanVal)
			648	+	v.SetBoolean(value)
			649	+	x.SetProperty("show-drag-handle", &v)
			650	+	}
			651	+
			652	+	// GetPropertyShowDragHandle gets the "show-drag-handle" property.
			653	+	// Whether to overlay a drag handle in the bottom sheet.
			654	+	//
			655	+	// The handle will be overlaid over [property@BottomSheet:sheet].
			656	+	//
			657	+	// When the handle is shown, [class@HeaderBar] will hide its default title,
			658	+	// and [class@ToolbarView] will reserve space if there are no top bars.
			659	+	//
			660	+	// Showing drag handle also allows to swipe the bottom sheet down (and to
			661	+	// swipe the bottom bar up) with a pointer, instead of just touchscreen.
			662	+	func (x *BottomSheet) GetPropertyShowDragHandle() bool {
			663	+	var v gobject.Value
			664	+	x.GetProperty("show-drag-handle", &v)
			665	+	return v.GetBoolean()
			666	+	}
			667	+
437		// Emitted when the close button or shortcut is used while	668		// Emitted when the close button or shortcut is used while
438		// [property@Dialog:can-close] is set to `FALSE`.	669		// [property@Dialog:can-close] is set to `FALSE`.
439		func (x BottomSheet) ConnectCloseAttempt(cb func(BottomSheet)) uint32 {	670		func (x BottomSheet) ConnectCloseAttempt(cb func(BottomSheet)) uint32 {

@@ -482,7 +713,7 @@ func (x *BottomSheet) GetProgress() float64 {
482		//	713		//
483		// Each snap point represents a progress value that is considered acceptable to	714		// Each snap point represents a progress value that is considered acceptable to
484		// end the swipe on.	715		// end the swipe on.
485	-	func (x *BottomSheet) GetSnapPoints(NSnapPointsVar int) uintptr {	716	+	func (x BottomSheet) GetSnapPoints(NSnapPointsVar int) uintptr {
486			717
487		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)	718		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)
488		return cret	719		return cret

@@ -560,7 +791,7 @@ func (x BottomSheet) GetAtContext() gtk.ATContext {
560		// This functionality can be overridden by `GtkAccessible`	791		// This functionality can be overridden by `GtkAccessible`
561		// implementations, e.g. to get the bounds from an ignored	792		// implementations, e.g. to get the bounds from an ignored
562		// child widget.	793		// child widget.
563	-	func (x *BottomSheet) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	794	+	func (x BottomSheet) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
564			795
565		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	796		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
566		return cret	797		return cret

M v4/adw/adw-breakpoint-bin.go +1 -1


@@ -303,7 +303,7 @@ func (x BreakpointBin) GetAtContext() gtk.ATContext {
303		// This functionality can be overridden by `GtkAccessible`	303		// This functionality can be overridden by `GtkAccessible`
304		// implementations, e.g. to get the bounds from an ignored	304		// implementations, e.g. to get the bounds from an ignored
305		// child widget.	305		// child widget.
306	-	func (x *BreakpointBin) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	306	+	func (x BreakpointBin) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
307			307
308		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	308		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
309		return cret	309		return cret

M v4/adw/adw-breakpoint.go +17 -0


@@ -431,6 +431,23 @@ func (c *Breakpoint) SetGoPointer(ptr uintptr) {
431	c.Ptr = ptr	431		c.Ptr = ptr
432	}	432		}
433		433
		434	+	// SetPropertyCondition sets the "condition" property.
		435	+	// The breakpoint's condition.
		436	+	func (x *Breakpoint) SetPropertyCondition(value uintptr) {
		437	+	var v gobject.Value
		438	+	v.Init(gobject.TypePointerVal)
		439	+	v.SetPointer(value)
		440	+	x.SetProperty("condition", &v)
		441	+	}
		442	+
		443	+	// GetPropertyCondition gets the "condition" property.
		444	+	// The breakpoint's condition.
		445	+	func (x *Breakpoint) GetPropertyCondition() uintptr {
		446	+	var v gobject.Value
		447	+	x.GetProperty("condition", &v)
		448	+	return v.GetPointer()
		449	+	}
		450	+
434	// Emitted when the breakpoint is applied.	451		// Emitted when the breakpoint is applied.
435	//	452		//
436	// This signal is emitted after the setters have been applied.	453		// This signal is emitted after the setters have been applied.

M v4/adw/adw-button-content.go +89 -1


@@ -201,6 +201,94 @@ func (c *ButtonContent) SetGoPointer(ptr uintptr) {
201		c.Ptr = ptr	201		c.Ptr = ptr
202		}	202		}
203			203
			204	+	// SetPropertyCanShrink sets the "can-shrink" property.
			205	+	// Whether the button can be smaller than the natural size of its contents.
			206	+	//
			207	+	// If set to `TRUE`, the label will ellipsize.
			208	+	//
			209	+	// See [property@Gtk.Button:can-shrink].
			210	+	func (x *ButtonContent) SetPropertyCanShrink(value bool) {
			211	+	var v gobject.Value
			212	+	v.Init(gobject.TypeBooleanVal)
			213	+	v.SetBoolean(value)
			214	+	x.SetProperty("can-shrink", &v)
			215	+	}
			216	+
			217	+	// GetPropertyCanShrink gets the "can-shrink" property.
			218	+	// Whether the button can be smaller than the natural size of its contents.
			219	+	//
			220	+	// If set to `TRUE`, the label will ellipsize.
			221	+	//
			222	+	// See [property@Gtk.Button:can-shrink].
			223	+	func (x *ButtonContent) GetPropertyCanShrink() bool {
			224	+	var v gobject.Value
			225	+	x.GetProperty("can-shrink", &v)
			226	+	return v.GetBoolean()
			227	+	}
			228	+
			229	+	// SetPropertyIconName sets the "icon-name" property.
			230	+	// The name of the displayed icon.
			231	+	//
			232	+	// If empty, the icon is not shown.
			233	+	func (x *ButtonContent) SetPropertyIconName(value string) {
			234	+	var v gobject.Value
			235	+	v.Init(gobject.TypeStringVal)
			236	+	v.SetString(value)
			237	+	x.SetProperty("icon-name", &v)
			238	+	}
			239	+
			240	+	// GetPropertyIconName gets the "icon-name" property.
			241	+	// The name of the displayed icon.
			242	+	//
			243	+	// If empty, the icon is not shown.
			244	+	func (x *ButtonContent) GetPropertyIconName() string {
			245	+	var v gobject.Value
			246	+	x.GetProperty("icon-name", &v)
			247	+	return v.GetString()
			248	+	}
			249	+
			250	+	// SetPropertyLabel sets the "label" property.
			251	+	// The displayed label.
			252	+	func (x *ButtonContent) SetPropertyLabel(value string) {
			253	+	var v gobject.Value
			254	+	v.Init(gobject.TypeStringVal)
			255	+	v.SetString(value)
			256	+	x.SetProperty("label", &v)
			257	+	}
			258	+
			259	+	// GetPropertyLabel gets the "label" property.
			260	+	// The displayed label.
			261	+	func (x *ButtonContent) GetPropertyLabel() string {
			262	+	var v gobject.Value
			263	+	x.GetProperty("label", &v)
			264	+	return v.GetString()
			265	+	}
			266	+
			267	+	// SetPropertyUseUnderline sets the "use-underline" property.
			268	+	// Whether an underline in the text indicates a mnemonic.
			269	+	//
			270	+	// The mnemonic can be used to activate the parent button.
			271	+	//
			272	+	// See [property@ButtonContent:label].
			273	+	func (x *ButtonContent) SetPropertyUseUnderline(value bool) {
			274	+	var v gobject.Value
			275	+	v.Init(gobject.TypeBooleanVal)
			276	+	v.SetBoolean(value)
			277	+	x.SetProperty("use-underline", &v)
			278	+	}
			279	+
			280	+	// GetPropertyUseUnderline gets the "use-underline" property.
			281	+	// Whether an underline in the text indicates a mnemonic.
			282	+	//
			283	+	// The mnemonic can be used to activate the parent button.
			284	+	//
			285	+	// See [property@ButtonContent:label].
			286	+	func (x *ButtonContent) GetPropertyUseUnderline() bool {
			287	+	var v gobject.Value
			288	+	x.GetProperty("use-underline", &v)
			289	+	return v.GetBoolean()
			290	+	}
			291	+
204		// Requests the user's screen reader to announce the given message.	292		// Requests the user's screen reader to announce the given message.
205		//	293		//
206		// This kind of notification is useful for messages that	294		// This kind of notification is useful for messages that

@@ -258,7 +346,7 @@ func (x ButtonContent) GetAtContext() gtk.ATContext {
258		// This functionality can be overridden by `GtkAccessible`	346		// This functionality can be overridden by `GtkAccessible`
259		// implementations, e.g. to get the bounds from an ignored	347		// implementations, e.g. to get the bounds from an ignored
260		// child widget.	348		// child widget.
261	-	func (x *ButtonContent) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	349	+	func (x ButtonContent) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
262			350
263		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	351		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
264		return cret	352		return cret

M v4/adw/adw-button-row.go +35 -1


@@ -153,6 +153,40 @@ func (c *ButtonRow) SetGoPointer(ptr uintptr) {
153		c.Ptr = ptr	153		c.Ptr = ptr
154		}	154		}
155			155
			156	+	// SetPropertyEndIconName sets the "end-icon-name" property.
			157	+	// The icon name to show after the title.
			158	+	func (x *ButtonRow) SetPropertyEndIconName(value string) {
			159	+	var v gobject.Value
			160	+	v.Init(gobject.TypeStringVal)
			161	+	v.SetString(value)
			162	+	x.SetProperty("end-icon-name", &v)
			163	+	}
			164	+
			165	+	// GetPropertyEndIconName gets the "end-icon-name" property.
			166	+	// The icon name to show after the title.
			167	+	func (x *ButtonRow) GetPropertyEndIconName() string {
			168	+	var v gobject.Value
			169	+	x.GetProperty("end-icon-name", &v)
			170	+	return v.GetString()
			171	+	}
			172	+
			173	+	// SetPropertyStartIconName sets the "start-icon-name" property.
			174	+	// The icon name to show before the title.
			175	+	func (x *ButtonRow) SetPropertyStartIconName(value string) {
			176	+	var v gobject.Value
			177	+	v.Init(gobject.TypeStringVal)
			178	+	v.SetString(value)
			179	+	x.SetProperty("start-icon-name", &v)
			180	+	}
			181	+
			182	+	// GetPropertyStartIconName gets the "start-icon-name" property.
			183	+	// The icon name to show before the title.
			184	+	func (x *ButtonRow) GetPropertyStartIconName() string {
			185	+	var v gobject.Value
			186	+	x.GetProperty("start-icon-name", &v)
			187	+	return v.GetString()
			188	+	}
			189	+
156		// This signal is emitted after the row has been activated.	190		// This signal is emitted after the row has been activated.
157		func (x ButtonRow) ConnectActivated(cb func(ButtonRow)) uint32 {	191		func (x ButtonRow) ConnectActivated(cb func(ButtonRow)) uint32 {
158		cbPtr := uintptr(unsafe.Pointer(cb))	192		cbPtr := uintptr(unsafe.Pointer(cb))

@@ -230,7 +264,7 @@ func (x ButtonRow) GetAtContext() gtk.ATContext {
230		// This functionality can be overridden by `GtkAccessible`	264		// This functionality can be overridden by `GtkAccessible`
231		// implementations, e.g. to get the bounds from an ignored	265		// implementations, e.g. to get the bounds from an ignored
232		// child widget.	266		// child widget.
233	-	func (x *ButtonRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	267	+	func (x ButtonRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
234			268
235		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	269		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
236		return cret	270		return cret

M v4/adw/adw-carousel-indicator-dots.go +1 -1


@@ -169,7 +169,7 @@ func (x CarouselIndicatorDots) GetAtContext() gtk.ATContext {
169		// This functionality can be overridden by `GtkAccessible`	169		// This functionality can be overridden by `GtkAccessible`
170		// implementations, e.g. to get the bounds from an ignored	170		// implementations, e.g. to get the bounds from an ignored
171		// child widget.	171		// child widget.
172	-	func (x *CarouselIndicatorDots) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	172	+	func (x CarouselIndicatorDots) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
173			173
174		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	174		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
175		return cret	175		return cret

M v4/adw/adw-carousel-indicator-lines.go +1 -1


@@ -168,7 +168,7 @@ func (x CarouselIndicatorLines) GetAtContext() gtk.ATContext {
168		// This functionality can be overridden by `GtkAccessible`	168		// This functionality can be overridden by `GtkAccessible`
169		// implementations, e.g. to get the bounds from an ignored	169		// implementations, e.g. to get the bounds from an ignored
170		// child widget.	170		// child widget.
171	-	func (x *CarouselIndicatorLines) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	171	+	func (x CarouselIndicatorLines) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
172			172
173		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	173		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
174		return cret	174		return cret

M v4/adw/adw-carousel.go +173 -2


@@ -329,6 +329,177 @@ func (c *Carousel) SetGoPointer(ptr uintptr) {
329		c.Ptr = ptr	329		c.Ptr = ptr
330		}	330		}
331			331
			332	+	// SetPropertyAllowLongSwipes sets the "allow-long-swipes" property.
			333	+	// Whether to allow swiping for more than one page at a time.
			334	+	//
			335	+	// If the value is `FALSE`, each swipe can only move to the adjacent pages.
			336	+	func (x *Carousel) SetPropertyAllowLongSwipes(value bool) {
			337	+	var v gobject.Value
			338	+	v.Init(gobject.TypeBooleanVal)
			339	+	v.SetBoolean(value)
			340	+	x.SetProperty("allow-long-swipes", &v)
			341	+	}
			342	+
			343	+	// GetPropertyAllowLongSwipes gets the "allow-long-swipes" property.
			344	+	// Whether to allow swiping for more than one page at a time.
			345	+	//
			346	+	// If the value is `FALSE`, each swipe can only move to the adjacent pages.
			347	+	func (x *Carousel) GetPropertyAllowLongSwipes() bool {
			348	+	var v gobject.Value
			349	+	x.GetProperty("allow-long-swipes", &v)
			350	+	return v.GetBoolean()
			351	+	}
			352	+
			353	+	// SetPropertyAllowMouseDrag sets the "allow-mouse-drag" property.
			354	+	// Sets whether the `AdwCarousel` can be dragged with mouse pointer.
			355	+	//
			356	+	// If the value is `FALSE`, dragging is only available on touch.
			357	+	func (x *Carousel) SetPropertyAllowMouseDrag(value bool) {
			358	+	var v gobject.Value
			359	+	v.Init(gobject.TypeBooleanVal)
			360	+	v.SetBoolean(value)
			361	+	x.SetProperty("allow-mouse-drag", &v)
			362	+	}
			363	+
			364	+	// GetPropertyAllowMouseDrag gets the "allow-mouse-drag" property.
			365	+	// Sets whether the `AdwCarousel` can be dragged with mouse pointer.
			366	+	//
			367	+	// If the value is `FALSE`, dragging is only available on touch.
			368	+	func (x *Carousel) GetPropertyAllowMouseDrag() bool {
			369	+	var v gobject.Value
			370	+	x.GetProperty("allow-mouse-drag", &v)
			371	+	return v.GetBoolean()
			372	+	}
			373	+
			374	+	// SetPropertyAllowScrollWheel sets the "allow-scroll-wheel" property.
			375	+	// Whether the widget will respond to scroll wheel events.
			376	+	//
			377	+	// If the value is `FALSE`, wheel events will be ignored.
			378	+	func (x *Carousel) SetPropertyAllowScrollWheel(value bool) {
			379	+	var v gobject.Value
			380	+	v.Init(gobject.TypeBooleanVal)
			381	+	v.SetBoolean(value)
			382	+	x.SetProperty("allow-scroll-wheel", &v)
			383	+	}
			384	+
			385	+	// GetPropertyAllowScrollWheel gets the "allow-scroll-wheel" property.
			386	+	// Whether the widget will respond to scroll wheel events.
			387	+	//
			388	+	// If the value is `FALSE`, wheel events will be ignored.
			389	+	func (x *Carousel) GetPropertyAllowScrollWheel() bool {
			390	+	var v gobject.Value
			391	+	x.GetProperty("allow-scroll-wheel", &v)
			392	+	return v.GetBoolean()
			393	+	}
			394	+
			395	+	// SetPropertyInteractive sets the "interactive" property.
			396	+	// Whether the carousel can be navigated.
			397	+	//
			398	+	// This can be used to temporarily disable the carousel to only allow
			399	+	// navigating it in a certain state.
			400	+	func (x *Carousel) SetPropertyInteractive(value bool) {
			401	+	var v gobject.Value
			402	+	v.Init(gobject.TypeBooleanVal)
			403	+	v.SetBoolean(value)
			404	+	x.SetProperty("interactive", &v)
			405	+	}
			406	+
			407	+	// GetPropertyInteractive gets the "interactive" property.
			408	+	// Whether the carousel can be navigated.
			409	+	//
			410	+	// This can be used to temporarily disable the carousel to only allow
			411	+	// navigating it in a certain state.
			412	+	func (x *Carousel) GetPropertyInteractive() bool {
			413	+	var v gobject.Value
			414	+	x.GetProperty("interactive", &v)
			415	+	return v.GetBoolean()
			416	+	}
			417	+
			418	+	// GetPropertyNPages gets the "n-pages" property.
			419	+	// The number of pages in a `AdwCarousel`.
			420	+	func (x *Carousel) GetPropertyNPages() uint {
			421	+	var v gobject.Value
			422	+	x.GetProperty("n-pages", &v)
			423	+	return v.GetUint()
			424	+	}
			425	+
			426	+	// GetPropertyPosition gets the "position" property.
			427	+	// Current scrolling position, unitless.
			428	+	//
			429	+	// 1 matches 1 page. Use [method@Carousel.scroll_to] for changing it.
			430	+	func (x *Carousel) GetPropertyPosition() float64 {
			431	+	var v gobject.Value
			432	+	x.GetProperty("position", &v)
			433	+	return v.GetDouble()
			434	+	}
			435	+
			436	+	// SetPropertyRevealDuration sets the "reveal-duration" property.
			437	+	// Page reveal duration, in milliseconds.
			438	+	//
			439	+	// Reveal duration is used when animating adding or removing pages.
			440	+	func (x *Carousel) SetPropertyRevealDuration(value uint) {
			441	+	var v gobject.Value
			442	+	v.Init(gobject.TypeUintVal)
			443	+	v.SetUint(value)
			444	+	x.SetProperty("reveal-duration", &v)
			445	+	}
			446	+
			447	+	// GetPropertyRevealDuration gets the "reveal-duration" property.
			448	+	// Page reveal duration, in milliseconds.
			449	+	//
			450	+	// Reveal duration is used when animating adding or removing pages.
			451	+	func (x *Carousel) GetPropertyRevealDuration() uint {
			452	+	var v gobject.Value
			453	+	x.GetProperty("reveal-duration", &v)
			454	+	return v.GetUint()
			455	+	}
			456	+
			457	+	// SetPropertyScrollParams sets the "scroll-params" property.
			458	+	// Scroll animation spring parameters.
			459	+	//
			460	+	// The default value is equivalent to:
			461	+	//
			462	+	// ```c
			463	+	// adw_spring_params_new (1, 0.5, 500)
			464	+	// ```
			465	+	func (x *Carousel) SetPropertyScrollParams(value uintptr) {
			466	+	var v gobject.Value
			467	+	v.Init(gobject.TypePointerVal)
			468	+	v.SetPointer(value)
			469	+	x.SetProperty("scroll-params", &v)
			470	+	}
			471	+
			472	+	// GetPropertyScrollParams gets the "scroll-params" property.
			473	+	// Scroll animation spring parameters.
			474	+	//
			475	+	// The default value is equivalent to:
			476	+	//
			477	+	// ```c
			478	+	// adw_spring_params_new (1, 0.5, 500)
			479	+	// ```
			480	+	func (x *Carousel) GetPropertyScrollParams() uintptr {
			481	+	var v gobject.Value
			482	+	x.GetProperty("scroll-params", &v)
			483	+	return v.GetPointer()
			484	+	}
			485	+
			486	+	// SetPropertySpacing sets the "spacing" property.
			487	+	// Spacing between pages in pixels.
			488	+	func (x *Carousel) SetPropertySpacing(value uint) {
			489	+	var v gobject.Value
			490	+	v.Init(gobject.TypeUintVal)
			491	+	v.SetUint(value)
			492	+	x.SetProperty("spacing", &v)
			493	+	}
			494	+
			495	+	// GetPropertySpacing gets the "spacing" property.
			496	+	// Spacing between pages in pixels.
			497	+	func (x *Carousel) GetPropertySpacing() uint {
			498	+	var v gobject.Value
			499	+	x.GetProperty("spacing", &v)
			500	+	return v.GetUint()
			501	+	}
			502	+
332		// This signal is emitted after a page has been changed.	503		// This signal is emitted after a page has been changed.
333		//	504		//
334		// It can be used to implement "infinite scrolling" by amending the pages	505		// It can be used to implement "infinite scrolling" by amending the pages

@@ -383,7 +554,7 @@ func (x *Carousel) GetProgress() float64 {
383		//	554		//
384		// Each snap point represents a progress value that is considered acceptable to	555		// Each snap point represents a progress value that is considered acceptable to
385		// end the swipe on.	556		// end the swipe on.
386	-	func (x *Carousel) GetSnapPoints(NSnapPointsVar int) uintptr {	557	+	func (x Carousel) GetSnapPoints(NSnapPointsVar int) uintptr {
387			558
388		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)	559		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)
389		return cret	560		return cret

@@ -461,7 +632,7 @@ func (x Carousel) GetAtContext() gtk.ATContext {
461		// This functionality can be overridden by `GtkAccessible`	632		// This functionality can be overridden by `GtkAccessible`
462		// implementations, e.g. to get the bounds from an ignored	633		// implementations, e.g. to get the bounds from an ignored
463		// child widget.	634		// child widget.
464	-	func (x *Carousel) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	635	+	func (x Carousel) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
465			636
466		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	637		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
467		return cret	638		return cret

M v4/adw/adw-clamp-layout.go +67 -0


@@ -7,6 +7,7 @@ import (
7		7
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
		10	+	"github.com/jwijenbergh/puregotk/v4/gobject"
10	"github.com/jwijenbergh/puregotk/v4/gobject/types"	11		"github.com/jwijenbergh/puregotk/v4/gobject/types"
11	"github.com/jwijenbergh/puregotk/v4/gtk"	12		"github.com/jwijenbergh/puregotk/v4/gtk"
12	)	13		)

@@ -162,6 +163,72 @@ func (c *ClampLayout) SetGoPointer(ptr uintptr) {
162	c.Ptr = ptr	163		c.Ptr = ptr
163	}	164		}
164		165
		166	+	// SetPropertyMaximumSize sets the "maximum-size" property.
		167	+	// The maximum size to allocate to the children.
		168	+	//
		169	+	// It is the width if the layout is horizontal, or the height if it is
		170	+	// vertical.
		171	+	func (x *ClampLayout) SetPropertyMaximumSize(value int) {
		172	+	var v gobject.Value
		173	+	v.Init(gobject.TypeIntVal)
		174	+	v.SetInt(value)
		175	+	x.SetProperty("maximum-size", &v)
		176	+	}
		177	+
		178	+	// GetPropertyMaximumSize gets the "maximum-size" property.
		179	+	// The maximum size to allocate to the children.
		180	+	//
		181	+	// It is the width if the layout is horizontal, or the height if it is
		182	+	// vertical.
		183	+	func (x *ClampLayout) GetPropertyMaximumSize() int {
		184	+	var v gobject.Value
		185	+	x.GetProperty("maximum-size", &v)
		186	+	return v.GetInt()
		187	+	}
		188	+
		189	+	// SetPropertyTighteningThreshold sets the "tightening-threshold" property.
		190	+	// The size above which the children are clamped.
		191	+	//
		192	+	// Starting from this size, the layout will tighten its grip on the children,
		193	+	// slowly allocating less and less of the available size up to the maximum
		194	+	// allocated size. Below that threshold and below the maximum size, the
		195	+	// children will be allocated all the available size.
		196	+	//
		197	+	// If the threshold is greater than the maximum size to allocate to the
		198	+	// children, they will be allocated the whole size up to the maximum. If the
		199	+	// threshold is lower than the minimum size to allocate to the children, that
		200	+	// size will be used as the tightening threshold.
		201	+	//
		202	+	// Effectively, tightening the grip on a child before it reaches its maximum
		203	+	// size makes transitions to and from the maximum size smoother when resizing.
		204	+	func (x *ClampLayout) SetPropertyTighteningThreshold(value int) {
		205	+	var v gobject.Value
		206	+	v.Init(gobject.TypeIntVal)
		207	+	v.SetInt(value)
		208	+	x.SetProperty("tightening-threshold", &v)
		209	+	}
		210	+
		211	+	// GetPropertyTighteningThreshold gets the "tightening-threshold" property.
		212	+	// The size above which the children are clamped.
		213	+	//
		214	+	// Starting from this size, the layout will tighten its grip on the children,
		215	+	// slowly allocating less and less of the available size up to the maximum
		216	+	// allocated size. Below that threshold and below the maximum size, the
		217	+	// children will be allocated all the available size.
		218	+	//
		219	+	// If the threshold is greater than the maximum size to allocate to the
		220	+	// children, they will be allocated the whole size up to the maximum. If the
		221	+	// threshold is lower than the minimum size to allocate to the children, that
		222	+	// size will be used as the tightening threshold.
		223	+	//
		224	+	// Effectively, tightening the grip on a child before it reaches its maximum
		225	+	// size makes transitions to and from the maximum size smoother when resizing.
		226	+	func (x *ClampLayout) GetPropertyTighteningThreshold() int {
		227	+	var v gobject.Value
		228	+	x.GetProperty("tightening-threshold", &v)
		229	+	return v.GetInt()
		230	+	}
		231	+
165	// Retrieves the orientation of the @orientable.	232		// Retrieves the orientation of the @orientable.
166	func (x *ClampLayout) GetOrientation() gtk.Orientation {	233		func (x *ClampLayout) GetOrientation() gtk.Orientation {
167		234

M v4/adw/adw-clamp-scrollable.go +65 -1


@@ -172,6 +172,70 @@ func (c *ClampScrollable) SetGoPointer(ptr uintptr) {
172		c.Ptr = ptr	172		c.Ptr = ptr
173		}	173		}
174			174
			175	+	// SetPropertyMaximumSize sets the "maximum-size" property.
			176	+	// The maximum size allocated to the child.
			177	+	//
			178	+	// It is the width if the clamp is horizontal, or the height if it is vertical.
			179	+	func (x *ClampScrollable) SetPropertyMaximumSize(value int) {
			180	+	var v gobject.Value
			181	+	v.Init(gobject.TypeIntVal)
			182	+	v.SetInt(value)
			183	+	x.SetProperty("maximum-size", &v)
			184	+	}
			185	+
			186	+	// GetPropertyMaximumSize gets the "maximum-size" property.
			187	+	// The maximum size allocated to the child.
			188	+	//
			189	+	// It is the width if the clamp is horizontal, or the height if it is vertical.
			190	+	func (x *ClampScrollable) GetPropertyMaximumSize() int {
			191	+	var v gobject.Value
			192	+	x.GetProperty("maximum-size", &v)
			193	+	return v.GetInt()
			194	+	}
			195	+
			196	+	// SetPropertyTighteningThreshold sets the "tightening-threshold" property.
			197	+	// The size above which the child is clamped.
			198	+	//
			199	+	// Starting from this size, the clamp will tighten its grip on the child,
			200	+	// slowly allocating less and less of the available size up to the maximum
			201	+	// allocated size. Below that threshold and below the maximum width, the child
			202	+	// will be allocated all the available size.
			203	+	//
			204	+	// If the threshold is greater than the maximum size to allocate to the child,
			205	+	// the child will be allocated all the width up to the maximum.
			206	+	// If the threshold is lower than the minimum size to allocate to the child,
			207	+	// that size will be used as the tightening threshold.
			208	+	//
			209	+	// Effectively, tightening the grip on the child before it reaches its maximum
			210	+	// size makes transitions to and from the maximum size smoother when resizing.
			211	+	func (x *ClampScrollable) SetPropertyTighteningThreshold(value int) {
			212	+	var v gobject.Value
			213	+	v.Init(gobject.TypeIntVal)
			214	+	v.SetInt(value)
			215	+	x.SetProperty("tightening-threshold", &v)
			216	+	}
			217	+
			218	+	// GetPropertyTighteningThreshold gets the "tightening-threshold" property.
			219	+	// The size above which the child is clamped.
			220	+	//
			221	+	// Starting from this size, the clamp will tighten its grip on the child,
			222	+	// slowly allocating less and less of the available size up to the maximum
			223	+	// allocated size. Below that threshold and below the maximum width, the child
			224	+	// will be allocated all the available size.
			225	+	//
			226	+	// If the threshold is greater than the maximum size to allocate to the child,
			227	+	// the child will be allocated all the width up to the maximum.
			228	+	// If the threshold is lower than the minimum size to allocate to the child,
			229	+	// that size will be used as the tightening threshold.
			230	+	//
			231	+	// Effectively, tightening the grip on the child before it reaches its maximum
			232	+	// size makes transitions to and from the maximum size smoother when resizing.
			233	+	func (x *ClampScrollable) GetPropertyTighteningThreshold() int {
			234	+	var v gobject.Value
			235	+	x.GetProperty("tightening-threshold", &v)
			236	+	return v.GetInt()
			237	+	}
			238	+
175		// Requests the user's screen reader to announce the given message.	239		// Requests the user's screen reader to announce the given message.
176		//	240		//
177		// This kind of notification is useful for messages that	241		// This kind of notification is useful for messages that

@@ -229,7 +293,7 @@ func (x ClampScrollable) GetAtContext() gtk.ATContext {
229		// This functionality can be overridden by `GtkAccessible`	293		// This functionality can be overridden by `GtkAccessible`
230		// implementations, e.g. to get the bounds from an ignored	294		// implementations, e.g. to get the bounds from an ignored
231		// child widget.	295		// child widget.
232	-	func (x *ClampScrollable) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	296	+	func (x ClampScrollable) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
233			297
234		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	298		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
235		return cret	299		return cret

M v4/adw/adw-clamp.go +65 -1


@@ -194,6 +194,70 @@ func (c *Clamp) SetGoPointer(ptr uintptr) {
194		c.Ptr = ptr	194		c.Ptr = ptr
195		}	195		}
196			196
			197	+	// SetPropertyMaximumSize sets the "maximum-size" property.
			198	+	// The maximum size allocated to the child.
			199	+	//
			200	+	// It is the width if the clamp is horizontal, or the height if it is vertical.
			201	+	func (x *Clamp) SetPropertyMaximumSize(value int) {
			202	+	var v gobject.Value
			203	+	v.Init(gobject.TypeIntVal)
			204	+	v.SetInt(value)
			205	+	x.SetProperty("maximum-size", &v)
			206	+	}
			207	+
			208	+	// GetPropertyMaximumSize gets the "maximum-size" property.
			209	+	// The maximum size allocated to the child.
			210	+	//
			211	+	// It is the width if the clamp is horizontal, or the height if it is vertical.
			212	+	func (x *Clamp) GetPropertyMaximumSize() int {
			213	+	var v gobject.Value
			214	+	x.GetProperty("maximum-size", &v)
			215	+	return v.GetInt()
			216	+	}
			217	+
			218	+	// SetPropertyTighteningThreshold sets the "tightening-threshold" property.
			219	+	// The size above which the child is clamped.
			220	+	//
			221	+	// Starting from this size, the clamp will tighten its grip on the child,
			222	+	// slowly allocating less and less of the available size up to the maximum
			223	+	// allocated size. Below that threshold and below the maximum size, the child
			224	+	// will be allocated all the available size.
			225	+	//
			226	+	// If the threshold is greater than the maximum size to allocate to the child,
			227	+	// the child will be allocated all the size up to the maximum.
			228	+	// If the threshold is lower than the minimum size to allocate to the child,
			229	+	// that size will be used as the tightening threshold.
			230	+	//
			231	+	// Effectively, tightening the grip on the child before it reaches its maximum
			232	+	// size makes transitions to and from the maximum size smoother when resizing.
			233	+	func (x *Clamp) SetPropertyTighteningThreshold(value int) {
			234	+	var v gobject.Value
			235	+	v.Init(gobject.TypeIntVal)
			236	+	v.SetInt(value)
			237	+	x.SetProperty("tightening-threshold", &v)
			238	+	}
			239	+
			240	+	// GetPropertyTighteningThreshold gets the "tightening-threshold" property.
			241	+	// The size above which the child is clamped.
			242	+	//
			243	+	// Starting from this size, the clamp will tighten its grip on the child,
			244	+	// slowly allocating less and less of the available size up to the maximum
			245	+	// allocated size. Below that threshold and below the maximum size, the child
			246	+	// will be allocated all the available size.
			247	+	//
			248	+	// If the threshold is greater than the maximum size to allocate to the child,
			249	+	// the child will be allocated all the size up to the maximum.
			250	+	// If the threshold is lower than the minimum size to allocate to the child,
			251	+	// that size will be used as the tightening threshold.
			252	+	//
			253	+	// Effectively, tightening the grip on the child before it reaches its maximum
			254	+	// size makes transitions to and from the maximum size smoother when resizing.
			255	+	func (x *Clamp) GetPropertyTighteningThreshold() int {
			256	+	var v gobject.Value
			257	+	x.GetProperty("tightening-threshold", &v)
			258	+	return v.GetInt()
			259	+	}
			260	+
197		// Requests the user's screen reader to announce the given message.	261		// Requests the user's screen reader to announce the given message.
198		//	262		//
199		// This kind of notification is useful for messages that	263		// This kind of notification is useful for messages that

@@ -251,7 +315,7 @@ func (x Clamp) GetAtContext() gtk.ATContext {
251		// This functionality can be overridden by `GtkAccessible`	315		// This functionality can be overridden by `GtkAccessible`
252		// implementations, e.g. to get the bounds from an ignored	316		// implementations, e.g. to get the bounds from an ignored
253		// child widget.	317		// child widget.
254	-	func (x *Clamp) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	318	+	func (x Clamp) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
255			319
256		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	320		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
257		return cret	321		return cret

M v4/adw/adw-combo-row.go +84 -1


@@ -369,6 +369,89 @@ func (c *ComboRow) SetGoPointer(ptr uintptr) {
369		c.Ptr = ptr	369		c.Ptr = ptr
370		}	370		}
371			371
			372	+	// SetPropertyEnableSearch sets the "enable-search" property.
			373	+	// Whether to show a search entry in the popup.
			374	+	//
			375	+	// If set to `TRUE`, a search entry will be shown in the popup that
			376	+	// allows to search for items in the list.
			377	+	//
			378	+	// Search requires [property@ComboRow:expression] to be set.
			379	+	func (x *ComboRow) SetPropertyEnableSearch(value bool) {
			380	+	var v gobject.Value
			381	+	v.Init(gobject.TypeBooleanVal)
			382	+	v.SetBoolean(value)
			383	+	x.SetProperty("enable-search", &v)
			384	+	}
			385	+
			386	+	// GetPropertyEnableSearch gets the "enable-search" property.
			387	+	// Whether to show a search entry in the popup.
			388	+	//
			389	+	// If set to `TRUE`, a search entry will be shown in the popup that
			390	+	// allows to search for items in the list.
			391	+	//
			392	+	// Search requires [property@ComboRow:expression] to be set.
			393	+	func (x *ComboRow) GetPropertyEnableSearch() bool {
			394	+	var v gobject.Value
			395	+	x.GetProperty("enable-search", &v)
			396	+	return v.GetBoolean()
			397	+	}
			398	+
			399	+	// SetPropertySelected sets the "selected" property.
			400	+	// The position of the selected item.
			401	+	//
			402	+	// If no item is selected, the property has the value
			403	+	// [const@Gtk.INVALID_LIST_POSITION]
			404	+	func (x *ComboRow) SetPropertySelected(value uint) {
			405	+	var v gobject.Value
			406	+	v.Init(gobject.TypeUintVal)
			407	+	v.SetUint(value)
			408	+	x.SetProperty("selected", &v)
			409	+	}
			410	+
			411	+	// GetPropertySelected gets the "selected" property.
			412	+	// The position of the selected item.
			413	+	//
			414	+	// If no item is selected, the property has the value
			415	+	// [const@Gtk.INVALID_LIST_POSITION]
			416	+	func (x *ComboRow) GetPropertySelected() uint {
			417	+	var v gobject.Value
			418	+	x.GetProperty("selected", &v)
			419	+	return v.GetUint()
			420	+	}
			421	+
			422	+	// SetPropertyUseSubtitle sets the "use-subtitle" property.
			423	+	// Whether to use the current value as the subtitle.
			424	+	//
			425	+	// If you use a custom list item factory, you will need to give the row a
			426	+	// name conversion expression with [property@ComboRow:expression].
			427	+	//
			428	+	// If set to `TRUE`, you should not access [property@ActionRow:subtitle].
			429	+	//
			430	+	// The subtitle is interpreted as Pango markup if
			431	+	// [property@PreferencesRow:use-markup] is set to `TRUE`.
			432	+	func (x *ComboRow) SetPropertyUseSubtitle(value bool) {
			433	+	var v gobject.Value
			434	+	v.Init(gobject.TypeBooleanVal)
			435	+	v.SetBoolean(value)
			436	+	x.SetProperty("use-subtitle", &v)
			437	+	}
			438	+
			439	+	// GetPropertyUseSubtitle gets the "use-subtitle" property.
			440	+	// Whether to use the current value as the subtitle.
			441	+	//
			442	+	// If you use a custom list item factory, you will need to give the row a
			443	+	// name conversion expression with [property@ComboRow:expression].
			444	+	//
			445	+	// If set to `TRUE`, you should not access [property@ActionRow:subtitle].
			446	+	//
			447	+	// The subtitle is interpreted as Pango markup if
			448	+	// [property@PreferencesRow:use-markup] is set to `TRUE`.
			449	+	func (x *ComboRow) GetPropertyUseSubtitle() bool {
			450	+	var v gobject.Value
			451	+	x.GetProperty("use-subtitle", &v)
			452	+	return v.GetBoolean()
			453	+	}
			454	+
372		// Requests the user's screen reader to announce the given message.	455		// Requests the user's screen reader to announce the given message.
373		//	456		//
374		// This kind of notification is useful for messages that	457		// This kind of notification is useful for messages that

@@ -426,7 +509,7 @@ func (x ComboRow) GetAtContext() gtk.ATContext {
426		// This functionality can be overridden by `GtkAccessible`	509		// This functionality can be overridden by `GtkAccessible`
427		// implementations, e.g. to get the bounds from an ignored	510		// implementations, e.g. to get the bounds from an ignored
428		// child widget.	511		// child widget.
429	-	func (x *ComboRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	512	+	func (x ComboRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
430			513
431		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	514		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
432		return cret	515		return cret

M v4/adw/adw-dialog.go +128 -5


@@ -29,7 +29,7 @@ func (x *DialogClass) GoPointer() uintptr {
29		return uintptr(unsafe.Pointer(x))	29		return uintptr(unsafe.Pointer(x))
30		}	30		}
31			31
32	-	// OverrideCloseAttempt sets the callback function.	32	+	// OverrideCloseAttempt sets the "close_attempt" callback function.
33		func (x DialogClass) OverrideCloseAttempt(cb func(Dialog)) {	33		func (x DialogClass) OverrideCloseAttempt(cb func(Dialog)) {
34		if cb == nil {	34		if cb == nil {
35		x.xCloseAttempt = 0	35		x.xCloseAttempt = 0

@@ -40,7 +40,7 @@ func (x DialogClass) OverrideCloseAttempt(cb func(Dialog)) {
40		}	40		}
41		}	41		}
42			42
43	-	// GetCloseAttempt gets the callback function.	43	+	// GetCloseAttempt gets the "close_attempt" callback function.
44		func (x DialogClass) GetCloseAttempt() func(Dialog) {	44		func (x DialogClass) GetCloseAttempt() func(Dialog) {
45		if x.xCloseAttempt == 0 {	45		if x.xCloseAttempt == 0 {
46		return nil	46		return nil

@@ -52,7 +52,7 @@ func (x DialogClass) GetCloseAttempt() func(Dialog) {
52		}	52		}
53		}	53		}
54			54
55	-	// OverrideClosed sets the callback function.	55	+	// OverrideClosed sets the "closed" callback function.
56		func (x DialogClass) OverrideClosed(cb func(Dialog)) {	56		func (x DialogClass) OverrideClosed(cb func(Dialog)) {
57		if cb == nil {	57		if cb == nil {
58		x.xClosed = 0	58		x.xClosed = 0

@@ -63,7 +63,7 @@ func (x DialogClass) OverrideClosed(cb func(Dialog)) {
63		}	63		}
64		}	64		}
65			65
66	-	// GetClosed gets the callback function.	66	+	// GetClosed gets the "closed" callback function.
67		func (x DialogClass) GetClosed() func(Dialog) {	67		func (x DialogClass) GetClosed() func(Dialog) {
68		if x.xClosed == 0 {	68		if x.xClosed == 0 {
69		return nil	69		return nil

@@ -494,6 +494,129 @@ func (c *Dialog) SetGoPointer(ptr uintptr) {
494		c.Ptr = ptr	494		c.Ptr = ptr
495		}	495		}
496			496
			497	+	// SetPropertyCanClose sets the "can-close" property.
			498	+	// Whether the dialog can be closed.
			499	+	//
			500	+	// If set to `FALSE`, the close button, shortcuts and
			501	+	// [method@Dialog.close] will result in [signal@Dialog::close-attempt] being
			502	+	// emitted instead, and bottom sheet close swipe will be disabled.
			503	+	// [method@Dialog.force_close] still works.
			504	+	func (x *Dialog) SetPropertyCanClose(value bool) {
			505	+	var v gobject.Value
			506	+	v.Init(gobject.TypeBooleanVal)
			507	+	v.SetBoolean(value)
			508	+	x.SetProperty("can-close", &v)
			509	+	}
			510	+
			511	+	// GetPropertyCanClose gets the "can-close" property.
			512	+	// Whether the dialog can be closed.
			513	+	//
			514	+	// If set to `FALSE`, the close button, shortcuts and
			515	+	// [method@Dialog.close] will result in [signal@Dialog::close-attempt] being
			516	+	// emitted instead, and bottom sheet close swipe will be disabled.
			517	+	// [method@Dialog.force_close] still works.
			518	+	func (x *Dialog) GetPropertyCanClose() bool {
			519	+	var v gobject.Value
			520	+	x.GetProperty("can-close", &v)
			521	+	return v.GetBoolean()
			522	+	}
			523	+
			524	+	// SetPropertyContentHeight sets the "content-height" property.
			525	+	// The height of the dialog's contents.
			526	+	//
			527	+	// Set it to -1 to reset it to the content's natural height.
			528	+	//
			529	+	// See also: [property@Gtk.Window:default-height]
			530	+	func (x *Dialog) SetPropertyContentHeight(value int) {
			531	+	var v gobject.Value
			532	+	v.Init(gobject.TypeIntVal)
			533	+	v.SetInt(value)
			534	+	x.SetProperty("content-height", &v)
			535	+	}
			536	+
			537	+	// GetPropertyContentHeight gets the "content-height" property.
			538	+	// The height of the dialog's contents.
			539	+	//
			540	+	// Set it to -1 to reset it to the content's natural height.
			541	+	//
			542	+	// See also: [property@Gtk.Window:default-height]
			543	+	func (x *Dialog) GetPropertyContentHeight() int {
			544	+	var v gobject.Value
			545	+	x.GetProperty("content-height", &v)
			546	+	return v.GetInt()
			547	+	}
			548	+
			549	+	// SetPropertyContentWidth sets the "content-width" property.
			550	+	// The width of the dialog's contents.
			551	+	//
			552	+	// Set it to -1 to reset it to the content's natural width.
			553	+	//
			554	+	// See also: [property@Gtk.Window:default-width]
			555	+	func (x *Dialog) SetPropertyContentWidth(value int) {
			556	+	var v gobject.Value
			557	+	v.Init(gobject.TypeIntVal)
			558	+	v.SetInt(value)
			559	+	x.SetProperty("content-width", &v)
			560	+	}
			561	+
			562	+	// GetPropertyContentWidth gets the "content-width" property.
			563	+	// The width of the dialog's contents.
			564	+	//
			565	+	// Set it to -1 to reset it to the content's natural width.
			566	+	//
			567	+	// See also: [property@Gtk.Window:default-width]
			568	+	func (x *Dialog) GetPropertyContentWidth() int {
			569	+	var v gobject.Value
			570	+	x.GetProperty("content-width", &v)
			571	+	return v.GetInt()
			572	+	}
			573	+
			574	+	// SetPropertyFollowsContentSize sets the "follows-content-size" property.
			575	+	// Whether to size content automatically.
			576	+	//
			577	+	// If set to `TRUE`, always use the content's natural size instead of
			578	+	// [property@Dialog:content-width] and [property@Dialog:content-height]. If
			579	+	// the content resizes, the dialog will immediately resize as well.
			580	+	//
			581	+	// See also: [property@Gtk.Window:resizable]
			582	+	func (x *Dialog) SetPropertyFollowsContentSize(value bool) {
			583	+	var v gobject.Value
			584	+	v.Init(gobject.TypeBooleanVal)
			585	+	v.SetBoolean(value)
			586	+	x.SetProperty("follows-content-size", &v)
			587	+	}
			588	+
			589	+	// GetPropertyFollowsContentSize gets the "follows-content-size" property.
			590	+	// Whether to size content automatically.
			591	+	//
			592	+	// If set to `TRUE`, always use the content's natural size instead of
			593	+	// [property@Dialog:content-width] and [property@Dialog:content-height]. If
			594	+	// the content resizes, the dialog will immediately resize as well.
			595	+	//
			596	+	// See also: [property@Gtk.Window:resizable]
			597	+	func (x *Dialog) GetPropertyFollowsContentSize() bool {
			598	+	var v gobject.Value
			599	+	x.GetProperty("follows-content-size", &v)
			600	+	return v.GetBoolean()
			601	+	}
			602	+
			603	+	// SetPropertyTitle sets the "title" property.
			604	+	// The title of the dialog.
			605	+	func (x *Dialog) SetPropertyTitle(value string) {
			606	+	var v gobject.Value
			607	+	v.Init(gobject.TypeStringVal)
			608	+	v.SetString(value)
			609	+	x.SetProperty("title", &v)
			610	+	}
			611	+
			612	+	// GetPropertyTitle gets the "title" property.
			613	+	// The title of the dialog.
			614	+	func (x *Dialog) GetPropertyTitle() string {
			615	+	var v gobject.Value
			616	+	x.GetProperty("title", &v)
			617	+	return v.GetString()
			618	+	}
			619	+
497		// Emitted when the close button or shortcut is used, or	620		// Emitted when the close button or shortcut is used, or
498		// [method@Dialog.close] is called while [property@Dialog:can-close] is set to	621		// [method@Dialog.close] is called while [property@Dialog:can-close] is set to
499		// `FALSE`.	622		// `FALSE`.

@@ -593,7 +716,7 @@ func (x Dialog) GetAtContext() gtk.ATContext {
593		// This functionality can be overridden by `GtkAccessible`	716		// This functionality can be overridden by `GtkAccessible`
594		// implementations, e.g. to get the bounds from an ignored	717		// implementations, e.g. to get the bounds from an ignored
595		// child widget.	718		// child widget.
596	-	func (x *Dialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	719	+	func (x Dialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
597			720
598		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	721		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
599		return cret	722		return cret

M v4/adw/adw-entry-row.go +121 -2


@@ -296,6 +296,125 @@ func (c *EntryRow) SetGoPointer(ptr uintptr) {
296		c.Ptr = ptr	296		c.Ptr = ptr
297		}	297		}
298			298
			299	+	// SetPropertyActivatesDefault sets the "activates-default" property.
			300	+	// Whether activating the embedded entry can activate the default widget.
			301	+	func (x *EntryRow) SetPropertyActivatesDefault(value bool) {
			302	+	var v gobject.Value
			303	+	v.Init(gobject.TypeBooleanVal)
			304	+	v.SetBoolean(value)
			305	+	x.SetProperty("activates-default", &v)
			306	+	}
			307	+
			308	+	// GetPropertyActivatesDefault gets the "activates-default" property.
			309	+	// Whether activating the embedded entry can activate the default widget.
			310	+	func (x *EntryRow) GetPropertyActivatesDefault() bool {
			311	+	var v gobject.Value
			312	+	x.GetProperty("activates-default", &v)
			313	+	return v.GetBoolean()
			314	+	}
			315	+
			316	+	// SetPropertyAttributes sets the "attributes" property.
			317	+	// A list of Pango attributes to apply to the text of the embedded entry.
			318	+	//
			319	+	// The [struct@Pango.Attribute]'s `start_index` and `end_index` must refer to
			320	+	// the [class@Gtk.EntryBuffer] text, i.e. without the preedit string.
			321	+	func (x *EntryRow) SetPropertyAttributes(value uintptr) {
			322	+	var v gobject.Value
			323	+	v.Init(gobject.TypePointerVal)
			324	+	v.SetPointer(value)
			325	+	x.SetProperty("attributes", &v)
			326	+	}
			327	+
			328	+	// GetPropertyAttributes gets the "attributes" property.
			329	+	// A list of Pango attributes to apply to the text of the embedded entry.
			330	+	//
			331	+	// The [struct@Pango.Attribute]'s `start_index` and `end_index` must refer to
			332	+	// the [class@Gtk.EntryBuffer] text, i.e. without the preedit string.
			333	+	func (x *EntryRow) GetPropertyAttributes() uintptr {
			334	+	var v gobject.Value
			335	+	x.GetProperty("attributes", &v)
			336	+	return v.GetPointer()
			337	+	}
			338	+
			339	+	// SetPropertyEnableEmojiCompletion sets the "enable-emoji-completion" property.
			340	+	// Whether to suggest emoji replacements on the entry row.
			341	+	//
			342	+	// Emoji replacement is done with :-delimited names, like `:heart:`.
			343	+	func (x *EntryRow) SetPropertyEnableEmojiCompletion(value bool) {
			344	+	var v gobject.Value
			345	+	v.Init(gobject.TypeBooleanVal)
			346	+	v.SetBoolean(value)
			347	+	x.SetProperty("enable-emoji-completion", &v)
			348	+	}
			349	+
			350	+	// GetPropertyEnableEmojiCompletion gets the "enable-emoji-completion" property.
			351	+	// Whether to suggest emoji replacements on the entry row.
			352	+	//
			353	+	// Emoji replacement is done with :-delimited names, like `:heart:`.
			354	+	func (x *EntryRow) GetPropertyEnableEmojiCompletion() bool {
			355	+	var v gobject.Value
			356	+	x.GetProperty("enable-emoji-completion", &v)
			357	+	return v.GetBoolean()
			358	+	}
			359	+
			360	+	// SetPropertyMaxLength sets the "max-length" property.
			361	+	// Maximum number of characters for the entry.
			362	+	func (x *EntryRow) SetPropertyMaxLength(value int) {
			363	+	var v gobject.Value
			364	+	v.Init(gobject.TypeIntVal)
			365	+	v.SetInt(value)
			366	+	x.SetProperty("max-length", &v)
			367	+	}
			368	+
			369	+	// GetPropertyMaxLength gets the "max-length" property.
			370	+	// Maximum number of characters for the entry.
			371	+	func (x *EntryRow) GetPropertyMaxLength() int {
			372	+	var v gobject.Value
			373	+	x.GetProperty("max-length", &v)
			374	+	return v.GetInt()
			375	+	}
			376	+
			377	+	// SetPropertyShowApplyButton sets the "show-apply-button" property.
			378	+	// Whether to show the apply button.
			379	+	//
			380	+	// When set to `TRUE`, typing text in the entry will reveal an apply button.
			381	+	// Clicking it or pressing the <kbd>Enter</kbd> key will hide the button and
			382	+	// emit the [signal@EntryRow::apply] signal.
			383	+	//
			384	+	// This is useful if changing the entry contents can trigger an expensive
			385	+	// operation, e.g. network activity, to avoid triggering it after typing every
			386	+	// character.
			387	+	func (x *EntryRow) SetPropertyShowApplyButton(value bool) {
			388	+	var v gobject.Value
			389	+	v.Init(gobject.TypeBooleanVal)
			390	+	v.SetBoolean(value)
			391	+	x.SetProperty("show-apply-button", &v)
			392	+	}
			393	+
			394	+	// GetPropertyShowApplyButton gets the "show-apply-button" property.
			395	+	// Whether to show the apply button.
			396	+	//
			397	+	// When set to `TRUE`, typing text in the entry will reveal an apply button.
			398	+	// Clicking it or pressing the <kbd>Enter</kbd> key will hide the button and
			399	+	// emit the [signal@EntryRow::apply] signal.
			400	+	//
			401	+	// This is useful if changing the entry contents can trigger an expensive
			402	+	// operation, e.g. network activity, to avoid triggering it after typing every
			403	+	// character.
			404	+	func (x *EntryRow) GetPropertyShowApplyButton() bool {
			405	+	var v gobject.Value
			406	+	x.GetProperty("show-apply-button", &v)
			407	+	return v.GetBoolean()
			408	+	}
			409	+
			410	+	// GetPropertyTextLength gets the "text-length" property.
			411	+	// The length of the text in the entry row.
			412	+	func (x *EntryRow) GetPropertyTextLength() uint {
			413	+	var v gobject.Value
			414	+	x.GetProperty("text-length", &v)
			415	+	return v.GetUint()
			416	+	}
			417	+
299		// Emitted when the apply button is pressed.	418		// Emitted when the apply button is pressed.
300		//	419		//
301		// See [property@EntryRow:show-apply-button].	420		// See [property@EntryRow:show-apply-button].

@@ -395,7 +514,7 @@ func (x EntryRow) GetAtContext() gtk.ATContext {
395		// This functionality can be overridden by `GtkAccessible`	514		// This functionality can be overridden by `GtkAccessible`
396		// implementations, e.g. to get the bounds from an ignored	515		// implementations, e.g. to get the bounds from an ignored
397		// child widget.	516		// child widget.
398	-	func (x *EntryRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	517	+	func (x EntryRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
399			518
400		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	519		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
401		return cret	520		return cret

@@ -851,7 +970,7 @@ func (x *EntryRow) GetPosition() int {
851		// and %FALSE will be returned.	970		// and %FALSE will be returned.
852		//	971		//
853		// Note that positions are specified in characters, not bytes.	972		// Note that positions are specified in characters, not bytes.
854	-	func (x *EntryRow) GetSelectionBounds(StartPosVar int, EndPosVar int) bool {	973	+	func (x EntryRow) GetSelectionBounds(StartPosVar int, EndPosVar *int) bool {
855			974
856		cret := gtk.XGtkEditableGetSelectionBounds(x.GoPointer(), StartPosVar, EndPosVar)	975		cret := gtk.XGtkEditableGetSelectionBounds(x.GoPointer(), StartPosVar, EndPosVar)
857		return cret	976		return cret

M v4/adw/adw-enum-list-model.go +24 -0


@@ -87,6 +87,30 @@ func (c *EnumListItem) SetGoPointer(ptr uintptr) {
87	c.Ptr = ptr	87		c.Ptr = ptr
88	}	88		}
89		89
		90	+	// GetPropertyName gets the "name" property.
		91	+	// The enum value name.
		92	+	func (x *EnumListItem) GetPropertyName() string {
		93	+	var v gobject.Value
		94	+	x.GetProperty("name", &v)
		95	+	return v.GetString()
		96	+	}
		97	+
		98	+	// GetPropertyNick gets the "nick" property.
		99	+	// The enum value nick.
		100	+	func (x *EnumListItem) GetPropertyNick() string {
		101	+	var v gobject.Value
		102	+	x.GetProperty("nick", &v)
		103	+	return v.GetString()
		104	+	}
		105	+
		106	+	// GetPropertyValue gets the "value" property.
		107	+	// The enum value.
		108	+	func (x *EnumListItem) GetPropertyValue() int {
		109	+	var v gobject.Value
		110	+	x.GetProperty("value", &v)
		111	+	return v.GetInt()
		112	+	}
		113	+
90	// A [iface@Gio.ListModel] representing values of a given enum.	114		// A [iface@Gio.ListModel] representing values of a given enum.
91	//	115		//
92	// `AdwEnumListModel` contains objects of type [class@EnumListItem].	116		// `AdwEnumListModel` contains objects of type [class@EnumListItem].

M v4/adw/adw-expander-row.go +136 -1


@@ -292,6 +292,141 @@ func (c *ExpanderRow) SetGoPointer(ptr uintptr) {
292		c.Ptr = ptr	292		c.Ptr = ptr
293		}	293		}
294			294
			295	+	// SetPropertyEnableExpansion sets the "enable-expansion" property.
			296	+	// Whether expansion is enabled.
			297	+	func (x *ExpanderRow) SetPropertyEnableExpansion(value bool) {
			298	+	var v gobject.Value
			299	+	v.Init(gobject.TypeBooleanVal)
			300	+	v.SetBoolean(value)
			301	+	x.SetProperty("enable-expansion", &v)
			302	+	}
			303	+
			304	+	// GetPropertyEnableExpansion gets the "enable-expansion" property.
			305	+	// Whether expansion is enabled.
			306	+	func (x *ExpanderRow) GetPropertyEnableExpansion() bool {
			307	+	var v gobject.Value
			308	+	x.GetProperty("enable-expansion", &v)
			309	+	return v.GetBoolean()
			310	+	}
			311	+
			312	+	// SetPropertyExpanded sets the "expanded" property.
			313	+	// Whether the row is expanded.
			314	+	func (x *ExpanderRow) SetPropertyExpanded(value bool) {
			315	+	var v gobject.Value
			316	+	v.Init(gobject.TypeBooleanVal)
			317	+	v.SetBoolean(value)
			318	+	x.SetProperty("expanded", &v)
			319	+	}
			320	+
			321	+	// GetPropertyExpanded gets the "expanded" property.
			322	+	// Whether the row is expanded.
			323	+	func (x *ExpanderRow) GetPropertyExpanded() bool {
			324	+	var v gobject.Value
			325	+	x.GetProperty("expanded", &v)
			326	+	return v.GetBoolean()
			327	+	}
			328	+
			329	+	// SetPropertyIconName sets the "icon-name" property.
			330	+	// The icon name for this row.
			331	+	func (x *ExpanderRow) SetPropertyIconName(value string) {
			332	+	var v gobject.Value
			333	+	v.Init(gobject.TypeStringVal)
			334	+	v.SetString(value)
			335	+	x.SetProperty("icon-name", &v)
			336	+	}
			337	+
			338	+	// GetPropertyIconName gets the "icon-name" property.
			339	+	// The icon name for this row.
			340	+	func (x *ExpanderRow) GetPropertyIconName() string {
			341	+	var v gobject.Value
			342	+	x.GetProperty("icon-name", &v)
			343	+	return v.GetString()
			344	+	}
			345	+
			346	+	// SetPropertyShowEnableSwitch sets the "show-enable-switch" property.
			347	+	// Whether the switch enabling the expansion is visible.
			348	+	func (x *ExpanderRow) SetPropertyShowEnableSwitch(value bool) {
			349	+	var v gobject.Value
			350	+	v.Init(gobject.TypeBooleanVal)
			351	+	v.SetBoolean(value)
			352	+	x.SetProperty("show-enable-switch", &v)
			353	+	}
			354	+
			355	+	// GetPropertyShowEnableSwitch gets the "show-enable-switch" property.
			356	+	// Whether the switch enabling the expansion is visible.
			357	+	func (x *ExpanderRow) GetPropertyShowEnableSwitch() bool {
			358	+	var v gobject.Value
			359	+	x.GetProperty("show-enable-switch", &v)
			360	+	return v.GetBoolean()
			361	+	}
			362	+
			363	+	// SetPropertySubtitle sets the "subtitle" property.
			364	+	// The subtitle for this row.
			365	+	//
			366	+	// The subtitle is interpreted as Pango markup unless
			367	+	// [property@PreferencesRow:use-markup] is set to `FALSE`.
			368	+	func (x *ExpanderRow) SetPropertySubtitle(value string) {
			369	+	var v gobject.Value
			370	+	v.Init(gobject.TypeStringVal)
			371	+	v.SetString(value)
			372	+	x.SetProperty("subtitle", &v)
			373	+	}
			374	+
			375	+	// GetPropertySubtitle gets the "subtitle" property.
			376	+	// The subtitle for this row.
			377	+	//
			378	+	// The subtitle is interpreted as Pango markup unless
			379	+	// [property@PreferencesRow:use-markup] is set to `FALSE`.
			380	+	func (x *ExpanderRow) GetPropertySubtitle() string {
			381	+	var v gobject.Value
			382	+	x.GetProperty("subtitle", &v)
			383	+	return v.GetString()
			384	+	}
			385	+
			386	+	// SetPropertySubtitleLines sets the "subtitle-lines" property.
			387	+	// The number of lines at the end of which the subtitle label will be
			388	+	// ellipsized.
			389	+	//
			390	+	// If the value is 0, the number of lines won't be limited.
			391	+	func (x *ExpanderRow) SetPropertySubtitleLines(value int) {
			392	+	var v gobject.Value
			393	+	v.Init(gobject.TypeIntVal)
			394	+	v.SetInt(value)
			395	+	x.SetProperty("subtitle-lines", &v)
			396	+	}
			397	+
			398	+	// GetPropertySubtitleLines gets the "subtitle-lines" property.
			399	+	// The number of lines at the end of which the subtitle label will be
			400	+	// ellipsized.
			401	+	//
			402	+	// If the value is 0, the number of lines won't be limited.
			403	+	func (x *ExpanderRow) GetPropertySubtitleLines() int {
			404	+	var v gobject.Value
			405	+	x.GetProperty("subtitle-lines", &v)
			406	+	return v.GetInt()
			407	+	}
			408	+
			409	+	// SetPropertyTitleLines sets the "title-lines" property.
			410	+	// The number of lines at the end of which the title label will be ellipsized.
			411	+	//
			412	+	// If the value is 0, the number of lines won't be limited.
			413	+	func (x *ExpanderRow) SetPropertyTitleLines(value int) {
			414	+	var v gobject.Value
			415	+	v.Init(gobject.TypeIntVal)
			416	+	v.SetInt(value)
			417	+	x.SetProperty("title-lines", &v)
			418	+	}
			419	+
			420	+	// GetPropertyTitleLines gets the "title-lines" property.
			421	+	// The number of lines at the end of which the title label will be ellipsized.
			422	+	//
			423	+	// If the value is 0, the number of lines won't be limited.
			424	+	func (x *ExpanderRow) GetPropertyTitleLines() int {
			425	+	var v gobject.Value
			426	+	x.GetProperty("title-lines", &v)
			427	+	return v.GetInt()
			428	+	}
			429	+
295		// Requests the user's screen reader to announce the given message.	430		// Requests the user's screen reader to announce the given message.
296		//	431		//
297		// This kind of notification is useful for messages that	432		// This kind of notification is useful for messages that

@@ -349,7 +484,7 @@ func (x ExpanderRow) GetAtContext() gtk.ATContext {
349		// This functionality can be overridden by `GtkAccessible`	484		// This functionality can be overridden by `GtkAccessible`
350		// implementations, e.g. to get the bounds from an ignored	485		// implementations, e.g. to get the bounds from an ignored
351		// child widget.	486		// child widget.
352	-	func (x *ExpanderRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	487	+	func (x ExpanderRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
353			488
354		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	489		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
355		return cret	490		return cret

M v4/adw/adw-flap.go +183 -2


@@ -519,6 +519,187 @@ func (c *Flap) SetGoPointer(ptr uintptr) {
519		c.Ptr = ptr	519		c.Ptr = ptr
520		}	520		}
521			521
			522	+	// SetPropertyFoldDuration sets the "fold-duration" property.
			523	+	// The fold transition animation duration, in milliseconds.
			524	+	func (x *Flap) SetPropertyFoldDuration(value uint) {
			525	+	var v gobject.Value
			526	+	v.Init(gobject.TypeUintVal)
			527	+	v.SetUint(value)
			528	+	x.SetProperty("fold-duration", &v)
			529	+	}
			530	+
			531	+	// GetPropertyFoldDuration gets the "fold-duration" property.
			532	+	// The fold transition animation duration, in milliseconds.
			533	+	func (x *Flap) GetPropertyFoldDuration() uint {
			534	+	var v gobject.Value
			535	+	x.GetProperty("fold-duration", &v)
			536	+	return v.GetUint()
			537	+	}
			538	+
			539	+	// GetPropertyFolded gets the "folded" property.
			540	+	// Whether the flap is currently folded.
			541	+	//
			542	+	// See [property@Flap:fold-policy].
			543	+	func (x *Flap) GetPropertyFolded() bool {
			544	+	var v gobject.Value
			545	+	x.GetProperty("folded", &v)
			546	+	return v.GetBoolean()
			547	+	}
			548	+
			549	+	// SetPropertyLocked sets the "locked" property.
			550	+	// Whether the flap is locked.
			551	+	//
			552	+	// If `FALSE`, folding when the flap is revealed automatically closes it, and
			553	+	// unfolding it when the flap is not revealed opens it. If `TRUE`,
			554	+	// [property@Flap:reveal-flap] value never changes on its own.
			555	+	func (x *Flap) SetPropertyLocked(value bool) {
			556	+	var v gobject.Value
			557	+	v.Init(gobject.TypeBooleanVal)
			558	+	v.SetBoolean(value)
			559	+	x.SetProperty("locked", &v)
			560	+	}
			561	+
			562	+	// GetPropertyLocked gets the "locked" property.
			563	+	// Whether the flap is locked.
			564	+	//
			565	+	// If `FALSE`, folding when the flap is revealed automatically closes it, and
			566	+	// unfolding it when the flap is not revealed opens it. If `TRUE`,
			567	+	// [property@Flap:reveal-flap] value never changes on its own.
			568	+	func (x *Flap) GetPropertyLocked() bool {
			569	+	var v gobject.Value
			570	+	x.GetProperty("locked", &v)
			571	+	return v.GetBoolean()
			572	+	}
			573	+
			574	+	// SetPropertyModal sets the "modal" property.
			575	+	// Whether the flap is modal.
			576	+	//
			577	+	// If `TRUE`, clicking the content widget while flap is revealed, as well as
			578	+	// pressing the <kbd>Esc</kbd> key, will close the flap. If `FALSE`, clicks
			579	+	// are passed through to the content widget.
			580	+	func (x *Flap) SetPropertyModal(value bool) {
			581	+	var v gobject.Value
			582	+	v.Init(gobject.TypeBooleanVal)
			583	+	v.SetBoolean(value)
			584	+	x.SetProperty("modal", &v)
			585	+	}
			586	+
			587	+	// GetPropertyModal gets the "modal" property.
			588	+	// Whether the flap is modal.
			589	+	//
			590	+	// If `TRUE`, clicking the content widget while flap is revealed, as well as
			591	+	// pressing the <kbd>Esc</kbd> key, will close the flap. If `FALSE`, clicks
			592	+	// are passed through to the content widget.
			593	+	func (x *Flap) GetPropertyModal() bool {
			594	+	var v gobject.Value
			595	+	x.GetProperty("modal", &v)
			596	+	return v.GetBoolean()
			597	+	}
			598	+
			599	+	// SetPropertyRevealFlap sets the "reveal-flap" property.
			600	+	// Whether the flap widget is revealed.
			601	+	func (x *Flap) SetPropertyRevealFlap(value bool) {
			602	+	var v gobject.Value
			603	+	v.Init(gobject.TypeBooleanVal)
			604	+	v.SetBoolean(value)
			605	+	x.SetProperty("reveal-flap", &v)
			606	+	}
			607	+
			608	+	// GetPropertyRevealFlap gets the "reveal-flap" property.
			609	+	// Whether the flap widget is revealed.
			610	+	func (x *Flap) GetPropertyRevealFlap() bool {
			611	+	var v gobject.Value
			612	+	x.GetProperty("reveal-flap", &v)
			613	+	return v.GetBoolean()
			614	+	}
			615	+
			616	+	// SetPropertyRevealParams sets the "reveal-params" property.
			617	+	// The reveal animation spring parameters.
			618	+	//
			619	+	// The default value is equivalent to:
			620	+	//
			621	+	// ```c
			622	+	// adw_spring_params_new (1, 0.5, 500)
			623	+	// ```
			624	+	func (x *Flap) SetPropertyRevealParams(value uintptr) {
			625	+	var v gobject.Value
			626	+	v.Init(gobject.TypePointerVal)
			627	+	v.SetPointer(value)
			628	+	x.SetProperty("reveal-params", &v)
			629	+	}
			630	+
			631	+	// GetPropertyRevealParams gets the "reveal-params" property.
			632	+	// The reveal animation spring parameters.
			633	+	//
			634	+	// The default value is equivalent to:
			635	+	//
			636	+	// ```c
			637	+	// adw_spring_params_new (1, 0.5, 500)
			638	+	// ```
			639	+	func (x *Flap) GetPropertyRevealParams() uintptr {
			640	+	var v gobject.Value
			641	+	x.GetProperty("reveal-params", &v)
			642	+	return v.GetPointer()
			643	+	}
			644	+
			645	+	// GetPropertyRevealProgress gets the "reveal-progress" property.
			646	+	// The current reveal transition progress.
			647	+	//
			648	+	// 0 means fully hidden, 1 means fully revealed.
			649	+	//
			650	+	// See [property@Flap:reveal-flap].
			651	+	func (x *Flap) GetPropertyRevealProgress() float64 {
			652	+	var v gobject.Value
			653	+	x.GetProperty("reveal-progress", &v)
			654	+	return v.GetDouble()
			655	+	}
			656	+
			657	+	// SetPropertySwipeToClose sets the "swipe-to-close" property.
			658	+	// Whether the flap can be closed with a swipe gesture.
			659	+	//
			660	+	// The area that can be swiped depends on the [property@Flap:transition-type]
			661	+	// value.
			662	+	func (x *Flap) SetPropertySwipeToClose(value bool) {
			663	+	var v gobject.Value
			664	+	v.Init(gobject.TypeBooleanVal)
			665	+	v.SetBoolean(value)
			666	+	x.SetProperty("swipe-to-close", &v)
			667	+	}
			668	+
			669	+	// GetPropertySwipeToClose gets the "swipe-to-close" property.
			670	+	// Whether the flap can be closed with a swipe gesture.
			671	+	//
			672	+	// The area that can be swiped depends on the [property@Flap:transition-type]
			673	+	// value.
			674	+	func (x *Flap) GetPropertySwipeToClose() bool {
			675	+	var v gobject.Value
			676	+	x.GetProperty("swipe-to-close", &v)
			677	+	return v.GetBoolean()
			678	+	}
			679	+
			680	+	// SetPropertySwipeToOpen sets the "swipe-to-open" property.
			681	+	// Whether the flap can be opened with a swipe gesture.
			682	+	//
			683	+	// The area that can be swiped depends on the [property@Flap:transition-type]
			684	+	// value.
			685	+	func (x *Flap) SetPropertySwipeToOpen(value bool) {
			686	+	var v gobject.Value
			687	+	v.Init(gobject.TypeBooleanVal)
			688	+	v.SetBoolean(value)
			689	+	x.SetProperty("swipe-to-open", &v)
			690	+	}
			691	+
			692	+	// GetPropertySwipeToOpen gets the "swipe-to-open" property.
			693	+	// Whether the flap can be opened with a swipe gesture.
			694	+	//
			695	+	// The area that can be swiped depends on the [property@Flap:transition-type]
			696	+	// value.
			697	+	func (x *Flap) GetPropertySwipeToOpen() bool {
			698	+	var v gobject.Value
			699	+	x.GetProperty("swipe-to-open", &v)
			700	+	return v.GetBoolean()
			701	+	}
			702	+
522		// Gets the progress @self will snap back to after the gesture is canceled.	703		// Gets the progress @self will snap back to after the gesture is canceled.
523		func (x *Flap) GetCancelProgress() float64 {	704		func (x *Flap) GetCancelProgress() float64 {
524			705

@@ -546,7 +727,7 @@ func (x *Flap) GetProgress() float64 {
546		//	727		//
547		// Each snap point represents a progress value that is considered acceptable to	728		// Each snap point represents a progress value that is considered acceptable to
548		// end the swipe on.	729		// end the swipe on.
549	-	func (x *Flap) GetSnapPoints(NSnapPointsVar int) uintptr {	730	+	func (x Flap) GetSnapPoints(NSnapPointsVar int) uintptr {
550			731
551		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)	732		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)
552		return cret	733		return cret

@@ -624,7 +805,7 @@ func (x Flap) GetAtContext() gtk.ATContext {
624		// This functionality can be overridden by `GtkAccessible`	805		// This functionality can be overridden by `GtkAccessible`
625		// implementations, e.g. to get the bounds from an ignored	806		// implementations, e.g. to get the bounds from an ignored
626		// child widget.	807		// child widget.
627	-	func (x *Flap) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	808	+	func (x Flap) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
628			809
629		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	810		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
630		return cret	811		return cret

M v4/adw/adw-header-bar.go +142 -1


@@ -388,6 +388,147 @@ func (c *HeaderBar) SetGoPointer(ptr uintptr) {
388		c.Ptr = ptr	388		c.Ptr = ptr
389		}	389		}
390			390
			391	+	// SetPropertyDecorationLayout sets the "decoration-layout" property.
			392	+	// The decoration layout for buttons.
			393	+	//
			394	+	// If this property is not set, the
			395	+	// [property@Gtk.Settings:gtk-decoration-layout] setting is used.
			396	+	//
			397	+	// The format of the string is button names, separated by commas. A colon
			398	+	// separates the buttons that should appear at the start from those at the
			399	+	// end. Recognized button names are minimize, maximize, close and icon (the
			400	+	// window icon).
			401	+	//
			402	+	// For example, “icon:minimize,maximize,close” specifies an icon at the start,
			403	+	// and minimize, maximize and close buttons at the end.
			404	+	func (x *HeaderBar) SetPropertyDecorationLayout(value string) {
			405	+	var v gobject.Value
			406	+	v.Init(gobject.TypeStringVal)
			407	+	v.SetString(value)
			408	+	x.SetProperty("decoration-layout", &v)
			409	+	}
			410	+
			411	+	// GetPropertyDecorationLayout gets the "decoration-layout" property.
			412	+	// The decoration layout for buttons.
			413	+	//
			414	+	// If this property is not set, the
			415	+	// [property@Gtk.Settings:gtk-decoration-layout] setting is used.
			416	+	//
			417	+	// The format of the string is button names, separated by commas. A colon
			418	+	// separates the buttons that should appear at the start from those at the
			419	+	// end. Recognized button names are minimize, maximize, close and icon (the
			420	+	// window icon).
			421	+	//
			422	+	// For example, “icon:minimize,maximize,close” specifies an icon at the start,
			423	+	// and minimize, maximize and close buttons at the end.
			424	+	func (x *HeaderBar) GetPropertyDecorationLayout() string {
			425	+	var v gobject.Value
			426	+	x.GetProperty("decoration-layout", &v)
			427	+	return v.GetString()
			428	+	}
			429	+
			430	+	// SetPropertyShowBackButton sets the "show-back-button" property.
			431	+	// Whether the header bar can show the back button.
			432	+	//
			433	+	// The back button will never be shown unless the header bar is placed inside an
			434	+	// [class@NavigationView]. Usually, there is no reason to set this to `FALSE`.
			435	+	func (x *HeaderBar) SetPropertyShowBackButton(value bool) {
			436	+	var v gobject.Value
			437	+	v.Init(gobject.TypeBooleanVal)
			438	+	v.SetBoolean(value)
			439	+	x.SetProperty("show-back-button", &v)
			440	+	}
			441	+
			442	+	// GetPropertyShowBackButton gets the "show-back-button" property.
			443	+	// Whether the header bar can show the back button.
			444	+	//
			445	+	// The back button will never be shown unless the header bar is placed inside an
			446	+	// [class@NavigationView]. Usually, there is no reason to set this to `FALSE`.
			447	+	func (x *HeaderBar) GetPropertyShowBackButton() bool {
			448	+	var v gobject.Value
			449	+	x.GetProperty("show-back-button", &v)
			450	+	return v.GetBoolean()
			451	+	}
			452	+
			453	+	// SetPropertyShowEndTitleButtons sets the "show-end-title-buttons" property.
			454	+	// Whether to show title buttons at the end of the header bar.
			455	+	//
			456	+	// See [property@HeaderBar:show-start-title-buttons] for the other side.
			457	+	//
			458	+	// Which buttons are actually shown and where is determined by the
			459	+	// [property@HeaderBar:decoration-layout] property, and by the state of the
			460	+	// window (e.g. a close button will not be shown if the window can't be
			461	+	// closed).
			462	+	func (x *HeaderBar) SetPropertyShowEndTitleButtons(value bool) {
			463	+	var v gobject.Value
			464	+	v.Init(gobject.TypeBooleanVal)
			465	+	v.SetBoolean(value)
			466	+	x.SetProperty("show-end-title-buttons", &v)
			467	+	}
			468	+
			469	+	// GetPropertyShowEndTitleButtons gets the "show-end-title-buttons" property.
			470	+	// Whether to show title buttons at the end of the header bar.
			471	+	//
			472	+	// See [property@HeaderBar:show-start-title-buttons] for the other side.
			473	+	//
			474	+	// Which buttons are actually shown and where is determined by the
			475	+	// [property@HeaderBar:decoration-layout] property, and by the state of the
			476	+	// window (e.g. a close button will not be shown if the window can't be
			477	+	// closed).
			478	+	func (x *HeaderBar) GetPropertyShowEndTitleButtons() bool {
			479	+	var v gobject.Value
			480	+	x.GetProperty("show-end-title-buttons", &v)
			481	+	return v.GetBoolean()
			482	+	}
			483	+
			484	+	// SetPropertyShowStartTitleButtons sets the "show-start-title-buttons" property.
			485	+	// Whether to show title buttons at the start of the header bar.
			486	+	//
			487	+	// See [property@HeaderBar:show-end-title-buttons] for the other side.
			488	+	//
			489	+	// Which buttons are actually shown and where is determined by the
			490	+	// [property@HeaderBar:decoration-layout] property, and by the state of the
			491	+	// window (e.g. a close button will not be shown if the window can't be
			492	+	// closed).
			493	+	func (x *HeaderBar) SetPropertyShowStartTitleButtons(value bool) {
			494	+	var v gobject.Value
			495	+	v.Init(gobject.TypeBooleanVal)
			496	+	v.SetBoolean(value)
			497	+	x.SetProperty("show-start-title-buttons", &v)
			498	+	}
			499	+
			500	+	// GetPropertyShowStartTitleButtons gets the "show-start-title-buttons" property.
			501	+	// Whether to show title buttons at the start of the header bar.
			502	+	//
			503	+	// See [property@HeaderBar:show-end-title-buttons] for the other side.
			504	+	//
			505	+	// Which buttons are actually shown and where is determined by the
			506	+	// [property@HeaderBar:decoration-layout] property, and by the state of the
			507	+	// window (e.g. a close button will not be shown if the window can't be
			508	+	// closed).
			509	+	func (x *HeaderBar) GetPropertyShowStartTitleButtons() bool {
			510	+	var v gobject.Value
			511	+	x.GetProperty("show-start-title-buttons", &v)
			512	+	return v.GetBoolean()
			513	+	}
			514	+
			515	+	// SetPropertyShowTitle sets the "show-title" property.
			516	+	// Whether the title widget should be shown.
			517	+	func (x *HeaderBar) SetPropertyShowTitle(value bool) {
			518	+	var v gobject.Value
			519	+	v.Init(gobject.TypeBooleanVal)
			520	+	v.SetBoolean(value)
			521	+	x.SetProperty("show-title", &v)
			522	+	}
			523	+
			524	+	// GetPropertyShowTitle gets the "show-title" property.
			525	+	// Whether the title widget should be shown.
			526	+	func (x *HeaderBar) GetPropertyShowTitle() bool {
			527	+	var v gobject.Value
			528	+	x.GetProperty("show-title", &v)
			529	+	return v.GetBoolean()
			530	+	}
			531	+
391		// Requests the user's screen reader to announce the given message.	532		// Requests the user's screen reader to announce the given message.
392		//	533		//
393		// This kind of notification is useful for messages that	534		// This kind of notification is useful for messages that

@@ -445,7 +586,7 @@ func (x HeaderBar) GetAtContext() gtk.ATContext {
445		// This functionality can be overridden by `GtkAccessible`	586		// This functionality can be overridden by `GtkAccessible`
446		// implementations, e.g. to get the bounds from an ignored	587		// implementations, e.g. to get the bounds from an ignored
447		// child widget.	588		// child widget.
448	-	func (x *HeaderBar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	589	+	func (x HeaderBar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
449			590
450		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	591		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
451		return cret	592		return cret

M v4/adw/adw-inline-view-switcher.go +43 -1


@@ -230,6 +230,48 @@ func (c *InlineViewSwitcher) SetGoPointer(ptr uintptr) {
230		c.Ptr = ptr	230		c.Ptr = ptr
231		}	231		}
232			232
			233	+	// SetPropertyCanShrink sets the "can-shrink" property.
			234	+	// Whether the toggles can be smaller than the natural size of their contents.
			235	+	//
			236	+	// If set to `TRUE`, the toggle labels will ellipsize.
			237	+	//
			238	+	// See [property@ToggleGroup:can-shrink].
			239	+	func (x *InlineViewSwitcher) SetPropertyCanShrink(value bool) {
			240	+	var v gobject.Value
			241	+	v.Init(gobject.TypeBooleanVal)
			242	+	v.SetBoolean(value)
			243	+	x.SetProperty("can-shrink", &v)
			244	+	}
			245	+
			246	+	// GetPropertyCanShrink gets the "can-shrink" property.
			247	+	// Whether the toggles can be smaller than the natural size of their contents.
			248	+	//
			249	+	// If set to `TRUE`, the toggle labels will ellipsize.
			250	+	//
			251	+	// See [property@ToggleGroup:can-shrink].
			252	+	func (x *InlineViewSwitcher) GetPropertyCanShrink() bool {
			253	+	var v gobject.Value
			254	+	x.GetProperty("can-shrink", &v)
			255	+	return v.GetBoolean()
			256	+	}
			257	+
			258	+	// SetPropertyHomogeneous sets the "homogeneous" property.
			259	+	// Whether all toggles take the same size.
			260	+	func (x *InlineViewSwitcher) SetPropertyHomogeneous(value bool) {
			261	+	var v gobject.Value
			262	+	v.Init(gobject.TypeBooleanVal)
			263	+	v.SetBoolean(value)
			264	+	x.SetProperty("homogeneous", &v)
			265	+	}
			266	+
			267	+	// GetPropertyHomogeneous gets the "homogeneous" property.
			268	+	// Whether all toggles take the same size.
			269	+	func (x *InlineViewSwitcher) GetPropertyHomogeneous() bool {
			270	+	var v gobject.Value
			271	+	x.GetProperty("homogeneous", &v)
			272	+	return v.GetBoolean()
			273	+	}
			274	+
233		// Requests the user's screen reader to announce the given message.	275		// Requests the user's screen reader to announce the given message.
234		//	276		//
235		// This kind of notification is useful for messages that	277		// This kind of notification is useful for messages that

@@ -287,7 +329,7 @@ func (x InlineViewSwitcher) GetAtContext() gtk.ATContext {
287		// This functionality can be overridden by `GtkAccessible`	329		// This functionality can be overridden by `GtkAccessible`
288		// implementations, e.g. to get the bounds from an ignored	330		// implementations, e.g. to get the bounds from an ignored
289		// child widget.	331		// child widget.
290	-	func (x *InlineViewSwitcher) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	332	+	func (x InlineViewSwitcher) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
291			333
292		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	334		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
293		return cret	335		return cret

M v4/adw/adw-layout-slot.go +22 -1


@@ -81,6 +81,27 @@ func (c *LayoutSlot) SetGoPointer(ptr uintptr) {
81		c.Ptr = ptr	81		c.Ptr = ptr
82		}	82		}
83			83
			84	+	// SetPropertyId sets the "id" property.
			85	+	// The slot ID.
			86	+	//
			87	+	// See [method@MultiLayoutView.set_child].
			88	+	func (x *LayoutSlot) SetPropertyId(value string) {
			89	+	var v gobject.Value
			90	+	v.Init(gobject.TypeStringVal)
			91	+	v.SetString(value)
			92	+	x.SetProperty("id", &v)
			93	+	}
			94	+
			95	+	// GetPropertyId gets the "id" property.
			96	+	// The slot ID.
			97	+	//
			98	+	// See [method@MultiLayoutView.set_child].
			99	+	func (x *LayoutSlot) GetPropertyId() string {
			100	+	var v gobject.Value
			101	+	x.GetProperty("id", &v)
			102	+	return v.GetString()
			103	+	}
			104	+
84		// Requests the user's screen reader to announce the given message.	105		// Requests the user's screen reader to announce the given message.
85		//	106		//
86		// This kind of notification is useful for messages that	107		// This kind of notification is useful for messages that

@@ -138,7 +159,7 @@ func (x LayoutSlot) GetAtContext() gtk.ATContext {
138		// This functionality can be overridden by `GtkAccessible`	159		// This functionality can be overridden by `GtkAccessible`
139		// implementations, e.g. to get the bounds from an ignored	160		// implementations, e.g. to get the bounds from an ignored
140		// child widget.	161		// child widget.
141	-	func (x *LayoutSlot) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	162	+	func (x LayoutSlot) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
142			163
143		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	164		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
144		return cret	165		return cret

M v4/adw/adw-layout.go +17 -0


@@ -101,6 +101,23 @@ func (c *Layout) SetGoPointer(ptr uintptr) {
101	c.Ptr = ptr	101		c.Ptr = ptr
102	}	102		}
103		103
		104	+	// SetPropertyName sets the "name" property.
		105	+	// The name of the layout.
		106	+	func (x *Layout) SetPropertyName(value string) {
		107	+	var v gobject.Value
		108	+	v.Init(gobject.TypeStringVal)
		109	+	v.SetString(value)
		110	+	x.SetProperty("name", &v)
		111	+	}
		112	+
		113	+	// GetPropertyName gets the "name" property.
		114	+	// The name of the layout.
		115	+	func (x *Layout) GetPropertyName() string {
		116	+	var v gobject.Value
		117	+	x.GetProperty("name", &v)
		118	+	return v.GetString()
		119	+	}
		120	+
104	// Gets the ID of the @buildable object.	121		// Gets the ID of the @buildable object.
105	//	122		//
106	// `GtkBuilder` sets the name based on the ID attribute	123		// `GtkBuilder` sets the name based on the ID attribute

M v4/adw/adw-leaflet.go +273 -2


@@ -572,6 +572,231 @@ func (c *Leaflet) SetGoPointer(ptr uintptr) {
572		c.Ptr = ptr	572		c.Ptr = ptr
573		}	573		}
574			574
			575	+	// SetPropertyCanNavigateBack sets the "can-navigate-back" property.
			576	+	// Whether gestures and shortcuts for navigating backward are enabled.
			577	+	//
			578	+	// The supported gestures are:
			579	+	//
			580	+	// - One-finger swipe on touchscreens
			581	+	// - Horizontal scrolling on touchpads (usually two-finger swipe)
			582	+	// - Back/forward mouse buttons
			583	+	//
			584	+	// The keyboard back/forward keys are also supported, as well as the
			585	+	// <kbd>Alt</kbd>+<kbd>←</kbd> shortcut for horizontal orientation, or
			586	+	// <kbd>Alt</kbd>+<kbd>↑</kbd> for vertical orientation.
			587	+	//
			588	+	// If the orientation is horizontal, for right-to-left locales, gestures and
			589	+	// shortcuts are reversed.
			590	+	//
			591	+	// Only children that have [property@LeafletPage:navigatable] set to `TRUE`
			592	+	// can be navigated to.
			593	+	func (x *Leaflet) SetPropertyCanNavigateBack(value bool) {
			594	+	var v gobject.Value
			595	+	v.Init(gobject.TypeBooleanVal)
			596	+	v.SetBoolean(value)
			597	+	x.SetProperty("can-navigate-back", &v)
			598	+	}
			599	+
			600	+	// GetPropertyCanNavigateBack gets the "can-navigate-back" property.
			601	+	// Whether gestures and shortcuts for navigating backward are enabled.
			602	+	//
			603	+	// The supported gestures are:
			604	+	//
			605	+	// - One-finger swipe on touchscreens
			606	+	// - Horizontal scrolling on touchpads (usually two-finger swipe)
			607	+	// - Back/forward mouse buttons
			608	+	//
			609	+	// The keyboard back/forward keys are also supported, as well as the
			610	+	// <kbd>Alt</kbd>+<kbd>←</kbd> shortcut for horizontal orientation, or
			611	+	// <kbd>Alt</kbd>+<kbd>↑</kbd> for vertical orientation.
			612	+	//
			613	+	// If the orientation is horizontal, for right-to-left locales, gestures and
			614	+	// shortcuts are reversed.
			615	+	//
			616	+	// Only children that have [property@LeafletPage:navigatable] set to `TRUE`
			617	+	// can be navigated to.
			618	+	func (x *Leaflet) GetPropertyCanNavigateBack() bool {
			619	+	var v gobject.Value
			620	+	x.GetProperty("can-navigate-back", &v)
			621	+	return v.GetBoolean()
			622	+	}
			623	+
			624	+	// SetPropertyCanNavigateForward sets the "can-navigate-forward" property.
			625	+	// Whether gestures and shortcuts for navigating forward are enabled.
			626	+	//
			627	+	// The supported gestures are:
			628	+	//
			629	+	// - One-finger swipe on touchscreens
			630	+	// - Horizontal scrolling on touchpads (usually two-finger swipe)
			631	+	// - Back/forward mouse buttons
			632	+	//
			633	+	// The keyboard back/forward keys are also supported, as well as the
			634	+	// <kbd>Alt</kbd>+<kbd>→</kbd> shortcut for horizontal orientation, or
			635	+	// <kbd>Alt</kbd>+<kbd>↓</kbd> for vertical orientation.
			636	+	//
			637	+	// If the orientation is horizontal, for right-to-left locales, gestures and
			638	+	// shortcuts are reversed.
			639	+	//
			640	+	// Only children that have [property@LeafletPage:navigatable] set to `TRUE`
			641	+	// can be navigated to.
			642	+	func (x *Leaflet) SetPropertyCanNavigateForward(value bool) {
			643	+	var v gobject.Value
			644	+	v.Init(gobject.TypeBooleanVal)
			645	+	v.SetBoolean(value)
			646	+	x.SetProperty("can-navigate-forward", &v)
			647	+	}
			648	+
			649	+	// GetPropertyCanNavigateForward gets the "can-navigate-forward" property.
			650	+	// Whether gestures and shortcuts for navigating forward are enabled.
			651	+	//
			652	+	// The supported gestures are:
			653	+	//
			654	+	// - One-finger swipe on touchscreens
			655	+	// - Horizontal scrolling on touchpads (usually two-finger swipe)
			656	+	// - Back/forward mouse buttons
			657	+	//
			658	+	// The keyboard back/forward keys are also supported, as well as the
			659	+	// <kbd>Alt</kbd>+<kbd>→</kbd> shortcut for horizontal orientation, or
			660	+	// <kbd>Alt</kbd>+<kbd>↓</kbd> for vertical orientation.
			661	+	//
			662	+	// If the orientation is horizontal, for right-to-left locales, gestures and
			663	+	// shortcuts are reversed.
			664	+	//
			665	+	// Only children that have [property@LeafletPage:navigatable] set to `TRUE`
			666	+	// can be navigated to.
			667	+	func (x *Leaflet) GetPropertyCanNavigateForward() bool {
			668	+	var v gobject.Value
			669	+	x.GetProperty("can-navigate-forward", &v)
			670	+	return v.GetBoolean()
			671	+	}
			672	+
			673	+	// SetPropertyCanUnfold sets the "can-unfold" property.
			674	+	// Whether or not the leaflet can unfold.
			675	+	func (x *Leaflet) SetPropertyCanUnfold(value bool) {
			676	+	var v gobject.Value
			677	+	v.Init(gobject.TypeBooleanVal)
			678	+	v.SetBoolean(value)
			679	+	x.SetProperty("can-unfold", &v)
			680	+	}
			681	+
			682	+	// GetPropertyCanUnfold gets the "can-unfold" property.
			683	+	// Whether or not the leaflet can unfold.
			684	+	func (x *Leaflet) GetPropertyCanUnfold() bool {
			685	+	var v gobject.Value
			686	+	x.GetProperty("can-unfold", &v)
			687	+	return v.GetBoolean()
			688	+	}
			689	+
			690	+	// SetPropertyChildTransitionParams sets the "child-transition-params" property.
			691	+	// The child transition spring parameters.
			692	+	//
			693	+	// The default value is equivalent to:
			694	+	//
			695	+	// ```c
			696	+	// adw_spring_params_new (1, 0.5, 500)
			697	+	// ```
			698	+	func (x *Leaflet) SetPropertyChildTransitionParams(value uintptr) {
			699	+	var v gobject.Value
			700	+	v.Init(gobject.TypePointerVal)
			701	+	v.SetPointer(value)
			702	+	x.SetProperty("child-transition-params", &v)
			703	+	}
			704	+
			705	+	// GetPropertyChildTransitionParams gets the "child-transition-params" property.
			706	+	// The child transition spring parameters.
			707	+	//
			708	+	// The default value is equivalent to:
			709	+	//
			710	+	// ```c
			711	+	// adw_spring_params_new (1, 0.5, 500)
			712	+	// ```
			713	+	func (x *Leaflet) GetPropertyChildTransitionParams() uintptr {
			714	+	var v gobject.Value
			715	+	x.GetProperty("child-transition-params", &v)
			716	+	return v.GetPointer()
			717	+	}
			718	+
			719	+	// GetPropertyChildTransitionRunning gets the "child-transition-running" property.
			720	+	// Whether a child transition is currently running.
			721	+	func (x *Leaflet) GetPropertyChildTransitionRunning() bool {
			722	+	var v gobject.Value
			723	+	x.GetProperty("child-transition-running", &v)
			724	+	return v.GetBoolean()
			725	+	}
			726	+
			727	+	// GetPropertyFolded gets the "folded" property.
			728	+	// Whether the leaflet is folded.
			729	+	//
			730	+	// The leaflet will be folded if the size allocated to it is smaller than the
			731	+	// sum of the minimum or natural sizes of the children (see
			732	+	// [property@Leaflet:fold-threshold-policy]), it will be unfolded otherwise.
			733	+	func (x *Leaflet) GetPropertyFolded() bool {
			734	+	var v gobject.Value
			735	+	x.GetProperty("folded", &v)
			736	+	return v.GetBoolean()
			737	+	}
			738	+
			739	+	// SetPropertyHomogeneous sets the "homogeneous" property.
			740	+	// Whether the leaflet allocates the same size for all children when folded.
			741	+	//
			742	+	// If set to `FALSE`, different children can have different size along the
			743	+	// opposite orientation.
			744	+	func (x *Leaflet) SetPropertyHomogeneous(value bool) {
			745	+	var v gobject.Value
			746	+	v.Init(gobject.TypeBooleanVal)
			747	+	v.SetBoolean(value)
			748	+	x.SetProperty("homogeneous", &v)
			749	+	}
			750	+
			751	+	// GetPropertyHomogeneous gets the "homogeneous" property.
			752	+	// Whether the leaflet allocates the same size for all children when folded.
			753	+	//
			754	+	// If set to `FALSE`, different children can have different size along the
			755	+	// opposite orientation.
			756	+	func (x *Leaflet) GetPropertyHomogeneous() bool {
			757	+	var v gobject.Value
			758	+	x.GetProperty("homogeneous", &v)
			759	+	return v.GetBoolean()
			760	+	}
			761	+
			762	+	// SetPropertyModeTransitionDuration sets the "mode-transition-duration" property.
			763	+	// The mode transition animation duration, in milliseconds.
			764	+	func (x *Leaflet) SetPropertyModeTransitionDuration(value uint) {
			765	+	var v gobject.Value
			766	+	v.Init(gobject.TypeUintVal)
			767	+	v.SetUint(value)
			768	+	x.SetProperty("mode-transition-duration", &v)
			769	+	}
			770	+
			771	+	// GetPropertyModeTransitionDuration gets the "mode-transition-duration" property.
			772	+	// The mode transition animation duration, in milliseconds.
			773	+	func (x *Leaflet) GetPropertyModeTransitionDuration() uint {
			774	+	var v gobject.Value
			775	+	x.GetProperty("mode-transition-duration", &v)
			776	+	return v.GetUint()
			777	+	}
			778	+
			779	+	// SetPropertyVisibleChildName sets the "visible-child-name" property.
			780	+	// The name of the widget currently visible when the leaflet is folded.
			781	+	//
			782	+	// See [property@Leaflet:visible-child].
			783	+	func (x *Leaflet) SetPropertyVisibleChildName(value string) {
			784	+	var v gobject.Value
			785	+	v.Init(gobject.TypeStringVal)
			786	+	v.SetString(value)
			787	+	x.SetProperty("visible-child-name", &v)
			788	+	}
			789	+
			790	+	// GetPropertyVisibleChildName gets the "visible-child-name" property.
			791	+	// The name of the widget currently visible when the leaflet is folded.
			792	+	//
			793	+	// See [property@Leaflet:visible-child].
			794	+	func (x *Leaflet) GetPropertyVisibleChildName() string {
			795	+	var v gobject.Value
			796	+	x.GetProperty("visible-child-name", &v)
			797	+	return v.GetString()
			798	+	}
			799	+
575		// Gets the progress @self will snap back to after the gesture is canceled.	800		// Gets the progress @self will snap back to after the gesture is canceled.
576		func (x *Leaflet) GetCancelProgress() float64 {	801		func (x *Leaflet) GetCancelProgress() float64 {
577			802

@@ -599,7 +824,7 @@ func (x *Leaflet) GetProgress() float64 {
599		//	824		//
600		// Each snap point represents a progress value that is considered acceptable to	825		// Each snap point represents a progress value that is considered acceptable to
601		// end the swipe on.	826		// end the swipe on.
602	-	func (x *Leaflet) GetSnapPoints(NSnapPointsVar int) uintptr {	827	+	func (x Leaflet) GetSnapPoints(NSnapPointsVar int) uintptr {
603			828
604		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)	829		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)
605		return cret	830		return cret

@@ -677,7 +902,7 @@ func (x Leaflet) GetAtContext() gtk.ATContext {
677		// This functionality can be overridden by `GtkAccessible`	902		// This functionality can be overridden by `GtkAccessible`
678		// implementations, e.g. to get the bounds from an ignored	903		// implementations, e.g. to get the bounds from an ignored
679		// child widget.	904		// child widget.
680	-	func (x *Leaflet) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	905	+	func (x Leaflet) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
681			906
682		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	907		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
683		return cret	908		return cret

@@ -998,6 +1223,52 @@ func (c *LeafletPage) SetGoPointer(ptr uintptr) {
998		c.Ptr = ptr	1223		c.Ptr = ptr
999		}	1224		}
1000			1225
			1226	+	// SetPropertyName sets the "name" property.
			1227	+	// The name of the child page.
			1228	+	func (x *LeafletPage) SetPropertyName(value string) {
			1229	+	var v gobject.Value
			1230	+	v.Init(gobject.TypeStringVal)
			1231	+	v.SetString(value)
			1232	+	x.SetProperty("name", &v)
			1233	+	}
			1234	+
			1235	+	// GetPropertyName gets the "name" property.
			1236	+	// The name of the child page.
			1237	+	func (x *LeafletPage) GetPropertyName() string {
			1238	+	var v gobject.Value
			1239	+	x.GetProperty("name", &v)
			1240	+	return v.GetString()
			1241	+	}
			1242	+
			1243	+	// SetPropertyNavigatable sets the "navigatable" property.
			1244	+	// Whether the child can be navigated to when folded.
			1245	+	//
			1246	+	// If `FALSE`, the child will be ignored by
			1247	+	// [method@Leaflet.get_adjacent_child], [method@Leaflet.navigate], and swipe
			1248	+	// gestures.
			1249	+	//
			1250	+	// This can be used used to prevent switching to widgets like separators.
			1251	+	func (x *LeafletPage) SetPropertyNavigatable(value bool) {
			1252	+	var v gobject.Value
			1253	+	v.Init(gobject.TypeBooleanVal)
			1254	+	v.SetBoolean(value)
			1255	+	x.SetProperty("navigatable", &v)
			1256	+	}
			1257	+
			1258	+	// GetPropertyNavigatable gets the "navigatable" property.
			1259	+	// Whether the child can be navigated to when folded.
			1260	+	//
			1261	+	// If `FALSE`, the child will be ignored by
			1262	+	// [method@Leaflet.get_adjacent_child], [method@Leaflet.navigate], and swipe
			1263	+	// gestures.
			1264	+	//
			1265	+	// This can be used used to prevent switching to widgets like separators.
			1266	+	func (x *LeafletPage) GetPropertyNavigatable() bool {
			1267	+	var v gobject.Value
			1268	+	x.GetProperty("navigatable", &v)
			1269	+	return v.GetBoolean()
			1270	+	}
			1271	+
1001		func init() {	1272		func init() {
1002		core.SetPackageName("ADW", "libadwaita-1")	1273		core.SetPackageName("ADW", "libadwaita-1")
1003		core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})	1274		core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})

M v4/adw/adw-message-dialog.go +144 -4


@@ -30,7 +30,7 @@ func (x *MessageDialogClass) GoPointer() uintptr {
30		return uintptr(unsafe.Pointer(x))	30		return uintptr(unsafe.Pointer(x))
31		}	31		}
32			32
33	-	// OverrideResponse sets the callback function.	33	+	// OverrideResponse sets the "response" callback function.
34		func (x MessageDialogClass) OverrideResponse(cb func(MessageDialog, string)) {	34		func (x MessageDialogClass) OverrideResponse(cb func(MessageDialog, string)) {
35		if cb == nil {	35		if cb == nil {
36		x.xResponse = 0	36		x.xResponse = 0

@@ -41,7 +41,7 @@ func (x MessageDialogClass) OverrideResponse(cb func(MessageDialog, string)) {
41		}	41		}
42		}	42		}
43			43
44	-	// GetResponse gets the callback function.	44	+	// GetResponse gets the "response" callback function.
45		func (x MessageDialogClass) GetResponse() func(MessageDialog, string) {	45		func (x MessageDialogClass) GetResponse() func(MessageDialog, string) {
46		if x.xResponse == 0 {	46		if x.xResponse == 0 {
47		return nil	47		return nil

@@ -648,6 +648,146 @@ func (c *MessageDialog) SetGoPointer(ptr uintptr) {
648		c.Ptr = ptr	648		c.Ptr = ptr
649		}	649		}
650			650
			651	+	// SetPropertyBody sets the "body" property.
			652	+	// The body text of the dialog.
			653	+	func (x *MessageDialog) SetPropertyBody(value string) {
			654	+	var v gobject.Value
			655	+	v.Init(gobject.TypeStringVal)
			656	+	v.SetString(value)
			657	+	x.SetProperty("body", &v)
			658	+	}
			659	+
			660	+	// GetPropertyBody gets the "body" property.
			661	+	// The body text of the dialog.
			662	+	func (x *MessageDialog) GetPropertyBody() string {
			663	+	var v gobject.Value
			664	+	x.GetProperty("body", &v)
			665	+	return v.GetString()
			666	+	}
			667	+
			668	+	// SetPropertyBodyUseMarkup sets the "body-use-markup" property.
			669	+	// Whether the body text includes Pango markup.
			670	+	//
			671	+	// See [func@Pango.parse_markup].
			672	+	func (x *MessageDialog) SetPropertyBodyUseMarkup(value bool) {
			673	+	var v gobject.Value
			674	+	v.Init(gobject.TypeBooleanVal)
			675	+	v.SetBoolean(value)
			676	+	x.SetProperty("body-use-markup", &v)
			677	+	}
			678	+
			679	+	// GetPropertyBodyUseMarkup gets the "body-use-markup" property.
			680	+	// Whether the body text includes Pango markup.
			681	+	//
			682	+	// See [func@Pango.parse_markup].
			683	+	func (x *MessageDialog) GetPropertyBodyUseMarkup() bool {
			684	+	var v gobject.Value
			685	+	x.GetProperty("body-use-markup", &v)
			686	+	return v.GetBoolean()
			687	+	}
			688	+
			689	+	// SetPropertyCloseResponse sets the "close-response" property.
			690	+	// The ID of the close response.
			691	+	//
			692	+	// It will be passed to [signal@MessageDialog::response] if the window is
			693	+	// closed by pressing <kbd>Escape</kbd> or with a system action.
			694	+	//
			695	+	// It doesn't have to correspond to any of the responses in the dialog.
			696	+	//
			697	+	// The default close response is `close`.
			698	+	func (x *MessageDialog) SetPropertyCloseResponse(value string) {
			699	+	var v gobject.Value
			700	+	v.Init(gobject.TypeStringVal)
			701	+	v.SetString(value)
			702	+	x.SetProperty("close-response", &v)
			703	+	}
			704	+
			705	+	// GetPropertyCloseResponse gets the "close-response" property.
			706	+	// The ID of the close response.
			707	+	//
			708	+	// It will be passed to [signal@MessageDialog::response] if the window is
			709	+	// closed by pressing <kbd>Escape</kbd> or with a system action.
			710	+	//
			711	+	// It doesn't have to correspond to any of the responses in the dialog.
			712	+	//
			713	+	// The default close response is `close`.
			714	+	func (x *MessageDialog) GetPropertyCloseResponse() string {
			715	+	var v gobject.Value
			716	+	x.GetProperty("close-response", &v)
			717	+	return v.GetString()
			718	+	}
			719	+
			720	+	// SetPropertyDefaultResponse sets the "default-response" property.
			721	+	// The response ID of the default response.
			722	+	//
			723	+	// The button corresponding to this response will be set as the default widget
			724	+	// of the dialog.
			725	+	//
			726	+	// If not set, the default widget will not be set, and the last added response
			727	+	// will be focused by default.
			728	+	//
			729	+	// See [property@Gtk.Window:default-widget].
			730	+	func (x *MessageDialog) SetPropertyDefaultResponse(value string) {
			731	+	var v gobject.Value
			732	+	v.Init(gobject.TypeStringVal)
			733	+	v.SetString(value)
			734	+	x.SetProperty("default-response", &v)
			735	+	}
			736	+
			737	+	// GetPropertyDefaultResponse gets the "default-response" property.
			738	+	// The response ID of the default response.
			739	+	//
			740	+	// The button corresponding to this response will be set as the default widget
			741	+	// of the dialog.
			742	+	//
			743	+	// If not set, the default widget will not be set, and the last added response
			744	+	// will be focused by default.
			745	+	//
			746	+	// See [property@Gtk.Window:default-widget].
			747	+	func (x *MessageDialog) GetPropertyDefaultResponse() string {
			748	+	var v gobject.Value
			749	+	x.GetProperty("default-response", &v)
			750	+	return v.GetString()
			751	+	}
			752	+
			753	+	// SetPropertyHeading sets the "heading" property.
			754	+	// The heading of the dialog.
			755	+	func (x *MessageDialog) SetPropertyHeading(value string) {
			756	+	var v gobject.Value
			757	+	v.Init(gobject.TypeStringVal)
			758	+	v.SetString(value)
			759	+	x.SetProperty("heading", &v)
			760	+	}
			761	+
			762	+	// GetPropertyHeading gets the "heading" property.
			763	+	// The heading of the dialog.
			764	+	func (x *MessageDialog) GetPropertyHeading() string {
			765	+	var v gobject.Value
			766	+	x.GetProperty("heading", &v)
			767	+	return v.GetString()
			768	+	}
			769	+
			770	+	// SetPropertyHeadingUseMarkup sets the "heading-use-markup" property.
			771	+	// Whether the heading includes Pango markup.
			772	+	//
			773	+	// See [func@Pango.parse_markup].
			774	+	func (x *MessageDialog) SetPropertyHeadingUseMarkup(value bool) {
			775	+	var v gobject.Value
			776	+	v.Init(gobject.TypeBooleanVal)
			777	+	v.SetBoolean(value)
			778	+	x.SetProperty("heading-use-markup", &v)
			779	+	}
			780	+
			781	+	// GetPropertyHeadingUseMarkup gets the "heading-use-markup" property.
			782	+	// Whether the heading includes Pango markup.
			783	+	//
			784	+	// See [func@Pango.parse_markup].
			785	+	func (x *MessageDialog) GetPropertyHeadingUseMarkup() bool {
			786	+	var v gobject.Value
			787	+	x.GetProperty("heading-use-markup", &v)
			788	+	return v.GetBoolean()
			789	+	}
			790	+
651		// This signal is emitted when the dialog is closed.	791		// This signal is emitted when the dialog is closed.
652		//	792		//
653		// @response will be set to the response ID of the button that had been	793		// @response will be set to the response ID of the button that had been

@@ -732,7 +872,7 @@ func (x MessageDialog) GetAtContext() gtk.ATContext {
732		// This functionality can be overridden by `GtkAccessible`	872		// This functionality can be overridden by `GtkAccessible`
733		// implementations, e.g. to get the bounds from an ignored	873		// implementations, e.g. to get the bounds from an ignored
734		// child widget.	874		// child widget.
735	-	func (x *MessageDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	875	+	func (x MessageDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
736			876
737		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	877		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
738		return cret	878		return cret

@@ -987,7 +1127,7 @@ func (x MessageDialog) GetSurface() gdk.Surface {
987		//	1127		//
988		// This is the translation from @self's surface coordinates into	1128		// This is the translation from @self's surface coordinates into
989		// @self's widget coordinates.	1129		// @self's widget coordinates.
990	-	func (x *MessageDialog) GetSurfaceTransform(XVar float64, YVar float64) {	1130	+	func (x MessageDialog) GetSurfaceTransform(XVar float64, YVar *float64) {
991			1131
992		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	1132		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
993			1133

M v4/adw/adw-multi-layout-view.go +22 -1


@@ -259,6 +259,27 @@ func (c *MultiLayoutView) SetGoPointer(ptr uintptr) {
259		c.Ptr = ptr	259		c.Ptr = ptr
260		}	260		}
261			261
			262	+	// SetPropertyLayoutName sets the "layout-name" property.
			263	+	// The name of the currently used layout.
			264	+	//
			265	+	// See [property@Layout:name].
			266	+	func (x *MultiLayoutView) SetPropertyLayoutName(value string) {
			267	+	var v gobject.Value
			268	+	v.Init(gobject.TypeStringVal)
			269	+	v.SetString(value)
			270	+	x.SetProperty("layout-name", &v)
			271	+	}
			272	+
			273	+	// GetPropertyLayoutName gets the "layout-name" property.
			274	+	// The name of the currently used layout.
			275	+	//
			276	+	// See [property@Layout:name].
			277	+	func (x *MultiLayoutView) GetPropertyLayoutName() string {
			278	+	var v gobject.Value
			279	+	x.GetProperty("layout-name", &v)
			280	+	return v.GetString()
			281	+	}
			282	+
262		// Requests the user's screen reader to announce the given message.	283		// Requests the user's screen reader to announce the given message.
263		//	284		//
264		// This kind of notification is useful for messages that	285		// This kind of notification is useful for messages that

@@ -316,7 +337,7 @@ func (x MultiLayoutView) GetAtContext() gtk.ATContext {
316		// This functionality can be overridden by `GtkAccessible`	337		// This functionality can be overridden by `GtkAccessible`
317		// implementations, e.g. to get the bounds from an ignored	338		// implementations, e.g. to get the bounds from an ignored
318		// child widget.	339		// child widget.
319	-	func (x *MultiLayoutView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	340	+	func (x MultiLayoutView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
320			341
321		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	342		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
322		return cret	343		return cret

M v4/adw/adw-navigation-split-view.go +150 -1


@@ -428,6 +428,155 @@ func (c *NavigationSplitView) SetGoPointer(ptr uintptr) {
428		c.Ptr = ptr	428		c.Ptr = ptr
429		}	429		}
430			430
			431	+	// SetPropertyCollapsed sets the "collapsed" property.
			432	+	// Whether the split view is collapsed.
			433	+	//
			434	+	// When collapsed, the children are put inside an [class@NavigationView],
			435	+	// otherwise they are displayed side by side.
			436	+	//
			437	+	// The [property@NavigationSplitView:show-content] controls which child is
			438	+	// visible while collapsed.
			439	+	func (x *NavigationSplitView) SetPropertyCollapsed(value bool) {
			440	+	var v gobject.Value
			441	+	v.Init(gobject.TypeBooleanVal)
			442	+	v.SetBoolean(value)
			443	+	x.SetProperty("collapsed", &v)
			444	+	}
			445	+
			446	+	// GetPropertyCollapsed gets the "collapsed" property.
			447	+	// Whether the split view is collapsed.
			448	+	//
			449	+	// When collapsed, the children are put inside an [class@NavigationView],
			450	+	// otherwise they are displayed side by side.
			451	+	//
			452	+	// The [property@NavigationSplitView:show-content] controls which child is
			453	+	// visible while collapsed.
			454	+	func (x *NavigationSplitView) GetPropertyCollapsed() bool {
			455	+	var v gobject.Value
			456	+	x.GetProperty("collapsed", &v)
			457	+	return v.GetBoolean()
			458	+	}
			459	+
			460	+	// SetPropertyMaxSidebarWidth sets the "max-sidebar-width" property.
			461	+	// The maximum sidebar width.
			462	+	//
			463	+	// Maximum width is affected by
			464	+	// [property@NavigationSplitView:sidebar-width-unit].
			465	+	//
			466	+	// The sidebar widget can still be allocated with larger width if its own
			467	+	// minimum width exceeds it.
			468	+	func (x *NavigationSplitView) SetPropertyMaxSidebarWidth(value float64) {
			469	+	var v gobject.Value
			470	+	v.Init(gobject.TypeDoubleVal)
			471	+	v.SetDouble(value)
			472	+	x.SetProperty("max-sidebar-width", &v)
			473	+	}
			474	+
			475	+	// GetPropertyMaxSidebarWidth gets the "max-sidebar-width" property.
			476	+	// The maximum sidebar width.
			477	+	//
			478	+	// Maximum width is affected by
			479	+	// [property@NavigationSplitView:sidebar-width-unit].
			480	+	//
			481	+	// The sidebar widget can still be allocated with larger width if its own
			482	+	// minimum width exceeds it.
			483	+	func (x *NavigationSplitView) GetPropertyMaxSidebarWidth() float64 {
			484	+	var v gobject.Value
			485	+	x.GetProperty("max-sidebar-width", &v)
			486	+	return v.GetDouble()
			487	+	}
			488	+
			489	+	// SetPropertyMinSidebarWidth sets the "min-sidebar-width" property.
			490	+	// The minimum sidebar width.
			491	+	//
			492	+	// Minimum width is affected by
			493	+	// [property@NavigationSplitView:sidebar-width-unit].
			494	+	//
			495	+	// The sidebar widget can still be allocated with larger width if its own
			496	+	// minimum width exceeds it.
			497	+	func (x *NavigationSplitView) SetPropertyMinSidebarWidth(value float64) {
			498	+	var v gobject.Value
			499	+	v.Init(gobject.TypeDoubleVal)
			500	+	v.SetDouble(value)
			501	+	x.SetProperty("min-sidebar-width", &v)
			502	+	}
			503	+
			504	+	// GetPropertyMinSidebarWidth gets the "min-sidebar-width" property.
			505	+	// The minimum sidebar width.
			506	+	//
			507	+	// Minimum width is affected by
			508	+	// [property@NavigationSplitView:sidebar-width-unit].
			509	+	//
			510	+	// The sidebar widget can still be allocated with larger width if its own
			511	+	// minimum width exceeds it.
			512	+	func (x *NavigationSplitView) GetPropertyMinSidebarWidth() float64 {
			513	+	var v gobject.Value
			514	+	x.GetProperty("min-sidebar-width", &v)
			515	+	return v.GetDouble()
			516	+	}
			517	+
			518	+	// SetPropertyShowContent sets the "show-content" property.
			519	+	// Determines the visible page when collapsed.
			520	+	//
			521	+	// If set to `TRUE`, the content widget will be the visible page when
			522	+	// [property@NavigationSplitView:collapsed] is `TRUE`; otherwise the sidebar
			523	+	// widget will be visible.
			524	+	//
			525	+	// If the split view is already collapsed, the visible page changes
			526	+	// immediately.
			527	+	func (x *NavigationSplitView) SetPropertyShowContent(value bool) {
			528	+	var v gobject.Value
			529	+	v.Init(gobject.TypeBooleanVal)
			530	+	v.SetBoolean(value)
			531	+	x.SetProperty("show-content", &v)
			532	+	}
			533	+
			534	+	// GetPropertyShowContent gets the "show-content" property.
			535	+	// Determines the visible page when collapsed.
			536	+	//
			537	+	// If set to `TRUE`, the content widget will be the visible page when
			538	+	// [property@NavigationSplitView:collapsed] is `TRUE`; otherwise the sidebar
			539	+	// widget will be visible.
			540	+	//
			541	+	// If the split view is already collapsed, the visible page changes
			542	+	// immediately.
			543	+	func (x *NavigationSplitView) GetPropertyShowContent() bool {
			544	+	var v gobject.Value
			545	+	x.GetProperty("show-content", &v)
			546	+	return v.GetBoolean()
			547	+	}
			548	+
			549	+	// SetPropertySidebarWidthFraction sets the "sidebar-width-fraction" property.
			550	+	// The preferred sidebar width as a fraction of the total width.
			551	+	//
			552	+	// The preferred width is additionally limited by
			553	+	// [property@NavigationSplitView:min-sidebar-width] and
			554	+	// [property@NavigationSplitView:max-sidebar-width].
			555	+	//
			556	+	// The sidebar widget can be allocated with larger width if its own minimum
			557	+	// width exceeds the preferred width.
			558	+	func (x *NavigationSplitView) SetPropertySidebarWidthFraction(value float64) {
			559	+	var v gobject.Value
			560	+	v.Init(gobject.TypeDoubleVal)
			561	+	v.SetDouble(value)
			562	+	x.SetProperty("sidebar-width-fraction", &v)
			563	+	}
			564	+
			565	+	// GetPropertySidebarWidthFraction gets the "sidebar-width-fraction" property.
			566	+	// The preferred sidebar width as a fraction of the total width.
			567	+	//
			568	+	// The preferred width is additionally limited by
			569	+	// [property@NavigationSplitView:min-sidebar-width] and
			570	+	// [property@NavigationSplitView:max-sidebar-width].
			571	+	//
			572	+	// The sidebar widget can be allocated with larger width if its own minimum
			573	+	// width exceeds the preferred width.
			574	+	func (x *NavigationSplitView) GetPropertySidebarWidthFraction() float64 {
			575	+	var v gobject.Value
			576	+	x.GetProperty("sidebar-width-fraction", &v)
			577	+	return v.GetDouble()
			578	+	}
			579	+
431		// Requests the user's screen reader to announce the given message.	580		// Requests the user's screen reader to announce the given message.
432		//	581		//
433		// This kind of notification is useful for messages that	582		// This kind of notification is useful for messages that

@@ -485,7 +634,7 @@ func (x NavigationSplitView) GetAtContext() gtk.ATContext {
485		// This functionality can be overridden by `GtkAccessible`	634		// This functionality can be overridden by `GtkAccessible`
486		// implementations, e.g. to get the bounds from an ignored	635		// implementations, e.g. to get the bounds from an ignored
487		// child widget.	636		// child widget.
488	-	func (x *NavigationSplitView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	637	+	func (x NavigationSplitView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
489			638
490		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	639		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
491		return cret	640		return cret

M v4/adw/adw-navigation-view.go +214 -11


@@ -35,7 +35,7 @@ func (x *NavigationPageClass) GoPointer() uintptr {
35		return uintptr(unsafe.Pointer(x))	35		return uintptr(unsafe.Pointer(x))
36		}	36		}
37			37
38	-	// OverrideShowing sets the callback function.	38	+	// OverrideShowing sets the "showing" callback function.
39		func (x NavigationPageClass) OverrideShowing(cb func(NavigationPage)) {	39		func (x NavigationPageClass) OverrideShowing(cb func(NavigationPage)) {
40		if cb == nil {	40		if cb == nil {
41		x.xShowing = 0	41		x.xShowing = 0

@@ -46,7 +46,7 @@ func (x NavigationPageClass) OverrideShowing(cb func(NavigationPage)) {
46		}	46		}
47		}	47		}
48			48
49	-	// GetShowing gets the callback function.	49	+	// GetShowing gets the "showing" callback function.
50		func (x NavigationPageClass) GetShowing() func(NavigationPage) {	50		func (x NavigationPageClass) GetShowing() func(NavigationPage) {
51		if x.xShowing == 0 {	51		if x.xShowing == 0 {
52		return nil	52		return nil

@@ -58,7 +58,7 @@ func (x NavigationPageClass) GetShowing() func(NavigationPage) {
58		}	58		}
59		}	59		}
60			60
61	-	// OverrideShown sets the callback function.	61	+	// OverrideShown sets the "shown" callback function.
62		func (x NavigationPageClass) OverrideShown(cb func(NavigationPage)) {	62		func (x NavigationPageClass) OverrideShown(cb func(NavigationPage)) {
63		if cb == nil {	63		if cb == nil {
64		x.xShown = 0	64		x.xShown = 0

@@ -69,7 +69,7 @@ func (x NavigationPageClass) OverrideShown(cb func(NavigationPage)) {
69		}	69		}
70		}	70		}
71			71
72	-	// GetShown gets the callback function.	72	+	// GetShown gets the "shown" callback function.
73		func (x NavigationPageClass) GetShown() func(NavigationPage) {	73		func (x NavigationPageClass) GetShown() func(NavigationPage) {
74		if x.xShown == 0 {	74		if x.xShown == 0 {
75		return nil	75		return nil

@@ -81,7 +81,7 @@ func (x NavigationPageClass) GetShown() func(NavigationPage) {
81		}	81		}
82		}	82		}
83			83
84	-	// OverrideHiding sets the callback function.	84	+	// OverrideHiding sets the "hiding" callback function.
85		func (x NavigationPageClass) OverrideHiding(cb func(NavigationPage)) {	85		func (x NavigationPageClass) OverrideHiding(cb func(NavigationPage)) {
86		if cb == nil {	86		if cb == nil {
87		x.xHiding = 0	87		x.xHiding = 0

@@ -92,7 +92,7 @@ func (x NavigationPageClass) OverrideHiding(cb func(NavigationPage)) {
92		}	92		}
93		}	93		}
94			94
95	-	// GetHiding gets the callback function.	95	+	// GetHiding gets the "hiding" callback function.
96		func (x NavigationPageClass) GetHiding() func(NavigationPage) {	96		func (x NavigationPageClass) GetHiding() func(NavigationPage) {
97		if x.xHiding == 0 {	97		if x.xHiding == 0 {
98		return nil	98		return nil

@@ -104,7 +104,7 @@ func (x NavigationPageClass) GetHiding() func(NavigationPage) {
104		}	104		}
105		}	105		}
106			106
107	-	// OverrideHidden sets the callback function.	107	+	// OverrideHidden sets the "hidden" callback function.
108		func (x NavigationPageClass) OverrideHidden(cb func(NavigationPage)) {	108		func (x NavigationPageClass) OverrideHidden(cb func(NavigationPage)) {
109		if cb == nil {	109		if cb == nil {
110		x.xHidden = 0	110		x.xHidden = 0

@@ -115,7 +115,7 @@ func (x NavigationPageClass) OverrideHidden(cb func(NavigationPage)) {
115		}	115		}
116		}	116		}
117			117
118	-	// GetHidden gets the callback function.	118	+	// GetHidden gets the "hidden" callback function.
119		func (x NavigationPageClass) GetHidden() func(NavigationPage) {	119		func (x NavigationPageClass) GetHidden() func(NavigationPage) {
120		if x.xHidden == 0 {	120		if x.xHidden == 0 {
121		return nil	121		return nil

@@ -325,6 +325,99 @@ func (c *NavigationPage) SetGoPointer(ptr uintptr) {
325		c.Ptr = ptr	325		c.Ptr = ptr
326		}	326		}
327			327
			328	+	// SetPropertyCanPop sets the "can-pop" property.
			329	+	// Whether the page can be popped from navigation stack.
			330	+	//
			331	+	// Set it to `FALSE` to disable shortcuts and gestures, as well as remove the
			332	+	// back button from [class@HeaderBar].
			333	+	//
			334	+	// Manually calling [method@NavigationView.pop] or using the `navigation.pop`
			335	+	// action will still work.
			336	+	//
			337	+	// See [property@HeaderBar:show-back-button] for removing only the back
			338	+	// button, but not shortcuts.
			339	+	func (x *NavigationPage) SetPropertyCanPop(value bool) {
			340	+	var v gobject.Value
			341	+	v.Init(gobject.TypeBooleanVal)
			342	+	v.SetBoolean(value)
			343	+	x.SetProperty("can-pop", &v)
			344	+	}
			345	+
			346	+	// GetPropertyCanPop gets the "can-pop" property.
			347	+	// Whether the page can be popped from navigation stack.
			348	+	//
			349	+	// Set it to `FALSE` to disable shortcuts and gestures, as well as remove the
			350	+	// back button from [class@HeaderBar].
			351	+	//
			352	+	// Manually calling [method@NavigationView.pop] or using the `navigation.pop`
			353	+	// action will still work.
			354	+	//
			355	+	// See [property@HeaderBar:show-back-button] for removing only the back
			356	+	// button, but not shortcuts.
			357	+	func (x *NavigationPage) GetPropertyCanPop() bool {
			358	+	var v gobject.Value
			359	+	x.GetProperty("can-pop", &v)
			360	+	return v.GetBoolean()
			361	+	}
			362	+
			363	+	// SetPropertyTag sets the "tag" property.
			364	+	// The page tag.
			365	+	//
			366	+	// The tag can be used to retrieve the page with
			367	+	// [method@NavigationView.find_page], as well as with
			368	+	// [method@NavigationView.push_by_tag], [method@NavigationView.pop_to_tag] or
			369	+	// [method@NavigationView.replace_with_tags].
			370	+	//
			371	+	// Tags must be unique within each [class@NavigationView].
			372	+	//
			373	+	// The tag also must be set to use the `navigation.push` action.
			374	+	func (x *NavigationPage) SetPropertyTag(value string) {
			375	+	var v gobject.Value
			376	+	v.Init(gobject.TypeStringVal)
			377	+	v.SetString(value)
			378	+	x.SetProperty("tag", &v)
			379	+	}
			380	+
			381	+	// GetPropertyTag gets the "tag" property.
			382	+	// The page tag.
			383	+	//
			384	+	// The tag can be used to retrieve the page with
			385	+	// [method@NavigationView.find_page], as well as with
			386	+	// [method@NavigationView.push_by_tag], [method@NavigationView.pop_to_tag] or
			387	+	// [method@NavigationView.replace_with_tags].
			388	+	//
			389	+	// Tags must be unique within each [class@NavigationView].
			390	+	//
			391	+	// The tag also must be set to use the `navigation.push` action.
			392	+	func (x *NavigationPage) GetPropertyTag() string {
			393	+	var v gobject.Value
			394	+	x.GetProperty("tag", &v)
			395	+	return v.GetString()
			396	+	}
			397	+
			398	+	// SetPropertyTitle sets the "title" property.
			399	+	// The page title.
			400	+	//
			401	+	// It's displayed in [class@HeaderBar] instead of the window title, and used
			402	+	// as the tooltip on the next page's back button, as well as by screen reader.
			403	+	func (x *NavigationPage) SetPropertyTitle(value string) {
			404	+	var v gobject.Value
			405	+	v.Init(gobject.TypeStringVal)
			406	+	v.SetString(value)
			407	+	x.SetProperty("title", &v)
			408	+	}
			409	+
			410	+	// GetPropertyTitle gets the "title" property.
			411	+	// The page title.
			412	+	//
			413	+	// It's displayed in [class@HeaderBar] instead of the window title, and used
			414	+	// as the tooltip on the next page's back button, as well as by screen reader.
			415	+	func (x *NavigationPage) GetPropertyTitle() string {
			416	+	var v gobject.Value
			417	+	x.GetProperty("title", &v)
			418	+	return v.GetString()
			419	+	}
			420	+
328		// Emitted when the navigation view transition has been completed and the page	421		// Emitted when the navigation view transition has been completed and the page
329		// is fully hidden.	422		// is fully hidden.
330		//	423		//

@@ -478,7 +571,7 @@ func (x NavigationPage) GetAtContext() gtk.ATContext {
478		// This functionality can be overridden by `GtkAccessible`	571		// This functionality can be overridden by `GtkAccessible`
479		// implementations, e.g. to get the bounds from an ignored	572		// implementations, e.g. to get the bounds from an ignored
480		// child widget.	573		// child widget.
481	-	func (x *NavigationPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	574	+	func (x NavigationPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
482			575
483		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	576		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
484		return cret	577		return cret

@@ -1246,6 +1339,116 @@ func (c *NavigationView) SetGoPointer(ptr uintptr) {
1246		c.Ptr = ptr	1339		c.Ptr = ptr
1247		}	1340		}
1248			1341
			1342	+	// SetPropertyAnimateTransitions sets the "animate-transitions" property.
			1343	+	// Whether to animate page transitions.
			1344	+	//
			1345	+	// Gesture-based transitions are always animated.
			1346	+	func (x *NavigationView) SetPropertyAnimateTransitions(value bool) {
			1347	+	var v gobject.Value
			1348	+	v.Init(gobject.TypeBooleanVal)
			1349	+	v.SetBoolean(value)
			1350	+	x.SetProperty("animate-transitions", &v)
			1351	+	}
			1352	+
			1353	+	// GetPropertyAnimateTransitions gets the "animate-transitions" property.
			1354	+	// Whether to animate page transitions.
			1355	+	//
			1356	+	// Gesture-based transitions are always animated.
			1357	+	func (x *NavigationView) GetPropertyAnimateTransitions() bool {
			1358	+	var v gobject.Value
			1359	+	x.GetProperty("animate-transitions", &v)
			1360	+	return v.GetBoolean()
			1361	+	}
			1362	+
			1363	+	// SetPropertyHhomogeneous sets the "hhomogeneous" property.
			1364	+	// Whether the view is horizontally homogeneous.
			1365	+	//
			1366	+	// If the view is horizontally homogeneous, it allocates the same width for
			1367	+	// all pages.
			1368	+	//
			1369	+	// If it's not, the page may change width when a different page becomes
			1370	+	// visible.
			1371	+	func (x *NavigationView) SetPropertyHhomogeneous(value bool) {
			1372	+	var v gobject.Value
			1373	+	v.Init(gobject.TypeBooleanVal)
			1374	+	v.SetBoolean(value)
			1375	+	x.SetProperty("hhomogeneous", &v)
			1376	+	}
			1377	+
			1378	+	// GetPropertyHhomogeneous gets the "hhomogeneous" property.
			1379	+	// Whether the view is horizontally homogeneous.
			1380	+	//
			1381	+	// If the view is horizontally homogeneous, it allocates the same width for
			1382	+	// all pages.
			1383	+	//
			1384	+	// If it's not, the page may change width when a different page becomes
			1385	+	// visible.
			1386	+	func (x *NavigationView) GetPropertyHhomogeneous() bool {
			1387	+	var v gobject.Value
			1388	+	x.GetProperty("hhomogeneous", &v)
			1389	+	return v.GetBoolean()
			1390	+	}
			1391	+
			1392	+	// SetPropertyPopOnEscape sets the "pop-on-escape" property.
			1393	+	// Whether pressing Escape pops the current page.
			1394	+	//
			1395	+	// Applications using `AdwNavigationView` to implement a browser may want to
			1396	+	// disable it.
			1397	+	func (x *NavigationView) SetPropertyPopOnEscape(value bool) {
			1398	+	var v gobject.Value
			1399	+	v.Init(gobject.TypeBooleanVal)
			1400	+	v.SetBoolean(value)
			1401	+	x.SetProperty("pop-on-escape", &v)
			1402	+	}
			1403	+
			1404	+	// GetPropertyPopOnEscape gets the "pop-on-escape" property.
			1405	+	// Whether pressing Escape pops the current page.
			1406	+	//
			1407	+	// Applications using `AdwNavigationView` to implement a browser may want to
			1408	+	// disable it.
			1409	+	func (x *NavigationView) GetPropertyPopOnEscape() bool {
			1410	+	var v gobject.Value
			1411	+	x.GetProperty("pop-on-escape", &v)
			1412	+	return v.GetBoolean()
			1413	+	}
			1414	+
			1415	+	// SetPropertyVhomogeneous sets the "vhomogeneous" property.
			1416	+	// Whether the view is vertically homogeneous.
			1417	+	//
			1418	+	// If the view is vertically homogeneous, it allocates the same height for
			1419	+	// all pages.
			1420	+	//
			1421	+	// If it's not, the view may change height when a different page becomes
			1422	+	// visible.
			1423	+	func (x *NavigationView) SetPropertyVhomogeneous(value bool) {
			1424	+	var v gobject.Value
			1425	+	v.Init(gobject.TypeBooleanVal)
			1426	+	v.SetBoolean(value)
			1427	+	x.SetProperty("vhomogeneous", &v)
			1428	+	}
			1429	+
			1430	+	// GetPropertyVhomogeneous gets the "vhomogeneous" property.
			1431	+	// Whether the view is vertically homogeneous.
			1432	+	//
			1433	+	// If the view is vertically homogeneous, it allocates the same height for
			1434	+	// all pages.
			1435	+	//
			1436	+	// If it's not, the view may change height when a different page becomes
			1437	+	// visible.
			1438	+	func (x *NavigationView) GetPropertyVhomogeneous() bool {
			1439	+	var v gobject.Value
			1440	+	x.GetProperty("vhomogeneous", &v)
			1441	+	return v.GetBoolean()
			1442	+	}
			1443	+
			1444	+	// GetPropertyVisiblePageTag gets the "visible-page-tag" property.
			1445	+	// The tag of the currently visible page.
			1446	+	func (x *NavigationView) GetPropertyVisiblePageTag() string {
			1447	+	var v gobject.Value
			1448	+	x.GetProperty("visible-page-tag", &v)
			1449	+	return v.GetString()
			1450	+	}
			1451	+
1249		// Emitted when a push shortcut or a gesture is triggered.	1452		// Emitted when a push shortcut or a gesture is triggered.
1250		//	1453		//
1251		// To support the push shortcuts and gestures, the application is expected to	1454		// To support the push shortcuts and gestures, the application is expected to

@@ -1374,7 +1577,7 @@ func (x *NavigationView) GetProgress() float64 {
1374		//	1577		//
1375		// Each snap point represents a progress value that is considered acceptable to	1578		// Each snap point represents a progress value that is considered acceptable to
1376		// end the swipe on.	1579		// end the swipe on.
1377	-	func (x *NavigationView) GetSnapPoints(NSnapPointsVar int) uintptr {	1580	+	func (x NavigationView) GetSnapPoints(NSnapPointsVar int) uintptr {
1378			1581
1379		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)	1582		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)
1380		return cret	1583		return cret

@@ -1452,7 +1655,7 @@ func (x NavigationView) GetAtContext() gtk.ATContext {
1452		// This functionality can be overridden by `GtkAccessible`	1655		// This functionality can be overridden by `GtkAccessible`
1453		// implementations, e.g. to get the bounds from an ignored	1656		// implementations, e.g. to get the bounds from an ignored
1454		// child widget.	1657		// child widget.
1455	-	func (x *NavigationView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	1658	+	func (x NavigationView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
1456			1659
1457		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	1660		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
1458		return cret	1661		return cret

M v4/adw/adw-overlay-split-view.go +198 -2


@@ -474,6 +474,202 @@ func (c *OverlaySplitView) SetGoPointer(ptr uintptr) {
474		c.Ptr = ptr	474		c.Ptr = ptr
475		}	475		}
476			476
			477	+	// SetPropertyCollapsed sets the "collapsed" property.
			478	+	// Whether the split view is collapsed.
			479	+	//
			480	+	// When collapsed, the sidebar widget is presented as an overlay above the
			481	+	// content widget, otherwise they are displayed side by side.
			482	+	func (x *OverlaySplitView) SetPropertyCollapsed(value bool) {
			483	+	var v gobject.Value
			484	+	v.Init(gobject.TypeBooleanVal)
			485	+	v.SetBoolean(value)
			486	+	x.SetProperty("collapsed", &v)
			487	+	}
			488	+
			489	+	// GetPropertyCollapsed gets the "collapsed" property.
			490	+	// Whether the split view is collapsed.
			491	+	//
			492	+	// When collapsed, the sidebar widget is presented as an overlay above the
			493	+	// content widget, otherwise they are displayed side by side.
			494	+	func (x *OverlaySplitView) GetPropertyCollapsed() bool {
			495	+	var v gobject.Value
			496	+	x.GetProperty("collapsed", &v)
			497	+	return v.GetBoolean()
			498	+	}
			499	+
			500	+	// SetPropertyEnableHideGesture sets the "enable-hide-gesture" property.
			501	+	// Whether the sidebar can be closed with a swipe gesture.
			502	+	//
			503	+	// Only touchscreen swipes are supported.
			504	+	func (x *OverlaySplitView) SetPropertyEnableHideGesture(value bool) {
			505	+	var v gobject.Value
			506	+	v.Init(gobject.TypeBooleanVal)
			507	+	v.SetBoolean(value)
			508	+	x.SetProperty("enable-hide-gesture", &v)
			509	+	}
			510	+
			511	+	// GetPropertyEnableHideGesture gets the "enable-hide-gesture" property.
			512	+	// Whether the sidebar can be closed with a swipe gesture.
			513	+	//
			514	+	// Only touchscreen swipes are supported.
			515	+	func (x *OverlaySplitView) GetPropertyEnableHideGesture() bool {
			516	+	var v gobject.Value
			517	+	x.GetProperty("enable-hide-gesture", &v)
			518	+	return v.GetBoolean()
			519	+	}
			520	+
			521	+	// SetPropertyEnableShowGesture sets the "enable-show-gesture" property.
			522	+	// Whether the sidebar can be opened with an edge swipe gesture.
			523	+	//
			524	+	// Only touchscreen swipes are supported.
			525	+	func (x *OverlaySplitView) SetPropertyEnableShowGesture(value bool) {
			526	+	var v gobject.Value
			527	+	v.Init(gobject.TypeBooleanVal)
			528	+	v.SetBoolean(value)
			529	+	x.SetProperty("enable-show-gesture", &v)
			530	+	}
			531	+
			532	+	// GetPropertyEnableShowGesture gets the "enable-show-gesture" property.
			533	+	// Whether the sidebar can be opened with an edge swipe gesture.
			534	+	//
			535	+	// Only touchscreen swipes are supported.
			536	+	func (x *OverlaySplitView) GetPropertyEnableShowGesture() bool {
			537	+	var v gobject.Value
			538	+	x.GetProperty("enable-show-gesture", &v)
			539	+	return v.GetBoolean()
			540	+	}
			541	+
			542	+	// SetPropertyMaxSidebarWidth sets the "max-sidebar-width" property.
			543	+	// The maximum sidebar width.
			544	+	//
			545	+	// Maximum width is affected by
			546	+	// [property@OverlaySplitView:sidebar-width-unit].
			547	+	//
			548	+	// The sidebar widget can still be allocated with larger width if its own
			549	+	// minimum width exceeds it.
			550	+	func (x *OverlaySplitView) SetPropertyMaxSidebarWidth(value float64) {
			551	+	var v gobject.Value
			552	+	v.Init(gobject.TypeDoubleVal)
			553	+	v.SetDouble(value)
			554	+	x.SetProperty("max-sidebar-width", &v)
			555	+	}
			556	+
			557	+	// GetPropertyMaxSidebarWidth gets the "max-sidebar-width" property.
			558	+	// The maximum sidebar width.
			559	+	//
			560	+	// Maximum width is affected by
			561	+	// [property@OverlaySplitView:sidebar-width-unit].
			562	+	//
			563	+	// The sidebar widget can still be allocated with larger width if its own
			564	+	// minimum width exceeds it.
			565	+	func (x *OverlaySplitView) GetPropertyMaxSidebarWidth() float64 {
			566	+	var v gobject.Value
			567	+	x.GetProperty("max-sidebar-width", &v)
			568	+	return v.GetDouble()
			569	+	}
			570	+
			571	+	// SetPropertyMinSidebarWidth sets the "min-sidebar-width" property.
			572	+	// The minimum sidebar width.
			573	+	//
			574	+	// Minimum width is affected by
			575	+	// [property@OverlaySplitView:sidebar-width-unit].
			576	+	//
			577	+	// The sidebar widget can still be allocated with larger width if its own
			578	+	// minimum width exceeds it.
			579	+	func (x *OverlaySplitView) SetPropertyMinSidebarWidth(value float64) {
			580	+	var v gobject.Value
			581	+	v.Init(gobject.TypeDoubleVal)
			582	+	v.SetDouble(value)
			583	+	x.SetProperty("min-sidebar-width", &v)
			584	+	}
			585	+
			586	+	// GetPropertyMinSidebarWidth gets the "min-sidebar-width" property.
			587	+	// The minimum sidebar width.
			588	+	//
			589	+	// Minimum width is affected by
			590	+	// [property@OverlaySplitView:sidebar-width-unit].
			591	+	//
			592	+	// The sidebar widget can still be allocated with larger width if its own
			593	+	// minimum width exceeds it.
			594	+	func (x *OverlaySplitView) GetPropertyMinSidebarWidth() float64 {
			595	+	var v gobject.Value
			596	+	x.GetProperty("min-sidebar-width", &v)
			597	+	return v.GetDouble()
			598	+	}
			599	+
			600	+	// SetPropertyPinSidebar sets the "pin-sidebar" property.
			601	+	// Whether the sidebar widget is pinned.
			602	+	//
			603	+	// By default, collapsing @self automatically hides the sidebar widget, and
			604	+	// uncollapsing it shows the sidebar. If set to `TRUE`, sidebar visibility
			605	+	// never changes on its own.
			606	+	func (x *OverlaySplitView) SetPropertyPinSidebar(value bool) {
			607	+	var v gobject.Value
			608	+	v.Init(gobject.TypeBooleanVal)
			609	+	v.SetBoolean(value)
			610	+	x.SetProperty("pin-sidebar", &v)
			611	+	}
			612	+
			613	+	// GetPropertyPinSidebar gets the "pin-sidebar" property.
			614	+	// Whether the sidebar widget is pinned.
			615	+	//
			616	+	// By default, collapsing @self automatically hides the sidebar widget, and
			617	+	// uncollapsing it shows the sidebar. If set to `TRUE`, sidebar visibility
			618	+	// never changes on its own.
			619	+	func (x *OverlaySplitView) GetPropertyPinSidebar() bool {
			620	+	var v gobject.Value
			621	+	x.GetProperty("pin-sidebar", &v)
			622	+	return v.GetBoolean()
			623	+	}
			624	+
			625	+	// SetPropertyShowSidebar sets the "show-sidebar" property.
			626	+	// Whether the sidebar widget is shown.
			627	+	func (x *OverlaySplitView) SetPropertyShowSidebar(value bool) {
			628	+	var v gobject.Value
			629	+	v.Init(gobject.TypeBooleanVal)
			630	+	v.SetBoolean(value)
			631	+	x.SetProperty("show-sidebar", &v)
			632	+	}
			633	+
			634	+	// GetPropertyShowSidebar gets the "show-sidebar" property.
			635	+	// Whether the sidebar widget is shown.
			636	+	func (x *OverlaySplitView) GetPropertyShowSidebar() bool {
			637	+	var v gobject.Value
			638	+	x.GetProperty("show-sidebar", &v)
			639	+	return v.GetBoolean()
			640	+	}
			641	+
			642	+	// SetPropertySidebarWidthFraction sets the "sidebar-width-fraction" property.
			643	+	// The preferred sidebar width as a fraction of the total width.
			644	+	//
			645	+	// The preferred width is additionally limited by
			646	+	// [property@OverlaySplitView:min-sidebar-width] and
			647	+	// [property@OverlaySplitView:max-sidebar-width].
			648	+	//
			649	+	// The sidebar widget can be allocated with larger width if its own minimum
			650	+	// width exceeds the preferred width.
			651	+	func (x *OverlaySplitView) SetPropertySidebarWidthFraction(value float64) {
			652	+	var v gobject.Value
			653	+	v.Init(gobject.TypeDoubleVal)
			654	+	v.SetDouble(value)
			655	+	x.SetProperty("sidebar-width-fraction", &v)
			656	+	}
			657	+
			658	+	// GetPropertySidebarWidthFraction gets the "sidebar-width-fraction" property.
			659	+	// The preferred sidebar width as a fraction of the total width.
			660	+	//
			661	+	// The preferred width is additionally limited by
			662	+	// [property@OverlaySplitView:min-sidebar-width] and
			663	+	// [property@OverlaySplitView:max-sidebar-width].
			664	+	//
			665	+	// The sidebar widget can be allocated with larger width if its own minimum
			666	+	// width exceeds the preferred width.
			667	+	func (x *OverlaySplitView) GetPropertySidebarWidthFraction() float64 {
			668	+	var v gobject.Value
			669	+	x.GetProperty("sidebar-width-fraction", &v)
			670	+	return v.GetDouble()
			671	+	}
			672	+
477		// Gets the progress @self will snap back to after the gesture is canceled.	673		// Gets the progress @self will snap back to after the gesture is canceled.
478		func (x *OverlaySplitView) GetCancelProgress() float64 {	674		func (x *OverlaySplitView) GetCancelProgress() float64 {
479			675

@@ -501,7 +697,7 @@ func (x *OverlaySplitView) GetProgress() float64 {
501		//	697		//
502		// Each snap point represents a progress value that is considered acceptable to	698		// Each snap point represents a progress value that is considered acceptable to
503		// end the swipe on.	699		// end the swipe on.
504	-	func (x *OverlaySplitView) GetSnapPoints(NSnapPointsVar int) uintptr {	700	+	func (x OverlaySplitView) GetSnapPoints(NSnapPointsVar int) uintptr {
505			701
506		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)	702		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)
507		return cret	703		return cret

@@ -579,7 +775,7 @@ func (x OverlaySplitView) GetAtContext() gtk.ATContext {
579		// This functionality can be overridden by `GtkAccessible`	775		// This functionality can be overridden by `GtkAccessible`
580		// implementations, e.g. to get the bounds from an ignored	776		// implementations, e.g. to get the bounds from an ignored
581		// child widget.	777		// child widget.
582	-	func (x *OverlaySplitView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	778	+	func (x OverlaySplitView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
583			779
584		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	780		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
585		return cret	781		return cret

M v4/adw/adw-password-entry-row.go +2 -2


@@ -145,7 +145,7 @@ func (x PasswordEntryRow) GetAtContext() gtk.ATContext {
145		// This functionality can be overridden by `GtkAccessible`	145		// This functionality can be overridden by `GtkAccessible`
146		// implementations, e.g. to get the bounds from an ignored	146		// implementations, e.g. to get the bounds from an ignored
147		// child widget.	147		// child widget.
148	-	func (x *PasswordEntryRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	148	+	func (x PasswordEntryRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
149			149
150		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	150		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
151		return cret	151		return cret

@@ -601,7 +601,7 @@ func (x *PasswordEntryRow) GetPosition() int {
601		// and %FALSE will be returned.	601		// and %FALSE will be returned.
602		//	602		//
603		// Note that positions are specified in characters, not bytes.	603		// Note that positions are specified in characters, not bytes.
604	-	func (x *PasswordEntryRow) GetSelectionBounds(StartPosVar int, EndPosVar int) bool {	604	+	func (x PasswordEntryRow) GetSelectionBounds(StartPosVar int, EndPosVar *int) bool {
605			605
606		cret := gtk.XGtkEditableGetSelectionBounds(x.GoPointer(), StartPosVar, EndPosVar)	606		cret := gtk.XGtkEditableGetSelectionBounds(x.GoPointer(), StartPosVar, EndPosVar)
607		return cret	607		return cret

M v4/adw/adw-preferences-dialog.go +39 -1


@@ -203,6 +203,44 @@ func (c *PreferencesDialog) SetGoPointer(ptr uintptr) {
203		c.Ptr = ptr	203		c.Ptr = ptr
204		}	204		}
205			205
			206	+	// SetPropertySearchEnabled sets the "search-enabled" property.
			207	+	// Whether search is enabled.
			208	+	func (x *PreferencesDialog) SetPropertySearchEnabled(value bool) {
			209	+	var v gobject.Value
			210	+	v.Init(gobject.TypeBooleanVal)
			211	+	v.SetBoolean(value)
			212	+	x.SetProperty("search-enabled", &v)
			213	+	}
			214	+
			215	+	// GetPropertySearchEnabled gets the "search-enabled" property.
			216	+	// Whether search is enabled.
			217	+	func (x *PreferencesDialog) GetPropertySearchEnabled() bool {
			218	+	var v gobject.Value
			219	+	x.GetProperty("search-enabled", &v)
			220	+	return v.GetBoolean()
			221	+	}
			222	+
			223	+	// SetPropertyVisiblePageName sets the "visible-page-name" property.
			224	+	// The name of the currently visible page.
			225	+	//
			226	+	// See [property@AdwPreferencesDialog:visible-page].
			227	+	func (x *PreferencesDialog) SetPropertyVisiblePageName(value string) {
			228	+	var v gobject.Value
			229	+	v.Init(gobject.TypeStringVal)
			230	+	v.SetString(value)
			231	+	x.SetProperty("visible-page-name", &v)
			232	+	}
			233	+
			234	+	// GetPropertyVisiblePageName gets the "visible-page-name" property.
			235	+	// The name of the currently visible page.
			236	+	//
			237	+	// See [property@AdwPreferencesDialog:visible-page].
			238	+	func (x *PreferencesDialog) GetPropertyVisiblePageName() string {
			239	+	var v gobject.Value
			240	+	x.GetProperty("visible-page-name", &v)
			241	+	return v.GetString()
			242	+	}
			243	+
206		// Requests the user's screen reader to announce the given message.	244		// Requests the user's screen reader to announce the given message.
207		//	245		//
208		// This kind of notification is useful for messages that	246		// This kind of notification is useful for messages that

@@ -260,7 +298,7 @@ func (x PreferencesDialog) GetAtContext() gtk.ATContext {
260		// This functionality can be overridden by `GtkAccessible`	298		// This functionality can be overridden by `GtkAccessible`
261		// implementations, e.g. to get the bounds from an ignored	299		// implementations, e.g. to get the bounds from an ignored
262		// child widget.	300		// child widget.
263	-	func (x *PreferencesDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	301	+	func (x PreferencesDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
264			302
265		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	303		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
266		return cret	304		return cret

M v4/adw/adw-preferences-group.go +60 -1


@@ -244,6 +244,65 @@ func (c *PreferencesGroup) SetGoPointer(ptr uintptr) {
244		c.Ptr = ptr	244		c.Ptr = ptr
245		}	245		}
246			246
			247	+	// SetPropertyDescription sets the "description" property.
			248	+	// The description for this group of preferences.
			249	+	func (x *PreferencesGroup) SetPropertyDescription(value string) {
			250	+	var v gobject.Value
			251	+	v.Init(gobject.TypeStringVal)
			252	+	v.SetString(value)
			253	+	x.SetProperty("description", &v)
			254	+	}
			255	+
			256	+	// GetPropertyDescription gets the "description" property.
			257	+	// The description for this group of preferences.
			258	+	func (x *PreferencesGroup) GetPropertyDescription() string {
			259	+	var v gobject.Value
			260	+	x.GetProperty("description", &v)
			261	+	return v.GetString()
			262	+	}
			263	+
			264	+	// SetPropertySeparateRows sets the "separate-rows" property.
			265	+	// Whether to separate rows.
			266	+	//
			267	+	// Equivalent to using the
			268	+	// [`.boxed-list-separate`](style-classes.html#boxed-lists-cards) style class
			269	+	// on a [class@Gtk.ListBox] instead of `.boxed-list`.
			270	+	func (x *PreferencesGroup) SetPropertySeparateRows(value bool) {
			271	+	var v gobject.Value
			272	+	v.Init(gobject.TypeBooleanVal)
			273	+	v.SetBoolean(value)
			274	+	x.SetProperty("separate-rows", &v)
			275	+	}
			276	+
			277	+	// GetPropertySeparateRows gets the "separate-rows" property.
			278	+	// Whether to separate rows.
			279	+	//
			280	+	// Equivalent to using the
			281	+	// [`.boxed-list-separate`](style-classes.html#boxed-lists-cards) style class
			282	+	// on a [class@Gtk.ListBox] instead of `.boxed-list`.
			283	+	func (x *PreferencesGroup) GetPropertySeparateRows() bool {
			284	+	var v gobject.Value
			285	+	x.GetProperty("separate-rows", &v)
			286	+	return v.GetBoolean()
			287	+	}
			288	+
			289	+	// SetPropertyTitle sets the "title" property.
			290	+	// The title for this group of preferences.
			291	+	func (x *PreferencesGroup) SetPropertyTitle(value string) {
			292	+	var v gobject.Value
			293	+	v.Init(gobject.TypeStringVal)
			294	+	v.SetString(value)
			295	+	x.SetProperty("title", &v)
			296	+	}
			297	+
			298	+	// GetPropertyTitle gets the "title" property.
			299	+	// The title for this group of preferences.
			300	+	func (x *PreferencesGroup) GetPropertyTitle() string {
			301	+	var v gobject.Value
			302	+	x.GetProperty("title", &v)
			303	+	return v.GetString()
			304	+	}
			305	+
247		// Requests the user's screen reader to announce the given message.	306		// Requests the user's screen reader to announce the given message.
248		//	307		//
249		// This kind of notification is useful for messages that	308		// This kind of notification is useful for messages that

@@ -301,7 +360,7 @@ func (x PreferencesGroup) GetAtContext() gtk.ATContext {
301		// This functionality can be overridden by `GtkAccessible`	360		// This functionality can be overridden by `GtkAccessible`
302		// implementations, e.g. to get the bounds from an ignored	361		// implementations, e.g. to get the bounds from an ignored
303		// child widget.	362		// child widget.
304	-	func (x *PreferencesGroup) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	363	+	func (x PreferencesGroup) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
305			364
306		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	365		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
307		return cret	366		return cret

M v4/adw/adw-preferences-page.go +103 -1


@@ -281,6 +281,108 @@ func (c *PreferencesPage) SetGoPointer(ptr uintptr) {
281		c.Ptr = ptr	281		c.Ptr = ptr
282		}	282		}
283			283
			284	+	// SetPropertyDescription sets the "description" property.
			285	+	// The description to be displayed at the top of the page.
			286	+	func (x *PreferencesPage) SetPropertyDescription(value string) {
			287	+	var v gobject.Value
			288	+	v.Init(gobject.TypeStringVal)
			289	+	v.SetString(value)
			290	+	x.SetProperty("description", &v)
			291	+	}
			292	+
			293	+	// GetPropertyDescription gets the "description" property.
			294	+	// The description to be displayed at the top of the page.
			295	+	func (x *PreferencesPage) GetPropertyDescription() string {
			296	+	var v gobject.Value
			297	+	x.GetProperty("description", &v)
			298	+	return v.GetString()
			299	+	}
			300	+
			301	+	// SetPropertyDescriptionCentered sets the "description-centered" property.
			302	+	// Whether the description should be centered.
			303	+	func (x *PreferencesPage) SetPropertyDescriptionCentered(value bool) {
			304	+	var v gobject.Value
			305	+	v.Init(gobject.TypeBooleanVal)
			306	+	v.SetBoolean(value)
			307	+	x.SetProperty("description-centered", &v)
			308	+	}
			309	+
			310	+	// GetPropertyDescriptionCentered gets the "description-centered" property.
			311	+	// Whether the description should be centered.
			312	+	func (x *PreferencesPage) GetPropertyDescriptionCentered() bool {
			313	+	var v gobject.Value
			314	+	x.GetProperty("description-centered", &v)
			315	+	return v.GetBoolean()
			316	+	}
			317	+
			318	+	// SetPropertyIconName sets the "icon-name" property.
			319	+	// The icon name for this page.
			320	+	func (x *PreferencesPage) SetPropertyIconName(value string) {
			321	+	var v gobject.Value
			322	+	v.Init(gobject.TypeStringVal)
			323	+	v.SetString(value)
			324	+	x.SetProperty("icon-name", &v)
			325	+	}
			326	+
			327	+	// GetPropertyIconName gets the "icon-name" property.
			328	+	// The icon name for this page.
			329	+	func (x *PreferencesPage) GetPropertyIconName() string {
			330	+	var v gobject.Value
			331	+	x.GetProperty("icon-name", &v)
			332	+	return v.GetString()
			333	+	}
			334	+
			335	+	// SetPropertyName sets the "name" property.
			336	+	// The name of this page.
			337	+	func (x *PreferencesPage) SetPropertyName(value string) {
			338	+	var v gobject.Value
			339	+	v.Init(gobject.TypeStringVal)
			340	+	v.SetString(value)
			341	+	x.SetProperty("name", &v)
			342	+	}
			343	+
			344	+	// GetPropertyName gets the "name" property.
			345	+	// The name of this page.
			346	+	func (x *PreferencesPage) GetPropertyName() string {
			347	+	var v gobject.Value
			348	+	x.GetProperty("name", &v)
			349	+	return v.GetString()
			350	+	}
			351	+
			352	+	// SetPropertyTitle sets the "title" property.
			353	+	// The title for this page.
			354	+	func (x *PreferencesPage) SetPropertyTitle(value string) {
			355	+	var v gobject.Value
			356	+	v.Init(gobject.TypeStringVal)
			357	+	v.SetString(value)
			358	+	x.SetProperty("title", &v)
			359	+	}
			360	+
			361	+	// GetPropertyTitle gets the "title" property.
			362	+	// The title for this page.
			363	+	func (x *PreferencesPage) GetPropertyTitle() string {
			364	+	var v gobject.Value
			365	+	x.GetProperty("title", &v)
			366	+	return v.GetString()
			367	+	}
			368	+
			369	+	// SetPropertyUseUnderline sets the "use-underline" property.
			370	+	// Whether an embedded underline in the title indicates a mnemonic.
			371	+	func (x *PreferencesPage) SetPropertyUseUnderline(value bool) {
			372	+	var v gobject.Value
			373	+	v.Init(gobject.TypeBooleanVal)
			374	+	v.SetBoolean(value)
			375	+	x.SetProperty("use-underline", &v)
			376	+	}
			377	+
			378	+	// GetPropertyUseUnderline gets the "use-underline" property.
			379	+	// Whether an embedded underline in the title indicates a mnemonic.
			380	+	func (x *PreferencesPage) GetPropertyUseUnderline() bool {
			381	+	var v gobject.Value
			382	+	x.GetProperty("use-underline", &v)
			383	+	return v.GetBoolean()
			384	+	}
			385	+
284		// Requests the user's screen reader to announce the given message.	386		// Requests the user's screen reader to announce the given message.
285		//	387		//
286		// This kind of notification is useful for messages that	388		// This kind of notification is useful for messages that

@@ -338,7 +440,7 @@ func (x PreferencesPage) GetAtContext() gtk.ATContext {
338		// This functionality can be overridden by `GtkAccessible`	440		// This functionality can be overridden by `GtkAccessible`
339		// implementations, e.g. to get the bounds from an ignored	441		// implementations, e.g. to get the bounds from an ignored
340		// child widget.	442		// child widget.
341	-	func (x *PreferencesPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	443	+	func (x PreferencesPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
342			444
343		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	445		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
344		return cret	446		return cret

M v4/adw/adw-preferences-row.go +87 -1


@@ -159,6 +159,92 @@ func (c *PreferencesRow) SetGoPointer(ptr uintptr) {
159		c.Ptr = ptr	159		c.Ptr = ptr
160		}	160		}
161			161
			162	+	// SetPropertyTitle sets the "title" property.
			163	+	// The title of the preference represented by this row.
			164	+	//
			165	+	// The title is interpreted as Pango markup unless
			166	+	// [property@PreferencesRow:use-markup] is set to `FALSE`.
			167	+	func (x *PreferencesRow) SetPropertyTitle(value string) {
			168	+	var v gobject.Value
			169	+	v.Init(gobject.TypeStringVal)
			170	+	v.SetString(value)
			171	+	x.SetProperty("title", &v)
			172	+	}
			173	+
			174	+	// GetPropertyTitle gets the "title" property.
			175	+	// The title of the preference represented by this row.
			176	+	//
			177	+	// The title is interpreted as Pango markup unless
			178	+	// [property@PreferencesRow:use-markup] is set to `FALSE`.
			179	+	func (x *PreferencesRow) GetPropertyTitle() string {
			180	+	var v gobject.Value
			181	+	x.GetProperty("title", &v)
			182	+	return v.GetString()
			183	+	}
			184	+
			185	+	// SetPropertyTitleSelectable sets the "title-selectable" property.
			186	+	// Whether the user can copy the title from the label.
			187	+	//
			188	+	// See also [property@Gtk.Label:selectable].
			189	+	func (x *PreferencesRow) SetPropertyTitleSelectable(value bool) {
			190	+	var v gobject.Value
			191	+	v.Init(gobject.TypeBooleanVal)
			192	+	v.SetBoolean(value)
			193	+	x.SetProperty("title-selectable", &v)
			194	+	}
			195	+
			196	+	// GetPropertyTitleSelectable gets the "title-selectable" property.
			197	+	// Whether the user can copy the title from the label.
			198	+	//
			199	+	// See also [property@Gtk.Label:selectable].
			200	+	func (x *PreferencesRow) GetPropertyTitleSelectable() bool {
			201	+	var v gobject.Value
			202	+	x.GetProperty("title-selectable", &v)
			203	+	return v.GetBoolean()
			204	+	}
			205	+
			206	+	// SetPropertyUseMarkup sets the "use-markup" property.
			207	+	// Whether to use Pango markup for the title label.
			208	+	//
			209	+	// Subclasses may also use it for other labels, such as subtitle.
			210	+	//
			211	+	// See also [func@Pango.parse_markup].
			212	+	func (x *PreferencesRow) SetPropertyUseMarkup(value bool) {
			213	+	var v gobject.Value
			214	+	v.Init(gobject.TypeBooleanVal)
			215	+	v.SetBoolean(value)
			216	+	x.SetProperty("use-markup", &v)
			217	+	}
			218	+
			219	+	// GetPropertyUseMarkup gets the "use-markup" property.
			220	+	// Whether to use Pango markup for the title label.
			221	+	//
			222	+	// Subclasses may also use it for other labels, such as subtitle.
			223	+	//
			224	+	// See also [func@Pango.parse_markup].
			225	+	func (x *PreferencesRow) GetPropertyUseMarkup() bool {
			226	+	var v gobject.Value
			227	+	x.GetProperty("use-markup", &v)
			228	+	return v.GetBoolean()
			229	+	}
			230	+
			231	+	// SetPropertyUseUnderline sets the "use-underline" property.
			232	+	// Whether an embedded underline in the title indicates a mnemonic.
			233	+	func (x *PreferencesRow) SetPropertyUseUnderline(value bool) {
			234	+	var v gobject.Value
			235	+	v.Init(gobject.TypeBooleanVal)
			236	+	v.SetBoolean(value)
			237	+	x.SetProperty("use-underline", &v)
			238	+	}
			239	+
			240	+	// GetPropertyUseUnderline gets the "use-underline" property.
			241	+	// Whether an embedded underline in the title indicates a mnemonic.
			242	+	func (x *PreferencesRow) GetPropertyUseUnderline() bool {
			243	+	var v gobject.Value
			244	+	x.GetProperty("use-underline", &v)
			245	+	return v.GetBoolean()
			246	+	}
			247	+
162		// Requests the user's screen reader to announce the given message.	248		// Requests the user's screen reader to announce the given message.
163		//	249		//
164		// This kind of notification is useful for messages that	250		// This kind of notification is useful for messages that

@@ -216,7 +302,7 @@ func (x PreferencesRow) GetAtContext() gtk.ATContext {
216		// This functionality can be overridden by `GtkAccessible`	302		// This functionality can be overridden by `GtkAccessible`
217		// implementations, e.g. to get the bounds from an ignored	303		// implementations, e.g. to get the bounds from an ignored
218		// child widget.	304		// child widget.
219	-	func (x *PreferencesRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	305	+	func (x PreferencesRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
220			306
221		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	307		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
222		return cret	308		return cret

M v4/adw/adw-preferences-window.go +85 -2


@@ -253,6 +253,89 @@ func (c *PreferencesWindow) SetGoPointer(ptr uintptr) {
253		c.Ptr = ptr	253		c.Ptr = ptr
254		}	254		}
255			255
			256	+	// SetPropertyCanNavigateBack sets the "can-navigate-back" property.
			257	+	// Whether gestures and shortcuts for closing subpages are enabled.
			258	+	//
			259	+	// The supported gestures are:
			260	+	//
			261	+	// - One-finger swipe on touchscreens
			262	+	// - Horizontal scrolling on touchpads (usually two-finger swipe)
			263	+	// - Back mouse button
			264	+	//
			265	+	// The keyboard back key is also supported, as well as the
			266	+	// <kbd>Alt</kbd>+<kbd>←</kbd> shortcut.
			267	+	//
			268	+	// For right-to-left locales, gestures and shortcuts are reversed.
			269	+	//
			270	+	// Has no effect for subpages added with
			271	+	// [method@PreferencesWindow.push_subpage].
			272	+	func (x *PreferencesWindow) SetPropertyCanNavigateBack(value bool) {
			273	+	var v gobject.Value
			274	+	v.Init(gobject.TypeBooleanVal)
			275	+	v.SetBoolean(value)
			276	+	x.SetProperty("can-navigate-back", &v)
			277	+	}
			278	+
			279	+	// GetPropertyCanNavigateBack gets the "can-navigate-back" property.
			280	+	// Whether gestures and shortcuts for closing subpages are enabled.
			281	+	//
			282	+	// The supported gestures are:
			283	+	//
			284	+	// - One-finger swipe on touchscreens
			285	+	// - Horizontal scrolling on touchpads (usually two-finger swipe)
			286	+	// - Back mouse button
			287	+	//
			288	+	// The keyboard back key is also supported, as well as the
			289	+	// <kbd>Alt</kbd>+<kbd>←</kbd> shortcut.
			290	+	//
			291	+	// For right-to-left locales, gestures and shortcuts are reversed.
			292	+	//
			293	+	// Has no effect for subpages added with
			294	+	// [method@PreferencesWindow.push_subpage].
			295	+	func (x *PreferencesWindow) GetPropertyCanNavigateBack() bool {
			296	+	var v gobject.Value
			297	+	x.GetProperty("can-navigate-back", &v)
			298	+	return v.GetBoolean()
			299	+	}
			300	+
			301	+	// SetPropertySearchEnabled sets the "search-enabled" property.
			302	+	// Whether search is enabled.
			303	+	func (x *PreferencesWindow) SetPropertySearchEnabled(value bool) {
			304	+	var v gobject.Value
			305	+	v.Init(gobject.TypeBooleanVal)
			306	+	v.SetBoolean(value)
			307	+	x.SetProperty("search-enabled", &v)
			308	+	}
			309	+
			310	+	// GetPropertySearchEnabled gets the "search-enabled" property.
			311	+	// Whether search is enabled.
			312	+	func (x *PreferencesWindow) GetPropertySearchEnabled() bool {
			313	+	var v gobject.Value
			314	+	x.GetProperty("search-enabled", &v)
			315	+	return v.GetBoolean()
			316	+	}
			317	+
			318	+	// SetPropertyVisiblePageName sets the "visible-page-name" property.
			319	+	// The name of the currently visible page.
			320	+	//
			321	+	// See [property@PreferencesWindow:visible-page].
			322	+	func (x *PreferencesWindow) SetPropertyVisiblePageName(value string) {
			323	+	var v gobject.Value
			324	+	v.Init(gobject.TypeStringVal)
			325	+	v.SetString(value)
			326	+	x.SetProperty("visible-page-name", &v)
			327	+	}
			328	+
			329	+	// GetPropertyVisiblePageName gets the "visible-page-name" property.
			330	+	// The name of the currently visible page.
			331	+	//
			332	+	// See [property@PreferencesWindow:visible-page].
			333	+	func (x *PreferencesWindow) GetPropertyVisiblePageName() string {
			334	+	var v gobject.Value
			335	+	x.GetProperty("visible-page-name", &v)
			336	+	return v.GetString()
			337	+	}
			338	+
256		// Requests the user's screen reader to announce the given message.	339		// Requests the user's screen reader to announce the given message.
257		//	340		//
258		// This kind of notification is useful for messages that	341		// This kind of notification is useful for messages that

@@ -310,7 +393,7 @@ func (x PreferencesWindow) GetAtContext() gtk.ATContext {
310		// This functionality can be overridden by `GtkAccessible`	393		// This functionality can be overridden by `GtkAccessible`
311		// implementations, e.g. to get the bounds from an ignored	394		// implementations, e.g. to get the bounds from an ignored
312		// child widget.	395		// child widget.
313	-	func (x *PreferencesWindow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	396	+	func (x PreferencesWindow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
314			397
315		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	398		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
316		return cret	399		return cret

@@ -565,7 +648,7 @@ func (x PreferencesWindow) GetSurface() gdk.Surface {
565		//	648		//
566		// This is the translation from @self's surface coordinates into	649		// This is the translation from @self's surface coordinates into
567		// @self's widget coordinates.	650		// @self's widget coordinates.
568	-	func (x *PreferencesWindow) GetSurfaceTransform(XVar float64, YVar float64) {	651	+	func (x PreferencesWindow) GetSurfaceTransform(XVar float64, YVar *float64) {
569			652
570		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	653		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
571			654

M v4/adw/adw-shortcut-label.go +35 -1


@@ -169,6 +169,40 @@ func (c *ShortcutLabel) SetGoPointer(ptr uintptr) {
169		c.Ptr = ptr	169		c.Ptr = ptr
170		}	170		}
171			171
			172	+	// SetPropertyAccelerator sets the "accelerator" property.
			173	+	// The displayed accelerator.
			174	+	func (x *ShortcutLabel) SetPropertyAccelerator(value string) {
			175	+	var v gobject.Value
			176	+	v.Init(gobject.TypeStringVal)
			177	+	v.SetString(value)
			178	+	x.SetProperty("accelerator", &v)
			179	+	}
			180	+
			181	+	// GetPropertyAccelerator gets the "accelerator" property.
			182	+	// The displayed accelerator.
			183	+	func (x *ShortcutLabel) GetPropertyAccelerator() string {
			184	+	var v gobject.Value
			185	+	x.GetProperty("accelerator", &v)
			186	+	return v.GetString()
			187	+	}
			188	+
			189	+	// SetPropertyDisabledText sets the "disabled-text" property.
			190	+	// The text displayed when no accelerator is set.
			191	+	func (x *ShortcutLabel) SetPropertyDisabledText(value string) {
			192	+	var v gobject.Value
			193	+	v.Init(gobject.TypeStringVal)
			194	+	v.SetString(value)
			195	+	x.SetProperty("disabled-text", &v)
			196	+	}
			197	+
			198	+	// GetPropertyDisabledText gets the "disabled-text" property.
			199	+	// The text displayed when no accelerator is set.
			200	+	func (x *ShortcutLabel) GetPropertyDisabledText() string {
			201	+	var v gobject.Value
			202	+	x.GetProperty("disabled-text", &v)
			203	+	return v.GetString()
			204	+	}
			205	+
172		// Requests the user's screen reader to announce the given message.	206		// Requests the user's screen reader to announce the given message.
173		//	207		//
174		// This kind of notification is useful for messages that	208		// This kind of notification is useful for messages that

@@ -226,7 +260,7 @@ func (x ShortcutLabel) GetAtContext() gtk.ATContext {
226		// This functionality can be overridden by `GtkAccessible`	260		// This functionality can be overridden by `GtkAccessible`
227		// implementations, e.g. to get the bounds from an ignored	261		// implementations, e.g. to get the bounds from an ignored
228		// child widget.	262		// child widget.
229	-	func (x *ShortcutLabel) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	263	+	func (x ShortcutLabel) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
230			264
231		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	265		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
232		return cret	266		return cret

M v4/adw/adw-shortcuts-dialog.go +1 -1


@@ -223,7 +223,7 @@ func (x ShortcutsDialog) GetAtContext() gtk.ATContext {
223		// This functionality can be overridden by `GtkAccessible`	223		// This functionality can be overridden by `GtkAccessible`
224		// implementations, e.g. to get the bounds from an ignored	224		// implementations, e.g. to get the bounds from an ignored
225		// child widget.	225		// child widget.
226	-	func (x *ShortcutsDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	226	+	func (x ShortcutsDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
227			227
228		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	228		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
229		return cret	229		return cret

M v4/adw/adw-shortcuts-item.go +72 -0


@@ -192,6 +192,78 @@ func (c *ShortcutsItem) SetGoPointer(ptr uintptr) {
192	c.Ptr = ptr	192		c.Ptr = ptr
193	}	193		}
194		194
		195	+	// SetPropertyAccelerator sets the "accelerator" property.
		196	+	// The shortcut accelerator.
		197	+	//
		198	+	// Accelerator must be in the format [class@ShortcutLabel] accepts.
		199	+	func (x *ShortcutsItem) SetPropertyAccelerator(value string) {
		200	+	var v gobject.Value
		201	+	v.Init(gobject.TypeStringVal)
		202	+	v.SetString(value)
		203	+	x.SetProperty("accelerator", &v)
		204	+	}
		205	+
		206	+	// GetPropertyAccelerator gets the "accelerator" property.
		207	+	// The shortcut accelerator.
		208	+	//
		209	+	// Accelerator must be in the format [class@ShortcutLabel] accepts.
		210	+	func (x *ShortcutsItem) GetPropertyAccelerator() string {
		211	+	var v gobject.Value
		212	+	x.GetProperty("accelerator", &v)
		213	+	return v.GetString()
		214	+	}
		215	+
		216	+	// SetPropertyActionName sets the "action-name" property.
		217	+	// Fully qualified action name to get the accelerator from.
		218	+	func (x *ShortcutsItem) SetPropertyActionName(value string) {
		219	+	var v gobject.Value
		220	+	v.Init(gobject.TypeStringVal)
		221	+	v.SetString(value)
		222	+	x.SetProperty("action-name", &v)
		223	+	}
		224	+
		225	+	// GetPropertyActionName gets the "action-name" property.
		226	+	// Fully qualified action name to get the accelerator from.
		227	+	func (x *ShortcutsItem) GetPropertyActionName() string {
		228	+	var v gobject.Value
		229	+	x.GetProperty("action-name", &v)
		230	+	return v.GetString()
		231	+	}
		232	+
		233	+	// SetPropertySubtitle sets the "subtitle" property.
		234	+	// The subtitle of the shortcut.
		235	+	func (x *ShortcutsItem) SetPropertySubtitle(value string) {
		236	+	var v gobject.Value
		237	+	v.Init(gobject.TypeStringVal)
		238	+	v.SetString(value)
		239	+	x.SetProperty("subtitle", &v)
		240	+	}
		241	+
		242	+	// GetPropertySubtitle gets the "subtitle" property.
		243	+	// The subtitle of the shortcut.
		244	+	func (x *ShortcutsItem) GetPropertySubtitle() string {
		245	+	var v gobject.Value
		246	+	x.GetProperty("subtitle", &v)
		247	+	return v.GetString()
		248	+	}
		249	+
		250	+	// SetPropertyTitle sets the "title" property.
		251	+	// The title of the shortcut.
		252	+	func (x *ShortcutsItem) SetPropertyTitle(value string) {
		253	+	var v gobject.Value
		254	+	v.Init(gobject.TypeStringVal)
		255	+	v.SetString(value)
		256	+	x.SetProperty("title", &v)
		257	+	}
		258	+
		259	+	// GetPropertyTitle gets the "title" property.
		260	+	// The title of the shortcut.
		261	+	func (x *ShortcutsItem) GetPropertyTitle() string {
		262	+	var v gobject.Value
		263	+	x.GetProperty("title", &v)
		264	+	return v.GetString()
		265	+	}
		266	+
195	func init() {	267		func init() {
196	core.SetPackageName("ADW", "libadwaita-1")	268		core.SetPackageName("ADW", "libadwaita-1")
197	core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})	269		core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})

M v4/adw/adw-shortcuts-section.go +17 -0


@@ -104,6 +104,23 @@ func (c *ShortcutsSection) SetGoPointer(ptr uintptr) {
104	c.Ptr = ptr	104		c.Ptr = ptr
105	}	105		}
106		106
		107	+	// SetPropertyTitle sets the "title" property.
		108	+	// The title of the section, can be `NULL`.
		109	+	func (x *ShortcutsSection) SetPropertyTitle(value string) {
		110	+	var v gobject.Value
		111	+	v.Init(gobject.TypeStringVal)
		112	+	v.SetString(value)
		113	+	x.SetProperty("title", &v)
		114	+	}
		115	+
		116	+	// GetPropertyTitle gets the "title" property.
		117	+	// The title of the section, can be `NULL`.
		118	+	func (x *ShortcutsSection) GetPropertyTitle() string {
		119	+	var v gobject.Value
		120	+	x.GetProperty("title", &v)
		121	+	return v.GetString()
		122	+	}
		123	+
107	// Get the item at @position.	124		// Get the item at @position.
108	//	125		//
109	// If @position is greater than the number of items in @list, %NULL is	126		// If @position is greater than the number of items in @list, %NULL is

M v4/adw/adw-spin-row.go +106 -4


@@ -321,6 +321,108 @@ func (c *SpinRow) SetGoPointer(ptr uintptr) {
321		c.Ptr = ptr	321		c.Ptr = ptr
322		}	322		}
323			323
			324	+	// SetPropertyClimbRate sets the "climb-rate" property.
			325	+	// The acceleration rate when you hold down a button or key.
			326	+	func (x *SpinRow) SetPropertyClimbRate(value float64) {
			327	+	var v gobject.Value
			328	+	v.Init(gobject.TypeDoubleVal)
			329	+	v.SetDouble(value)
			330	+	x.SetProperty("climb-rate", &v)
			331	+	}
			332	+
			333	+	// GetPropertyClimbRate gets the "climb-rate" property.
			334	+	// The acceleration rate when you hold down a button or key.
			335	+	func (x *SpinRow) GetPropertyClimbRate() float64 {
			336	+	var v gobject.Value
			337	+	x.GetProperty("climb-rate", &v)
			338	+	return v.GetDouble()
			339	+	}
			340	+
			341	+	// SetPropertyDigits sets the "digits" property.
			342	+	// The number of decimal places to display.
			343	+	func (x *SpinRow) SetPropertyDigits(value uint) {
			344	+	var v gobject.Value
			345	+	v.Init(gobject.TypeUintVal)
			346	+	v.SetUint(value)
			347	+	x.SetProperty("digits", &v)
			348	+	}
			349	+
			350	+	// GetPropertyDigits gets the "digits" property.
			351	+	// The number of decimal places to display.
			352	+	func (x *SpinRow) GetPropertyDigits() uint {
			353	+	var v gobject.Value
			354	+	x.GetProperty("digits", &v)
			355	+	return v.GetUint()
			356	+	}
			357	+
			358	+	// SetPropertyNumeric sets the "numeric" property.
			359	+	// Whether non-numeric characters should be ignored.
			360	+	func (x *SpinRow) SetPropertyNumeric(value bool) {
			361	+	var v gobject.Value
			362	+	v.Init(gobject.TypeBooleanVal)
			363	+	v.SetBoolean(value)
			364	+	x.SetProperty("numeric", &v)
			365	+	}
			366	+
			367	+	// GetPropertyNumeric gets the "numeric" property.
			368	+	// Whether non-numeric characters should be ignored.
			369	+	func (x *SpinRow) GetPropertyNumeric() bool {
			370	+	var v gobject.Value
			371	+	x.GetProperty("numeric", &v)
			372	+	return v.GetBoolean()
			373	+	}
			374	+
			375	+	// SetPropertySnapToTicks sets the "snap-to-ticks" property.
			376	+	// Whether invalid values are snapped to the nearest step increment.
			377	+	func (x *SpinRow) SetPropertySnapToTicks(value bool) {
			378	+	var v gobject.Value
			379	+	v.Init(gobject.TypeBooleanVal)
			380	+	v.SetBoolean(value)
			381	+	x.SetProperty("snap-to-ticks", &v)
			382	+	}
			383	+
			384	+	// GetPropertySnapToTicks gets the "snap-to-ticks" property.
			385	+	// Whether invalid values are snapped to the nearest step increment.
			386	+	func (x *SpinRow) GetPropertySnapToTicks() bool {
			387	+	var v gobject.Value
			388	+	x.GetProperty("snap-to-ticks", &v)
			389	+	return v.GetBoolean()
			390	+	}
			391	+
			392	+	// SetPropertyValue sets the "value" property.
			393	+	// The current value.
			394	+	func (x *SpinRow) SetPropertyValue(value float64) {
			395	+	var v gobject.Value
			396	+	v.Init(gobject.TypeDoubleVal)
			397	+	v.SetDouble(value)
			398	+	x.SetProperty("value", &v)
			399	+	}
			400	+
			401	+	// GetPropertyValue gets the "value" property.
			402	+	// The current value.
			403	+	func (x *SpinRow) GetPropertyValue() float64 {
			404	+	var v gobject.Value
			405	+	x.GetProperty("value", &v)
			406	+	return v.GetDouble()
			407	+	}
			408	+
			409	+	// SetPropertyWrap sets the "wrap" property.
			410	+	// Whether the spin row should wrap upon reaching its limits.
			411	+	func (x *SpinRow) SetPropertyWrap(value bool) {
			412	+	var v gobject.Value
			413	+	v.Init(gobject.TypeBooleanVal)
			414	+	v.SetBoolean(value)
			415	+	x.SetProperty("wrap", &v)
			416	+	}
			417	+
			418	+	// GetPropertyWrap gets the "wrap" property.
			419	+	// Whether the spin row should wrap upon reaching its limits.
			420	+	func (x *SpinRow) GetPropertyWrap() bool {
			421	+	var v gobject.Value
			422	+	x.GetProperty("wrap", &v)
			423	+	return v.GetBoolean()
			424	+	}
			425	+
324		// Emitted to convert the user's input into a double value.	426		// Emitted to convert the user's input into a double value.
325		//	427		//
326		// The signal handler is expected to use [method@Gtk.Editable.get_text] to	428		// The signal handler is expected to use [method@Gtk.Editable.get_text] to

@@ -329,13 +431,13 @@ func (c *SpinRow) SetGoPointer(ptr uintptr) {
329		// The default conversion uses [func@GLib.strtod].	431		// The default conversion uses [func@GLib.strtod].
330		//	432		//
331		// See [signal@Gtk.SpinButton::input].	433		// See [signal@Gtk.SpinButton::input].
332	-	func (x SpinRow) ConnectInput(cb func(SpinRow, float64) int) uint32 {	434	+	func (x SpinRow) ConnectInput(cb func(SpinRow, *float64) int) uint32 {
333		cbPtr := uintptr(unsafe.Pointer(cb))	435		cbPtr := uintptr(unsafe.Pointer(cb))
334		if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {	436		if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
335		return gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)	437		return gobject.SignalConnect(x.GoPointer(), "input", cbRefPtr)
336		}	438		}
337			439
338	-	fcb := func(clsPtr uintptr, NewValueVarp float64) int {	440	+	fcb := func(clsPtr uintptr, NewValueVarp *float64) int {
339		fa := SpinRow{}	441		fa := SpinRow{}
340		fa.Ptr = clsPtr	442		fa.Ptr = clsPtr
341		cbFn := *cb	443		cbFn := *cb

@@ -449,7 +551,7 @@ func (x SpinRow) GetAtContext() gtk.ATContext {
449		// This functionality can be overridden by `GtkAccessible`	551		// This functionality can be overridden by `GtkAccessible`
450		// implementations, e.g. to get the bounds from an ignored	552		// implementations, e.g. to get the bounds from an ignored
451		// child widget.	553		// child widget.
452	-	func (x *SpinRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	554	+	func (x SpinRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
453			555
454		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	556		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
455		return cret	557		return cret

@@ -905,7 +1007,7 @@ func (x *SpinRow) GetPosition() int {
905		// and %FALSE will be returned.	1007		// and %FALSE will be returned.
906		//	1008		//
907		// Note that positions are specified in characters, not bytes.	1009		// Note that positions are specified in characters, not bytes.
908	-	func (x *SpinRow) GetSelectionBounds(StartPosVar int, EndPosVar int) bool {	1010	+	func (x SpinRow) GetSelectionBounds(StartPosVar int, EndPosVar *int) bool {
909			1011
910		cret := gtk.XGtkEditableGetSelectionBounds(x.GoPointer(), StartPosVar, EndPosVar)	1012		cret := gtk.XGtkEditableGetSelectionBounds(x.GoPointer(), StartPosVar, EndPosVar)
911		return cret	1013		return cret

M v4/adw/adw-spinner-paintable.go +1 -1


@@ -135,7 +135,7 @@ func (c *SpinnerPaintable) SetGoPointer(ptr uintptr) {
135		// and @specified_height are known, but it is useful to call this	135		// and @specified_height are known, but it is useful to call this
136		// function in GtkWidget:measure implementations to compute the	136		// function in GtkWidget:measure implementations to compute the
137		// other dimension when only one dimension is given.	137		// other dimension when only one dimension is given.
138	-	func (x *SpinnerPaintable) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar float64) {	138	+	func (x SpinnerPaintable) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar *float64) {
139			139
140		gdk.XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)	140		gdk.XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)
141			141

M v4/adw/adw-spinner.go +1 -1


@@ -163,7 +163,7 @@ func (x Spinner) GetAtContext() gtk.ATContext {
163		// This functionality can be overridden by `GtkAccessible`	163		// This functionality can be overridden by `GtkAccessible`
164		// implementations, e.g. to get the bounds from an ignored	164		// implementations, e.g. to get the bounds from an ignored
165		// child widget.	165		// child widget.
166	-	func (x *Spinner) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	166	+	func (x Spinner) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
167			167
168		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	168		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
169		return cret	169		return cret

M v4/adw/adw-split-button.go +116 -1


@@ -362,6 +362,121 @@ func (c *SplitButton) SetGoPointer(ptr uintptr) {
362		c.Ptr = ptr	362		c.Ptr = ptr
363		}	363		}
364			364
			365	+	// SetPropertyCanShrink sets the "can-shrink" property.
			366	+	// Whether the button can be smaller than the natural size of its contents.
			367	+	//
			368	+	// If set to `TRUE`, the label will ellipsize.
			369	+	//
			370	+	// See [property@Gtk.Button:can-shrink] and
			371	+	// [property@Gtk.MenuButton:can-shrink].
			372	+	func (x *SplitButton) SetPropertyCanShrink(value bool) {
			373	+	var v gobject.Value
			374	+	v.Init(gobject.TypeBooleanVal)
			375	+	v.SetBoolean(value)
			376	+	x.SetProperty("can-shrink", &v)
			377	+	}
			378	+
			379	+	// GetPropertyCanShrink gets the "can-shrink" property.
			380	+	// Whether the button can be smaller than the natural size of its contents.
			381	+	//
			382	+	// If set to `TRUE`, the label will ellipsize.
			383	+	//
			384	+	// See [property@Gtk.Button:can-shrink] and
			385	+	// [property@Gtk.MenuButton:can-shrink].
			386	+	func (x *SplitButton) GetPropertyCanShrink() bool {
			387	+	var v gobject.Value
			388	+	x.GetProperty("can-shrink", &v)
			389	+	return v.GetBoolean()
			390	+	}
			391	+
			392	+	// SetPropertyDropdownTooltip sets the "dropdown-tooltip" property.
			393	+	// The tooltip of the dropdown button.
			394	+	//
			395	+	// The tooltip can be marked up with the Pango text markup language.
			396	+	func (x *SplitButton) SetPropertyDropdownTooltip(value string) {
			397	+	var v gobject.Value
			398	+	v.Init(gobject.TypeStringVal)
			399	+	v.SetString(value)
			400	+	x.SetProperty("dropdown-tooltip", &v)
			401	+	}
			402	+
			403	+	// GetPropertyDropdownTooltip gets the "dropdown-tooltip" property.
			404	+	// The tooltip of the dropdown button.
			405	+	//
			406	+	// The tooltip can be marked up with the Pango text markup language.
			407	+	func (x *SplitButton) GetPropertyDropdownTooltip() string {
			408	+	var v gobject.Value
			409	+	x.GetProperty("dropdown-tooltip", &v)
			410	+	return v.GetString()
			411	+	}
			412	+
			413	+	// SetPropertyIconName sets the "icon-name" property.
			414	+	// The name of the icon used to automatically populate the button.
			415	+	//
			416	+	// Setting the icon name will set [property@SplitButton:label] and
			417	+	// [property@SplitButton:child] to `NULL`.
			418	+	func (x *SplitButton) SetPropertyIconName(value string) {
			419	+	var v gobject.Value
			420	+	v.Init(gobject.TypeStringVal)
			421	+	v.SetString(value)
			422	+	x.SetProperty("icon-name", &v)
			423	+	}
			424	+
			425	+	// GetPropertyIconName gets the "icon-name" property.
			426	+	// The name of the icon used to automatically populate the button.
			427	+	//
			428	+	// Setting the icon name will set [property@SplitButton:label] and
			429	+	// [property@SplitButton:child] to `NULL`.
			430	+	func (x *SplitButton) GetPropertyIconName() string {
			431	+	var v gobject.Value
			432	+	x.GetProperty("icon-name", &v)
			433	+	return v.GetString()
			434	+	}
			435	+
			436	+	// SetPropertyLabel sets the "label" property.
			437	+	// The label for the button.
			438	+	//
			439	+	// Setting the label will set [property@SplitButton:icon-name] and
			440	+	// [property@SplitButton:child] to `NULL`.
			441	+	func (x *SplitButton) SetPropertyLabel(value string) {
			442	+	var v gobject.Value
			443	+	v.Init(gobject.TypeStringVal)
			444	+	v.SetString(value)
			445	+	x.SetProperty("label", &v)
			446	+	}
			447	+
			448	+	// GetPropertyLabel gets the "label" property.
			449	+	// The label for the button.
			450	+	//
			451	+	// Setting the label will set [property@SplitButton:icon-name] and
			452	+	// [property@SplitButton:child] to `NULL`.
			453	+	func (x *SplitButton) GetPropertyLabel() string {
			454	+	var v gobject.Value
			455	+	x.GetProperty("label", &v)
			456	+	return v.GetString()
			457	+	}
			458	+
			459	+	// SetPropertyUseUnderline sets the "use-underline" property.
			460	+	// Whether an underline in the text indicates a mnemonic.
			461	+	//
			462	+	// See [property@SplitButton:label].
			463	+	func (x *SplitButton) SetPropertyUseUnderline(value bool) {
			464	+	var v gobject.Value
			465	+	v.Init(gobject.TypeBooleanVal)
			466	+	v.SetBoolean(value)
			467	+	x.SetProperty("use-underline", &v)
			468	+	}
			469	+
			470	+	// GetPropertyUseUnderline gets the "use-underline" property.
			471	+	// Whether an underline in the text indicates a mnemonic.
			472	+	//
			473	+	// See [property@SplitButton:label].
			474	+	func (x *SplitButton) GetPropertyUseUnderline() bool {
			475	+	var v gobject.Value
			476	+	x.GetProperty("use-underline", &v)
			477	+	return v.GetBoolean()
			478	+	}
			479	+
365		// Emitted to animate press then release.	480		// Emitted to animate press then release.
366		//	481		//
367		// This is an action signal. Applications should never connect to this signal,	482		// This is an action signal. Applications should never connect to this signal,

@@ -462,7 +577,7 @@ func (x SplitButton) GetAtContext() gtk.ATContext {
462		// This functionality can be overridden by `GtkAccessible`	577		// This functionality can be overridden by `GtkAccessible`
463		// implementations, e.g. to get the bounds from an ignored	578		// implementations, e.g. to get the bounds from an ignored
464		// child widget.	579		// child widget.
465	-	func (x *SplitButton) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	580	+	func (x SplitButton) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
466			581
467		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	582		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
468		return cret	583		return cret

M v4/adw/adw-spring-animation.go +170 -0


@@ -279,6 +279,176 @@ func (c *SpringAnimation) SetGoPointer(ptr uintptr) {
279	c.Ptr = ptr	279		c.Ptr = ptr
280	}	280		}
281		281
		282	+	// SetPropertyClamp sets the "clamp" property.
		283	+	// Whether the animation should be clamped.
		284	+	//
		285	+	// If set to `TRUE`, the animation will abruptly end as soon as it reaches the
		286	+	// final value, preventing overshooting.
		287	+	//
		288	+	// It won't prevent overshooting [property@SpringAnimation:value-from] if a
		289	+	// relative negative [property@SpringAnimation:initial-velocity] is set.
		290	+	func (x *SpringAnimation) SetPropertyClamp(value bool) {
		291	+	var v gobject.Value
		292	+	v.Init(gobject.TypeBooleanVal)
		293	+	v.SetBoolean(value)
		294	+	x.SetProperty("clamp", &v)
		295	+	}
		296	+
		297	+	// GetPropertyClamp gets the "clamp" property.
		298	+	// Whether the animation should be clamped.
		299	+	//
		300	+	// If set to `TRUE`, the animation will abruptly end as soon as it reaches the
		301	+	// final value, preventing overshooting.
		302	+	//
		303	+	// It won't prevent overshooting [property@SpringAnimation:value-from] if a
		304	+	// relative negative [property@SpringAnimation:initial-velocity] is set.
		305	+	func (x *SpringAnimation) GetPropertyClamp() bool {
		306	+	var v gobject.Value
		307	+	x.GetProperty("clamp", &v)
		308	+	return v.GetBoolean()
		309	+	}
		310	+
		311	+	// SetPropertyEpsilon sets the "epsilon" property.
		312	+	// Precision of the spring.
		313	+	//
		314	+	// The level of precision used to determine when the animation has come to a
		315	+	// rest, that is, when the amplitude of the oscillations becomes smaller than
		316	+	// this value.
		317	+	//
		318	+	// If the epsilon value is too small, the animation will take a long time to
		319	+	// stop after the animated value has stopped visibly changing.
		320	+	//
		321	+	// If the epsilon value is too large, the animation will end prematurely.
		322	+	//
		323	+	// The default value is 0.001.
		324	+	func (x *SpringAnimation) SetPropertyEpsilon(value float64) {
		325	+	var v gobject.Value
		326	+	v.Init(gobject.TypeDoubleVal)
		327	+	v.SetDouble(value)
		328	+	x.SetProperty("epsilon", &v)
		329	+	}
		330	+
		331	+	// GetPropertyEpsilon gets the "epsilon" property.
		332	+	// Precision of the spring.
		333	+	//
		334	+	// The level of precision used to determine when the animation has come to a
		335	+	// rest, that is, when the amplitude of the oscillations becomes smaller than
		336	+	// this value.
		337	+	//
		338	+	// If the epsilon value is too small, the animation will take a long time to
		339	+	// stop after the animated value has stopped visibly changing.
		340	+	//
		341	+	// If the epsilon value is too large, the animation will end prematurely.
		342	+	//
		343	+	// The default value is 0.001.
		344	+	func (x *SpringAnimation) GetPropertyEpsilon() float64 {
		345	+	var v gobject.Value
		346	+	x.GetProperty("epsilon", &v)
		347	+	return v.GetDouble()
		348	+	}
		349	+
		350	+	// GetPropertyEstimatedDuration gets the "estimated-duration" property.
		351	+	// Estimated duration of the animation, in milliseconds.
		352	+	//
		353	+	// Can be [const@DURATION_INFINITE] if the spring damping is set to 0.
		354	+	func (x *SpringAnimation) GetPropertyEstimatedDuration() uint {
		355	+	var v gobject.Value
		356	+	x.GetProperty("estimated-duration", &v)
		357	+	return v.GetUint()
		358	+	}
		359	+
		360	+	// SetPropertyInitialVelocity sets the "initial-velocity" property.
		361	+	// The initial velocity to start the animation with.
		362	+	//
		363	+	// Initial velocity affects only the animation curve, but not its duration.
		364	+	func (x *SpringAnimation) SetPropertyInitialVelocity(value float64) {
		365	+	var v gobject.Value
		366	+	v.Init(gobject.TypeDoubleVal)
		367	+	v.SetDouble(value)
		368	+	x.SetProperty("initial-velocity", &v)
		369	+	}
		370	+
		371	+	// GetPropertyInitialVelocity gets the "initial-velocity" property.
		372	+	// The initial velocity to start the animation with.
		373	+	//
		374	+	// Initial velocity affects only the animation curve, but not its duration.
		375	+	func (x *SpringAnimation) GetPropertyInitialVelocity() float64 {
		376	+	var v gobject.Value
		377	+	x.GetProperty("initial-velocity", &v)
		378	+	return v.GetDouble()
		379	+	}
		380	+
		381	+	// SetPropertySpringParams sets the "spring-params" property.
		382	+	// Physical parameters describing the spring.
		383	+	func (x *SpringAnimation) SetPropertySpringParams(value uintptr) {
		384	+	var v gobject.Value
		385	+	v.Init(gobject.TypePointerVal)
		386	+	v.SetPointer(value)
		387	+	x.SetProperty("spring-params", &v)
		388	+	}
		389	+
		390	+	// GetPropertySpringParams gets the "spring-params" property.
		391	+	// Physical parameters describing the spring.
		392	+	func (x *SpringAnimation) GetPropertySpringParams() uintptr {
		393	+	var v gobject.Value
		394	+	x.GetProperty("spring-params", &v)
		395	+	return v.GetPointer()
		396	+	}
		397	+
		398	+	// SetPropertyValueFrom sets the "value-from" property.
		399	+	// The value to animate from.
		400	+	//
		401	+	// The animation will start at this value and end at
		402	+	// [property@SpringAnimation:value-to].
		403	+	func (x *SpringAnimation) SetPropertyValueFrom(value float64) {
		404	+	var v gobject.Value
		405	+	v.Init(gobject.TypeDoubleVal)
		406	+	v.SetDouble(value)
		407	+	x.SetProperty("value-from", &v)
		408	+	}
		409	+
		410	+	// GetPropertyValueFrom gets the "value-from" property.
		411	+	// The value to animate from.
		412	+	//
		413	+	// The animation will start at this value and end at
		414	+	// [property@SpringAnimation:value-to].
		415	+	func (x *SpringAnimation) GetPropertyValueFrom() float64 {
		416	+	var v gobject.Value
		417	+	x.GetProperty("value-from", &v)
		418	+	return v.GetDouble()
		419	+	}
		420	+
		421	+	// SetPropertyValueTo sets the "value-to" property.
		422	+	// The value to animate to.
		423	+	//
		424	+	// The animation will start at [property@SpringAnimation:value-from] and end
		425	+	// at this value.
		426	+	func (x *SpringAnimation) SetPropertyValueTo(value float64) {
		427	+	var v gobject.Value
		428	+	v.Init(gobject.TypeDoubleVal)
		429	+	v.SetDouble(value)
		430	+	x.SetProperty("value-to", &v)
		431	+	}
		432	+
		433	+	// GetPropertyValueTo gets the "value-to" property.
		434	+	// The value to animate to.
		435	+	//
		436	+	// The animation will start at [property@SpringAnimation:value-from] and end
		437	+	// at this value.
		438	+	func (x *SpringAnimation) GetPropertyValueTo() float64 {
		439	+	var v gobject.Value
		440	+	x.GetProperty("value-to", &v)
		441	+	return v.GetDouble()
		442	+	}
		443	+
		444	+	// GetPropertyVelocity gets the "velocity" property.
		445	+	// Current velocity of the animation.
		446	+	func (x *SpringAnimation) GetPropertyVelocity() float64 {
		447	+	var v gobject.Value
		448	+	x.GetProperty("velocity", &v)
		449	+	return v.GetDouble()
		450	+	}
		451	+
282	func init() {	452		func init() {
283	core.SetPackageName("ADW", "libadwaita-1")	453		core.SetPackageName("ADW", "libadwaita-1")
284	core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})	454		core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})

M v4/adw/adw-squeezer.go +200 -1


@@ -389,6 +389,170 @@ func (c *Squeezer) SetGoPointer(ptr uintptr) {
389		c.Ptr = ptr	389		c.Ptr = ptr
390		}	390		}
391			391
			392	+	// SetPropertyAllowNone sets the "allow-none" property.
			393	+	// Whether to allow squeezing beyond the last child's minimum size.
			394	+	//
			395	+	// If set to `TRUE`, the squeezer can shrink to the point where no child can
			396	+	// be shown. This is functionally equivalent to appending a widget with 0×0
			397	+	// minimum size.
			398	+	func (x *Squeezer) SetPropertyAllowNone(value bool) {
			399	+	var v gobject.Value
			400	+	v.Init(gobject.TypeBooleanVal)
			401	+	v.SetBoolean(value)
			402	+	x.SetProperty("allow-none", &v)
			403	+	}
			404	+
			405	+	// GetPropertyAllowNone gets the "allow-none" property.
			406	+	// Whether to allow squeezing beyond the last child's minimum size.
			407	+	//
			408	+	// If set to `TRUE`, the squeezer can shrink to the point where no child can
			409	+	// be shown. This is functionally equivalent to appending a widget with 0×0
			410	+	// minimum size.
			411	+	func (x *Squeezer) GetPropertyAllowNone() bool {
			412	+	var v gobject.Value
			413	+	x.GetProperty("allow-none", &v)
			414	+	return v.GetBoolean()
			415	+	}
			416	+
			417	+	// SetPropertyHomogeneous sets the "homogeneous" property.
			418	+	// Whether all children have the same size for the opposite orientation.
			419	+	//
			420	+	// For example, if a squeezer is horizontal and is homogeneous, it will
			421	+	// request the same height for all its children. If it isn't, the squeezer may
			422	+	// change size when a different child becomes visible.
			423	+	func (x *Squeezer) SetPropertyHomogeneous(value bool) {
			424	+	var v gobject.Value
			425	+	v.Init(gobject.TypeBooleanVal)
			426	+	v.SetBoolean(value)
			427	+	x.SetProperty("homogeneous", &v)
			428	+	}
			429	+
			430	+	// GetPropertyHomogeneous gets the "homogeneous" property.
			431	+	// Whether all children have the same size for the opposite orientation.
			432	+	//
			433	+	// For example, if a squeezer is horizontal and is homogeneous, it will
			434	+	// request the same height for all its children. If it isn't, the squeezer may
			435	+	// change size when a different child becomes visible.
			436	+	func (x *Squeezer) GetPropertyHomogeneous() bool {
			437	+	var v gobject.Value
			438	+	x.GetProperty("homogeneous", &v)
			439	+	return v.GetBoolean()
			440	+	}
			441	+
			442	+	// SetPropertyInterpolateSize sets the "interpolate-size" property.
			443	+	// Whether the squeezer interpolates its size when changing the visible child.
			444	+	//
			445	+	// If `TRUE`, the squeezer will interpolate its size between the one of the
			446	+	// previous visible child and the one of the new visible child, according to
			447	+	// the set transition duration and the orientation, e.g. if the squeezer is
			448	+	// horizontal, it will interpolate the its height.
			449	+	func (x *Squeezer) SetPropertyInterpolateSize(value bool) {
			450	+	var v gobject.Value
			451	+	v.Init(gobject.TypeBooleanVal)
			452	+	v.SetBoolean(value)
			453	+	x.SetProperty("interpolate-size", &v)
			454	+	}
			455	+
			456	+	// GetPropertyInterpolateSize gets the "interpolate-size" property.
			457	+	// Whether the squeezer interpolates its size when changing the visible child.
			458	+	//
			459	+	// If `TRUE`, the squeezer will interpolate its size between the one of the
			460	+	// previous visible child and the one of the new visible child, according to
			461	+	// the set transition duration and the orientation, e.g. if the squeezer is
			462	+	// horizontal, it will interpolate the its height.
			463	+	func (x *Squeezer) GetPropertyInterpolateSize() bool {
			464	+	var v gobject.Value
			465	+	x.GetProperty("interpolate-size", &v)
			466	+	return v.GetBoolean()
			467	+	}
			468	+
			469	+	// SetPropertyTransitionDuration sets the "transition-duration" property.
			470	+	// The transition animation duration, in milliseconds.
			471	+	func (x *Squeezer) SetPropertyTransitionDuration(value uint) {
			472	+	var v gobject.Value
			473	+	v.Init(gobject.TypeUintVal)
			474	+	v.SetUint(value)
			475	+	x.SetProperty("transition-duration", &v)
			476	+	}
			477	+
			478	+	// GetPropertyTransitionDuration gets the "transition-duration" property.
			479	+	// The transition animation duration, in milliseconds.
			480	+	func (x *Squeezer) GetPropertyTransitionDuration() uint {
			481	+	var v gobject.Value
			482	+	x.GetProperty("transition-duration", &v)
			483	+	return v.GetUint()
			484	+	}
			485	+
			486	+	// GetPropertyTransitionRunning gets the "transition-running" property.
			487	+	// Whether a transition is currently running.
			488	+	//
			489	+	// If a transition is impossible, the property value will be set to `TRUE` and
			490	+	// then immediately to `FALSE`, so it's possible to rely on its notifications
			491	+	// to know that a transition has happened.
			492	+	func (x *Squeezer) GetPropertyTransitionRunning() bool {
			493	+	var v gobject.Value
			494	+	x.GetProperty("transition-running", &v)
			495	+	return v.GetBoolean()
			496	+	}
			497	+
			498	+	// SetPropertyXalign sets the "xalign" property.
			499	+	// The horizontal alignment, from 0 (start) to 1 (end).
			500	+	//
			501	+	// This affects the children allocation during transitions, when they exceed
			502	+	// the size of the squeezer.
			503	+	//
			504	+	// For example, 0.5 means the child will be centered, 0 means it will keep the
			505	+	// start side aligned and overflow the end side, and 1 means the opposite.
			506	+	func (x *Squeezer) SetPropertyXalign(value float32) {
			507	+	var v gobject.Value
			508	+	v.Init(gobject.TypeFloatVal)
			509	+	v.SetFloat(value)
			510	+	x.SetProperty("xalign", &v)
			511	+	}
			512	+
			513	+	// GetPropertyXalign gets the "xalign" property.
			514	+	// The horizontal alignment, from 0 (start) to 1 (end).
			515	+	//
			516	+	// This affects the children allocation during transitions, when they exceed
			517	+	// the size of the squeezer.
			518	+	//
			519	+	// For example, 0.5 means the child will be centered, 0 means it will keep the
			520	+	// start side aligned and overflow the end side, and 1 means the opposite.
			521	+	func (x *Squeezer) GetPropertyXalign() float32 {
			522	+	var v gobject.Value
			523	+	x.GetProperty("xalign", &v)
			524	+	return v.GetFloat()
			525	+	}
			526	+
			527	+	// SetPropertyYalign sets the "yalign" property.
			528	+	// The vertical alignment, from 0 (top) to 1 (bottom).
			529	+	//
			530	+	// This affects the children allocation during transitions, when they exceed
			531	+	// the size of the squeezer.
			532	+	//
			533	+	// For example, 0.5 means the child will be centered, 0 means it will keep the
			534	+	// top side aligned and overflow the bottom side, and 1 means the opposite.
			535	+	func (x *Squeezer) SetPropertyYalign(value float32) {
			536	+	var v gobject.Value
			537	+	v.Init(gobject.TypeFloatVal)
			538	+	v.SetFloat(value)
			539	+	x.SetProperty("yalign", &v)
			540	+	}
			541	+
			542	+	// GetPropertyYalign gets the "yalign" property.
			543	+	// The vertical alignment, from 0 (top) to 1 (bottom).
			544	+	//
			545	+	// This affects the children allocation during transitions, when they exceed
			546	+	// the size of the squeezer.
			547	+	//
			548	+	// For example, 0.5 means the child will be centered, 0 means it will keep the
			549	+	// top side aligned and overflow the bottom side, and 1 means the opposite.
			550	+	func (x *Squeezer) GetPropertyYalign() float32 {
			551	+	var v gobject.Value
			552	+	x.GetProperty("yalign", &v)
			553	+	return v.GetFloat()
			554	+	}
			555	+
392		// Requests the user's screen reader to announce the given message.	556		// Requests the user's screen reader to announce the given message.
393		//	557		//
394		// This kind of notification is useful for messages that	558		// This kind of notification is useful for messages that

@@ -446,7 +610,7 @@ func (x Squeezer) GetAtContext() gtk.ATContext {
446		// This functionality can be overridden by `GtkAccessible`	610		// This functionality can be overridden by `GtkAccessible`
447		// implementations, e.g. to get the bounds from an ignored	611		// implementations, e.g. to get the bounds from an ignored
448		// child widget.	612		// child widget.
449	-	func (x *Squeezer) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	613	+	func (x Squeezer) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
450			614
451		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	615		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
452		return cret	616		return cret

@@ -753,6 +917,41 @@ func (c *SqueezerPage) SetGoPointer(ptr uintptr) {
753		c.Ptr = ptr	917		c.Ptr = ptr
754		}	918		}
755			919
			920	+	// SetPropertyEnabled sets the "enabled" property.
			921	+	// Whether the child is enabled.
			922	+	//
			923	+	// If a child is disabled, it will be ignored when looking for the child
			924	+	// fitting the available size best.
			925	+	//
			926	+	// This allows to programmatically and prematurely hide a child even if it
			927	+	// fits in the available space.
			928	+	//
			929	+	// This can be used e.g. to ensure a certain child is hidden below a certain
			930	+	// window width, or any other constraint you find suitable.
			931	+	func (x *SqueezerPage) SetPropertyEnabled(value bool) {
			932	+	var v gobject.Value
			933	+	v.Init(gobject.TypeBooleanVal)
			934	+	v.SetBoolean(value)
			935	+	x.SetProperty("enabled", &v)
			936	+	}
			937	+
			938	+	// GetPropertyEnabled gets the "enabled" property.
			939	+	// Whether the child is enabled.
			940	+	//
			941	+	// If a child is disabled, it will be ignored when looking for the child
			942	+	// fitting the available size best.
			943	+	//
			944	+	// This allows to programmatically and prematurely hide a child even if it
			945	+	// fits in the available space.
			946	+	//
			947	+	// This can be used e.g. to ensure a certain child is hidden below a certain
			948	+	// window width, or any other constraint you find suitable.
			949	+	func (x *SqueezerPage) GetPropertyEnabled() bool {
			950	+	var v gobject.Value
			951	+	x.GetProperty("enabled", &v)
			952	+	return v.GetBoolean()
			953	+	}
			954	+
756		func init() {	955		func init() {
757		core.SetPackageName("ADW", "libadwaita-1")	956		core.SetPackageName("ADW", "libadwaita-1")
758		core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})	957		core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})

M v4/adw/adw-status-page.go +60 -1


@@ -214,6 +214,65 @@ func (c *StatusPage) SetGoPointer(ptr uintptr) {
214		c.Ptr = ptr	214		c.Ptr = ptr
215		}	215		}
216			216
			217	+	// SetPropertyDescription sets the "description" property.
			218	+	// The description markup to be displayed below the title.
			219	+	func (x *StatusPage) SetPropertyDescription(value string) {
			220	+	var v gobject.Value
			221	+	v.Init(gobject.TypeStringVal)
			222	+	v.SetString(value)
			223	+	x.SetProperty("description", &v)
			224	+	}
			225	+
			226	+	// GetPropertyDescription gets the "description" property.
			227	+	// The description markup to be displayed below the title.
			228	+	func (x *StatusPage) GetPropertyDescription() string {
			229	+	var v gobject.Value
			230	+	x.GetProperty("description", &v)
			231	+	return v.GetString()
			232	+	}
			233	+
			234	+	// SetPropertyIconName sets the "icon-name" property.
			235	+	// The name of the icon to be used.
			236	+	//
			237	+	// Changing this will set [property@StatusPage:paintable] to `NULL`.
			238	+	func (x *StatusPage) SetPropertyIconName(value string) {
			239	+	var v gobject.Value
			240	+	v.Init(gobject.TypeStringVal)
			241	+	v.SetString(value)
			242	+	x.SetProperty("icon-name", &v)
			243	+	}
			244	+
			245	+	// GetPropertyIconName gets the "icon-name" property.
			246	+	// The name of the icon to be used.
			247	+	//
			248	+	// Changing this will set [property@StatusPage:paintable] to `NULL`.
			249	+	func (x *StatusPage) GetPropertyIconName() string {
			250	+	var v gobject.Value
			251	+	x.GetProperty("icon-name", &v)
			252	+	return v.GetString()
			253	+	}
			254	+
			255	+	// SetPropertyTitle sets the "title" property.
			256	+	// The title to be displayed below the icon.
			257	+	//
			258	+	// It is not parsed as Pango markup.
			259	+	func (x *StatusPage) SetPropertyTitle(value string) {
			260	+	var v gobject.Value
			261	+	v.Init(gobject.TypeStringVal)
			262	+	v.SetString(value)
			263	+	x.SetProperty("title", &v)
			264	+	}
			265	+
			266	+	// GetPropertyTitle gets the "title" property.
			267	+	// The title to be displayed below the icon.
			268	+	//
			269	+	// It is not parsed as Pango markup.
			270	+	func (x *StatusPage) GetPropertyTitle() string {
			271	+	var v gobject.Value
			272	+	x.GetProperty("title", &v)
			273	+	return v.GetString()
			274	+	}
			275	+
217		// Requests the user's screen reader to announce the given message.	276		// Requests the user's screen reader to announce the given message.
218		//	277		//
219		// This kind of notification is useful for messages that	278		// This kind of notification is useful for messages that

@@ -271,7 +330,7 @@ func (x StatusPage) GetAtContext() gtk.ATContext {
271		// This functionality can be overridden by `GtkAccessible`	330		// This functionality can be overridden by `GtkAccessible`
272		// implementations, e.g. to get the bounds from an ignored	331		// implementations, e.g. to get the bounds from an ignored
273		// child widget.	332		// child widget.
274	-	func (x *StatusPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	333	+	func (x StatusPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
275			334
276		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	335		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
277		return cret	336		return cret

M v4/adw/adw-style-manager.go +88 -0


@@ -258,6 +258,94 @@ func (c *StyleManager) SetGoPointer(ptr uintptr) {
258	c.Ptr = ptr	258		c.Ptr = ptr
259	}	259		}
260		260
		261	+	// GetPropertyAccentColorRgba gets the "accent-color-rgba" property.
		262	+	// The current system accent color as a `GdkRGBA`.
		263	+	//
		264	+	// Equivalent to calling [func@AccentColor.to_rgba] on the value of
		265	+	// [property@StyleManager:accent-color].
		266	+	//
		267	+	// This is a background color. The matching foreground color is white.
		268	+	func (x *StyleManager) GetPropertyAccentColorRgba() uintptr {
		269	+	var v gobject.Value
		270	+	x.GetProperty("accent-color-rgba", &v)
		271	+	return v.GetPointer()
		272	+	}
		273	+
		274	+	// GetPropertyDark gets the "dark" property.
		275	+	// Whether the application is using dark appearance.
		276	+	//
		277	+	// This property can be used to query the current appearance, as requested via
		278	+	// [property@StyleManager:color-scheme].
		279	+	func (x *StyleManager) GetPropertyDark() bool {
		280	+	var v gobject.Value
		281	+	x.GetProperty("dark", &v)
		282	+	return v.GetBoolean()
		283	+	}
		284	+
		285	+	// GetPropertyDocumentFontName gets the "document-font-name" property.
		286	+	// The system document font.
		287	+	//
		288	+	// The font is in the same format as [property@Gtk.Settings:gtk-font-name],
		289	+	// e.g. "Adwaita Sans 12".
		290	+	//
		291	+	// Use [func@Pango.FontDescription.from_string] to parse it.
		292	+	func (x *StyleManager) GetPropertyDocumentFontName() string {
		293	+	var v gobject.Value
		294	+	x.GetProperty("document-font-name", &v)
		295	+	return v.GetString()
		296	+	}
		297	+
		298	+	// GetPropertyHighContrast gets the "high-contrast" property.
		299	+	// Whether the application is using high contrast appearance.
		300	+	//
		301	+	// This cannot be overridden by applications.
		302	+	func (x *StyleManager) GetPropertyHighContrast() bool {
		303	+	var v gobject.Value
		304	+	x.GetProperty("high-contrast", &v)
		305	+	return v.GetBoolean()
		306	+	}
		307	+
		308	+	// GetPropertyMonospaceFontName gets the "monospace-font-name" property.
		309	+	// The system monospace font.
		310	+	//
		311	+	// The font is in the same format as [property@Gtk.Settings:gtk-font-name],
		312	+	// e.g. "Adwaita Mono 11".
		313	+	//
		314	+	// Use [func@Pango.FontDescription.from_string] to parse it.
		315	+	func (x *StyleManager) GetPropertyMonospaceFontName() string {
		316	+	var v gobject.Value
		317	+	x.GetProperty("monospace-font-name", &v)
		318	+	return v.GetString()
		319	+	}
		320	+
		321	+	// GetPropertySystemSupportsAccentColors gets the "system-supports-accent-colors" property.
		322	+	// Whether the system supports accent colors.
		323	+	//
		324	+	// This property can be used to check if the current environment provides an
		325	+	// accent color preference. For example, applications might want to show a
		326	+	// preference for choosing accent color if it's set to `FALSE`.
		327	+	//
		328	+	// See [property@StyleManager:accent-color].
		329	+	func (x *StyleManager) GetPropertySystemSupportsAccentColors() bool {
		330	+	var v gobject.Value
		331	+	x.GetProperty("system-supports-accent-colors", &v)
		332	+	return v.GetBoolean()
		333	+	}
		334	+
		335	+	// GetPropertySystemSupportsColorSchemes gets the "system-supports-color-schemes" property.
		336	+	// Whether the system supports color schemes.
		337	+	//
		338	+	// This property can be used to check if the current environment provides a
		339	+	// color scheme preference. For example, applications might want to show a
		340	+	// separate appearance switcher if it's set to `FALSE`.
		341	+	//
		342	+	// See [property@StyleManager:color-scheme].
		343	+	func (x *StyleManager) GetPropertySystemSupportsColorSchemes() bool {
		344	+	var v gobject.Value
		345	+	x.GetProperty("system-supports-color-schemes", &v)
		346	+	return v.GetBoolean()
		347	+	}
		348	+
261	var xStyleManagerGetDefault func() uintptr	349		var xStyleManagerGetDefault func() uintptr
262		350
263	// Gets the default `AdwStyleManager` instance.	351		// Gets the default `AdwStyleManager` instance.

M v4/adw/adw-swipe-tracker.go +141 -0


@@ -243,6 +243,147 @@ func (c *SwipeTracker) SetGoPointer(ptr uintptr) {
243	c.Ptr = ptr	243		c.Ptr = ptr
244	}	244		}
245		245
		246	+	// SetPropertyAllowLongSwipes sets the "allow-long-swipes" property.
		247	+	// Whether to allow swiping for more than one snap point at a time.
		248	+	//
		249	+	// If the value is `FALSE`, each swipe can only move to the adjacent snap
		250	+	// points.
		251	+	func (x *SwipeTracker) SetPropertyAllowLongSwipes(value bool) {
		252	+	var v gobject.Value
		253	+	v.Init(gobject.TypeBooleanVal)
		254	+	v.SetBoolean(value)
		255	+	x.SetProperty("allow-long-swipes", &v)
		256	+	}
		257	+
		258	+	// GetPropertyAllowLongSwipes gets the "allow-long-swipes" property.
		259	+	// Whether to allow swiping for more than one snap point at a time.
		260	+	//
		261	+	// If the value is `FALSE`, each swipe can only move to the adjacent snap
		262	+	// points.
		263	+	func (x *SwipeTracker) GetPropertyAllowLongSwipes() bool {
		264	+	var v gobject.Value
		265	+	x.GetProperty("allow-long-swipes", &v)
		266	+	return v.GetBoolean()
		267	+	}
		268	+
		269	+	// SetPropertyAllowMouseDrag sets the "allow-mouse-drag" property.
		270	+	// Whether to allow dragging with mouse pointer.
		271	+	func (x *SwipeTracker) SetPropertyAllowMouseDrag(value bool) {
		272	+	var v gobject.Value
		273	+	v.Init(gobject.TypeBooleanVal)
		274	+	v.SetBoolean(value)
		275	+	x.SetProperty("allow-mouse-drag", &v)
		276	+	}
		277	+
		278	+	// GetPropertyAllowMouseDrag gets the "allow-mouse-drag" property.
		279	+	// Whether to allow dragging with mouse pointer.
		280	+	func (x *SwipeTracker) GetPropertyAllowMouseDrag() bool {
		281	+	var v gobject.Value
		282	+	x.GetProperty("allow-mouse-drag", &v)
		283	+	return v.GetBoolean()
		284	+	}
		285	+
		286	+	// SetPropertyAllowWindowHandle sets the "allow-window-handle" property.
		287	+	// Whether to allow touchscreen swiping from `GtkWindowHandle`.
		288	+	//
		289	+	// This will make dragging the window impossible.
		290	+	func (x *SwipeTracker) SetPropertyAllowWindowHandle(value bool) {
		291	+	var v gobject.Value
		292	+	v.Init(gobject.TypeBooleanVal)
		293	+	v.SetBoolean(value)
		294	+	x.SetProperty("allow-window-handle", &v)
		295	+	}
		296	+
		297	+	// GetPropertyAllowWindowHandle gets the "allow-window-handle" property.
		298	+	// Whether to allow touchscreen swiping from `GtkWindowHandle`.
		299	+	//
		300	+	// This will make dragging the window impossible.
		301	+	func (x *SwipeTracker) GetPropertyAllowWindowHandle() bool {
		302	+	var v gobject.Value
		303	+	x.GetProperty("allow-window-handle", &v)
		304	+	return v.GetBoolean()
		305	+	}
		306	+
		307	+	// SetPropertyEnabled sets the "enabled" property.
		308	+	// Whether the swipe tracker is enabled.
		309	+	//
		310	+	// When it's not enabled, no events will be processed. Usually widgets will
		311	+	// want to expose this via a property.
		312	+	func (x *SwipeTracker) SetPropertyEnabled(value bool) {
		313	+	var v gobject.Value
		314	+	v.Init(gobject.TypeBooleanVal)
		315	+	v.SetBoolean(value)
		316	+	x.SetProperty("enabled", &v)
		317	+	}
		318	+
		319	+	// GetPropertyEnabled gets the "enabled" property.
		320	+	// Whether the swipe tracker is enabled.
		321	+	//
		322	+	// When it's not enabled, no events will be processed. Usually widgets will
		323	+	// want to expose this via a property.
		324	+	func (x *SwipeTracker) GetPropertyEnabled() bool {
		325	+	var v gobject.Value
		326	+	x.GetProperty("enabled", &v)
		327	+	return v.GetBoolean()
		328	+	}
		329	+
		330	+	// SetPropertyLowerOvershoot sets the "lower-overshoot" property.
		331	+	// Whether to allow swiping past the first available snap point.
		332	+	func (x *SwipeTracker) SetPropertyLowerOvershoot(value bool) {
		333	+	var v gobject.Value
		334	+	v.Init(gobject.TypeBooleanVal)
		335	+	v.SetBoolean(value)
		336	+	x.SetProperty("lower-overshoot", &v)
		337	+	}
		338	+
		339	+	// GetPropertyLowerOvershoot gets the "lower-overshoot" property.
		340	+	// Whether to allow swiping past the first available snap point.
		341	+	func (x *SwipeTracker) GetPropertyLowerOvershoot() bool {
		342	+	var v gobject.Value
		343	+	x.GetProperty("lower-overshoot", &v)
		344	+	return v.GetBoolean()
		345	+	}
		346	+
		347	+	// SetPropertyReversed sets the "reversed" property.
		348	+	// Whether to reverse the swipe direction.
		349	+	//
		350	+	// If the swipe tracker is horizontal, it can be used for supporting RTL text
		351	+	// direction.
		352	+	func (x *SwipeTracker) SetPropertyReversed(value bool) {
		353	+	var v gobject.Value
		354	+	v.Init(gobject.TypeBooleanVal)
		355	+	v.SetBoolean(value)
		356	+	x.SetProperty("reversed", &v)
		357	+	}
		358	+
		359	+	// GetPropertyReversed gets the "reversed" property.
		360	+	// Whether to reverse the swipe direction.
		361	+	//
		362	+	// If the swipe tracker is horizontal, it can be used for supporting RTL text
		363	+	// direction.
		364	+	func (x *SwipeTracker) GetPropertyReversed() bool {
		365	+	var v gobject.Value
		366	+	x.GetProperty("reversed", &v)
		367	+	return v.GetBoolean()
		368	+	}
		369	+
		370	+	// SetPropertyUpperOvershoot sets the "upper-overshoot" property.
		371	+	// Whether to allow swiping past the last available snap point.
		372	+	func (x *SwipeTracker) SetPropertyUpperOvershoot(value bool) {
		373	+	var v gobject.Value
		374	+	v.Init(gobject.TypeBooleanVal)
		375	+	v.SetBoolean(value)
		376	+	x.SetProperty("upper-overshoot", &v)
		377	+	}
		378	+
		379	+	// GetPropertyUpperOvershoot gets the "upper-overshoot" property.
		380	+	// Whether to allow swiping past the last available snap point.
		381	+	func (x *SwipeTracker) GetPropertyUpperOvershoot() bool {
		382	+	var v gobject.Value
		383	+	x.GetProperty("upper-overshoot", &v)
		384	+	return v.GetBoolean()
		385	+	}
		386	+
246	// This signal is emitted right before a swipe will be started, after the	387		// This signal is emitted right before a swipe will be started, after the
247	// drag threshold has been passed.	388		// drag threshold has been passed.
248	func (x SwipeTracker) ConnectBeginSwipe(cb func(SwipeTracker)) uint32 {	389		func (x SwipeTracker) ConnectBeginSwipe(cb func(SwipeTracker)) uint32 {

M v4/adw/adw-swipeable.go +18 -18


@@ -34,7 +34,7 @@ func (x *SwipeableInterface) GoPointer() uintptr {
34		return uintptr(unsafe.Pointer(x))	34		return uintptr(unsafe.Pointer(x))
35		}	35		}
36			36
37	-	// OverrideGetDistance sets the callback function.	37	+	// OverrideGetDistance sets the "get_distance" callback function.
38		// Gets the swipe distance.	38		// Gets the swipe distance.
39		func (x *SwipeableInterface) OverrideGetDistance(cb func(Swipeable) float64) {	39		func (x *SwipeableInterface) OverrideGetDistance(cb func(Swipeable) float64) {
40		if cb == nil {	40		if cb == nil {

@@ -46,7 +46,7 @@ func (x *SwipeableInterface) OverrideGetDistance(cb func(Swipeable) float64) {
46		}	46		}
47		}	47		}
48			48
49	-	// GetGetDistance gets the callback function.	49	+	// GetGetDistance gets the "get_distance" callback function.
50		// Gets the swipe distance.	50		// Gets the swipe distance.
51		func (x *SwipeableInterface) GetGetDistance() func(Swipeable) float64 {	51		func (x *SwipeableInterface) GetGetDistance() func(Swipeable) float64 {
52		if x.xGetDistance == 0 {	52		if x.xGetDistance == 0 {

@@ -59,32 +59,32 @@ func (x *SwipeableInterface) GetGetDistance() func(Swipeable) float64 {
59		}	59		}
60		}	60		}
61			61
62	-	// OverrideGetSnapPoints sets the callback function.	62	+	// OverrideGetSnapPoints sets the "get_snap_points" callback function.
63		// Gets the snap points.	63		// Gets the snap points.
64	-	func (x *SwipeableInterface) OverrideGetSnapPoints(cb func(Swipeable, int) uintptr) {	64	+	func (x SwipeableInterface) OverrideGetSnapPoints(cb func(Swipeable, int) uintptr) {
65		if cb == nil {	65		if cb == nil {
66		x.xGetSnapPoints = 0	66		x.xGetSnapPoints = 0
67		} else {	67		} else {
68	-	x.xGetSnapPoints = purego.NewCallback(func(SelfVarp uintptr, NSnapPointsVarp int) uintptr {	68	+	x.xGetSnapPoints = purego.NewCallback(func(SelfVarp uintptr, NSnapPointsVarp *int) uintptr {
69		return cb(&SwipeableBase{Ptr: SelfVarp}, NSnapPointsVarp)	69		return cb(&SwipeableBase{Ptr: SelfVarp}, NSnapPointsVarp)
70		})	70		})
71		}	71		}
72		}	72		}
73			73
74	-	// GetGetSnapPoints gets the callback function.	74	+	// GetGetSnapPoints gets the "get_snap_points" callback function.
75		// Gets the snap points.	75		// Gets the snap points.
76	-	func (x *SwipeableInterface) GetGetSnapPoints() func(Swipeable, int) uintptr {	76	+	func (x SwipeableInterface) GetGetSnapPoints() func(Swipeable, int) uintptr {
77		if x.xGetSnapPoints == 0 {	77		if x.xGetSnapPoints == 0 {
78		return nil	78		return nil
79		}	79		}
80	-	var rawCallback func(SelfVarp uintptr, NSnapPointsVarp int) uintptr	80	+	var rawCallback func(SelfVarp uintptr, NSnapPointsVarp *int) uintptr
81		purego.RegisterFunc(&rawCallback, x.xGetSnapPoints)	81		purego.RegisterFunc(&rawCallback, x.xGetSnapPoints)
82	-	return func(SelfVar Swipeable, NSnapPointsVar int) uintptr {	82	+	return func(SelfVar Swipeable, NSnapPointsVar *int) uintptr {
83		return rawCallback(SelfVar.GoPointer(), NSnapPointsVar)	83		return rawCallback(SelfVar.GoPointer(), NSnapPointsVar)
84		}	84		}
85		}	85		}
86			86
87	-	// OverrideGetProgress sets the callback function.	87	+	// OverrideGetProgress sets the "get_progress" callback function.
88		// Gets the current progress.	88		// Gets the current progress.
89		func (x *SwipeableInterface) OverrideGetProgress(cb func(Swipeable) float64) {	89		func (x *SwipeableInterface) OverrideGetProgress(cb func(Swipeable) float64) {
90		if cb == nil {	90		if cb == nil {

@@ -96,7 +96,7 @@ func (x *SwipeableInterface) OverrideGetProgress(cb func(Swipeable) float64) {
96		}	96		}
97		}	97		}
98			98
99	-	// GetGetProgress gets the callback function.	99	+	// GetGetProgress gets the "get_progress" callback function.
100		// Gets the current progress.	100		// Gets the current progress.
101		func (x *SwipeableInterface) GetGetProgress() func(Swipeable) float64 {	101		func (x *SwipeableInterface) GetGetProgress() func(Swipeable) float64 {
102		if x.xGetProgress == 0 {	102		if x.xGetProgress == 0 {

@@ -109,7 +109,7 @@ func (x *SwipeableInterface) GetGetProgress() func(Swipeable) float64 {
109		}	109		}
110		}	110		}
111			111
112	-	// OverrideGetCancelProgress sets the callback function.	112	+	// OverrideGetCancelProgress sets the "get_cancel_progress" callback function.
113		// Gets the cancel progress.	113		// Gets the cancel progress.
114		func (x *SwipeableInterface) OverrideGetCancelProgress(cb func(Swipeable) float64) {	114		func (x *SwipeableInterface) OverrideGetCancelProgress(cb func(Swipeable) float64) {
115		if cb == nil {	115		if cb == nil {

@@ -121,7 +121,7 @@ func (x *SwipeableInterface) OverrideGetCancelProgress(cb func(Swipeable) float6
121		}	121		}
122		}	122		}
123			123
124	-	// GetGetCancelProgress gets the callback function.	124	+	// GetGetCancelProgress gets the "get_cancel_progress" callback function.
125		// Gets the cancel progress.	125		// Gets the cancel progress.
126		func (x *SwipeableInterface) GetGetCancelProgress() func(Swipeable) float64 {	126		func (x *SwipeableInterface) GetGetCancelProgress() func(Swipeable) float64 {
127		if x.xGetCancelProgress == 0 {	127		if x.xGetCancelProgress == 0 {

@@ -134,7 +134,7 @@ func (x *SwipeableInterface) GetGetCancelProgress() func(Swipeable) float64 {
134		}	134		}
135		}	135		}
136			136
137	-	// OverrideGetSwipeArea sets the callback function.	137	+	// OverrideGetSwipeArea sets the "get_swipe_area" callback function.
138		// Gets the swipeable rectangle.	138		// Gets the swipeable rectangle.
139		func (x SwipeableInterface) OverrideGetSwipeArea(cb func(Swipeable, NavigationDirection, bool, gdk.Rectangle)) {	139		func (x SwipeableInterface) OverrideGetSwipeArea(cb func(Swipeable, NavigationDirection, bool, gdk.Rectangle)) {
140		if cb == nil {	140		if cb == nil {

@@ -146,7 +146,7 @@ func (x *SwipeableInterface) OverrideGetSwipeArea(cb func(Swipeable, NavigationD
146		}	146		}
147		}	147		}
148			148
149	-	// GetGetSwipeArea gets the callback function.	149	+	// GetGetSwipeArea gets the "get_swipe_area" callback function.
150		// Gets the swipeable rectangle.	150		// Gets the swipeable rectangle.
151		func (x SwipeableInterface) GetGetSwipeArea() func(Swipeable, NavigationDirection, bool, gdk.Rectangle) {	151		func (x SwipeableInterface) GetGetSwipeArea() func(Swipeable, NavigationDirection, bool, gdk.Rectangle) {
152		if x.xGetSwipeArea == 0 {	152		if x.xGetSwipeArea == 0 {

@@ -170,7 +170,7 @@ type Swipeable interface {
170		GetCancelProgress() float64	170		GetCancelProgress() float64
171		GetDistance() float64	171		GetDistance() float64
172		GetProgress() float64	172		GetProgress() float64
173	-	GetSnapPoints(NSnapPointsVar int) uintptr	173	+	GetSnapPoints(NSnapPointsVar *int) uintptr
174		GetSwipeArea(NavigationDirectionVar NavigationDirection, IsDragVar bool, RectVar *gdk.Rectangle)	174		GetSwipeArea(NavigationDirectionVar NavigationDirection, IsDragVar bool, RectVar *gdk.Rectangle)
175		}	175		}
176			176

@@ -222,7 +222,7 @@ func (x *SwipeableBase) GetProgress() float64 {
222		//	222		//
223		// Each snap point represents a progress value that is considered acceptable to	223		// Each snap point represents a progress value that is considered acceptable to
224		// end the swipe on.	224		// end the swipe on.
225	-	func (x *SwipeableBase) GetSnapPoints(NSnapPointsVar int) uintptr {	225	+	func (x SwipeableBase) GetSnapPoints(NSnapPointsVar int) uintptr {
226			226
227		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)	227		cret := XAdwSwipeableGetSnapPoints(x.GoPointer(), NSnapPointsVar)
228		return cret	228		return cret

@@ -246,7 +246,7 @@ func (x *SwipeableBase) GetSwipeArea(NavigationDirectionVar NavigationDirection,
246		var XAdwSwipeableGetCancelProgress func(uintptr) float64	246		var XAdwSwipeableGetCancelProgress func(uintptr) float64
247		var XAdwSwipeableGetDistance func(uintptr) float64	247		var XAdwSwipeableGetDistance func(uintptr) float64
248		var XAdwSwipeableGetProgress func(uintptr) float64	248		var XAdwSwipeableGetProgress func(uintptr) float64
249	-	var XAdwSwipeableGetSnapPoints func(uintptr, int) uintptr	249	+	var XAdwSwipeableGetSnapPoints func(uintptr, *int) uintptr
250		var XAdwSwipeableGetSwipeArea func(uintptr, NavigationDirection, bool, *gdk.Rectangle)	250		var XAdwSwipeableGetSwipeArea func(uintptr, NavigationDirection, bool, *gdk.Rectangle)
251			251
252		func init() {	252		func init() {

M v4/adw/adw-switch-row.go +18 -1


@@ -119,6 +119,23 @@ func (c *SwitchRow) SetGoPointer(ptr uintptr) {
119		c.Ptr = ptr	119		c.Ptr = ptr
120		}	120		}
121			121
			122	+	// SetPropertyActive sets the "active" property.
			123	+	// Whether the switch row is in the "on" or "off" position.
			124	+	func (x *SwitchRow) SetPropertyActive(value bool) {
			125	+	var v gobject.Value
			126	+	v.Init(gobject.TypeBooleanVal)
			127	+	v.SetBoolean(value)
			128	+	x.SetProperty("active", &v)
			129	+	}
			130	+
			131	+	// GetPropertyActive gets the "active" property.
			132	+	// Whether the switch row is in the "on" or "off" position.
			133	+	func (x *SwitchRow) GetPropertyActive() bool {
			134	+	var v gobject.Value
			135	+	x.GetProperty("active", &v)
			136	+	return v.GetBoolean()
			137	+	}
			138	+
122		// Requests the user's screen reader to announce the given message.	139		// Requests the user's screen reader to announce the given message.
123		//	140		//
124		// This kind of notification is useful for messages that	141		// This kind of notification is useful for messages that

@@ -176,7 +193,7 @@ func (x SwitchRow) GetAtContext() gtk.ATContext {
176		// This functionality can be overridden by `GtkAccessible`	193		// This functionality can be overridden by `GtkAccessible`
177		// implementations, e.g. to get the bounds from an ignored	194		// implementations, e.g. to get the bounds from an ignored
178		// child widget.	195		// child widget.
179	-	func (x *SwitchRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	196	+	func (x SwitchRow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
180			197
181		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	198		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
182		return cret	199		return cret

M v4/adw/adw-tab-bar.go +115 -1


@@ -317,6 +317,120 @@ func (c *TabBar) SetGoPointer(ptr uintptr) {
317		c.Ptr = ptr	317		c.Ptr = ptr
318		}	318		}
319			319
			320	+	// SetPropertyAutohide sets the "autohide" property.
			321	+	// Whether the tabs automatically hide.
			322	+	//
			323	+	// If set to `TRUE`, the tab bar disappears when [property@TabBar:view] has 0
			324	+	// or 1 tab, no pinned tabs, and no tab is being transferred.
			325	+	//
			326	+	// See [property@TabBar:tabs-revealed].
			327	+	func (x *TabBar) SetPropertyAutohide(value bool) {
			328	+	var v gobject.Value
			329	+	v.Init(gobject.TypeBooleanVal)
			330	+	v.SetBoolean(value)
			331	+	x.SetProperty("autohide", &v)
			332	+	}
			333	+
			334	+	// GetPropertyAutohide gets the "autohide" property.
			335	+	// Whether the tabs automatically hide.
			336	+	//
			337	+	// If set to `TRUE`, the tab bar disappears when [property@TabBar:view] has 0
			338	+	// or 1 tab, no pinned tabs, and no tab is being transferred.
			339	+	//
			340	+	// See [property@TabBar:tabs-revealed].
			341	+	func (x *TabBar) GetPropertyAutohide() bool {
			342	+	var v gobject.Value
			343	+	x.GetProperty("autohide", &v)
			344	+	return v.GetBoolean()
			345	+	}
			346	+
			347	+	// SetPropertyExpandTabs sets the "expand-tabs" property.
			348	+	// Whether tabs expand to full width.
			349	+	//
			350	+	// If set to `TRUE`, the tabs will always vary width filling the whole width
			351	+	// when possible, otherwise tabs will always have the minimum possible size.
			352	+	func (x *TabBar) SetPropertyExpandTabs(value bool) {
			353	+	var v gobject.Value
			354	+	v.Init(gobject.TypeBooleanVal)
			355	+	v.SetBoolean(value)
			356	+	x.SetProperty("expand-tabs", &v)
			357	+	}
			358	+
			359	+	// GetPropertyExpandTabs gets the "expand-tabs" property.
			360	+	// Whether tabs expand to full width.
			361	+	//
			362	+	// If set to `TRUE`, the tabs will always vary width filling the whole width
			363	+	// when possible, otherwise tabs will always have the minimum possible size.
			364	+	func (x *TabBar) GetPropertyExpandTabs() bool {
			365	+	var v gobject.Value
			366	+	x.GetProperty("expand-tabs", &v)
			367	+	return v.GetBoolean()
			368	+	}
			369	+
			370	+	// SetPropertyExtraDragPreload sets the "extra-drag-preload" property.
			371	+	// Whether the drop data should be preloaded on hover.
			372	+	//
			373	+	// See [property@Gtk.DropTarget:preload].
			374	+	func (x *TabBar) SetPropertyExtraDragPreload(value bool) {
			375	+	var v gobject.Value
			376	+	v.Init(gobject.TypeBooleanVal)
			377	+	v.SetBoolean(value)
			378	+	x.SetProperty("extra-drag-preload", &v)
			379	+	}
			380	+
			381	+	// GetPropertyExtraDragPreload gets the "extra-drag-preload" property.
			382	+	// Whether the drop data should be preloaded on hover.
			383	+	//
			384	+	// See [property@Gtk.DropTarget:preload].
			385	+	func (x *TabBar) GetPropertyExtraDragPreload() bool {
			386	+	var v gobject.Value
			387	+	x.GetProperty("extra-drag-preload", &v)
			388	+	return v.GetBoolean()
			389	+	}
			390	+
			391	+	// SetPropertyInverted sets the "inverted" property.
			392	+	// Whether tabs use inverted layout.
			393	+	//
			394	+	// If set to `TRUE`, non-pinned tabs will have the close button at the
			395	+	// beginning and the indicator at the end rather than the opposite.
			396	+	func (x *TabBar) SetPropertyInverted(value bool) {
			397	+	var v gobject.Value
			398	+	v.Init(gobject.TypeBooleanVal)
			399	+	v.SetBoolean(value)
			400	+	x.SetProperty("inverted", &v)
			401	+	}
			402	+
			403	+	// GetPropertyInverted gets the "inverted" property.
			404	+	// Whether tabs use inverted layout.
			405	+	//
			406	+	// If set to `TRUE`, non-pinned tabs will have the close button at the
			407	+	// beginning and the indicator at the end rather than the opposite.
			408	+	func (x *TabBar) GetPropertyInverted() bool {
			409	+	var v gobject.Value
			410	+	x.GetProperty("inverted", &v)
			411	+	return v.GetBoolean()
			412	+	}
			413	+
			414	+	// GetPropertyIsOverflowing gets the "is-overflowing" property.
			415	+	// Whether the tab bar is overflowing.
			416	+	//
			417	+	// If `TRUE`, all tabs cannot be displayed at once and require scrolling.
			418	+	func (x *TabBar) GetPropertyIsOverflowing() bool {
			419	+	var v gobject.Value
			420	+	x.GetProperty("is-overflowing", &v)
			421	+	return v.GetBoolean()
			422	+	}
			423	+
			424	+	// GetPropertyTabsRevealed gets the "tabs-revealed" property.
			425	+	// Whether the tabs are currently revealed.
			426	+	//
			427	+	// See [property@TabBar:autohide].
			428	+	func (x *TabBar) GetPropertyTabsRevealed() bool {
			429	+	var v gobject.Value
			430	+	x.GetProperty("tabs-revealed", &v)
			431	+	return v.GetBoolean()
			432	+	}
			433	+
320		// This signal is emitted when content is dropped onto a tab.	434		// This signal is emitted when content is dropped onto a tab.
321		//	435		//
322		// The content must be of one of the types set up via	436		// The content must be of one of the types set up via

@@ -427,7 +541,7 @@ func (x TabBar) GetAtContext() gtk.ATContext {
427		// This functionality can be overridden by `GtkAccessible`	541		// This functionality can be overridden by `GtkAccessible`
428		// implementations, e.g. to get the bounds from an ignored	542		// implementations, e.g. to get the bounds from an ignored
429		// child widget.	543		// child widget.
430	-	func (x *TabBar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	544	+	func (x TabBar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
431			545
432		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	546		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
433		return cret	547		return cret

M v4/adw/adw-tab-button.go +1 -1


@@ -225,7 +225,7 @@ func (x TabButton) GetAtContext() gtk.ATContext {
225		// This functionality can be overridden by `GtkAccessible`	225		// This functionality can be overridden by `GtkAccessible`
226		// implementations, e.g. to get the bounds from an ignored	226		// implementations, e.g. to get the bounds from an ignored
227		// child widget.	227		// child widget.
228	-	func (x *TabButton) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	228	+	func (x TabButton) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
229			229
230		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	230		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
231		return cret	231		return cret

M v4/adw/adw-tab-overview.go +170 -1


@@ -395,6 +395,175 @@ func (c *TabOverview) SetGoPointer(ptr uintptr) {
395		c.Ptr = ptr	395		c.Ptr = ptr
396		}	396		}
397			397
			398	+	// SetPropertyEnableNewTab sets the "enable-new-tab" property.
			399	+	// Whether to enable new tab button.
			400	+	//
			401	+	// Connect to the [signal@TabOverview::create-tab] signal to use it.
			402	+	func (x *TabOverview) SetPropertyEnableNewTab(value bool) {
			403	+	var v gobject.Value
			404	+	v.Init(gobject.TypeBooleanVal)
			405	+	v.SetBoolean(value)
			406	+	x.SetProperty("enable-new-tab", &v)
			407	+	}
			408	+
			409	+	// GetPropertyEnableNewTab gets the "enable-new-tab" property.
			410	+	// Whether to enable new tab button.
			411	+	//
			412	+	// Connect to the [signal@TabOverview::create-tab] signal to use it.
			413	+	func (x *TabOverview) GetPropertyEnableNewTab() bool {
			414	+	var v gobject.Value
			415	+	x.GetProperty("enable-new-tab", &v)
			416	+	return v.GetBoolean()
			417	+	}
			418	+
			419	+	// SetPropertyEnableSearch sets the "enable-search" property.
			420	+	// Whether to enable search in tabs.
			421	+	//
			422	+	// Search matches tab titles and tooltips, as well as keywords, set via
			423	+	// [property@TabPage:keyword]. Use keywords to search in e.g. page URLs in a
			424	+	// web browser.
			425	+	//
			426	+	// During search, tab reordering and drag-n-drop are disabled.
			427	+	//
			428	+	// Use [property@TabOverview:search-active] to check out if search is
			429	+	// currently active.
			430	+	func (x *TabOverview) SetPropertyEnableSearch(value bool) {
			431	+	var v gobject.Value
			432	+	v.Init(gobject.TypeBooleanVal)
			433	+	v.SetBoolean(value)
			434	+	x.SetProperty("enable-search", &v)
			435	+	}
			436	+
			437	+	// GetPropertyEnableSearch gets the "enable-search" property.
			438	+	// Whether to enable search in tabs.
			439	+	//
			440	+	// Search matches tab titles and tooltips, as well as keywords, set via
			441	+	// [property@TabPage:keyword]. Use keywords to search in e.g. page URLs in a
			442	+	// web browser.
			443	+	//
			444	+	// During search, tab reordering and drag-n-drop are disabled.
			445	+	//
			446	+	// Use [property@TabOverview:search-active] to check out if search is
			447	+	// currently active.
			448	+	func (x *TabOverview) GetPropertyEnableSearch() bool {
			449	+	var v gobject.Value
			450	+	x.GetProperty("enable-search", &v)
			451	+	return v.GetBoolean()
			452	+	}
			453	+
			454	+	// SetPropertyExtraDragPreload sets the "extra-drag-preload" property.
			455	+	// Whether the drop data should be preloaded on hover.
			456	+	//
			457	+	// See [property@Gtk.DropTarget:preload].
			458	+	func (x *TabOverview) SetPropertyExtraDragPreload(value bool) {
			459	+	var v gobject.Value
			460	+	v.Init(gobject.TypeBooleanVal)
			461	+	v.SetBoolean(value)
			462	+	x.SetProperty("extra-drag-preload", &v)
			463	+	}
			464	+
			465	+	// GetPropertyExtraDragPreload gets the "extra-drag-preload" property.
			466	+	// Whether the drop data should be preloaded on hover.
			467	+	//
			468	+	// See [property@Gtk.DropTarget:preload].
			469	+	func (x *TabOverview) GetPropertyExtraDragPreload() bool {
			470	+	var v gobject.Value
			471	+	x.GetProperty("extra-drag-preload", &v)
			472	+	return v.GetBoolean()
			473	+	}
			474	+
			475	+	// SetPropertyInverted sets the "inverted" property.
			476	+	// Whether thumbnails use inverted layout.
			477	+	//
			478	+	// If set to `TRUE`, thumbnails will have the close or unpin buttons at the
			479	+	// beginning and the indicator at the end rather than the other way around.
			480	+	func (x *TabOverview) SetPropertyInverted(value bool) {
			481	+	var v gobject.Value
			482	+	v.Init(gobject.TypeBooleanVal)
			483	+	v.SetBoolean(value)
			484	+	x.SetProperty("inverted", &v)
			485	+	}
			486	+
			487	+	// GetPropertyInverted gets the "inverted" property.
			488	+	// Whether thumbnails use inverted layout.
			489	+	//
			490	+	// If set to `TRUE`, thumbnails will have the close or unpin buttons at the
			491	+	// beginning and the indicator at the end rather than the other way around.
			492	+	func (x *TabOverview) GetPropertyInverted() bool {
			493	+	var v gobject.Value
			494	+	x.GetProperty("inverted", &v)
			495	+	return v.GetBoolean()
			496	+	}
			497	+
			498	+	// SetPropertyOpen sets the "open" property.
			499	+	// Whether the overview is open.
			500	+	func (x *TabOverview) SetPropertyOpen(value bool) {
			501	+	var v gobject.Value
			502	+	v.Init(gobject.TypeBooleanVal)
			503	+	v.SetBoolean(value)
			504	+	x.SetProperty("open", &v)
			505	+	}
			506	+
			507	+	// GetPropertyOpen gets the "open" property.
			508	+	// Whether the overview is open.
			509	+	func (x *TabOverview) GetPropertyOpen() bool {
			510	+	var v gobject.Value
			511	+	x.GetProperty("open", &v)
			512	+	return v.GetBoolean()
			513	+	}
			514	+
			515	+	// GetPropertySearchActive gets the "search-active" property.
			516	+	// Whether search is currently active.
			517	+	//
			518	+	// See [property@TabOverview:enable-search].
			519	+	func (x *TabOverview) GetPropertySearchActive() bool {
			520	+	var v gobject.Value
			521	+	x.GetProperty("search-active", &v)
			522	+	return v.GetBoolean()
			523	+	}
			524	+
			525	+	// SetPropertyShowEndTitleButtons sets the "show-end-title-buttons" property.
			526	+	// Whether to show end title buttons in the overview's header bar.
			527	+	//
			528	+	// See [property@HeaderBar:show-start-title-buttons] for the other side.
			529	+	func (x *TabOverview) SetPropertyShowEndTitleButtons(value bool) {
			530	+	var v gobject.Value
			531	+	v.Init(gobject.TypeBooleanVal)
			532	+	v.SetBoolean(value)
			533	+	x.SetProperty("show-end-title-buttons", &v)
			534	+	}
			535	+
			536	+	// GetPropertyShowEndTitleButtons gets the "show-end-title-buttons" property.
			537	+	// Whether to show end title buttons in the overview's header bar.
			538	+	//
			539	+	// See [property@HeaderBar:show-start-title-buttons] for the other side.
			540	+	func (x *TabOverview) GetPropertyShowEndTitleButtons() bool {
			541	+	var v gobject.Value
			542	+	x.GetProperty("show-end-title-buttons", &v)
			543	+	return v.GetBoolean()
			544	+	}
			545	+
			546	+	// SetPropertyShowStartTitleButtons sets the "show-start-title-buttons" property.
			547	+	// Whether to show start title buttons in the overview's header bar.
			548	+	//
			549	+	// See [property@HeaderBar:show-end-title-buttons] for the other side.
			550	+	func (x *TabOverview) SetPropertyShowStartTitleButtons(value bool) {
			551	+	var v gobject.Value
			552	+	v.Init(gobject.TypeBooleanVal)
			553	+	v.SetBoolean(value)
			554	+	x.SetProperty("show-start-title-buttons", &v)
			555	+	}
			556	+
			557	+	// GetPropertyShowStartTitleButtons gets the "show-start-title-buttons" property.
			558	+	// Whether to show start title buttons in the overview's header bar.
			559	+	//
			560	+	// See [property@HeaderBar:show-end-title-buttons] for the other side.
			561	+	func (x *TabOverview) GetPropertyShowStartTitleButtons() bool {
			562	+	var v gobject.Value
			563	+	x.GetProperty("show-start-title-buttons", &v)
			564	+	return v.GetBoolean()
			565	+	}
			566	+
398		// Emitted when a tab needs to be created.	567		// Emitted when a tab needs to be created.
399		//	568		//
400		// This can happen after the new tab button has been pressed, see	569		// This can happen after the new tab button has been pressed, see

@@ -532,7 +701,7 @@ func (x TabOverview) GetAtContext() gtk.ATContext {
532		// This functionality can be overridden by `GtkAccessible`	701		// This functionality can be overridden by `GtkAccessible`
533		// implementations, e.g. to get the bounds from an ignored	702		// implementations, e.g. to get the bounds from an ignored
534		// child widget.	703		// child widget.
535	-	func (x *TabOverview) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	704	+	func (x TabOverview) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
536			705
537		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	706		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
538		return cret	707		return cret

M v4/adw/adw-tab-view.go +358 -2


@@ -508,6 +508,330 @@ func (c *TabPage) SetGoPointer(ptr uintptr) {
508		c.Ptr = ptr	508		c.Ptr = ptr
509		}	509		}
510			510
			511	+	// SetPropertyIndicatorActivatable sets the "indicator-activatable" property.
			512	+	// Whether the indicator icon is activatable.
			513	+	//
			514	+	// If set to `TRUE`, [signal@TabView::indicator-activated] will be emitted
			515	+	// when the indicator icon is clicked.
			516	+	//
			517	+	// If [property@TabPage:indicator-icon] is not set, does nothing.
			518	+	func (x *TabPage) SetPropertyIndicatorActivatable(value bool) {
			519	+	var v gobject.Value
			520	+	v.Init(gobject.TypeBooleanVal)
			521	+	v.SetBoolean(value)
			522	+	x.SetProperty("indicator-activatable", &v)
			523	+	}
			524	+
			525	+	// GetPropertyIndicatorActivatable gets the "indicator-activatable" property.
			526	+	// Whether the indicator icon is activatable.
			527	+	//
			528	+	// If set to `TRUE`, [signal@TabView::indicator-activated] will be emitted
			529	+	// when the indicator icon is clicked.
			530	+	//
			531	+	// If [property@TabPage:indicator-icon] is not set, does nothing.
			532	+	func (x *TabPage) GetPropertyIndicatorActivatable() bool {
			533	+	var v gobject.Value
			534	+	x.GetProperty("indicator-activatable", &v)
			535	+	return v.GetBoolean()
			536	+	}
			537	+
			538	+	// SetPropertyIndicatorTooltip sets the "indicator-tooltip" property.
			539	+	// The tooltip of the indicator icon.
			540	+	//
			541	+	// The tooltip can be marked up with the Pango text markup language.
			542	+	//
			543	+	// See [property@TabPage:indicator-icon].
			544	+	func (x *TabPage) SetPropertyIndicatorTooltip(value string) {
			545	+	var v gobject.Value
			546	+	v.Init(gobject.TypeStringVal)
			547	+	v.SetString(value)
			548	+	x.SetProperty("indicator-tooltip", &v)
			549	+	}
			550	+
			551	+	// GetPropertyIndicatorTooltip gets the "indicator-tooltip" property.
			552	+	// The tooltip of the indicator icon.
			553	+	//
			554	+	// The tooltip can be marked up with the Pango text markup language.
			555	+	//
			556	+	// See [property@TabPage:indicator-icon].
			557	+	func (x *TabPage) GetPropertyIndicatorTooltip() string {
			558	+	var v gobject.Value
			559	+	x.GetProperty("indicator-tooltip", &v)
			560	+	return v.GetString()
			561	+	}
			562	+
			563	+	// SetPropertyKeyword sets the "keyword" property.
			564	+	// The search keyboard of the page.
			565	+	//
			566	+	// [class@TabOverview] can search pages by their keywords in addition to their
			567	+	// titles and tooltips.
			568	+	//
			569	+	// Keywords allow to include e.g. page URLs into tab search in a web browser.
			570	+	func (x *TabPage) SetPropertyKeyword(value string) {
			571	+	var v gobject.Value
			572	+	v.Init(gobject.TypeStringVal)
			573	+	v.SetString(value)
			574	+	x.SetProperty("keyword", &v)
			575	+	}
			576	+
			577	+	// GetPropertyKeyword gets the "keyword" property.
			578	+	// The search keyboard of the page.
			579	+	//
			580	+	// [class@TabOverview] can search pages by their keywords in addition to their
			581	+	// titles and tooltips.
			582	+	//
			583	+	// Keywords allow to include e.g. page URLs into tab search in a web browser.
			584	+	func (x *TabPage) GetPropertyKeyword() string {
			585	+	var v gobject.Value
			586	+	x.GetProperty("keyword", &v)
			587	+	return v.GetString()
			588	+	}
			589	+
			590	+	// SetPropertyLiveThumbnail sets the "live-thumbnail" property.
			591	+	// Whether to enable live thumbnail for this page.
			592	+	//
			593	+	// When set to `TRUE`, the page's thumbnail in [class@TabOverview] will update
			594	+	// immediately when the page is redrawn or resized.
			595	+	//
			596	+	// If it's set to `FALSE`, the thumbnail will only be live when the page is
			597	+	// selected, and otherwise it will be static and will only update when
			598	+	// [method@TabPage.invalidate_thumbnail] or
			599	+	// [method@TabView.invalidate_thumbnails] is called.
			600	+	func (x *TabPage) SetPropertyLiveThumbnail(value bool) {
			601	+	var v gobject.Value
			602	+	v.Init(gobject.TypeBooleanVal)
			603	+	v.SetBoolean(value)
			604	+	x.SetProperty("live-thumbnail", &v)
			605	+	}
			606	+
			607	+	// GetPropertyLiveThumbnail gets the "live-thumbnail" property.
			608	+	// Whether to enable live thumbnail for this page.
			609	+	//
			610	+	// When set to `TRUE`, the page's thumbnail in [class@TabOverview] will update
			611	+	// immediately when the page is redrawn or resized.
			612	+	//
			613	+	// If it's set to `FALSE`, the thumbnail will only be live when the page is
			614	+	// selected, and otherwise it will be static and will only update when
			615	+	// [method@TabPage.invalidate_thumbnail] or
			616	+	// [method@TabView.invalidate_thumbnails] is called.
			617	+	func (x *TabPage) GetPropertyLiveThumbnail() bool {
			618	+	var v gobject.Value
			619	+	x.GetProperty("live-thumbnail", &v)
			620	+	return v.GetBoolean()
			621	+	}
			622	+
			623	+	// SetPropertyLoading sets the "loading" property.
			624	+	// Whether the page is loading.
			625	+	//
			626	+	// If set to `TRUE`, [class@TabBar] and [class@TabOverview] will display a
			627	+	// spinner in place of icon.
			628	+	//
			629	+	// If the page is pinned and [property@TabPage:indicator-icon] is set,
			630	+	// loading status will not be visible with `AdwTabBar`.
			631	+	func (x *TabPage) SetPropertyLoading(value bool) {
			632	+	var v gobject.Value
			633	+	v.Init(gobject.TypeBooleanVal)
			634	+	v.SetBoolean(value)
			635	+	x.SetProperty("loading", &v)
			636	+	}
			637	+
			638	+	// GetPropertyLoading gets the "loading" property.
			639	+	// Whether the page is loading.
			640	+	//
			641	+	// If set to `TRUE`, [class@TabBar] and [class@TabOverview] will display a
			642	+	// spinner in place of icon.
			643	+	//
			644	+	// If the page is pinned and [property@TabPage:indicator-icon] is set,
			645	+	// loading status will not be visible with `AdwTabBar`.
			646	+	func (x *TabPage) GetPropertyLoading() bool {
			647	+	var v gobject.Value
			648	+	x.GetProperty("loading", &v)
			649	+	return v.GetBoolean()
			650	+	}
			651	+
			652	+	// SetPropertyNeedsAttention sets the "needs-attention" property.
			653	+	// Whether the page needs attention.
			654	+	//
			655	+	// [class@TabBar] will display a line under the tab representing the page if
			656	+	// set to `TRUE`. If the tab is not visible, the corresponding edge of the tab
			657	+	// bar will be highlighted.
			658	+	//
			659	+	// [class@TabOverview] will display a dot in the corner of the thumbnail if set
			660	+	// to `TRUE`.
			661	+	//
			662	+	// [class@TabButton] will display a dot if any of the pages that aren't
			663	+	// selected have this property set to `TRUE`.
			664	+	func (x *TabPage) SetPropertyNeedsAttention(value bool) {
			665	+	var v gobject.Value
			666	+	v.Init(gobject.TypeBooleanVal)
			667	+	v.SetBoolean(value)
			668	+	x.SetProperty("needs-attention", &v)
			669	+	}
			670	+
			671	+	// GetPropertyNeedsAttention gets the "needs-attention" property.
			672	+	// Whether the page needs attention.
			673	+	//
			674	+	// [class@TabBar] will display a line under the tab representing the page if
			675	+	// set to `TRUE`. If the tab is not visible, the corresponding edge of the tab
			676	+	// bar will be highlighted.
			677	+	//
			678	+	// [class@TabOverview] will display a dot in the corner of the thumbnail if set
			679	+	// to `TRUE`.
			680	+	//
			681	+	// [class@TabButton] will display a dot if any of the pages that aren't
			682	+	// selected have this property set to `TRUE`.
			683	+	func (x *TabPage) GetPropertyNeedsAttention() bool {
			684	+	var v gobject.Value
			685	+	x.GetProperty("needs-attention", &v)
			686	+	return v.GetBoolean()
			687	+	}
			688	+
			689	+	// GetPropertyPinned gets the "pinned" property.
			690	+	// Whether the page is pinned.
			691	+	//
			692	+	// See [method@TabView.set_page_pinned].
			693	+	func (x *TabPage) GetPropertyPinned() bool {
			694	+	var v gobject.Value
			695	+	x.GetProperty("pinned", &v)
			696	+	return v.GetBoolean()
			697	+	}
			698	+
			699	+	// GetPropertySelected gets the "selected" property.
			700	+	// Whether the page is selected.
			701	+	func (x *TabPage) GetPropertySelected() bool {
			702	+	var v gobject.Value
			703	+	x.GetProperty("selected", &v)
			704	+	return v.GetBoolean()
			705	+	}
			706	+
			707	+	// SetPropertyThumbnailXalign sets the "thumbnail-xalign" property.
			708	+	// The horizontal alignment of the page thumbnail.
			709	+	//
			710	+	// If the page is so wide that [class@TabOverview] can't display it completely
			711	+	// and has to crop it, horizontal alignment will determine which part of the
			712	+	// page will be visible.
			713	+	//
			714	+	// For example, 0.5 means the center of the page will be visible, 0 means the
			715	+	// start edge will be visible and 1 means the end edge will be visible.
			716	+	//
			717	+	// The default horizontal alignment is 0.
			718	+	func (x *TabPage) SetPropertyThumbnailXalign(value float32) {
			719	+	var v gobject.Value
			720	+	v.Init(gobject.TypeFloatVal)
			721	+	v.SetFloat(value)
			722	+	x.SetProperty("thumbnail-xalign", &v)
			723	+	}
			724	+
			725	+	// GetPropertyThumbnailXalign gets the "thumbnail-xalign" property.
			726	+	// The horizontal alignment of the page thumbnail.
			727	+	//
			728	+	// If the page is so wide that [class@TabOverview] can't display it completely
			729	+	// and has to crop it, horizontal alignment will determine which part of the
			730	+	// page will be visible.
			731	+	//
			732	+	// For example, 0.5 means the center of the page will be visible, 0 means the
			733	+	// start edge will be visible and 1 means the end edge will be visible.
			734	+	//
			735	+	// The default horizontal alignment is 0.
			736	+	func (x *TabPage) GetPropertyThumbnailXalign() float32 {
			737	+	var v gobject.Value
			738	+	x.GetProperty("thumbnail-xalign", &v)
			739	+	return v.GetFloat()
			740	+	}
			741	+
			742	+	// SetPropertyThumbnailYalign sets the "thumbnail-yalign" property.
			743	+	// The vertical alignment of the page thumbnail.
			744	+	//
			745	+	// If the page is so tall that [class@TabOverview] can't display it completely
			746	+	// and has to crop it, vertical alignment will determine which part of the
			747	+	// page will be visible.
			748	+	//
			749	+	// For example, 0.5 means the center of the page will be visible, 0 means the
			750	+	// top edge will be visible and 1 means the bottom edge will be visible.
			751	+	//
			752	+	// The default vertical alignment is 0.
			753	+	func (x *TabPage) SetPropertyThumbnailYalign(value float32) {
			754	+	var v gobject.Value
			755	+	v.Init(gobject.TypeFloatVal)
			756	+	v.SetFloat(value)
			757	+	x.SetProperty("thumbnail-yalign", &v)
			758	+	}
			759	+
			760	+	// GetPropertyThumbnailYalign gets the "thumbnail-yalign" property.
			761	+	// The vertical alignment of the page thumbnail.
			762	+	//
			763	+	// If the page is so tall that [class@TabOverview] can't display it completely
			764	+	// and has to crop it, vertical alignment will determine which part of the
			765	+	// page will be visible.
			766	+	//
			767	+	// For example, 0.5 means the center of the page will be visible, 0 means the
			768	+	// top edge will be visible and 1 means the bottom edge will be visible.
			769	+	//
			770	+	// The default vertical alignment is 0.
			771	+	func (x *TabPage) GetPropertyThumbnailYalign() float32 {
			772	+	var v gobject.Value
			773	+	x.GetProperty("thumbnail-yalign", &v)
			774	+	return v.GetFloat()
			775	+	}
			776	+
			777	+	// SetPropertyTitle sets the "title" property.
			778	+	// The title of the page.
			779	+	//
			780	+	// [class@TabBar] will display it in the center of the tab unless it's pinned,
			781	+	// and will use it as a tooltip unless [property@TabPage:tooltip] is set.
			782	+	//
			783	+	// [class@TabOverview] will display it below the thumbnail unless it's pinned,
			784	+	// or inside the card otherwise, and will use it as a tooltip unless
			785	+	// [property@TabPage:tooltip] is set.
			786	+	func (x *TabPage) SetPropertyTitle(value string) {
			787	+	var v gobject.Value
			788	+	v.Init(gobject.TypeStringVal)
			789	+	v.SetString(value)
			790	+	x.SetProperty("title", &v)
			791	+	}
			792	+
			793	+	// GetPropertyTitle gets the "title" property.
			794	+	// The title of the page.
			795	+	//
			796	+	// [class@TabBar] will display it in the center of the tab unless it's pinned,
			797	+	// and will use it as a tooltip unless [property@TabPage:tooltip] is set.
			798	+	//
			799	+	// [class@TabOverview] will display it below the thumbnail unless it's pinned,
			800	+	// or inside the card otherwise, and will use it as a tooltip unless
			801	+	// [property@TabPage:tooltip] is set.
			802	+	func (x *TabPage) GetPropertyTitle() string {
			803	+	var v gobject.Value
			804	+	x.GetProperty("title", &v)
			805	+	return v.GetString()
			806	+	}
			807	+
			808	+	// SetPropertyTooltip sets the "tooltip" property.
			809	+	// The tooltip of the page.
			810	+	//
			811	+	// The tooltip can be marked up with the Pango text markup language.
			812	+	//
			813	+	// If not set, [class@TabBar] and [class@TabOverview] will use
			814	+	// [property@TabPage:title] as a tooltip instead.
			815	+	func (x *TabPage) SetPropertyTooltip(value string) {
			816	+	var v gobject.Value
			817	+	v.Init(gobject.TypeStringVal)
			818	+	v.SetString(value)
			819	+	x.SetProperty("tooltip", &v)
			820	+	}
			821	+
			822	+	// GetPropertyTooltip gets the "tooltip" property.
			823	+	// The tooltip of the page.
			824	+	//
			825	+	// The tooltip can be marked up with the Pango text markup language.
			826	+	//
			827	+	// If not set, [class@TabBar] and [class@TabOverview] will use
			828	+	// [property@TabPage:title] as a tooltip instead.
			829	+	func (x *TabPage) GetPropertyTooltip() string {
			830	+	var v gobject.Value
			831	+	x.GetProperty("tooltip", &v)
			832	+	return v.GetString()
			833	+	}
			834	+
511		// Requests the user's screen reader to announce the given message.	835		// Requests the user's screen reader to announce the given message.
512		//	836		//
513		// This kind of notification is useful for messages that	837		// This kind of notification is useful for messages that

@@ -565,7 +889,7 @@ func (x TabPage) GetAtContext() gtk.ATContext {
565		// This functionality can be overridden by `GtkAccessible`	889		// This functionality can be overridden by `GtkAccessible`
566		// implementations, e.g. to get the bounds from an ignored	890		// implementations, e.g. to get the bounds from an ignored
567		// child widget.	891		// child widget.
568	-	func (x *TabPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	892	+	func (x TabPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
569			893
570		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	894		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
571		return cret	895		return cret

@@ -1437,6 +1761,38 @@ func (c *TabView) SetGoPointer(ptr uintptr) {
1437		c.Ptr = ptr	1761		c.Ptr = ptr
1438		}	1762		}
1439			1763
			1764	+	// GetPropertyIsTransferringPage gets the "is-transferring-page" property.
			1765	+	// Whether a page is being transferred.
			1766	+	//
			1767	+	// This property will be set to `TRUE` when a drag-n-drop tab transfer starts
			1768	+	// on any `AdwTabView`, and to `FALSE` after it ends.
			1769	+	//
			1770	+	// During the transfer, children cannot receive pointer input and a tab can
			1771	+	// be safely dropped on the tab view.
			1772	+	func (x *TabView) GetPropertyIsTransferringPage() bool {
			1773	+	var v gobject.Value
			1774	+	x.GetProperty("is-transferring-page", &v)
			1775	+	return v.GetBoolean()
			1776	+	}
			1777	+
			1778	+	// GetPropertyNPages gets the "n-pages" property.
			1779	+	// The number of pages in the tab view.
			1780	+	func (x *TabView) GetPropertyNPages() int {
			1781	+	var v gobject.Value
			1782	+	x.GetProperty("n-pages", &v)
			1783	+	return v.GetInt()
			1784	+	}
			1785	+
			1786	+	// GetPropertyNPinnedPages gets the "n-pinned-pages" property.
			1787	+	// The number of pinned pages in the tab view.
			1788	+	//
			1789	+	// See [method@TabView.set_page_pinned].
			1790	+	func (x *TabView) GetPropertyNPinnedPages() int {
			1791	+	var v gobject.Value
			1792	+	x.GetProperty("n-pinned-pages", &v)
			1793	+	return v.GetInt()
			1794	+	}
			1795	+
1440		// Emitted after [method@TabView.close_page] has been called for @page.	1796		// Emitted after [method@TabView.close_page] has been called for @page.
1441		//	1797		//
1442		// The handler is expected to call [method@TabView.close_page_finish] to	1798		// The handler is expected to call [method@TabView.close_page_finish] to

@@ -1690,7 +2046,7 @@ func (x TabView) GetAtContext() gtk.ATContext {
1690		// This functionality can be overridden by `GtkAccessible`	2046		// This functionality can be overridden by `GtkAccessible`
1691		// implementations, e.g. to get the bounds from an ignored	2047		// implementations, e.g. to get the bounds from an ignored
1692		// child widget.	2048		// child widget.
1693	-	func (x *TabView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	2049	+	func (x TabView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
1694			2050
1695		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	2051		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
1696		return cret	2052		return cret

M v4/adw/adw-timed-animation.go +140 -0


@@ -225,6 +225,146 @@ func (c *TimedAnimation) SetGoPointer(ptr uintptr) {
225	c.Ptr = ptr	225		c.Ptr = ptr
226	}	226		}
227		227
		228	+	// SetPropertyAlternate sets the "alternate" property.
		229	+	// Whether the animation changes direction on every iteration.
		230	+	func (x *TimedAnimation) SetPropertyAlternate(value bool) {
		231	+	var v gobject.Value
		232	+	v.Init(gobject.TypeBooleanVal)
		233	+	v.SetBoolean(value)
		234	+	x.SetProperty("alternate", &v)
		235	+	}
		236	+
		237	+	// GetPropertyAlternate gets the "alternate" property.
		238	+	// Whether the animation changes direction on every iteration.
		239	+	func (x *TimedAnimation) GetPropertyAlternate() bool {
		240	+	var v gobject.Value
		241	+	x.GetProperty("alternate", &v)
		242	+	return v.GetBoolean()
		243	+	}
		244	+
		245	+	// SetPropertyDuration sets the "duration" property.
		246	+	// Duration of the animation, in milliseconds.
		247	+	//
		248	+	// Describes how much time the animation will take.
		249	+	//
		250	+	// If the animation repeats more than once, describes the duration of one
		251	+	// iteration.
		252	+	func (x *TimedAnimation) SetPropertyDuration(value uint) {
		253	+	var v gobject.Value
		254	+	v.Init(gobject.TypeUintVal)
		255	+	v.SetUint(value)
		256	+	x.SetProperty("duration", &v)
		257	+	}
		258	+
		259	+	// GetPropertyDuration gets the "duration" property.
		260	+	// Duration of the animation, in milliseconds.
		261	+	//
		262	+	// Describes how much time the animation will take.
		263	+	//
		264	+	// If the animation repeats more than once, describes the duration of one
		265	+	// iteration.
		266	+	func (x *TimedAnimation) GetPropertyDuration() uint {
		267	+	var v gobject.Value
		268	+	x.GetProperty("duration", &v)
		269	+	return v.GetUint()
		270	+	}
		271	+
		272	+	// SetPropertyRepeatCount sets the "repeat-count" property.
		273	+	// Number of times the animation will play.
		274	+	//
		275	+	// If set to 0, the animation will repeat endlessly.
		276	+	func (x *TimedAnimation) SetPropertyRepeatCount(value uint) {
		277	+	var v gobject.Value
		278	+	v.Init(gobject.TypeUintVal)
		279	+	v.SetUint(value)
		280	+	x.SetProperty("repeat-count", &v)
		281	+	}
		282	+
		283	+	// GetPropertyRepeatCount gets the "repeat-count" property.
		284	+	// Number of times the animation will play.
		285	+	//
		286	+	// If set to 0, the animation will repeat endlessly.
		287	+	func (x *TimedAnimation) GetPropertyRepeatCount() uint {
		288	+	var v gobject.Value
		289	+	x.GetProperty("repeat-count", &v)
		290	+	return v.GetUint()
		291	+	}
		292	+
		293	+	// SetPropertyReverse sets the "reverse" property.
		294	+	// Whether the animation plays backwards.
		295	+	func (x *TimedAnimation) SetPropertyReverse(value bool) {
		296	+	var v gobject.Value
		297	+	v.Init(gobject.TypeBooleanVal)
		298	+	v.SetBoolean(value)
		299	+	x.SetProperty("reverse", &v)
		300	+	}
		301	+
		302	+	// GetPropertyReverse gets the "reverse" property.
		303	+	// Whether the animation plays backwards.
		304	+	func (x *TimedAnimation) GetPropertyReverse() bool {
		305	+	var v gobject.Value
		306	+	x.GetProperty("reverse", &v)
		307	+	return v.GetBoolean()
		308	+	}
		309	+
		310	+	// SetPropertyValueFrom sets the "value-from" property.
		311	+	// The value to animate from.
		312	+	//
		313	+	// The animation will start at this value and end at
		314	+	// [property@TimedAnimation:value-to].
		315	+	//
		316	+	// If [property@TimedAnimation:reverse] is `TRUE`, the animation will end at
		317	+	// this value instead.
		318	+	func (x *TimedAnimation) SetPropertyValueFrom(value float64) {
		319	+	var v gobject.Value
		320	+	v.Init(gobject.TypeDoubleVal)
		321	+	v.SetDouble(value)
		322	+	x.SetProperty("value-from", &v)
		323	+	}
		324	+
		325	+	// GetPropertyValueFrom gets the "value-from" property.
		326	+	// The value to animate from.
		327	+	//
		328	+	// The animation will start at this value and end at
		329	+	// [property@TimedAnimation:value-to].
		330	+	//
		331	+	// If [property@TimedAnimation:reverse] is `TRUE`, the animation will end at
		332	+	// this value instead.
		333	+	func (x *TimedAnimation) GetPropertyValueFrom() float64 {
		334	+	var v gobject.Value
		335	+	x.GetProperty("value-from", &v)
		336	+	return v.GetDouble()
		337	+	}
		338	+
		339	+	// SetPropertyValueTo sets the "value-to" property.
		340	+	// The value to animate to.
		341	+	//
		342	+	// The animation will start at [property@TimedAnimation:value-from] and end at
		343	+	// this value.
		344	+	//
		345	+	// If [property@TimedAnimation:reverse] is `TRUE`, the animation will start
		346	+	// at this value instead.
		347	+	func (x *TimedAnimation) SetPropertyValueTo(value float64) {
		348	+	var v gobject.Value
		349	+	v.Init(gobject.TypeDoubleVal)
		350	+	v.SetDouble(value)
		351	+	x.SetProperty("value-to", &v)
		352	+	}
		353	+
		354	+	// GetPropertyValueTo gets the "value-to" property.
		355	+	// The value to animate to.
		356	+	//
		357	+	// The animation will start at [property@TimedAnimation:value-from] and end at
		358	+	// this value.
		359	+	//
		360	+	// If [property@TimedAnimation:reverse] is `TRUE`, the animation will start
		361	+	// at this value instead.
		362	+	func (x *TimedAnimation) GetPropertyValueTo() float64 {
		363	+	var v gobject.Value
		364	+	x.GetProperty("value-to", &v)
		365	+	return v.GetDouble()
		366	+	}
		367	+
228	func init() {	368		func init() {
229	core.SetPackageName("ADW", "libadwaita-1")	369		core.SetPackageName("ADW", "libadwaita-1")
230	core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})	370		core.SetSharedLibraries("ADW", []string{"libadwaita-1.so.0"})

M v4/adw/adw-toast-overlay.go +1 -1


@@ -224,7 +224,7 @@ func (x ToastOverlay) GetAtContext() gtk.ATContext {
224		// This functionality can be overridden by `GtkAccessible`	224		// This functionality can be overridden by `GtkAccessible`
225		// implementations, e.g. to get the bounds from an ignored	225		// implementations, e.g. to get the bounds from an ignored
226		// child widget.	226		// child widget.
227	-	func (x *ToastOverlay) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	227	+	func (x ToastOverlay) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
228			228
229		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	229		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
230		return cret	230		return cret

M v4/adw/adw-toast.go +150 -0


@@ -479,6 +479,156 @@ func (c *Toast) SetGoPointer(ptr uintptr) {
479	c.Ptr = ptr	479		c.Ptr = ptr
480	}	480		}
481		481
		482	+	// SetPropertyActionName sets the "action-name" property.
		483	+	// The name of the associated action.
		484	+	//
		485	+	// It will be activated when clicking the button.
		486	+	//
		487	+	// See [property@Toast:action-target].
		488	+	func (x *Toast) SetPropertyActionName(value string) {
		489	+	var v gobject.Value
		490	+	v.Init(gobject.TypeStringVal)
		491	+	v.SetString(value)
		492	+	x.SetProperty("action-name", &v)
		493	+	}
		494	+
		495	+	// GetPropertyActionName gets the "action-name" property.
		496	+	// The name of the associated action.
		497	+	//
		498	+	// It will be activated when clicking the button.
		499	+	//
		500	+	// See [property@Toast:action-target].
		501	+	func (x *Toast) GetPropertyActionName() string {
		502	+	var v gobject.Value
		503	+	x.GetProperty("action-name", &v)
		504	+	return v.GetString()
		505	+	}
		506	+
		507	+	// SetPropertyActionTarget sets the "action-target" property.
		508	+	// The parameter for action invocations.
		509	+	func (x *Toast) SetPropertyActionTarget(value uintptr) {
		510	+	var v gobject.Value
		511	+	v.Init(gobject.TypePointerVal)
		512	+	v.SetPointer(value)
		513	+	x.SetProperty("action-target", &v)
		514	+	}
		515	+
		516	+	// GetPropertyActionTarget gets the "action-target" property.
		517	+	// The parameter for action invocations.
		518	+	func (x *Toast) GetPropertyActionTarget() uintptr {
		519	+	var v gobject.Value
		520	+	x.GetProperty("action-target", &v)
		521	+	return v.GetPointer()
		522	+	}
		523	+
		524	+	// SetPropertyButtonLabel sets the "button-label" property.
		525	+	// The label to show on the button.
		526	+	//
		527	+	// Underlines in the button text can be used to indicate a mnemonic.
		528	+	//
		529	+	// If set to `NULL`, the button won't be shown.
		530	+	//
		531	+	// See [property@Toast:action-name].
		532	+	func (x *Toast) SetPropertyButtonLabel(value string) {
		533	+	var v gobject.Value
		534	+	v.Init(gobject.TypeStringVal)
		535	+	v.SetString(value)
		536	+	x.SetProperty("button-label", &v)
		537	+	}
		538	+
		539	+	// GetPropertyButtonLabel gets the "button-label" property.
		540	+	// The label to show on the button.
		541	+	//
		542	+	// Underlines in the button text can be used to indicate a mnemonic.
		543	+	//
		544	+	// If set to `NULL`, the button won't be shown.
		545	+	//
		546	+	// See [property@Toast:action-name].
		547	+	func (x *Toast) GetPropertyButtonLabel() string {
		548	+	var v gobject.Value
		549	+	x.GetProperty("button-label", &v)
		550	+	return v.GetString()
		551	+	}
		552	+
		553	+	// SetPropertyTimeout sets the "timeout" property.
		554	+	// The timeout of the toast, in seconds.
		555	+	//
		556	+	// If timeout is 0, the toast is displayed indefinitely until manually
		557	+	// dismissed.
		558	+	//
		559	+	// Toasts cannot disappear while being hovered, pressed (on touchscreen), or
		560	+	// have keyboard focus inside them.
		561	+	func (x *Toast) SetPropertyTimeout(value uint) {
		562	+	var v gobject.Value
		563	+	v.Init(gobject.TypeUintVal)
		564	+	v.SetUint(value)
		565	+	x.SetProperty("timeout", &v)
		566	+	}
		567	+
		568	+	// GetPropertyTimeout gets the "timeout" property.
		569	+	// The timeout of the toast, in seconds.
		570	+	//
		571	+	// If timeout is 0, the toast is displayed indefinitely until manually
		572	+	// dismissed.
		573	+	//
		574	+	// Toasts cannot disappear while being hovered, pressed (on touchscreen), or
		575	+	// have keyboard focus inside them.
		576	+	func (x *Toast) GetPropertyTimeout() uint {
		577	+	var v gobject.Value
		578	+	x.GetProperty("timeout", &v)
		579	+	return v.GetUint()
		580	+	}
		581	+
		582	+	// SetPropertyTitle sets the "title" property.
		583	+	// The title of the toast.
		584	+	//
		585	+	// The title can be marked up with the Pango text markup language.
		586	+	//
		587	+	// Setting a title will unset [property@Toast:custom-title].
		588	+	//
		589	+	// If [property@Toast:custom-title] is set, it will be used instead.
		590	+	func (x *Toast) SetPropertyTitle(value string) {
		591	+	var v gobject.Value
		592	+	v.Init(gobject.TypeStringVal)
		593	+	v.SetString(value)
		594	+	x.SetProperty("title", &v)
		595	+	}
		596	+
		597	+	// GetPropertyTitle gets the "title" property.
		598	+	// The title of the toast.
		599	+	//
		600	+	// The title can be marked up with the Pango text markup language.
		601	+	//
		602	+	// Setting a title will unset [property@Toast:custom-title].
		603	+	//
		604	+	// If [property@Toast:custom-title] is set, it will be used instead.
		605	+	func (x *Toast) GetPropertyTitle() string {
		606	+	var v gobject.Value
		607	+	x.GetProperty("title", &v)
		608	+	return v.GetString()
		609	+	}
		610	+
		611	+	// SetPropertyUseMarkup sets the "use-markup" property.
		612	+	// Whether to use Pango markup for the toast title.
		613	+	//
		614	+	// See also [func@Pango.parse_markup].
		615	+	func (x *Toast) SetPropertyUseMarkup(value bool) {
		616	+	var v gobject.Value
		617	+	v.Init(gobject.TypeBooleanVal)
		618	+	v.SetBoolean(value)
		619	+	x.SetProperty("use-markup", &v)
		620	+	}
		621	+
		622	+	// GetPropertyUseMarkup gets the "use-markup" property.
		623	+	// Whether to use Pango markup for the toast title.
		624	+	//
		625	+	// See also [func@Pango.parse_markup].
		626	+	func (x *Toast) GetPropertyUseMarkup() bool {
		627	+	var v gobject.Value
		628	+	x.GetProperty("use-markup", &v)
		629	+	return v.GetBoolean()
		630	+	}
		631	+
482	// Emitted after the button has been clicked.	632		// Emitted after the button has been clicked.
483	//	633		//
484	// It can be used as an alternative to setting an action.	634		// It can be used as an alternative to setting an action.

M v4/adw/adw-toggle-group.go +239 -1


@@ -243,6 +243,138 @@ func (c *Toggle) SetGoPointer(ptr uintptr) {
243		c.Ptr = ptr	243		c.Ptr = ptr
244		}	244		}
245			245
			246	+	// SetPropertyEnabled sets the "enabled" property.
			247	+	// Whether this toggle is enabled.
			248	+	func (x *Toggle) SetPropertyEnabled(value bool) {
			249	+	var v gobject.Value
			250	+	v.Init(gobject.TypeBooleanVal)
			251	+	v.SetBoolean(value)
			252	+	x.SetProperty("enabled", &v)
			253	+	}
			254	+
			255	+	// GetPropertyEnabled gets the "enabled" property.
			256	+	// Whether this toggle is enabled.
			257	+	func (x *Toggle) GetPropertyEnabled() bool {
			258	+	var v gobject.Value
			259	+	x.GetProperty("enabled", &v)
			260	+	return v.GetBoolean()
			261	+	}
			262	+
			263	+	// SetPropertyIconName sets the "icon-name" property.
			264	+	// The toggle icon name.
			265	+	//
			266	+	// The icon will be displayed alone or next to the label, unless
			267	+	// [property@Toggle:child] is set.
			268	+	func (x *Toggle) SetPropertyIconName(value string) {
			269	+	var v gobject.Value
			270	+	v.Init(gobject.TypeStringVal)
			271	+	v.SetString(value)
			272	+	x.SetProperty("icon-name", &v)
			273	+	}
			274	+
			275	+	// GetPropertyIconName gets the "icon-name" property.
			276	+	// The toggle icon name.
			277	+	//
			278	+	// The icon will be displayed alone or next to the label, unless
			279	+	// [property@Toggle:child] is set.
			280	+	func (x *Toggle) GetPropertyIconName() string {
			281	+	var v gobject.Value
			282	+	x.GetProperty("icon-name", &v)
			283	+	return v.GetString()
			284	+	}
			285	+
			286	+	// SetPropertyLabel sets the "label" property.
			287	+	// The toggle label.
			288	+	//
			289	+	// The label will be displayed alone or next to the icon, unless
			290	+	// [property@Toggle:child] is set, but will still be read out by the screen
			291	+	// reader.
			292	+	func (x *Toggle) SetPropertyLabel(value string) {
			293	+	var v gobject.Value
			294	+	v.Init(gobject.TypeStringVal)
			295	+	v.SetString(value)
			296	+	x.SetProperty("label", &v)
			297	+	}
			298	+
			299	+	// GetPropertyLabel gets the "label" property.
			300	+	// The toggle label.
			301	+	//
			302	+	// The label will be displayed alone or next to the icon, unless
			303	+	// [property@Toggle:child] is set, but will still be read out by the screen
			304	+	// reader.
			305	+	func (x *Toggle) GetPropertyLabel() string {
			306	+	var v gobject.Value
			307	+	x.GetProperty("label", &v)
			308	+	return v.GetString()
			309	+	}
			310	+
			311	+	// SetPropertyName sets the "name" property.
			312	+	// The toggle name.
			313	+	//
			314	+	// Allows accessing the toggle by its name instead of index.
			315	+	//
			316	+	// See [property@ToggleGroup:active-name].
			317	+	func (x *Toggle) SetPropertyName(value string) {
			318	+	var v gobject.Value
			319	+	v.Init(gobject.TypeStringVal)
			320	+	v.SetString(value)
			321	+	x.SetProperty("name", &v)
			322	+	}
			323	+
			324	+	// GetPropertyName gets the "name" property.
			325	+	// The toggle name.
			326	+	//
			327	+	// Allows accessing the toggle by its name instead of index.
			328	+	//
			329	+	// See [property@ToggleGroup:active-name].
			330	+	func (x *Toggle) GetPropertyName() string {
			331	+	var v gobject.Value
			332	+	x.GetProperty("name", &v)
			333	+	return v.GetString()
			334	+	}
			335	+
			336	+	// SetPropertyTooltip sets the "tooltip" property.
			337	+	// The tooltip of the toggle.
			338	+	//
			339	+	// The tooltip can be marked up with the Pango text markup language.
			340	+	func (x *Toggle) SetPropertyTooltip(value string) {
			341	+	var v gobject.Value
			342	+	v.Init(gobject.TypeStringVal)
			343	+	v.SetString(value)
			344	+	x.SetProperty("tooltip", &v)
			345	+	}
			346	+
			347	+	// GetPropertyTooltip gets the "tooltip" property.
			348	+	// The tooltip of the toggle.
			349	+	//
			350	+	// The tooltip can be marked up with the Pango text markup language.
			351	+	func (x *Toggle) GetPropertyTooltip() string {
			352	+	var v gobject.Value
			353	+	x.GetProperty("tooltip", &v)
			354	+	return v.GetString()
			355	+	}
			356	+
			357	+	// SetPropertyUseUnderline sets the "use-underline" property.
			358	+	// Whether an embedded underline in the label indicates a mnemonic.
			359	+	//
			360	+	// See [property@Toggle:label].
			361	+	func (x *Toggle) SetPropertyUseUnderline(value bool) {
			362	+	var v gobject.Value
			363	+	v.Init(gobject.TypeBooleanVal)
			364	+	v.SetBoolean(value)
			365	+	x.SetProperty("use-underline", &v)
			366	+	}
			367	+
			368	+	// GetPropertyUseUnderline gets the "use-underline" property.
			369	+	// Whether an embedded underline in the label indicates a mnemonic.
			370	+	//
			371	+	// See [property@Toggle:label].
			372	+	func (x *Toggle) GetPropertyUseUnderline() bool {
			373	+	var v gobject.Value
			374	+	x.GetProperty("use-underline", &v)
			375	+	return v.GetBoolean()
			376	+	}
			377	+
246		// A group of exclusive toggles.	378		// A group of exclusive toggles.
247		//	379		//
248		// <picture>	380		// <picture>

@@ -574,6 +706,112 @@ func (c *ToggleGroup) SetGoPointer(ptr uintptr) {
574		c.Ptr = ptr	706		c.Ptr = ptr
575		}	707		}
576			708
			709	+	// SetPropertyActive sets the "active" property.
			710	+	// The index of the active toggle.
			711	+	//
			712	+	// Setting the index to a larger value than the number of toggles in the group
			713	+	// unsets the current active toggle.
			714	+	//
			715	+	// If no toggle is active, the property will be set to
			716	+	// [const@Gtk.INVALID_LIST_POSITION].
			717	+	func (x *ToggleGroup) SetPropertyActive(value uint) {
			718	+	var v gobject.Value
			719	+	v.Init(gobject.TypeUintVal)
			720	+	v.SetUint(value)
			721	+	x.SetProperty("active", &v)
			722	+	}
			723	+
			724	+	// GetPropertyActive gets the "active" property.
			725	+	// The index of the active toggle.
			726	+	//
			727	+	// Setting the index to a larger value than the number of toggles in the group
			728	+	// unsets the current active toggle.
			729	+	//
			730	+	// If no toggle is active, the property will be set to
			731	+	// [const@Gtk.INVALID_LIST_POSITION].
			732	+	func (x *ToggleGroup) GetPropertyActive() uint {
			733	+	var v gobject.Value
			734	+	x.GetProperty("active", &v)
			735	+	return v.GetUint()
			736	+	}
			737	+
			738	+	// SetPropertyActiveName sets the "active-name" property.
			739	+	// The name of the active toggle.
			740	+	//
			741	+	// The name can be set via [property@Toggle:name]. If the currently active
			742	+	// toggle doesn't have a name, the property will be set to `NULL`.
			743	+	//
			744	+	// Set it to `NULL` to unset the current active toggle.
			745	+	func (x *ToggleGroup) SetPropertyActiveName(value string) {
			746	+	var v gobject.Value
			747	+	v.Init(gobject.TypeStringVal)
			748	+	v.SetString(value)
			749	+	x.SetProperty("active-name", &v)
			750	+	}
			751	+
			752	+	// GetPropertyActiveName gets the "active-name" property.
			753	+	// The name of the active toggle.
			754	+	//
			755	+	// The name can be set via [property@Toggle:name]. If the currently active
			756	+	// toggle doesn't have a name, the property will be set to `NULL`.
			757	+	//
			758	+	// Set it to `NULL` to unset the current active toggle.
			759	+	func (x *ToggleGroup) GetPropertyActiveName() string {
			760	+	var v gobject.Value
			761	+	x.GetProperty("active-name", &v)
			762	+	return v.GetString()
			763	+	}
			764	+
			765	+	// SetPropertyCanShrink sets the "can-shrink" property.
			766	+	// Whether the toggles can be smaller than the natural size of their contents.
			767	+	//
			768	+	// If set to `TRUE`, the toggle labels will ellipsize.
			769	+	//
			770	+	// See [property@Gtk.Button:can-shrink].
			771	+	func (x *ToggleGroup) SetPropertyCanShrink(value bool) {
			772	+	var v gobject.Value
			773	+	v.Init(gobject.TypeBooleanVal)
			774	+	v.SetBoolean(value)
			775	+	x.SetProperty("can-shrink", &v)
			776	+	}
			777	+
			778	+	// GetPropertyCanShrink gets the "can-shrink" property.
			779	+	// Whether the toggles can be smaller than the natural size of their contents.
			780	+	//
			781	+	// If set to `TRUE`, the toggle labels will ellipsize.
			782	+	//
			783	+	// See [property@Gtk.Button:can-shrink].
			784	+	func (x *ToggleGroup) GetPropertyCanShrink() bool {
			785	+	var v gobject.Value
			786	+	x.GetProperty("can-shrink", &v)
			787	+	return v.GetBoolean()
			788	+	}
			789	+
			790	+	// SetPropertyHomogeneous sets the "homogeneous" property.
			791	+	// Whether all toggles take the same size.
			792	+	func (x *ToggleGroup) SetPropertyHomogeneous(value bool) {
			793	+	var v gobject.Value
			794	+	v.Init(gobject.TypeBooleanVal)
			795	+	v.SetBoolean(value)
			796	+	x.SetProperty("homogeneous", &v)
			797	+	}
			798	+
			799	+	// GetPropertyHomogeneous gets the "homogeneous" property.
			800	+	// Whether all toggles take the same size.
			801	+	func (x *ToggleGroup) GetPropertyHomogeneous() bool {
			802	+	var v gobject.Value
			803	+	x.GetProperty("homogeneous", &v)
			804	+	return v.GetBoolean()
			805	+	}
			806	+
			807	+	// GetPropertyNToggles gets the "n-toggles" property.
			808	+	// The number of toggles within the group.
			809	+	func (x *ToggleGroup) GetPropertyNToggles() uint {
			810	+	var v gobject.Value
			811	+	x.GetProperty("n-toggles", &v)
			812	+	return v.GetUint()
			813	+	}
			814	+
577		// Requests the user's screen reader to announce the given message.	815		// Requests the user's screen reader to announce the given message.
578		//	816		//
579		// This kind of notification is useful for messages that	817		// This kind of notification is useful for messages that

@@ -631,7 +869,7 @@ func (x ToggleGroup) GetAtContext() gtk.ATContext {
631		// This functionality can be overridden by `GtkAccessible`	869		// This functionality can be overridden by `GtkAccessible`
632		// implementations, e.g. to get the bounds from an ignored	870		// implementations, e.g. to get the bounds from an ignored
633		// child widget.	871		// child widget.
634	-	func (x *ToggleGroup) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	872	+	func (x ToggleGroup) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
635			873
636		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	874		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
637		return cret	875		return cret

M v4/adw/adw-toolbar-view.go +149 -1


@@ -505,6 +505,154 @@ func (c *ToolbarView) SetGoPointer(ptr uintptr) {
505		c.Ptr = ptr	505		c.Ptr = ptr
506		}	506		}
507			507
			508	+	// GetPropertyBottomBarHeight gets the "bottom-bar-height" property.
			509	+	// The current bottom bar height.
			510	+	//
			511	+	// Bottom bar height does change depending on
			512	+	// [property@ToolbarView:reveal-bottom-bars], including during the transition.
			513	+	//
			514	+	// See [property@ToolbarView:top-bar-height].
			515	+	func (x *ToolbarView) GetPropertyBottomBarHeight() int {
			516	+	var v gobject.Value
			517	+	x.GetProperty("bottom-bar-height", &v)
			518	+	return v.GetInt()
			519	+	}
			520	+
			521	+	// SetPropertyExtendContentToBottomEdge sets the "extend-content-to-bottom-edge" property.
			522	+	// Whether the content widget can extend behind bottom bars.
			523	+	//
			524	+	// This can be used in combination with
			525	+	// [property@ToolbarView:reveal-bottom-bars] to show and hide toolbars in
			526	+	// fullscreen.
			527	+	//
			528	+	// See [property@ToolbarView:extend-content-to-top-edge].
			529	+	func (x *ToolbarView) SetPropertyExtendContentToBottomEdge(value bool) {
			530	+	var v gobject.Value
			531	+	v.Init(gobject.TypeBooleanVal)
			532	+	v.SetBoolean(value)
			533	+	x.SetProperty("extend-content-to-bottom-edge", &v)
			534	+	}
			535	+
			536	+	// GetPropertyExtendContentToBottomEdge gets the "extend-content-to-bottom-edge" property.
			537	+	// Whether the content widget can extend behind bottom bars.
			538	+	//
			539	+	// This can be used in combination with
			540	+	// [property@ToolbarView:reveal-bottom-bars] to show and hide toolbars in
			541	+	// fullscreen.
			542	+	//
			543	+	// See [property@ToolbarView:extend-content-to-top-edge].
			544	+	func (x *ToolbarView) GetPropertyExtendContentToBottomEdge() bool {
			545	+	var v gobject.Value
			546	+	x.GetProperty("extend-content-to-bottom-edge", &v)
			547	+	return v.GetBoolean()
			548	+	}
			549	+
			550	+	// SetPropertyExtendContentToTopEdge sets the "extend-content-to-top-edge" property.
			551	+	// Whether the content widget can extend behind top bars.
			552	+	//
			553	+	// This can be used in combination with [property@ToolbarView:reveal-top-bars]
			554	+	// to show and hide toolbars in fullscreen.
			555	+	//
			556	+	// See [property@ToolbarView:extend-content-to-bottom-edge].
			557	+	func (x *ToolbarView) SetPropertyExtendContentToTopEdge(value bool) {
			558	+	var v gobject.Value
			559	+	v.Init(gobject.TypeBooleanVal)
			560	+	v.SetBoolean(value)
			561	+	x.SetProperty("extend-content-to-top-edge", &v)
			562	+	}
			563	+
			564	+	// GetPropertyExtendContentToTopEdge gets the "extend-content-to-top-edge" property.
			565	+	// Whether the content widget can extend behind top bars.
			566	+	//
			567	+	// This can be used in combination with [property@ToolbarView:reveal-top-bars]
			568	+	// to show and hide toolbars in fullscreen.
			569	+	//
			570	+	// See [property@ToolbarView:extend-content-to-bottom-edge].
			571	+	func (x *ToolbarView) GetPropertyExtendContentToTopEdge() bool {
			572	+	var v gobject.Value
			573	+	x.GetProperty("extend-content-to-top-edge", &v)
			574	+	return v.GetBoolean()
			575	+	}
			576	+
			577	+	// SetPropertyRevealBottomBars sets the "reveal-bottom-bars" property.
			578	+	// Whether bottom bars are visible.
			579	+	//
			580	+	// The transition will be animated.
			581	+	//
			582	+	// This can be used in combination with
			583	+	// [property@ToolbarView:extend-content-to-bottom-edge] to show and hide
			584	+	// toolbars in fullscreen.
			585	+	//
			586	+	// See [property@ToolbarView:reveal-top-bars].
			587	+	func (x *ToolbarView) SetPropertyRevealBottomBars(value bool) {
			588	+	var v gobject.Value
			589	+	v.Init(gobject.TypeBooleanVal)
			590	+	v.SetBoolean(value)
			591	+	x.SetProperty("reveal-bottom-bars", &v)
			592	+	}
			593	+
			594	+	// GetPropertyRevealBottomBars gets the "reveal-bottom-bars" property.
			595	+	// Whether bottom bars are visible.
			596	+	//
			597	+	// The transition will be animated.
			598	+	//
			599	+	// This can be used in combination with
			600	+	// [property@ToolbarView:extend-content-to-bottom-edge] to show and hide
			601	+	// toolbars in fullscreen.
			602	+	//
			603	+	// See [property@ToolbarView:reveal-top-bars].
			604	+	func (x *ToolbarView) GetPropertyRevealBottomBars() bool {
			605	+	var v gobject.Value
			606	+	x.GetProperty("reveal-bottom-bars", &v)
			607	+	return v.GetBoolean()
			608	+	}
			609	+
			610	+	// SetPropertyRevealTopBars sets the "reveal-top-bars" property.
			611	+	// Whether top bars are revealed.
			612	+	//
			613	+	// The transition will be animated.
			614	+	//
			615	+	// This can be used in combination with
			616	+	// [property@ToolbarView:extend-content-to-top-edge] to show and hide toolbars
			617	+	// in fullscreen.
			618	+	//
			619	+	// See [property@ToolbarView:reveal-bottom-bars].
			620	+	func (x *ToolbarView) SetPropertyRevealTopBars(value bool) {
			621	+	var v gobject.Value
			622	+	v.Init(gobject.TypeBooleanVal)
			623	+	v.SetBoolean(value)
			624	+	x.SetProperty("reveal-top-bars", &v)
			625	+	}
			626	+
			627	+	// GetPropertyRevealTopBars gets the "reveal-top-bars" property.
			628	+	// Whether top bars are revealed.
			629	+	//
			630	+	// The transition will be animated.
			631	+	//
			632	+	// This can be used in combination with
			633	+	// [property@ToolbarView:extend-content-to-top-edge] to show and hide toolbars
			634	+	// in fullscreen.
			635	+	//
			636	+	// See [property@ToolbarView:reveal-bottom-bars].
			637	+	func (x *ToolbarView) GetPropertyRevealTopBars() bool {
			638	+	var v gobject.Value
			639	+	x.GetProperty("reveal-top-bars", &v)
			640	+	return v.GetBoolean()
			641	+	}
			642	+
			643	+	// GetPropertyTopBarHeight gets the "top-bar-height" property.
			644	+	// The current top bar height.
			645	+	//
			646	+	// Top bar height does change depending [property@ToolbarView:reveal-top-bars],
			647	+	// including during the transition.
			648	+	//
			649	+	// See [property@ToolbarView:bottom-bar-height].
			650	+	func (x *ToolbarView) GetPropertyTopBarHeight() int {
			651	+	var v gobject.Value
			652	+	x.GetProperty("top-bar-height", &v)
			653	+	return v.GetInt()
			654	+	}
			655	+
508		// Requests the user's screen reader to announce the given message.	656		// Requests the user's screen reader to announce the given message.
509		//	657		//
510		// This kind of notification is useful for messages that	658		// This kind of notification is useful for messages that

@@ -562,7 +710,7 @@ func (x ToolbarView) GetAtContext() gtk.ATContext {
562		// This functionality can be overridden by `GtkAccessible`	710		// This functionality can be overridden by `GtkAccessible`
563		// implementations, e.g. to get the bounds from an ignored	711		// implementations, e.g. to get the bounds from an ignored
564		// child widget.	712		// child widget.
565	-	func (x *ToolbarView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	713	+	func (x ToolbarView) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
566			714
567		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	715		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
568		return cret	716		return cret

M v4/adw/adw-view-stack.go +278 -2


@@ -433,6 +433,143 @@ func (c *ViewStack) SetGoPointer(ptr uintptr) {
433		c.Ptr = ptr	433		c.Ptr = ptr
434		}	434		}
435			435
			436	+	// SetPropertyEnableTransitions sets the "enable-transitions" property.
			437	+	// Whether the stack uses a crossfade transition between pages.
			438	+	//
			439	+	// Use [property@ViewStack:transition-duration] to control the duration, and
			440	+	// [property@ViewStack:transition-running] to know when the transition is
			441	+	// running.
			442	+	func (x *ViewStack) SetPropertyEnableTransitions(value bool) {
			443	+	var v gobject.Value
			444	+	v.Init(gobject.TypeBooleanVal)
			445	+	v.SetBoolean(value)
			446	+	x.SetProperty("enable-transitions", &v)
			447	+	}
			448	+
			449	+	// GetPropertyEnableTransitions gets the "enable-transitions" property.
			450	+	// Whether the stack uses a crossfade transition between pages.
			451	+	//
			452	+	// Use [property@ViewStack:transition-duration] to control the duration, and
			453	+	// [property@ViewStack:transition-running] to know when the transition is
			454	+	// running.
			455	+	func (x *ViewStack) GetPropertyEnableTransitions() bool {
			456	+	var v gobject.Value
			457	+	x.GetProperty("enable-transitions", &v)
			458	+	return v.GetBoolean()
			459	+	}
			460	+
			461	+	// SetPropertyHhomogeneous sets the "hhomogeneous" property.
			462	+	// Whether the stack is horizontally homogeneous.
			463	+	//
			464	+	// If the stack is horizontally homogeneous, it allocates the same width for
			465	+	// all children.
			466	+	//
			467	+	// If it's `FALSE`, the stack may change width when a different child becomes
			468	+	// visible.
			469	+	func (x *ViewStack) SetPropertyHhomogeneous(value bool) {
			470	+	var v gobject.Value
			471	+	v.Init(gobject.TypeBooleanVal)
			472	+	v.SetBoolean(value)
			473	+	x.SetProperty("hhomogeneous", &v)
			474	+	}
			475	+
			476	+	// GetPropertyHhomogeneous gets the "hhomogeneous" property.
			477	+	// Whether the stack is horizontally homogeneous.
			478	+	//
			479	+	// If the stack is horizontally homogeneous, it allocates the same width for
			480	+	// all children.
			481	+	//
			482	+	// If it's `FALSE`, the stack may change width when a different child becomes
			483	+	// visible.
			484	+	func (x *ViewStack) GetPropertyHhomogeneous() bool {
			485	+	var v gobject.Value
			486	+	x.GetProperty("hhomogeneous", &v)
			487	+	return v.GetBoolean()
			488	+	}
			489	+
			490	+	// SetPropertyTransitionDuration sets the "transition-duration" property.
			491	+	// The transition animation duration, in milliseconds.
			492	+	//
			493	+	// Only used when [property@ViewStack:enable-transitions] is set to `TRUE`.
			494	+	func (x *ViewStack) SetPropertyTransitionDuration(value uint) {
			495	+	var v gobject.Value
			496	+	v.Init(gobject.TypeUintVal)
			497	+	v.SetUint(value)
			498	+	x.SetProperty("transition-duration", &v)
			499	+	}
			500	+
			501	+	// GetPropertyTransitionDuration gets the "transition-duration" property.
			502	+	// The transition animation duration, in milliseconds.
			503	+	//
			504	+	// Only used when [property@ViewStack:enable-transitions] is set to `TRUE`.
			505	+	func (x *ViewStack) GetPropertyTransitionDuration() uint {
			506	+	var v gobject.Value
			507	+	x.GetProperty("transition-duration", &v)
			508	+	return v.GetUint()
			509	+	}
			510	+
			511	+	// GetPropertyTransitionRunning gets the "transition-running" property.
			512	+	// Whether a transition is currently running.
			513	+	//
			514	+	// If a transition is impossible, the property value will be set to `TRUE` and
			515	+	// then immediately to `FALSE`, so it's possible to rely on its notifications
			516	+	// to know that a transition has happened.
			517	+	func (x *ViewStack) GetPropertyTransitionRunning() bool {
			518	+	var v gobject.Value
			519	+	x.GetProperty("transition-running", &v)
			520	+	return v.GetBoolean()
			521	+	}
			522	+
			523	+	// SetPropertyVhomogeneous sets the "vhomogeneous" property.
			524	+	// Whether the stack is vertically homogeneous.
			525	+	//
			526	+	// If the stack is vertically homogeneous, it allocates the same height for
			527	+	// all children.
			528	+	//
			529	+	// If it's `FALSE`, the stack may change height when a different child becomes
			530	+	// visible.
			531	+	func (x *ViewStack) SetPropertyVhomogeneous(value bool) {
			532	+	var v gobject.Value
			533	+	v.Init(gobject.TypeBooleanVal)
			534	+	v.SetBoolean(value)
			535	+	x.SetProperty("vhomogeneous", &v)
			536	+	}
			537	+
			538	+	// GetPropertyVhomogeneous gets the "vhomogeneous" property.
			539	+	// Whether the stack is vertically homogeneous.
			540	+	//
			541	+	// If the stack is vertically homogeneous, it allocates the same height for
			542	+	// all children.
			543	+	//
			544	+	// If it's `FALSE`, the stack may change height when a different child becomes
			545	+	// visible.
			546	+	func (x *ViewStack) GetPropertyVhomogeneous() bool {
			547	+	var v gobject.Value
			548	+	x.GetProperty("vhomogeneous", &v)
			549	+	return v.GetBoolean()
			550	+	}
			551	+
			552	+	// SetPropertyVisibleChildName sets the "visible-child-name" property.
			553	+	// The name of the widget currently visible in the stack.
			554	+	//
			555	+	// See [property@ViewStack:visible-child].
			556	+	func (x *ViewStack) SetPropertyVisibleChildName(value string) {
			557	+	var v gobject.Value
			558	+	v.Init(gobject.TypeStringVal)
			559	+	v.SetString(value)
			560	+	x.SetProperty("visible-child-name", &v)
			561	+	}
			562	+
			563	+	// GetPropertyVisibleChildName gets the "visible-child-name" property.
			564	+	// The name of the widget currently visible in the stack.
			565	+	//
			566	+	// See [property@ViewStack:visible-child].
			567	+	func (x *ViewStack) GetPropertyVisibleChildName() string {
			568	+	var v gobject.Value
			569	+	x.GetProperty("visible-child-name", &v)
			570	+	return v.GetString()
			571	+	}
			572	+
436		// Requests the user's screen reader to announce the given message.	573		// Requests the user's screen reader to announce the given message.
437		//	574		//
438		// This kind of notification is useful for messages that	575		// This kind of notification is useful for messages that

@@ -490,7 +627,7 @@ func (x ViewStack) GetAtContext() gtk.ATContext {
490		// This functionality can be overridden by `GtkAccessible`	627		// This functionality can be overridden by `GtkAccessible`
491		// implementations, e.g. to get the bounds from an ignored	628		// implementations, e.g. to get the bounds from an ignored
492		// child widget.	629		// child widget.
493	-	func (x *ViewStack) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	630	+	func (x ViewStack) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
494			631
495		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	632		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
496		return cret	633		return cret

@@ -895,6 +1032,145 @@ func (c *ViewStackPage) SetGoPointer(ptr uintptr) {
895		c.Ptr = ptr	1032		c.Ptr = ptr
896		}	1033		}
897			1034
			1035	+	// SetPropertyBadgeNumber sets the "badge-number" property.
			1036	+	// The badge number for this page.
			1037	+	//
			1038	+	// [class@ViewSwitcher] can display it as a badge next to the page icon. It is
			1039	+	// commonly used to display a number of unread items within the page.
			1040	+	//
			1041	+	// It can be used together with [property@ViewStack{age}:needs-attention].
			1042	+	func (x *ViewStackPage) SetPropertyBadgeNumber(value uint) {
			1043	+	var v gobject.Value
			1044	+	v.Init(gobject.TypeUintVal)
			1045	+	v.SetUint(value)
			1046	+	x.SetProperty("badge-number", &v)
			1047	+	}
			1048	+
			1049	+	// GetPropertyBadgeNumber gets the "badge-number" property.
			1050	+	// The badge number for this page.
			1051	+	//
			1052	+	// [class@ViewSwitcher] can display it as a badge next to the page icon. It is
			1053	+	// commonly used to display a number of unread items within the page.
			1054	+	//
			1055	+	// It can be used together with [property@ViewStack{age}:needs-attention].
			1056	+	func (x *ViewStackPage) GetPropertyBadgeNumber() uint {
			1057	+	var v gobject.Value
			1058	+	x.GetProperty("badge-number", &v)
			1059	+	return v.GetUint()
			1060	+	}
			1061	+
			1062	+	// SetPropertyIconName sets the "icon-name" property.
			1063	+	// The icon name of the child page.
			1064	+	func (x *ViewStackPage) SetPropertyIconName(value string) {
			1065	+	var v gobject.Value
			1066	+	v.Init(gobject.TypeStringVal)
			1067	+	v.SetString(value)
			1068	+	x.SetProperty("icon-name", &v)
			1069	+	}
			1070	+
			1071	+	// GetPropertyIconName gets the "icon-name" property.
			1072	+	// The icon name of the child page.
			1073	+	func (x *ViewStackPage) GetPropertyIconName() string {
			1074	+	var v gobject.Value
			1075	+	x.GetProperty("icon-name", &v)
			1076	+	return v.GetString()
			1077	+	}
			1078	+
			1079	+	// SetPropertyName sets the "name" property.
			1080	+	// The name of the child page.
			1081	+	func (x *ViewStackPage) SetPropertyName(value string) {
			1082	+	var v gobject.Value
			1083	+	v.Init(gobject.TypeStringVal)
			1084	+	v.SetString(value)
			1085	+	x.SetProperty("name", &v)
			1086	+	}
			1087	+
			1088	+	// GetPropertyName gets the "name" property.
			1089	+	// The name of the child page.
			1090	+	func (x *ViewStackPage) GetPropertyName() string {
			1091	+	var v gobject.Value
			1092	+	x.GetProperty("name", &v)
			1093	+	return v.GetString()
			1094	+	}
			1095	+
			1096	+	// SetPropertyNeedsAttention sets the "needs-attention" property.
			1097	+	// Whether the page requires the user attention.
			1098	+	//
			1099	+	// [class@ViewSwitcher] will display it as a dot next to the page icon.
			1100	+	func (x *ViewStackPage) SetPropertyNeedsAttention(value bool) {
			1101	+	var v gobject.Value
			1102	+	v.Init(gobject.TypeBooleanVal)
			1103	+	v.SetBoolean(value)
			1104	+	x.SetProperty("needs-attention", &v)
			1105	+	}
			1106	+
			1107	+	// GetPropertyNeedsAttention gets the "needs-attention" property.
			1108	+	// Whether the page requires the user attention.
			1109	+	//
			1110	+	// [class@ViewSwitcher] will display it as a dot next to the page icon.
			1111	+	func (x *ViewStackPage) GetPropertyNeedsAttention() bool {
			1112	+	var v gobject.Value
			1113	+	x.GetProperty("needs-attention", &v)
			1114	+	return v.GetBoolean()
			1115	+	}
			1116	+
			1117	+	// SetPropertyTitle sets the "title" property.
			1118	+	// The title of the child page.
			1119	+	func (x *ViewStackPage) SetPropertyTitle(value string) {
			1120	+	var v gobject.Value
			1121	+	v.Init(gobject.TypeStringVal)
			1122	+	v.SetString(value)
			1123	+	x.SetProperty("title", &v)
			1124	+	}
			1125	+
			1126	+	// GetPropertyTitle gets the "title" property.
			1127	+	// The title of the child page.
			1128	+	func (x *ViewStackPage) GetPropertyTitle() string {
			1129	+	var v gobject.Value
			1130	+	x.GetProperty("title", &v)
			1131	+	return v.GetString()
			1132	+	}
			1133	+
			1134	+	// SetPropertyUseUnderline sets the "use-underline" property.
			1135	+	// Whether an embedded underline in the title indicates a mnemonic.
			1136	+	func (x *ViewStackPage) SetPropertyUseUnderline(value bool) {
			1137	+	var v gobject.Value
			1138	+	v.Init(gobject.TypeBooleanVal)
			1139	+	v.SetBoolean(value)
			1140	+	x.SetProperty("use-underline", &v)
			1141	+	}
			1142	+
			1143	+	// GetPropertyUseUnderline gets the "use-underline" property.
			1144	+	// Whether an embedded underline in the title indicates a mnemonic.
			1145	+	func (x *ViewStackPage) GetPropertyUseUnderline() bool {
			1146	+	var v gobject.Value
			1147	+	x.GetProperty("use-underline", &v)
			1148	+	return v.GetBoolean()
			1149	+	}
			1150	+
			1151	+	// SetPropertyVisible sets the "visible" property.
			1152	+	// Whether this page is visible.
			1153	+	//
			1154	+	// This is independent from the [property@Gtk.Widget:visible] property of
			1155	+	// [property@ViewStackPage:child].
			1156	+	func (x *ViewStackPage) SetPropertyVisible(value bool) {
			1157	+	var v gobject.Value
			1158	+	v.Init(gobject.TypeBooleanVal)
			1159	+	v.SetBoolean(value)
			1160	+	x.SetProperty("visible", &v)
			1161	+	}
			1162	+
			1163	+	// GetPropertyVisible gets the "visible" property.
			1164	+	// Whether this page is visible.
			1165	+	//
			1166	+	// This is independent from the [property@Gtk.Widget:visible] property of
			1167	+	// [property@ViewStackPage:child].
			1168	+	func (x *ViewStackPage) GetPropertyVisible() bool {
			1169	+	var v gobject.Value
			1170	+	x.GetProperty("visible", &v)
			1171	+	return v.GetBoolean()
			1172	+	}
			1173	+
898		// Requests the user's screen reader to announce the given message.	1174		// Requests the user's screen reader to announce the given message.
899		//	1175		//
900		// This kind of notification is useful for messages that	1176		// This kind of notification is useful for messages that

@@ -952,7 +1228,7 @@ func (x ViewStackPage) GetAtContext() gtk.ATContext {
952		// This functionality can be overridden by `GtkAccessible`	1228		// This functionality can be overridden by `GtkAccessible`
953		// implementations, e.g. to get the bounds from an ignored	1229		// implementations, e.g. to get the bounds from an ignored
954		// child widget.	1230		// child widget.
955	-	func (x *ViewStackPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	1231	+	func (x ViewStackPage) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
956			1232
957		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	1233		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
958		return cret	1234		return cret

M v4/adw/adw-view-switcher-bar.go +18 -1


@@ -173,6 +173,23 @@ func (c *ViewSwitcherBar) SetGoPointer(ptr uintptr) {
173		c.Ptr = ptr	173		c.Ptr = ptr
174		}	174		}
175			175
			176	+	// SetPropertyReveal sets the "reveal" property.
			177	+	// Whether the bar should be revealed or hidden.
			178	+	func (x *ViewSwitcherBar) SetPropertyReveal(value bool) {
			179	+	var v gobject.Value
			180	+	v.Init(gobject.TypeBooleanVal)
			181	+	v.SetBoolean(value)
			182	+	x.SetProperty("reveal", &v)
			183	+	}
			184	+
			185	+	// GetPropertyReveal gets the "reveal" property.
			186	+	// Whether the bar should be revealed or hidden.
			187	+	func (x *ViewSwitcherBar) GetPropertyReveal() bool {
			188	+	var v gobject.Value
			189	+	x.GetProperty("reveal", &v)
			190	+	return v.GetBoolean()
			191	+	}
			192	+
176		// Requests the user's screen reader to announce the given message.	193		// Requests the user's screen reader to announce the given message.
177		//	194		//
178		// This kind of notification is useful for messages that	195		// This kind of notification is useful for messages that

@@ -230,7 +247,7 @@ func (x ViewSwitcherBar) GetAtContext() gtk.ATContext {
230		// This functionality can be overridden by `GtkAccessible`	247		// This functionality can be overridden by `GtkAccessible`
231		// implementations, e.g. to get the bounds from an ignored	248		// implementations, e.g. to get the bounds from an ignored
232		// child widget.	249		// child widget.
233	-	func (x *ViewSwitcherBar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	250	+	func (x ViewSwitcherBar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
234			251
235		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	252		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
236		return cret	253		return cret

M v4/adw/adw-view-switcher-title.go +87 -1


@@ -233,6 +233,92 @@ func (c *ViewSwitcherTitle) SetGoPointer(ptr uintptr) {
233		c.Ptr = ptr	233		c.Ptr = ptr
234		}	234		}
235			235
			236	+	// SetPropertySubtitle sets the "subtitle" property.
			237	+	// The subtitle to display.
			238	+	//
			239	+	// The subtitle should give the user additional details.
			240	+	func (x *ViewSwitcherTitle) SetPropertySubtitle(value string) {
			241	+	var v gobject.Value
			242	+	v.Init(gobject.TypeStringVal)
			243	+	v.SetString(value)
			244	+	x.SetProperty("subtitle", &v)
			245	+	}
			246	+
			247	+	// GetPropertySubtitle gets the "subtitle" property.
			248	+	// The subtitle to display.
			249	+	//
			250	+	// The subtitle should give the user additional details.
			251	+	func (x *ViewSwitcherTitle) GetPropertySubtitle() string {
			252	+	var v gobject.Value
			253	+	x.GetProperty("subtitle", &v)
			254	+	return v.GetString()
			255	+	}
			256	+
			257	+	// SetPropertyTitle sets the "title" property.
			258	+	// The title to display.
			259	+	//
			260	+	// The title typically identifies the current view or content item, and
			261	+	// generally does not use the application name.
			262	+	func (x *ViewSwitcherTitle) SetPropertyTitle(value string) {
			263	+	var v gobject.Value
			264	+	v.Init(gobject.TypeStringVal)
			265	+	v.SetString(value)
			266	+	x.SetProperty("title", &v)
			267	+	}
			268	+
			269	+	// GetPropertyTitle gets the "title" property.
			270	+	// The title to display.
			271	+	//
			272	+	// The title typically identifies the current view or content item, and
			273	+	// generally does not use the application name.
			274	+	func (x *ViewSwitcherTitle) GetPropertyTitle() string {
			275	+	var v gobject.Value
			276	+	x.GetProperty("title", &v)
			277	+	return v.GetString()
			278	+	}
			279	+
			280	+	// GetPropertyTitleVisible gets the "title-visible" property.
			281	+	// Whether the title is currently visible.
			282	+	//
			283	+	// If the title is visible, it means the view switcher is hidden an it may be
			284	+	// wanted to show an alternative switcher, e.g. a [class@ViewSwitcherBar].
			285	+	func (x *ViewSwitcherTitle) GetPropertyTitleVisible() bool {
			286	+	var v gobject.Value
			287	+	x.GetProperty("title-visible", &v)
			288	+	return v.GetBoolean()
			289	+	}
			290	+
			291	+	// SetPropertyViewSwitcherEnabled sets the "view-switcher-enabled" property.
			292	+	// Whether the view switcher is enabled.
			293	+	//
			294	+	// If it is disabled, the title will be displayed instead. This allows to
			295	+	// programmatically hide the view switcher even if it fits in the available
			296	+	// space.
			297	+	//
			298	+	// This can be used e.g. to ensure the view switcher is hidden below a certain
			299	+	// window width, or any other constraint you find suitable.
			300	+	func (x *ViewSwitcherTitle) SetPropertyViewSwitcherEnabled(value bool) {
			301	+	var v gobject.Value
			302	+	v.Init(gobject.TypeBooleanVal)
			303	+	v.SetBoolean(value)
			304	+	x.SetProperty("view-switcher-enabled", &v)
			305	+	}
			306	+
			307	+	// GetPropertyViewSwitcherEnabled gets the "view-switcher-enabled" property.
			308	+	// Whether the view switcher is enabled.
			309	+	//
			310	+	// If it is disabled, the title will be displayed instead. This allows to
			311	+	// programmatically hide the view switcher even if it fits in the available
			312	+	// space.
			313	+	//
			314	+	// This can be used e.g. to ensure the view switcher is hidden below a certain
			315	+	// window width, or any other constraint you find suitable.
			316	+	func (x *ViewSwitcherTitle) GetPropertyViewSwitcherEnabled() bool {
			317	+	var v gobject.Value
			318	+	x.GetProperty("view-switcher-enabled", &v)
			319	+	return v.GetBoolean()
			320	+	}
			321	+
236		// Requests the user's screen reader to announce the given message.	322		// Requests the user's screen reader to announce the given message.
237		//	323		//
238		// This kind of notification is useful for messages that	324		// This kind of notification is useful for messages that

@@ -290,7 +376,7 @@ func (x ViewSwitcherTitle) GetAtContext() gtk.ATContext {
290		// This functionality can be overridden by `GtkAccessible`	376		// This functionality can be overridden by `GtkAccessible`
291		// implementations, e.g. to get the bounds from an ignored	377		// implementations, e.g. to get the bounds from an ignored
292		// child widget.	378		// child widget.
293	-	func (x *ViewSwitcherTitle) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	379	+	func (x ViewSwitcherTitle) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
294			380
295		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	381		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
296		return cret	382		return cret

M v4/adw/adw-view-switcher.go +1 -1


@@ -256,7 +256,7 @@ func (x ViewSwitcher) GetAtContext() gtk.ATContext {
256		// This functionality can be overridden by `GtkAccessible`	256		// This functionality can be overridden by `GtkAccessible`
257		// implementations, e.g. to get the bounds from an ignored	257		// implementations, e.g. to get the bounds from an ignored
258		// child widget.	258		// child widget.
259	-	func (x *ViewSwitcher) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	259	+	func (x ViewSwitcher) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
260			260
261		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	261		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
262		return cret	262		return cret

M v4/adw/adw-window-title.go +45 -1


@@ -122,6 +122,50 @@ func (c *WindowTitle) SetGoPointer(ptr uintptr) {
122		c.Ptr = ptr	122		c.Ptr = ptr
123		}	123		}
124			124
			125	+	// SetPropertySubtitle sets the "subtitle" property.
			126	+	// The subtitle to display.
			127	+	//
			128	+	// The subtitle should give the user additional details.
			129	+	func (x *WindowTitle) SetPropertySubtitle(value string) {
			130	+	var v gobject.Value
			131	+	v.Init(gobject.TypeStringVal)
			132	+	v.SetString(value)
			133	+	x.SetProperty("subtitle", &v)
			134	+	}
			135	+
			136	+	// GetPropertySubtitle gets the "subtitle" property.
			137	+	// The subtitle to display.
			138	+	//
			139	+	// The subtitle should give the user additional details.
			140	+	func (x *WindowTitle) GetPropertySubtitle() string {
			141	+	var v gobject.Value
			142	+	x.GetProperty("subtitle", &v)
			143	+	return v.GetString()
			144	+	}
			145	+
			146	+	// SetPropertyTitle sets the "title" property.
			147	+	// The title to display.
			148	+	//
			149	+	// The title typically identifies the current view or content item, and
			150	+	// generally does not use the application name.
			151	+	func (x *WindowTitle) SetPropertyTitle(value string) {
			152	+	var v gobject.Value
			153	+	v.Init(gobject.TypeStringVal)
			154	+	v.SetString(value)
			155	+	x.SetProperty("title", &v)
			156	+	}
			157	+
			158	+	// GetPropertyTitle gets the "title" property.
			159	+	// The title to display.
			160	+	//
			161	+	// The title typically identifies the current view or content item, and
			162	+	// generally does not use the application name.
			163	+	func (x *WindowTitle) GetPropertyTitle() string {
			164	+	var v gobject.Value
			165	+	x.GetProperty("title", &v)
			166	+	return v.GetString()
			167	+	}
			168	+
125		// Requests the user's screen reader to announce the given message.	169		// Requests the user's screen reader to announce the given message.
126		//	170		//
127		// This kind of notification is useful for messages that	171		// This kind of notification is useful for messages that

@@ -179,7 +223,7 @@ func (x WindowTitle) GetAtContext() gtk.ATContext {
179		// This functionality can be overridden by `GtkAccessible`	223		// This functionality can be overridden by `GtkAccessible`
180		// implementations, e.g. to get the bounds from an ignored	224		// implementations, e.g. to get the bounds from an ignored
181		// child widget.	225		// child widget.
182	-	func (x *WindowTitle) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	226	+	func (x WindowTitle) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
183			227
184		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	228		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
185		return cret	229		return cret

M v4/adw/adw-window.go +35 -2


@@ -273,6 +273,39 @@ func (c *Window) SetGoPointer(ptr uintptr) {
273		c.Ptr = ptr	273		c.Ptr = ptr
274		}	274		}
275			275
			276	+	// SetPropertyAdaptivePreview sets the "adaptive-preview" property.
			277	+	// Whether adaptive preview is currently open.
			278	+	//
			279	+	// Adaptive preview is a debugging tool used for testing the window
			280	+	// contents at specific screen sizes, simulating mobile environment.
			281	+	//
			282	+	// Adaptive preview can always be accessed from inspector. This function
			283	+	// allows applications to open it manually.
			284	+	//
			285	+	// Most applications should not use this property.
			286	+	func (x *Window) SetPropertyAdaptivePreview(value bool) {
			287	+	var v gobject.Value
			288	+	v.Init(gobject.TypeBooleanVal)
			289	+	v.SetBoolean(value)
			290	+	x.SetProperty("adaptive-preview", &v)
			291	+	}
			292	+
			293	+	// GetPropertyAdaptivePreview gets the "adaptive-preview" property.
			294	+	// Whether adaptive preview is currently open.
			295	+	//
			296	+	// Adaptive preview is a debugging tool used for testing the window
			297	+	// contents at specific screen sizes, simulating mobile environment.
			298	+	//
			299	+	// Adaptive preview can always be accessed from inspector. This function
			300	+	// allows applications to open it manually.
			301	+	//
			302	+	// Most applications should not use this property.
			303	+	func (x *Window) GetPropertyAdaptivePreview() bool {
			304	+	var v gobject.Value
			305	+	x.GetProperty("adaptive-preview", &v)
			306	+	return v.GetBoolean()
			307	+	}
			308	+
276		// Requests the user's screen reader to announce the given message.	309		// Requests the user's screen reader to announce the given message.
277		//	310		//
278		// This kind of notification is useful for messages that	311		// This kind of notification is useful for messages that

@@ -330,7 +363,7 @@ func (x Window) GetAtContext() gtk.ATContext {
330		// This functionality can be overridden by `GtkAccessible`	363		// This functionality can be overridden by `GtkAccessible`
331		// implementations, e.g. to get the bounds from an ignored	364		// implementations, e.g. to get the bounds from an ignored
332		// child widget.	365		// child widget.
333	-	func (x *Window) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	366	+	func (x Window) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
334			367
335		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	368		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
336		return cret	369		return cret

@@ -585,7 +618,7 @@ func (x Window) GetSurface() gdk.Surface {
585		//	618		//
586		// This is the translation from @self's surface coordinates into	619		// This is the translation from @self's surface coordinates into
587		// @self's widget coordinates.	620		// @self's widget coordinates.
588	-	func (x *Window) GetSurfaceTransform(XVar float64, YVar float64) {	621	+	func (x Window) GetSurfaceTransform(XVar float64, YVar *float64) {
589			622
590		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	623		gtk.XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
591			624

M v4/adw/adw-wrap-box.go +166 -1


@@ -480,6 +480,171 @@ func (c *WrapBox) SetGoPointer(ptr uintptr) {
480		c.Ptr = ptr	480		c.Ptr = ptr
481		}	481		}
482			482
			483	+	// SetPropertyAlign sets the "align" property.
			484	+	// The alignment of the children within each line.
			485	+	//
			486	+	// 0 means the children are placed at the start of the line, 1 means they are
			487	+	// placed at the end of the line. 0.5 means they are placed in the middle of
			488	+	// the line.
			489	+	//
			490	+	// Alignment is only used when [property@WrapBox:justify] is set to
			491	+	// `ADW_JUSTIFY_NONE`, or on the last line when the
			492	+	// [property@WrapBox:justify-last-line] is `FALSE`.
			493	+	func (x *WrapBox) SetPropertyAlign(value float32) {
			494	+	var v gobject.Value
			495	+	v.Init(gobject.TypeFloatVal)
			496	+	v.SetFloat(value)
			497	+	x.SetProperty("align", &v)
			498	+	}
			499	+
			500	+	// GetPropertyAlign gets the "align" property.
			501	+	// The alignment of the children within each line.
			502	+	//
			503	+	// 0 means the children are placed at the start of the line, 1 means they are
			504	+	// placed at the end of the line. 0.5 means they are placed in the middle of
			505	+	// the line.
			506	+	//
			507	+	// Alignment is only used when [property@WrapBox:justify] is set to
			508	+	// `ADW_JUSTIFY_NONE`, or on the last line when the
			509	+	// [property@WrapBox:justify-last-line] is `FALSE`.
			510	+	func (x *WrapBox) GetPropertyAlign() float32 {
			511	+	var v gobject.Value
			512	+	x.GetProperty("align", &v)
			513	+	return v.GetFloat()
			514	+	}
			515	+
			516	+	// SetPropertyChildSpacing sets the "child-spacing" property.
			517	+	// The spacing between widgets on the same line.
			518	+	//
			519	+	// See [property@WrapBox:child-spacing-unit].
			520	+	func (x *WrapBox) SetPropertyChildSpacing(value int) {
			521	+	var v gobject.Value
			522	+	v.Init(gobject.TypeIntVal)
			523	+	v.SetInt(value)
			524	+	x.SetProperty("child-spacing", &v)
			525	+	}
			526	+
			527	+	// GetPropertyChildSpacing gets the "child-spacing" property.
			528	+	// The spacing between widgets on the same line.
			529	+	//
			530	+	// See [property@WrapBox:child-spacing-unit].
			531	+	func (x *WrapBox) GetPropertyChildSpacing() int {
			532	+	var v gobject.Value
			533	+	x.GetProperty("child-spacing", &v)
			534	+	return v.GetInt()
			535	+	}
			536	+
			537	+	// SetPropertyJustifyLastLine sets the "justify-last-line" property.
			538	+	// Whether the last line should be stretched to fill the entire widget.
			539	+	//
			540	+	// See [property@WrapBox:justify].
			541	+	func (x *WrapBox) SetPropertyJustifyLastLine(value bool) {
			542	+	var v gobject.Value
			543	+	v.Init(gobject.TypeBooleanVal)
			544	+	v.SetBoolean(value)
			545	+	x.SetProperty("justify-last-line", &v)
			546	+	}
			547	+
			548	+	// GetPropertyJustifyLastLine gets the "justify-last-line" property.
			549	+	// Whether the last line should be stretched to fill the entire widget.
			550	+	//
			551	+	// See [property@WrapBox:justify].
			552	+	func (x *WrapBox) GetPropertyJustifyLastLine() bool {
			553	+	var v gobject.Value
			554	+	x.GetProperty("justify-last-line", &v)
			555	+	return v.GetBoolean()
			556	+	}
			557	+
			558	+	// SetPropertyLineHomogeneous sets the "line-homogeneous" property.
			559	+	// Whether all lines should take the same amount of space.
			560	+	func (x *WrapBox) SetPropertyLineHomogeneous(value bool) {
			561	+	var v gobject.Value
			562	+	v.Init(gobject.TypeBooleanVal)
			563	+	v.SetBoolean(value)
			564	+	x.SetProperty("line-homogeneous", &v)
			565	+	}
			566	+
			567	+	// GetPropertyLineHomogeneous gets the "line-homogeneous" property.
			568	+	// Whether all lines should take the same amount of space.
			569	+	func (x *WrapBox) GetPropertyLineHomogeneous() bool {
			570	+	var v gobject.Value
			571	+	x.GetProperty("line-homogeneous", &v)
			572	+	return v.GetBoolean()
			573	+	}
			574	+
			575	+	// SetPropertyLineSpacing sets the "line-spacing" property.
			576	+	// The spacing between lines.
			577	+	//
			578	+	// See [property@WrapBox:line-spacing-unit].
			579	+	func (x *WrapBox) SetPropertyLineSpacing(value int) {
			580	+	var v gobject.Value
			581	+	v.Init(gobject.TypeIntVal)
			582	+	v.SetInt(value)
			583	+	x.SetProperty("line-spacing", &v)
			584	+	}
			585	+
			586	+	// GetPropertyLineSpacing gets the "line-spacing" property.
			587	+	// The spacing between lines.
			588	+	//
			589	+	// See [property@WrapBox:line-spacing-unit].
			590	+	func (x *WrapBox) GetPropertyLineSpacing() int {
			591	+	var v gobject.Value
			592	+	x.GetProperty("line-spacing", &v)
			593	+	return v.GetInt()
			594	+	}
			595	+
			596	+	// SetPropertyNaturalLineLength sets the "natural-line-length" property.
			597	+	// Determines the natural size for each line.
			598	+	//
			599	+	// It should be used to limit the line lengths, for example when used in
			600	+	// popovers.
			601	+	//
			602	+	// See [property@WrapBox:natural-line-length-unit].
			603	+	func (x *WrapBox) SetPropertyNaturalLineLength(value int) {
			604	+	var v gobject.Value
			605	+	v.Init(gobject.TypeIntVal)
			606	+	v.SetInt(value)
			607	+	x.SetProperty("natural-line-length", &v)
			608	+	}
			609	+
			610	+	// GetPropertyNaturalLineLength gets the "natural-line-length" property.
			611	+	// Determines the natural size for each line.
			612	+	//
			613	+	// It should be used to limit the line lengths, for example when used in
			614	+	// popovers.
			615	+	//
			616	+	// See [property@WrapBox:natural-line-length-unit].
			617	+	func (x *WrapBox) GetPropertyNaturalLineLength() int {
			618	+	var v gobject.Value
			619	+	x.GetProperty("natural-line-length", &v)
			620	+	return v.GetInt()
			621	+	}
			622	+
			623	+	// SetPropertyWrapReverse sets the "wrap-reverse" property.
			624	+	// Whether wrap direction should be reversed.
			625	+	//
			626	+	// By default, lines wrap downwards in a horizontal box, and towards the end
			627	+	// in a vertical box. If set to `TRUE`, they wrap upwards or towards the start
			628	+	// respectively.
			629	+	func (x *WrapBox) SetPropertyWrapReverse(value bool) {
			630	+	var v gobject.Value
			631	+	v.Init(gobject.TypeBooleanVal)
			632	+	v.SetBoolean(value)
			633	+	x.SetProperty("wrap-reverse", &v)
			634	+	}
			635	+
			636	+	// GetPropertyWrapReverse gets the "wrap-reverse" property.
			637	+	// Whether wrap direction should be reversed.
			638	+	//
			639	+	// By default, lines wrap downwards in a horizontal box, and towards the end
			640	+	// in a vertical box. If set to `TRUE`, they wrap upwards or towards the start
			641	+	// respectively.
			642	+	func (x *WrapBox) GetPropertyWrapReverse() bool {
			643	+	var v gobject.Value
			644	+	x.GetProperty("wrap-reverse", &v)
			645	+	return v.GetBoolean()
			646	+	}
			647	+
483		// Requests the user's screen reader to announce the given message.	648		// Requests the user's screen reader to announce the given message.
484		//	649		//
485		// This kind of notification is useful for messages that	650		// This kind of notification is useful for messages that

@@ -537,7 +702,7 @@ func (x WrapBox) GetAtContext() gtk.ATContext {
537		// This functionality can be overridden by `GtkAccessible`	702		// This functionality can be overridden by `GtkAccessible`
538		// implementations, e.g. to get the bounds from an ignored	703		// implementations, e.g. to get the bounds from an ignored
539		// child widget.	704		// child widget.
540	-	func (x *WrapBox) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	705	+	func (x WrapBox) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
541			706
542		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	707		cret := gtk.XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
543		return cret	708		return cret

M v4/adw/adw-wrap-layout.go +166 -0


@@ -7,6 +7,7 @@ import (
7		7
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
		10	+	"github.com/jwijenbergh/puregotk/v4/gobject"
10	"github.com/jwijenbergh/puregotk/v4/gobject/types"	11		"github.com/jwijenbergh/puregotk/v4/gobject/types"
11	"github.com/jwijenbergh/puregotk/v4/gtk"	12		"github.com/jwijenbergh/puregotk/v4/gtk"
12	)	13		)

@@ -478,6 +479,171 @@ func (c *WrapLayout) SetGoPointer(ptr uintptr) {
478	c.Ptr = ptr	479		c.Ptr = ptr
479	}	480		}
480		481
		482	+	// SetPropertyAlign sets the "align" property.
		483	+	// The alignment of the children within each line.
		484	+	//
		485	+	// 0 means the children are placed at the start of the line, 1 means they are
		486	+	// placed at the end of the line. 0.5 means they are placed in the middle of
		487	+	// the line.
		488	+	//
		489	+	// Alignment is only used when [property@WrapLayout:justify] is set to
		490	+	// `ADW_JUSTIFY_NONE`, or on the last line when the
		491	+	// [property@WrapLayout:justify-last-line] is `FALSE`.
		492	+	func (x *WrapLayout) SetPropertyAlign(value float32) {
		493	+	var v gobject.Value
		494	+	v.Init(gobject.TypeFloatVal)
		495	+	v.SetFloat(value)
		496	+	x.SetProperty("align", &v)
		497	+	}
		498	+
		499	+	// GetPropertyAlign gets the "align" property.
		500	+	// The alignment of the children within each line.
		501	+	//
		502	+	// 0 means the children are placed at the start of the line, 1 means they are
		503	+	// placed at the end of the line. 0.5 means they are placed in the middle of
		504	+	// the line.
		505	+	//
		506	+	// Alignment is only used when [property@WrapLayout:justify] is set to
		507	+	// `ADW_JUSTIFY_NONE`, or on the last line when the
		508	+	// [property@WrapLayout:justify-last-line] is `FALSE`.
		509	+	func (x *WrapLayout) GetPropertyAlign() float32 {
		510	+	var v gobject.Value
		511	+	x.GetProperty("align", &v)
		512	+	return v.GetFloat()
		513	+	}
		514	+
		515	+	// SetPropertyChildSpacing sets the "child-spacing" property.
		516	+	// The spacing between widgets on the same line.
		517	+	//
		518	+	// See [property@WrapLayout:child-spacing-unit].
		519	+	func (x *WrapLayout) SetPropertyChildSpacing(value int) {
		520	+	var v gobject.Value
		521	+	v.Init(gobject.TypeIntVal)
		522	+	v.SetInt(value)
		523	+	x.SetProperty("child-spacing", &v)
		524	+	}
		525	+
		526	+	// GetPropertyChildSpacing gets the "child-spacing" property.
		527	+	// The spacing between widgets on the same line.
		528	+	//
		529	+	// See [property@WrapLayout:child-spacing-unit].
		530	+	func (x *WrapLayout) GetPropertyChildSpacing() int {
		531	+	var v gobject.Value
		532	+	x.GetProperty("child-spacing", &v)
		533	+	return v.GetInt()
		534	+	}
		535	+
		536	+	// SetPropertyJustifyLastLine sets the "justify-last-line" property.
		537	+	// Whether the last line should be stretched to fill the entire widget.
		538	+	//
		539	+	// See [property@WrapLayout:justify].
		540	+	func (x *WrapLayout) SetPropertyJustifyLastLine(value bool) {
		541	+	var v gobject.Value
		542	+	v.Init(gobject.TypeBooleanVal)
		543	+	v.SetBoolean(value)
		544	+	x.SetProperty("justify-last-line", &v)
		545	+	}
		546	+
		547	+	// GetPropertyJustifyLastLine gets the "justify-last-line" property.
		548	+	// Whether the last line should be stretched to fill the entire widget.
		549	+	//
		550	+	// See [property@WrapLayout:justify].
		551	+	func (x *WrapLayout) GetPropertyJustifyLastLine() bool {
		552	+	var v gobject.Value
		553	+	x.GetProperty("justify-last-line", &v)
		554	+	return v.GetBoolean()
		555	+	}
		556	+
		557	+	// SetPropertyLineHomogeneous sets the "line-homogeneous" property.
		558	+	// Whether all lines should take the same amount of space.
		559	+	func (x *WrapLayout) SetPropertyLineHomogeneous(value bool) {
		560	+	var v gobject.Value
		561	+	v.Init(gobject.TypeBooleanVal)
		562	+	v.SetBoolean(value)
		563	+	x.SetProperty("line-homogeneous", &v)
		564	+	}
		565	+
		566	+	// GetPropertyLineHomogeneous gets the "line-homogeneous" property.
		567	+	// Whether all lines should take the same amount of space.
		568	+	func (x *WrapLayout) GetPropertyLineHomogeneous() bool {
		569	+	var v gobject.Value
		570	+	x.GetProperty("line-homogeneous", &v)
		571	+	return v.GetBoolean()
		572	+	}
		573	+
		574	+	// SetPropertyLineSpacing sets the "line-spacing" property.
		575	+	// The spacing between lines.
		576	+	//
		577	+	// See [property@WrapLayout:line-spacing-unit].
		578	+	func (x *WrapLayout) SetPropertyLineSpacing(value int) {
		579	+	var v gobject.Value
		580	+	v.Init(gobject.TypeIntVal)
		581	+	v.SetInt(value)
		582	+	x.SetProperty("line-spacing", &v)
		583	+	}
		584	+
		585	+	// GetPropertyLineSpacing gets the "line-spacing" property.
		586	+	// The spacing between lines.
		587	+	//
		588	+	// See [property@WrapLayout:line-spacing-unit].
		589	+	func (x *WrapLayout) GetPropertyLineSpacing() int {
		590	+	var v gobject.Value
		591	+	x.GetProperty("line-spacing", &v)
		592	+	return v.GetInt()
		593	+	}
		594	+
		595	+	// SetPropertyNaturalLineLength sets the "natural-line-length" property.
		596	+	// Determines the natural size for each line.
		597	+	//
		598	+	// It should be used to limit the line lengths, for example when used in
		599	+	// popovers.
		600	+	//
		601	+	// See [property@WrapLayout:natural-line-length-unit].
		602	+	func (x *WrapLayout) SetPropertyNaturalLineLength(value int) {
		603	+	var v gobject.Value
		604	+	v.Init(gobject.TypeIntVal)
		605	+	v.SetInt(value)
		606	+	x.SetProperty("natural-line-length", &v)
		607	+	}
		608	+
		609	+	// GetPropertyNaturalLineLength gets the "natural-line-length" property.
		610	+	// Determines the natural size for each line.
		611	+	//
		612	+	// It should be used to limit the line lengths, for example when used in
		613	+	// popovers.
		614	+	//
		615	+	// See [property@WrapLayout:natural-line-length-unit].
		616	+	func (x *WrapLayout) GetPropertyNaturalLineLength() int {
		617	+	var v gobject.Value
		618	+	x.GetProperty("natural-line-length", &v)
		619	+	return v.GetInt()
		620	+	}
		621	+
		622	+	// SetPropertyWrapReverse sets the "wrap-reverse" property.
		623	+	// Whether wrap direction should be reversed.
		624	+	//
		625	+	// By default, lines wrap downwards in a horizontal box, and towards the end
		626	+	// in a vertical box. If set to `TRUE`, they wrap upwards or towards the start
		627	+	// respectively.
		628	+	func (x *WrapLayout) SetPropertyWrapReverse(value bool) {
		629	+	var v gobject.Value
		630	+	v.Init(gobject.TypeBooleanVal)
		631	+	v.SetBoolean(value)
		632	+	x.SetProperty("wrap-reverse", &v)
		633	+	}
		634	+
		635	+	// GetPropertyWrapReverse gets the "wrap-reverse" property.
		636	+	// Whether wrap direction should be reversed.
		637	+	//
		638	+	// By default, lines wrap downwards in a horizontal box, and towards the end
		639	+	// in a vertical box. If set to `TRUE`, they wrap upwards or towards the start
		640	+	// respectively.
		641	+	func (x *WrapLayout) GetPropertyWrapReverse() bool {
		642	+	var v gobject.Value
		643	+	x.GetProperty("wrap-reverse", &v)
		644	+	return v.GetBoolean()
		645	+	}
		646	+
481	// Retrieves the orientation of the @orientable.	647		// Retrieves the orientation of the @orientable.
482	func (x *WrapLayout) GetOrientation() gtk.Orientation {	648		func (x *WrapLayout) GetOrientation() gtk.Orientation {
483		649

M v4/gdk/gdkcicpparams.go +107 -0


@@ -199,6 +199,113 @@ func (c *CicpParams) SetGoPointer(ptr uintptr) {
199	c.Ptr = ptr	199		c.Ptr = ptr
200	}	200		}
201		201
		202	+	// SetPropertyColorPrimaries sets the "color-primaries" property.
		203	+	// The color primaries to use.
		204	+	//
		205	+	// Supported values:
		206	+	//
		207	+	// - 1: BT.709 / sRGB
		208	+	// - 2: unspecified
		209	+	// - 5: PAL
		210	+	// - 6,7: BT.601 / NTSC
		211	+	// - 9: BT.2020
		212	+	// - 12: Display P3
		213	+	func (x *CicpParams) SetPropertyColorPrimaries(value uint) {
		214	+	var v gobject.Value
		215	+	v.Init(gobject.TypeUintVal)
		216	+	v.SetUint(value)
		217	+	x.SetProperty("color-primaries", &v)
		218	+	}
		219	+
		220	+	// GetPropertyColorPrimaries gets the "color-primaries" property.
		221	+	// The color primaries to use.
		222	+	//
		223	+	// Supported values:
		224	+	//
		225	+	// - 1: BT.709 / sRGB
		226	+	// - 2: unspecified
		227	+	// - 5: PAL
		228	+	// - 6,7: BT.601 / NTSC
		229	+	// - 9: BT.2020
		230	+	// - 12: Display P3
		231	+	func (x *CicpParams) GetPropertyColorPrimaries() uint {
		232	+	var v gobject.Value
		233	+	x.GetProperty("color-primaries", &v)
		234	+	return v.GetUint()
		235	+	}
		236	+
		237	+	// SetPropertyMatrixCoefficients sets the "matrix-coefficients" property.
		238	+	// The matrix coefficients (for YUV to RGB conversion).
		239	+	//
		240	+	// Supported values:
		241	+	//
		242	+	// - 0: RGB
		243	+	// - 1: BT.709
		244	+	// - 2: unspecified
		245	+	// - 5,6: BT.601
		246	+	// - 9: BT.2020
		247	+	func (x *CicpParams) SetPropertyMatrixCoefficients(value uint) {
		248	+	var v gobject.Value
		249	+	v.Init(gobject.TypeUintVal)
		250	+	v.SetUint(value)
		251	+	x.SetProperty("matrix-coefficients", &v)
		252	+	}
		253	+
		254	+	// GetPropertyMatrixCoefficients gets the "matrix-coefficients" property.
		255	+	// The matrix coefficients (for YUV to RGB conversion).
		256	+	//
		257	+	// Supported values:
		258	+	//
		259	+	// - 0: RGB
		260	+	// - 1: BT.709
		261	+	// - 2: unspecified
		262	+	// - 5,6: BT.601
		263	+	// - 9: BT.2020
		264	+	func (x *CicpParams) GetPropertyMatrixCoefficients() uint {
		265	+	var v gobject.Value
		266	+	x.GetProperty("matrix-coefficients", &v)
		267	+	return v.GetUint()
		268	+	}
		269	+
		270	+	// SetPropertyTransferFunction sets the "transfer-function" property.
		271	+	// The transfer function to use.
		272	+	//
		273	+	// Supported values:
		274	+	//
		275	+	// - 1,6,14,15: BT.709, BT.601, BT.2020
		276	+	// - 2: unspecified
		277	+	// - 4: gamma 2.2
		278	+	// - 5: gamma 2.8
		279	+	// - 8: linear
		280	+	// - 13: sRGB
		281	+	// - 16: BT.2100 PQ
		282	+	// - 18: BT.2100 HLG
		283	+	func (x *CicpParams) SetPropertyTransferFunction(value uint) {
		284	+	var v gobject.Value
		285	+	v.Init(gobject.TypeUintVal)
		286	+	v.SetUint(value)
		287	+	x.SetProperty("transfer-function", &v)
		288	+	}
		289	+
		290	+	// GetPropertyTransferFunction gets the "transfer-function" property.
		291	+	// The transfer function to use.
		292	+	//
		293	+	// Supported values:
		294	+	//
		295	+	// - 1,6,14,15: BT.709, BT.601, BT.2020
		296	+	// - 2: unspecified
		297	+	// - 4: gamma 2.2
		298	+	// - 5: gamma 2.8
		299	+	// - 8: linear
		300	+	// - 13: sRGB
		301	+	// - 16: BT.2100 PQ
		302	+	// - 18: BT.2100 HLG
		303	+	func (x *CicpParams) GetPropertyTransferFunction() uint {
		304	+	var v gobject.Value
		305	+	x.GetProperty("transfer-function", &v)
		306	+	return v.GetUint()
		307	+	}
		308	+
202	func init() {	309		func init() {
203	core.SetPackageName("GDK", "gtk4")	310		core.SetPackageName("GDK", "gtk4")
204	core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})	311		core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})

M v4/gdk/gdkclipboard.go +18 -2

 }
-var xClipboardReadFinish func(uintptr, uintptr, string, **glib.Error) uintptr
+var xClipboardReadFinish func(uintptr, uintptr, *string, **glib.Error) uintptr
 // Finishes an asynchronous clipboard read.
 //
 // See [method@Gdk.Clipboard.read_async].
-func (x *Clipboard) ReadFinish(ResultVar gio.AsyncResult, OutMimeTypeVar string) (*gio.InputStream, error) {
+func (x *Clipboard) ReadFinish(ResultVar gio.AsyncResult, OutMimeTypeVar *string) (*gio.InputStream, error) {
 	var cls *gio.InputStream
 	var cerr *glib.Error
 	c.Ptr = ptr
 }
+// GetPropertyFormats gets the "formats" property.
+// The possible formats that the clipboard can provide its data in.
+func (x *Clipboard) GetPropertyFormats() uintptr {
+	var v gobject.Value
+	x.GetProperty("formats", &v)
+	return v.GetPointer()
+}
+// GetPropertyLocal gets the "local" property.
+// %TRUE if the contents of the clipboard are owned by this process.
+func (x *Clipboard) GetPropertyLocal() bool {
+	var v gobject.Value
+	x.GetProperty("local", &v)
+	return v.GetBoolean()
+}
 // Emitted when the clipboard changes ownership.
 func (x *Clipboard) ConnectChanged(cb *func(Clipboard)) uint32 {
 	cbPtr := uintptr(unsafe.Pointer(cb))

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

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideContentChanged sets the callback function.
+// OverrideContentChanged sets the "content_changed" callback function.
 // Signal class closure for `GdkContentProvider::content-changed`
 func (x *ContentProviderClass) OverrideContentChanged(cb func(*ContentProvider)) {
 	if cb == nil {
 	}
 }
-// GetContentChanged gets the callback function.
+// GetContentChanged gets the "content_changed" callback function.
 // Signal class closure for `GdkContentProvider::content-changed`
 func (x *ContentProviderClass) GetContentChanged() func(*ContentProvider) {
 	if x.xContentChanged == 0 {
 	}
 }
-// OverrideAttachClipboard sets the callback function.
+// OverrideAttachClipboard sets the "attach_clipboard" callback function.
 func (x *ContentProviderClass) OverrideAttachClipboard(cb func(*ContentProvider, *Clipboard)) {
 	if cb == nil {
 		x.xAttachClipboard = 0
 	}
 }
-// GetAttachClipboard gets the callback function.
+// GetAttachClipboard gets the "attach_clipboard" callback function.
 func (x *ContentProviderClass) GetAttachClipboard() func(*ContentProvider, *Clipboard) {
 	if x.xAttachClipboard == 0 {
 		return nil
 	}
 }
-// OverrideDetachClipboard sets the callback function.
+// OverrideDetachClipboard sets the "detach_clipboard" callback function.
 func (x *ContentProviderClass) OverrideDetachClipboard(cb func(*ContentProvider, *Clipboard)) {
 	if cb == nil {
 		x.xDetachClipboard = 0
 	}
 }
-// GetDetachClipboard gets the callback function.
+// GetDetachClipboard gets the "detach_clipboard" callback function.
 func (x *ContentProviderClass) GetDetachClipboard() func(*ContentProvider, *Clipboard) {
 	if x.xDetachClipboard == 0 {
 		return nil
 	}
 }
-// OverrideRefFormats sets the callback function.
+// OverrideRefFormats sets the "ref_formats" callback function.
 func (x *ContentProviderClass) OverrideRefFormats(cb func(*ContentProvider) *ContentFormats) {
 	if cb == nil {
 		x.xRefFormats = 0
 	}
 }
-// GetRefFormats gets the callback function.
+// GetRefFormats gets the "ref_formats" callback function.
 func (x *ContentProviderClass) GetRefFormats() func(*ContentProvider) *ContentFormats {
 	if x.xRefFormats == 0 {
 		return nil
 	}
 }
-// OverrideRefStorableFormats sets the callback function.
+// OverrideRefStorableFormats sets the "ref_storable_formats" callback function.
 func (x *ContentProviderClass) OverrideRefStorableFormats(cb func(*ContentProvider) *ContentFormats) {
 	if cb == nil {
 		x.xRefStorableFormats = 0
 	}
 }
-// GetRefStorableFormats gets the callback function.
+// GetRefStorableFormats gets the "ref_storable_formats" callback function.
 func (x *ContentProviderClass) GetRefStorableFormats() func(*ContentProvider) *ContentFormats {
 	if x.xRefStorableFormats == 0 {
 		return nil
 	}
 }
-// OverrideWriteMimeTypeAsync sets the callback function.
+// OverrideWriteMimeTypeAsync sets the "write_mime_type_async" callback function.
 func (x *ContentProviderClass) OverrideWriteMimeTypeAsync(cb func(*ContentProvider, string, *gio.OutputStream, int, *gio.Cancellable, *gio.AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xWriteMimeTypeAsync = 0
 	}
 }
-// GetWriteMimeTypeAsync gets the callback function.
+// GetWriteMimeTypeAsync gets the "write_mime_type_async" callback function.
 func (x *ContentProviderClass) GetWriteMimeTypeAsync() func(*ContentProvider, string, *gio.OutputStream, int, *gio.Cancellable, *gio.AsyncReadyCallback, uintptr) {
 	if x.xWriteMimeTypeAsync == 0 {
 		return nil
 	}
 }
-// OverrideWriteMimeTypeFinish sets the callback function.
+// OverrideWriteMimeTypeFinish sets the "write_mime_type_finish" callback function.
 func (x *ContentProviderClass) OverrideWriteMimeTypeFinish(cb func(*ContentProvider, gio.AsyncResult) bool) {
 	if cb == nil {
 		x.xWriteMimeTypeFinish = 0
 	}
 }
-// GetWriteMimeTypeFinish gets the callback function.
+// GetWriteMimeTypeFinish gets the "write_mime_type_finish" callback function.
 func (x *ContentProviderClass) GetWriteMimeTypeFinish() func(*ContentProvider, gio.AsyncResult) bool {
 	if x.xWriteMimeTypeFinish == 0 {
 		return nil
 	}
 }
-// OverrideGetValue sets the callback function.
+// OverrideGetValue sets the "get_value" callback function.
 func (x *ContentProviderClass) OverrideGetValue(cb func(*ContentProvider, *gobject.Value) bool) {
 	if cb == nil {
 		x.xGetValue = 0
 	}
 }
-// GetGetValue gets the callback function.
+// GetGetValue gets the "get_value" callback function.
 func (x *ContentProviderClass) GetGetValue() func(*ContentProvider, *gobject.Value) bool {
 	if x.xGetValue == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// GetPropertyFormats gets the "formats" property.
+// The possible formats that the provider can provide its data in.
+func (x *ContentProvider) GetPropertyFormats() uintptr {
+	var v gobject.Value
+	x.GetProperty("formats", &v)
+	return v.GetPointer()
+}
+// GetPropertyStorableFormats gets the "storable-formats" property.
+// The subset of formats that clipboard managers should store this provider's data in.
+func (x *ContentProvider) GetPropertyStorableFormats() uintptr {
+	var v gobject.Value
+	x.GetProperty("storable-formats", &v)
+	return v.GetPointer()
+}
 // Emitted whenever the content provided by this provider has changed.
 func (x *ContentProvider) ConnectContentChanged(cb *func(ContentProvider)) uint32 {
 	cbPtr := uintptr(unsafe.Pointer(cb))

M v4/gdk/gdkcursor.go +56 -1


@@ -21,7 +21,7 @@ import (
21		//	21		//
22		// This function may fail and return `NULL`, in which case	22		// This function may fail and return `NULL`, in which case
23		// the fallback cursor will be used.	23		// the fallback cursor will be used.
24	-	type CursorGetTextureCallback func(uintptr, int, float64, int, int, int, int, uintptr) uintptr	24	+	type CursorGetTextureCallback func(uintptr, int, float64, int, int, int, int, uintptr) uintptr
25			25
26		// Used to create and destroy cursors.	26		// Used to create and destroy cursors.
27		//	27		//

@@ -262,6 +262,61 @@ func (c *Cursor) SetGoPointer(ptr uintptr) {
262		c.Ptr = ptr	262		c.Ptr = ptr
263		}	263		}
264			264
			265	+	// SetPropertyHotspotX sets the "hotspot-x" property.
			266	+	// X position of the cursor hotspot in the cursor image.
			267	+	func (x *Cursor) SetPropertyHotspotX(value int) {
			268	+	var v gobject.Value
			269	+	v.Init(gobject.TypeIntVal)
			270	+	v.SetInt(value)
			271	+	x.SetProperty("hotspot-x", &v)
			272	+	}
			273	+
			274	+	// GetPropertyHotspotX gets the "hotspot-x" property.
			275	+	// X position of the cursor hotspot in the cursor image.
			276	+	func (x *Cursor) GetPropertyHotspotX() int {
			277	+	var v gobject.Value
			278	+	x.GetProperty("hotspot-x", &v)
			279	+	return v.GetInt()
			280	+	}
			281	+
			282	+	// SetPropertyHotspotY sets the "hotspot-y" property.
			283	+	// Y position of the cursor hotspot in the cursor image.
			284	+	func (x *Cursor) SetPropertyHotspotY(value int) {
			285	+	var v gobject.Value
			286	+	v.Init(gobject.TypeIntVal)
			287	+	v.SetInt(value)
			288	+	x.SetProperty("hotspot-y", &v)
			289	+	}
			290	+
			291	+	// GetPropertyHotspotY gets the "hotspot-y" property.
			292	+	// Y position of the cursor hotspot in the cursor image.
			293	+	func (x *Cursor) GetPropertyHotspotY() int {
			294	+	var v gobject.Value
			295	+	x.GetProperty("hotspot-y", &v)
			296	+	return v.GetInt()
			297	+	}
			298	+
			299	+	// SetPropertyName sets the "name" property.
			300	+	// Name of this this cursor.
			301	+	//
			302	+	// The name will be %NULL if the cursor was created from a texture.
			303	+	func (x *Cursor) SetPropertyName(value string) {
			304	+	var v gobject.Value
			305	+	v.Init(gobject.TypeStringVal)
			306	+	v.SetString(value)
			307	+	x.SetProperty("name", &v)
			308	+	}
			309	+
			310	+	// GetPropertyName gets the "name" property.
			311	+	// Name of this this cursor.
			312	+	//
			313	+	// The name will be %NULL if the cursor was created from a texture.
			314	+	func (x *Cursor) GetPropertyName() string {
			315	+	var v gobject.Value
			316	+	x.GetProperty("name", &v)
			317	+	return v.GetString()
			318	+	}
			319	+
265		func init() {	320		func init() {
266		core.SetPackageName("GDK", "gtk4")	321		core.SetPackageName("GDK", "gtk4")
267		core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})	322		core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})

M v4/gdk/gdkdevice.go +171 -2


@@ -269,14 +269,14 @@ func (x *Device) GetSource() InputSource {
269		return cret	269		return cret
270		}	270		}
271			271
272	-	var xDeviceGetSurfaceAtPosition func(uintptr, float64, float64) uintptr	272	+	var xDeviceGetSurfaceAtPosition func(uintptr, float64, float64) uintptr
273			273
274		// Obtains the surface underneath @device, returning the location of the	274		// Obtains the surface underneath @device, returning the location of the
275		// device in @win_x and @win_y.	275		// device in @win_x and @win_y.
276		//	276		//
277		// Returns %NULL if the surface tree under @device is not known to GDK	277		// Returns %NULL if the surface tree under @device is not known to GDK
278		// (for example, belongs to another application).	278		// (for example, belongs to another application).
279	-	func (x Device) GetSurfaceAtPosition(WinXVar float64, WinYVar float64) Surface {	279	+	func (x Device) GetSurfaceAtPosition(WinXVar float64, WinYVar float64) Surface {
280		var cls *Surface	280		var cls *Surface
281			281
282		cret := xDeviceGetSurfaceAtPosition(x.GoPointer(), WinXVar, WinYVar)	282		cret := xDeviceGetSurfaceAtPosition(x.GoPointer(), WinXVar, WinYVar)

@@ -364,6 +364,175 @@ func (c *Device) SetGoPointer(ptr uintptr) {
364		c.Ptr = ptr	364		c.Ptr = ptr
365		}	365		}
366			366
			367	+	// GetPropertyActiveLayoutIndex gets the "active-layout-index" property.
			368	+	// The index of the keyboard active layout of a `GdkDevice`.
			369	+	//
			370	+	// Will be -1 if there is no valid active layout.
			371	+	//
			372	+	// This is only relevant for keyboard devices.
			373	+	func (x *Device) GetPropertyActiveLayoutIndex() int {
			374	+	var v gobject.Value
			375	+	x.GetProperty("active-layout-index", &v)
			376	+	return v.GetInt()
			377	+	}
			378	+
			379	+	// GetPropertyCapsLockState gets the "caps-lock-state" property.
			380	+	// Whether Caps Lock is on.
			381	+	//
			382	+	// This is only relevant for keyboard devices.
			383	+	func (x *Device) GetPropertyCapsLockState() bool {
			384	+	var v gobject.Value
			385	+	x.GetProperty("caps-lock-state", &v)
			386	+	return v.GetBoolean()
			387	+	}
			388	+
			389	+	// GetPropertyHasBidiLayouts gets the "has-bidi-layouts" property.
			390	+	// Whether the device has both right-to-left and left-to-right layouts.
			391	+	//
			392	+	// This is only relevant for keyboard devices.
			393	+	func (x *Device) GetPropertyHasBidiLayouts() bool {
			394	+	var v gobject.Value
			395	+	x.GetProperty("has-bidi-layouts", &v)
			396	+	return v.GetBoolean()
			397	+	}
			398	+
			399	+	// SetPropertyHasCursor sets the "has-cursor" property.
			400	+	// Whether the device is represented by a cursor on the screen.
			401	+	func (x *Device) SetPropertyHasCursor(value bool) {
			402	+	var v gobject.Value
			403	+	v.Init(gobject.TypeBooleanVal)
			404	+	v.SetBoolean(value)
			405	+	x.SetProperty("has-cursor", &v)
			406	+	}
			407	+
			408	+	// GetPropertyHasCursor gets the "has-cursor" property.
			409	+	// Whether the device is represented by a cursor on the screen.
			410	+	func (x *Device) GetPropertyHasCursor() bool {
			411	+	var v gobject.Value
			412	+	x.GetProperty("has-cursor", &v)
			413	+	return v.GetBoolean()
			414	+	}
			415	+
			416	+	// GetPropertyLayoutNames gets the "layout-names" property.
			417	+	// The names of the keyboard layouts of a `GdkDevice`.
			418	+	//
			419	+	// This is only relevant for keyboard devices.
			420	+	func (x *Device) GetPropertyLayoutNames() []string {
			421	+	var v gobject.Value
			422	+	x.GetProperty("layout-names", &v)
			423	+	return core.GoStringSlice(v.GetBoxed())
			424	+	}
			425	+
			426	+	// GetPropertyNAxes gets the "n-axes" property.
			427	+	// Number of axes in the device.
			428	+	func (x *Device) GetPropertyNAxes() uint {
			429	+	var v gobject.Value
			430	+	x.GetProperty("n-axes", &v)
			431	+	return v.GetUint()
			432	+	}
			433	+
			434	+	// SetPropertyName sets the "name" property.
			435	+	// The device name.
			436	+	func (x *Device) SetPropertyName(value string) {
			437	+	var v gobject.Value
			438	+	v.Init(gobject.TypeStringVal)
			439	+	v.SetString(value)
			440	+	x.SetProperty("name", &v)
			441	+	}
			442	+
			443	+	// GetPropertyName gets the "name" property.
			444	+	// The device name.
			445	+	func (x *Device) GetPropertyName() string {
			446	+	var v gobject.Value
			447	+	x.GetProperty("name", &v)
			448	+	return v.GetString()
			449	+	}
			450	+
			451	+	// GetPropertyNumLockState gets the "num-lock-state" property.
			452	+	// Whether Num Lock is on.
			453	+	//
			454	+	// This is only relevant for keyboard devices.
			455	+	func (x *Device) GetPropertyNumLockState() bool {
			456	+	var v gobject.Value
			457	+	x.GetProperty("num-lock-state", &v)
			458	+	return v.GetBoolean()
			459	+	}
			460	+
			461	+	// SetPropertyNumTouches sets the "num-touches" property.
			462	+	// The maximal number of concurrent touches on a touch device.
			463	+	//
			464	+	// Will be 0 if the device is not a touch device or if the number
			465	+	// of touches is unknown.
			466	+	func (x *Device) SetPropertyNumTouches(value uint) {
			467	+	var v gobject.Value
			468	+	v.Init(gobject.TypeUintVal)
			469	+	v.SetUint(value)
			470	+	x.SetProperty("num-touches", &v)
			471	+	}
			472	+
			473	+	// GetPropertyNumTouches gets the "num-touches" property.
			474	+	// The maximal number of concurrent touches on a touch device.
			475	+	//
			476	+	// Will be 0 if the device is not a touch device or if the number
			477	+	// of touches is unknown.
			478	+	func (x *Device) GetPropertyNumTouches() uint {
			479	+	var v gobject.Value
			480	+	x.GetProperty("num-touches", &v)
			481	+	return v.GetUint()
			482	+	}
			483	+
			484	+	// SetPropertyProductId sets the "product-id" property.
			485	+	// Product ID of this device.
			486	+	//
			487	+	// See [method@Gdk.Device.get_product_id].
			488	+	func (x *Device) SetPropertyProductId(value string) {
			489	+	var v gobject.Value
			490	+	v.Init(gobject.TypeStringVal)
			491	+	v.SetString(value)
			492	+	x.SetProperty("product-id", &v)
			493	+	}
			494	+
			495	+	// GetPropertyProductId gets the "product-id" property.
			496	+	// Product ID of this device.
			497	+	//
			498	+	// See [method@Gdk.Device.get_product_id].
			499	+	func (x *Device) GetPropertyProductId() string {
			500	+	var v gobject.Value
			501	+	x.GetProperty("product-id", &v)
			502	+	return v.GetString()
			503	+	}
			504	+
			505	+	// GetPropertyScrollLockState gets the "scroll-lock-state" property.
			506	+	// Whether Scroll Lock is on.
			507	+	//
			508	+	// This is only relevant for keyboard devices.
			509	+	func (x *Device) GetPropertyScrollLockState() bool {
			510	+	var v gobject.Value
			511	+	x.GetProperty("scroll-lock-state", &v)
			512	+	return v.GetBoolean()
			513	+	}
			514	+
			515	+	// SetPropertyVendorId sets the "vendor-id" property.
			516	+	// Vendor ID of this device.
			517	+	//
			518	+	// See [method@Gdk.Device.get_vendor_id].
			519	+	func (x *Device) SetPropertyVendorId(value string) {
			520	+	var v gobject.Value
			521	+	v.Init(gobject.TypeStringVal)
			522	+	v.SetString(value)
			523	+	x.SetProperty("vendor-id", &v)
			524	+	}
			525	+
			526	+	// GetPropertyVendorId gets the "vendor-id" property.
			527	+	// Vendor ID of this device.
			528	+	//
			529	+	// See [method@Gdk.Device.get_vendor_id].
			530	+	func (x *Device) GetPropertyVendorId() string {
			531	+	var v gobject.Value
			532	+	x.GetProperty("vendor-id", &v)
			533	+	return v.GetString()
			534	+	}
			535	+
367		// Emitted either when the number of either axes or keys changes.	536		// Emitted either when the number of either axes or keys changes.
368		//	537		//
369		// On X11 this will normally happen when the physical device	538		// On X11 this will normally happen when the physical device

M v4/gdk/gdkdevicetool.go +34 -0


@@ -115,6 +115,40 @@ func (c *DeviceTool) SetGoPointer(ptr uintptr) {
115	c.Ptr = ptr	115		c.Ptr = ptr
116	}	116		}
117		117
		118	+	// SetPropertyHardwareId sets the "hardware-id" property.
		119	+	// The hardware ID of the tool.
		120	+	func (x *DeviceTool) SetPropertyHardwareId(value uint64) {
		121	+	var v gobject.Value
		122	+	v.Init(gobject.TypeUint64Val)
		123	+	v.SetUint64(value)
		124	+	x.SetProperty("hardware-id", &v)
		125	+	}
		126	+
		127	+	// GetPropertyHardwareId gets the "hardware-id" property.
		128	+	// The hardware ID of the tool.
		129	+	func (x *DeviceTool) GetPropertyHardwareId() uint64 {
		130	+	var v gobject.Value
		131	+	x.GetProperty("hardware-id", &v)
		132	+	return v.GetUint64()
		133	+	}
		134	+
		135	+	// SetPropertySerial sets the "serial" property.
		136	+	// The serial number of the tool.
		137	+	func (x *DeviceTool) SetPropertySerial(value uint64) {
		138	+	var v gobject.Value
		139	+	v.Init(gobject.TypeUint64Val)
		140	+	v.SetUint64(value)
		141	+	x.SetProperty("serial", &v)
		142	+	}
		143	+
		144	+	// GetPropertySerial gets the "serial" property.
		145	+	// The serial number of the tool.
		146	+	func (x *DeviceTool) GetPropertySerial() uint64 {
		147	+	var v gobject.Value
		148	+	x.GetProperty("serial", &v)
		149	+	return v.GetUint64()
		150	+	}
		151	+
118	func init() {	152		func init() {
119	core.SetPackageName("GDK", "gtk4")	153		core.SetPackageName("GDK", "gtk4")
120	core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})	154		core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})

M v4/gdk/gdkdisplay.go +46 -6

 	return cret
 }
-var xDisplayMapKeycode func(uintptr, uint, uintptr, []uint, int) bool
+var xDisplayMapKeycode func(uintptr, uint, *uintptr, *[]uint, *int) bool
 // Returns the keyvals bound to @keycode.
 //
 // keyboard group and level.
 //
 // Free the returned arrays with g_free().
-func (x *Display) MapKeycode(KeycodeVar uint, KeysVar uintptr, KeyvalsVar []uint, NEntriesVar int) bool {
+func (x *Display) MapKeycode(KeycodeVar uint, KeysVar *uintptr, KeyvalsVar *[]uint, NEntriesVar *int) bool {
 	cret := xDisplayMapKeycode(x.GoPointer(), KeycodeVar, KeysVar, KeyvalsVar, NEntriesVar)
 	return cret
 }
-var xDisplayMapKeyval func(uintptr, uint, uintptr, int) bool
+var xDisplayMapKeyval func(uintptr, uint, *uintptr, *int) bool
 // Obtains a list of keycode/group/level combinations that will
 // generate @keyval.
 // keyboard group. The level is computed from the modifier mask.
 //
 // The returned array should be freed with g_free().
-func (x *Display) MapKeyval(KeyvalVar uint, KeysVar uintptr, NKeysVar int) bool {
+func (x *Display) MapKeyval(KeyvalVar uint, KeysVar *uintptr, NKeysVar *int) bool {
 	cret := xDisplayMapKeyval(x.GoPointer(), KeyvalVar, KeysVar, NKeysVar)
 	return cret
 }
-var xDisplayTranslateKey func(uintptr, uint, ModifierType, int, uint, int, int, *ModifierType) bool
+var xDisplayTranslateKey func(uintptr, uint, ModifierType, int, *uint, *int, *int, *ModifierType) bool
 // Translates the contents of a `GdkEventKey` into a keyval, effective group,
 // and level.
 // This function should rarely be needed, since `GdkEventKey` already
 // contains the translated keyval. It is exported for the benefit of
 // virtualized test environments.
-func (x *Display) TranslateKey(KeycodeVar uint, StateVar ModifierType, GroupVar int, KeyvalVar uint, EffectiveGroupVar int, LevelVar int, ConsumedVar *ModifierType) bool {
+func (x *Display) TranslateKey(KeycodeVar uint, StateVar ModifierType, GroupVar int, KeyvalVar *uint, EffectiveGroupVar *int, LevelVar *int, ConsumedVar *ModifierType) bool {
 	cret := xDisplayTranslateKey(x.GoPointer(), KeycodeVar, StateVar, GroupVar, KeyvalVar, EffectiveGroupVar, LevelVar, ConsumedVar)
 	return cret
 	c.Ptr = ptr
 }
+// GetPropertyComposited gets the "composited" property.
+// %TRUE if the display properly composites the alpha channel.
+func (x *Display) GetPropertyComposited() bool {
+	var v gobject.Value
+	x.GetProperty("composited", &v)
+	return v.GetBoolean()
+}
+// GetPropertyDmabufFormats gets the "dmabuf-formats" property.
+// The dma-buf formats that are supported on this display
+func (x *Display) GetPropertyDmabufFormats() uintptr {
+	var v gobject.Value
+	x.GetProperty("dmabuf-formats", &v)
+	return v.GetPointer()
+}
+// GetPropertyInputShapes gets the "input-shapes" property.
+// %TRUE if the display supports input shapes.
+func (x *Display) GetPropertyInputShapes() bool {
+	var v gobject.Value
+	x.GetProperty("input-shapes", &v)
+	return v.GetBoolean()
+}
+// GetPropertyRgba gets the "rgba" property.
+// %TRUE if the display supports an alpha channel.
+func (x *Display) GetPropertyRgba() bool {
+	var v gobject.Value
+	x.GetProperty("rgba", &v)
+	return v.GetBoolean()
+}
+// GetPropertyShadowWidth gets the "shadow-width" property.
+// %TRUE if the display supports extensible frames.
+func (x *Display) GetPropertyShadowWidth() bool {
+	var v gobject.Value
+	x.GetProperty("shadow-width", &v)
+	return v.GetBoolean()
+}
 // Emitted when the connection to the windowing system for @display is closed.
 func (x *Display) ConnectClosed(cb *func(Display, bool)) uint32 {
 	cbPtr := uintptr(unsafe.Pointer(cb))

M v4/gdk/gdkdmabuftexture.go +3 -3


@@ -72,7 +72,7 @@ func (c *DmabufTexture) SetGoPointer(ptr uintptr) {
72		// and @specified_height are known, but it is useful to call this	72		// and @specified_height are known, but it is useful to call this
73		// function in GtkWidget:measure implementations to compute the	73		// function in GtkWidget:measure implementations to compute the
74		// other dimension when only one dimension is given.	74		// other dimension when only one dimension is given.
75	-	func (x *DmabufTexture) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar float64) {	75	+	func (x DmabufTexture) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar *float64) {
76			76
77		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)	77		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)
78			78

@@ -255,7 +255,7 @@ func (x *DmabufTexture) ToString() string {
255			255
256		// Loads a loadable icon. For the asynchronous version of this function,	256		// Loads a loadable icon. For the asynchronous version of this function,
257		// see g_loadable_icon_load_async().	257		// see g_loadable_icon_load_async().
258	-	func (x DmabufTexture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (*gio.InputStream, error) {	258	+	func (x DmabufTexture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (gio.InputStream, error) {
259		var cls *gio.InputStream	259		var cls *gio.InputStream
260		var cerr *glib.Error	260		var cerr *glib.Error
261			261

@@ -283,7 +283,7 @@ func (x DmabufTexture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable,
283		}	283		}
284			284
285		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().	285		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().
286	-	func (x DmabufTexture) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (gio.InputStream, error) {	286	+	func (x DmabufTexture) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (*gio.InputStream, error) {
287		var cls *gio.InputStream	287		var cls *gio.InputStream
288		var cerr *glib.Error	288		var cerr *glib.Error
289			289

M v4/gdk/gdkdmabuftexturebuilder.go +146 -0


@@ -445,6 +445,152 @@ func (c *DmabufTextureBuilder) SetGoPointer(ptr uintptr) {
445	c.Ptr = ptr	445		c.Ptr = ptr
446	}	446		}
447		447
		448	+	// SetPropertyColorState sets the "color-state" property.
		449	+	// The color state of the texture.
		450	+	func (x *DmabufTextureBuilder) SetPropertyColorState(value uintptr) {
		451	+	var v gobject.Value
		452	+	v.Init(gobject.TypePointerVal)
		453	+	v.SetPointer(value)
		454	+	x.SetProperty("color-state", &v)
		455	+	}
		456	+
		457	+	// GetPropertyColorState gets the "color-state" property.
		458	+	// The color state of the texture.
		459	+	func (x *DmabufTextureBuilder) GetPropertyColorState() uintptr {
		460	+	var v gobject.Value
		461	+	x.GetProperty("color-state", &v)
		462	+	return v.GetPointer()
		463	+	}
		464	+
		465	+	// SetPropertyFourcc sets the "fourcc" property.
		466	+	// The format of the texture, as a fourcc value.
		467	+	func (x *DmabufTextureBuilder) SetPropertyFourcc(value uint) {
		468	+	var v gobject.Value
		469	+	v.Init(gobject.TypeUintVal)
		470	+	v.SetUint(value)
		471	+	x.SetProperty("fourcc", &v)
		472	+	}
		473	+
		474	+	// GetPropertyFourcc gets the "fourcc" property.
		475	+	// The format of the texture, as a fourcc value.
		476	+	func (x *DmabufTextureBuilder) GetPropertyFourcc() uint {
		477	+	var v gobject.Value
		478	+	x.GetProperty("fourcc", &v)
		479	+	return v.GetUint()
		480	+	}
		481	+
		482	+	// SetPropertyHeight sets the "height" property.
		483	+	// The height of the texture.
		484	+	func (x *DmabufTextureBuilder) SetPropertyHeight(value uint) {
		485	+	var v gobject.Value
		486	+	v.Init(gobject.TypeUintVal)
		487	+	v.SetUint(value)
		488	+	x.SetProperty("height", &v)
		489	+	}
		490	+
		491	+	// GetPropertyHeight gets the "height" property.
		492	+	// The height of the texture.
		493	+	func (x *DmabufTextureBuilder) GetPropertyHeight() uint {
		494	+	var v gobject.Value
		495	+	x.GetProperty("height", &v)
		496	+	return v.GetUint()
		497	+	}
		498	+
		499	+	// SetPropertyModifier sets the "modifier" property.
		500	+	// The modifier.
		501	+	func (x *DmabufTextureBuilder) SetPropertyModifier(value uint64) {
		502	+	var v gobject.Value
		503	+	v.Init(gobject.TypeUint64Val)
		504	+	v.SetUint64(value)
		505	+	x.SetProperty("modifier", &v)
		506	+	}
		507	+
		508	+	// GetPropertyModifier gets the "modifier" property.
		509	+	// The modifier.
		510	+	func (x *DmabufTextureBuilder) GetPropertyModifier() uint64 {
		511	+	var v gobject.Value
		512	+	x.GetProperty("modifier", &v)
		513	+	return v.GetUint64()
		514	+	}
		515	+
		516	+	// SetPropertyNPlanes sets the "n-planes" property.
		517	+	// The number of planes of the texture.
		518	+	//
		519	+	// Note that you can set properties for other planes,
		520	+	// but they will be ignored when constructing the texture.
		521	+	func (x *DmabufTextureBuilder) SetPropertyNPlanes(value uint) {
		522	+	var v gobject.Value
		523	+	v.Init(gobject.TypeUintVal)
		524	+	v.SetUint(value)
		525	+	x.SetProperty("n-planes", &v)
		526	+	}
		527	+
		528	+	// GetPropertyNPlanes gets the "n-planes" property.
		529	+	// The number of planes of the texture.
		530	+	//
		531	+	// Note that you can set properties for other planes,
		532	+	// but they will be ignored when constructing the texture.
		533	+	func (x *DmabufTextureBuilder) GetPropertyNPlanes() uint {
		534	+	var v gobject.Value
		535	+	x.GetProperty("n-planes", &v)
		536	+	return v.GetUint()
		537	+	}
		538	+
		539	+	// SetPropertyPremultiplied sets the "premultiplied" property.
		540	+	// Whether the alpha channel is premultiplied into the others.
		541	+	//
		542	+	// Only relevant if the format has alpha.
		543	+	func (x *DmabufTextureBuilder) SetPropertyPremultiplied(value bool) {
		544	+	var v gobject.Value
		545	+	v.Init(gobject.TypeBooleanVal)
		546	+	v.SetBoolean(value)
		547	+	x.SetProperty("premultiplied", &v)
		548	+	}
		549	+
		550	+	// GetPropertyPremultiplied gets the "premultiplied" property.
		551	+	// Whether the alpha channel is premultiplied into the others.
		552	+	//
		553	+	// Only relevant if the format has alpha.
		554	+	func (x *DmabufTextureBuilder) GetPropertyPremultiplied() bool {
		555	+	var v gobject.Value
		556	+	x.GetProperty("premultiplied", &v)
		557	+	return v.GetBoolean()
		558	+	}
		559	+
		560	+	// SetPropertyUpdateRegion sets the "update-region" property.
		561	+	// The update region for [property@Gdk.DmabufTextureBuilder:update-texture].
		562	+	func (x *DmabufTextureBuilder) SetPropertyUpdateRegion(value uintptr) {
		563	+	var v gobject.Value
		564	+	v.Init(gobject.TypePointerVal)
		565	+	v.SetPointer(value)
		566	+	x.SetProperty("update-region", &v)
		567	+	}
		568	+
		569	+	// GetPropertyUpdateRegion gets the "update-region" property.
		570	+	// The update region for [property@Gdk.DmabufTextureBuilder:update-texture].
		571	+	func (x *DmabufTextureBuilder) GetPropertyUpdateRegion() uintptr {
		572	+	var v gobject.Value
		573	+	x.GetProperty("update-region", &v)
		574	+	return v.GetPointer()
		575	+	}
		576	+
		577	+	// SetPropertyWidth sets the "width" property.
		578	+	// The width of the texture.
		579	+	func (x *DmabufTextureBuilder) SetPropertyWidth(value uint) {
		580	+	var v gobject.Value
		581	+	v.Init(gobject.TypeUintVal)
		582	+	v.SetUint(value)
		583	+	x.SetProperty("width", &v)
		584	+	}
		585	+
		586	+	// GetPropertyWidth gets the "width" property.
		587	+	// The width of the texture.
		588	+	func (x *DmabufTextureBuilder) GetPropertyWidth() uint {
		589	+	var v gobject.Value
		590	+	x.GetProperty("width", &v)
		591	+	return v.GetUint()
		592	+	}
		593	+
448	func init() {	594		func init() {
449	core.SetPackageName("GDK", "gtk4")	595		core.SetPackageName("GDK", "gtk4")
450	core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})	596		core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})

M v4/gdk/gdkdrag.go +17 -0


@@ -229,6 +229,23 @@ func (c *Drag) SetGoPointer(ptr uintptr) {
229	c.Ptr = ptr	229		c.Ptr = ptr
230	}	230		}
231		231
		232	+	// SetPropertyFormats sets the "formats" property.
		233	+	// The possible formats that the drag can provide its data in.
		234	+	func (x *Drag) SetPropertyFormats(value uintptr) {
		235	+	var v gobject.Value
		236	+	v.Init(gobject.TypePointerVal)
		237	+	v.SetPointer(value)
		238	+	x.SetProperty("formats", &v)
		239	+	}
		240	+
		241	+	// GetPropertyFormats gets the "formats" property.
		242	+	// The possible formats that the drag can provide its data in.
		243	+	func (x *Drag) GetPropertyFormats() uintptr {
		244	+	var v gobject.Value
		245	+	x.GetProperty("formats", &v)
		246	+	return v.GetPointer()
		247	+	}
		248	+
232	// Emitted when the drag operation is cancelled.	249		// Emitted when the drag operation is cancelled.
233	func (x Drag) ConnectCancel(cb func(Drag, DragCancelReason)) uint32 {	250		func (x Drag) ConnectCancel(cb func(Drag, DragCancelReason)) uint32 {
234	cbPtr := uintptr(unsafe.Pointer(cb))	251		cbPtr := uintptr(unsafe.Pointer(cb))

M v4/gdk/gdkdrop.go +19 -2

 }
-var xDropReadFinish func(uintptr, uintptr, string, **glib.Error) uintptr
+var xDropReadFinish func(uintptr, uintptr, *string, **glib.Error) uintptr
 // Finishes an async drop read operation.
 //
 // g_input_stream_read_bytes_async().
 //
 // See [method@Gdk.Drop.read_async].
-func (x *Drop) ReadFinish(ResultVar gio.AsyncResult, OutMimeTypeVar string) (*gio.InputStream, error) {
+func (x *Drop) ReadFinish(ResultVar gio.AsyncResult, OutMimeTypeVar *string) (*gio.InputStream, error) {
 	var cls *gio.InputStream
 	var cerr *glib.Error
 	c.Ptr = ptr
 }
+// SetPropertyFormats sets the "formats" property.
+// The possible formats that the drop can provide its data in.
+func (x *Drop) SetPropertyFormats(value uintptr) {
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	x.SetProperty("formats", &v)
+}
+// GetPropertyFormats gets the "formats" property.
+// The possible formats that the drop can provide its data in.
+func (x *Drop) GetPropertyFormats() uintptr {
+	var v gobject.Value
+	x.GetProperty("formats", &v)
+	return v.GetPointer()
+}
 func init() {
 	core.SetPackageName("GDK", "gtk4")
 	core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})

M v4/gdk/gdkevents.go +30 -30


@@ -319,7 +319,7 @@ const (
319		TouchpadGesturePhaseCancelValue TouchpadGesturePhase = 3	319		TouchpadGesturePhaseCancelValue TouchpadGesturePhase = 3
320		)	320		)
321			321
322	-	var xEventsGetAngle func(uintptr, uintptr, float64) bool	322	+	var xEventsGetAngle func(uintptr, uintptr, *float64) bool
323			323
324		// Returns the relative angle from @event1 to @event2.	324		// Returns the relative angle from @event1 to @event2.
325		//	325		//

@@ -329,31 +329,31 @@ var xEventsGetAngle func(uintptr, uintptr, float64) bool
329		//	329		//
330		// This assumes that both events have X/Y information.	330		// This assumes that both events have X/Y information.
331		// If not, this function returns %FALSE.	331		// If not, this function returns %FALSE.
332	-	func EventsGetAngle(Event1Var Event, Event2Var Event, AngleVar float64) bool {	332	+	func EventsGetAngle(Event1Var Event, Event2Var Event, AngleVar *float64) bool {
333			333
334		cret := xEventsGetAngle(Event1Var.GoPointer(), Event2Var.GoPointer(), AngleVar)	334		cret := xEventsGetAngle(Event1Var.GoPointer(), Event2Var.GoPointer(), AngleVar)
335		return cret	335		return cret
336		}	336		}
337			337
338	-	var xEventsGetCenter func(uintptr, uintptr, float64, float64) bool	338	+	var xEventsGetCenter func(uintptr, uintptr, float64, float64) bool
339			339
340		// Returns the point halfway between the events' positions.	340		// Returns the point halfway between the events' positions.
341		//	341		//
342		// This assumes that both events have X/Y information.	342		// This assumes that both events have X/Y information.
343		// If not, this function returns %FALSE.	343		// If not, this function returns %FALSE.
344	-	func EventsGetCenter(Event1Var Event, Event2Var Event, XVar float64, YVar float64) bool {	344	+	func EventsGetCenter(Event1Var Event, Event2Var Event, XVar float64, YVar float64) bool {
345			345
346		cret := xEventsGetCenter(Event1Var.GoPointer(), Event2Var.GoPointer(), XVar, YVar)	346		cret := xEventsGetCenter(Event1Var.GoPointer(), Event2Var.GoPointer(), XVar, YVar)
347		return cret	347		return cret
348		}	348		}
349			349
350	-	var xEventsGetDistance func(uintptr, uintptr, float64) bool	350	+	var xEventsGetDistance func(uintptr, uintptr, *float64) bool
351			351
352		// Returns the distance between the event locations.	352		// Returns the distance between the event locations.
353		//	353		//
354		// This assumes that both events have X/Y information.	354		// This assumes that both events have X/Y information.
355		// If not, this function returns %FALSE.	355		// If not, this function returns %FALSE.
356	-	func EventsGetDistance(Event1Var Event, Event2Var Event, DistanceVar float64) bool {	356	+	func EventsGetDistance(Event1Var Event, Event2Var Event, DistanceVar *float64) bool {
357			357
358		cret := xEventsGetDistance(Event1Var.GoPointer(), Event2Var.GoPointer(), DistanceVar)	358		cret := xEventsGetDistance(Event1Var.GoPointer(), Event2Var.GoPointer(), DistanceVar)
359		return cret	359		return cret

@@ -547,7 +547,7 @@ func EventNewFromInternalPtr(ptr uintptr) *Event {
547		return cls	547		return cls
548		}	548		}
549			549
550	-	var xEventGetAngle func(uintptr, uintptr, float64) bool	550	+	var xEventGetAngle func(uintptr, uintptr, *float64) bool
551			551
552		// Returns the relative angle from @event1 to @event2.	552		// Returns the relative angle from @event1 to @event2.
553		//	553		//

@@ -557,56 +557,56 @@ var xEventGetAngle func(uintptr, uintptr, float64) bool
557		//	557		//
558		// This assumes that both events have X/Y information.	558		// This assumes that both events have X/Y information.
559		// If not, this function returns %FALSE.	559		// If not, this function returns %FALSE.
560	-	func (x Event) GetAngle(Event2Var Event, AngleVar float64) bool {	560	+	func (x Event) GetAngle(Event2Var Event, AngleVar *float64) bool {
561			561
562		cret := xEventGetAngle(x.GoPointer(), Event2Var.GoPointer(), AngleVar)	562		cret := xEventGetAngle(x.GoPointer(), Event2Var.GoPointer(), AngleVar)
563		return cret	563		return cret
564		}	564		}
565			565
566	-	var xEventGetCenter func(uintptr, uintptr, float64, float64) bool	566	+	var xEventGetCenter func(uintptr, uintptr, float64, float64) bool
567			567
568		// Returns the point halfway between the events' positions.	568		// Returns the point halfway between the events' positions.
569		//	569		//
570		// This assumes that both events have X/Y information.	570		// This assumes that both events have X/Y information.
571		// If not, this function returns %FALSE.	571		// If not, this function returns %FALSE.
572	-	func (x Event) GetCenter(Event2Var Event, XVar float64, YVar float64) bool {	572	+	func (x Event) GetCenter(Event2Var Event, XVar float64, YVar float64) bool {
573			573
574		cret := xEventGetCenter(x.GoPointer(), Event2Var.GoPointer(), XVar, YVar)	574		cret := xEventGetCenter(x.GoPointer(), Event2Var.GoPointer(), XVar, YVar)
575		return cret	575		return cret
576		}	576		}
577			577
578	-	var xEventGetDistance func(uintptr, uintptr, float64) bool	578	+	var xEventGetDistance func(uintptr, uintptr, *float64) bool
579			579
580		// Returns the distance between the event locations.	580		// Returns the distance between the event locations.
581		//	581		//
582		// This assumes that both events have X/Y information.	582		// This assumes that both events have X/Y information.
583		// If not, this function returns %FALSE.	583		// If not, this function returns %FALSE.
584	-	func (x Event) GetDistance(Event2Var Event, DistanceVar float64) bool {	584	+	func (x Event) GetDistance(Event2Var Event, DistanceVar *float64) bool {
585			585
586		cret := xEventGetDistance(x.GoPointer(), Event2Var.GoPointer(), DistanceVar)	586		cret := xEventGetDistance(x.GoPointer(), Event2Var.GoPointer(), DistanceVar)
587		return cret	587		return cret
588		}	588		}
589			589
590	-	var xEventGetAxes func(uintptr, []float64, uint) bool	590	+	var xEventGetAxes func(uintptr, []float64, uint) bool
591			591
592		// Extracts all axis values from an event.	592		// Extracts all axis values from an event.
593		//	593		//
594		// To find out which axes are used, use [method@Gdk.DeviceTool.get_axes]	594		// To find out which axes are used, use [method@Gdk.DeviceTool.get_axes]
595		// on the device tool returned by [method@Gdk.Event.get_device_tool].	595		// on the device tool returned by [method@Gdk.Event.get_device_tool].
596	-	func (x *Event) GetAxes(AxesVar []float64, NAxesVar uint) bool {	596	+	func (x Event) GetAxes(AxesVar []float64, NAxesVar *uint) bool {
597			597
598		cret := xEventGetAxes(x.GoPointer(), AxesVar, NAxesVar)	598		cret := xEventGetAxes(x.GoPointer(), AxesVar, NAxesVar)
599		return cret	599		return cret
600		}	600		}
601			601
602	-	var xEventGetAxis func(uintptr, AxisUse, float64) bool	602	+	var xEventGetAxis func(uintptr, AxisUse, *float64) bool
603			603
604		// Extract the axis value for a particular axis use from	604		// Extract the axis value for a particular axis use from
605		// an event structure.	605		// an event structure.
606		//	606		//
607		// To find out which axes are used, use [method@Gdk.DeviceTool.get_axes]	607		// To find out which axes are used, use [method@Gdk.DeviceTool.get_axes]
608		// on the device tool returned by [method@Gdk.Event.get_device_tool].	608		// on the device tool returned by [method@Gdk.Event.get_device_tool].
609	-	func (x *Event) GetAxis(AxisUseVar AxisUse, ValueVar float64) bool {	609	+	func (x Event) GetAxis(AxisUseVar AxisUse, ValueVar float64) bool {
610			610
611		cret := xEventGetAxis(x.GoPointer(), AxisUseVar, ValueVar)	611		cret := xEventGetAxis(x.GoPointer(), AxisUseVar, ValueVar)
612		return cret	612		return cret

@@ -693,7 +693,7 @@ func (x *Event) GetEventType() EventType {
693		return cret	693		return cret
694		}	694		}
695			695
696	-	var xEventGetHistory func(uintptr, uint) uintptr	696	+	var xEventGetHistory func(uintptr, *uint) uintptr
697			697
698		// Retrieves the history of the device that @event is for, as a list of	698		// Retrieves the history of the device that @event is for, as a list of
699		// time and coordinates.	699		// time and coordinates.

@@ -704,7 +704,7 @@ var xEventGetHistory func(uintptr, uint) uintptr
704		// Note that only motion and scroll events record history, and motion	704		// Note that only motion and scroll events record history, and motion
705		// events do it only if one of the mouse buttons is down, or the device	705		// events do it only if one of the mouse buttons is down, or the device
706		// has a tool.	706		// has a tool.
707	-	func (x *Event) GetHistory(OutNCoordsVar uint) uintptr {	707	+	func (x Event) GetHistory(OutNCoordsVar uint) uintptr {
708			708
709		cret := xEventGetHistory(x.GoPointer(), OutNCoordsVar)	709		cret := xEventGetHistory(x.GoPointer(), OutNCoordsVar)
710		return cret	710		return cret

@@ -730,12 +730,12 @@ func (x *Event) GetPointerEmulated() bool {
730		return cret	730		return cret
731		}	731		}
732			732
733	-	var xEventGetPosition func(uintptr, float64, float64) bool	733	+	var xEventGetPosition func(uintptr, float64, float64) bool
734			734
735		// Extract the event surface relative x/y coordinates from an event.	735		// Extract the event surface relative x/y coordinates from an event.
736		//	736		//
737		// This position is in [surface coordinates](coordinates.html).	737		// This position is in [surface coordinates](coordinates.html).
738	-	func (x *Event) GetPosition(XVar float64, YVar float64) bool {	738	+	func (x Event) GetPosition(XVar float64, YVar *float64) bool {
739			739
740		cret := xEventGetPosition(x.GoPointer(), XVar, YVar)	740		cret := xEventGetPosition(x.GoPointer(), XVar, YVar)
741		return cret	741		return cret

@@ -998,13 +998,13 @@ func (x *KeyEvent) GetLevel() uint {
998		return cret	998		return cret
999		}	999		}
1000			1000
1001	-	var xKeyEventGetMatch func(uintptr, uint, *ModifierType) bool	1001	+	var xKeyEventGetMatch func(uintptr, uint, ModifierType) bool
1002			1002
1003		// Gets a keyval and modifier combination that will match	1003		// Gets a keyval and modifier combination that will match
1004		// the event.	1004		// the event.
1005		//	1005		//
1006		// See [method@Gdk.KeyEvent.matches].	1006		// See [method@Gdk.KeyEvent.matches].
1007	-	func (x KeyEvent) GetMatch(KeyvalVar uint, ModifiersVar ModifierType) bool {	1007	+	func (x KeyEvent) GetMatch(KeyvalVar uint, ModifiersVar *ModifierType) bool {
1008			1008
1009		cret := xKeyEventGetMatch(x.GoPointer(), KeyvalVar, ModifiersVar)	1009		cret := xKeyEventGetMatch(x.GoPointer(), KeyvalVar, ModifiersVar)
1010		return cret	1010		return cret

@@ -1091,10 +1091,10 @@ func PadEventNewFromInternalPtr(ptr uintptr) *PadEvent {
1091		return cls	1091		return cls
1092		}	1092		}
1093			1093
1094	-	var xPadEventGetAxisValue func(uintptr, uint, float64)	1094	+	var xPadEventGetAxisValue func(uintptr, uint, float64)
1095			1095
1096		// Extracts the information from a pad strip or ring event.	1096		// Extracts the information from a pad strip or ring event.
1097	-	func (x *PadEvent) GetAxisValue(IndexVar uint, ValueVar float64) {	1097	+	func (x PadEvent) GetAxisValue(IndexVar uint, ValueVar *float64) {
1098			1098
1099		xPadEventGetAxisValue(x.GoPointer(), IndexVar, ValueVar)	1099		xPadEventGetAxisValue(x.GoPointer(), IndexVar, ValueVar)
1100			1100

@@ -1110,10 +1110,10 @@ func (x *PadEvent) GetButton() uint {
1110		return cret	1110		return cret
1111		}	1111		}
1112			1112
1113	-	var xPadEventGetGroupMode func(uintptr, uint, uint)	1113	+	var xPadEventGetGroupMode func(uintptr, uint, uint)
1114			1114
1115		// Extracts group and mode information from a pad event.	1115		// Extracts group and mode information from a pad event.
1116	-	func (x *PadEvent) GetGroupMode(GroupVar uint, ModeVar uint) {	1116	+	func (x PadEvent) GetGroupMode(GroupVar uint, ModeVar *uint) {
1117			1117
1118		xPadEventGetGroupMode(x.GoPointer(), GroupVar, ModeVar)	1118		xPadEventGetGroupMode(x.GoPointer(), GroupVar, ModeVar)
1119			1119

@@ -1175,7 +1175,7 @@ func ScrollEventNewFromInternalPtr(ptr uintptr) *ScrollEvent {
1175		return cls	1175		return cls
1176		}	1176		}
1177			1177
1178	-	var xScrollEventGetDeltas func(uintptr, float64, float64)	1178	+	var xScrollEventGetDeltas func(uintptr, float64, float64)
1179			1179
1180		// Extracts the scroll deltas of a scroll event.	1180		// Extracts the scroll deltas of a scroll event.
1181		//	1181		//

@@ -1184,7 +1184,7 @@ var xScrollEventGetDeltas func(uintptr, float64, float64)
1184		//	1184		//
1185		// For the representation unit of these deltas, see	1185		// For the representation unit of these deltas, see
1186		// [method@Gdk.ScrollEvent.get_unit].	1186		// [method@Gdk.ScrollEvent.get_unit].
1187	-	func (x *ScrollEvent) GetDeltas(DeltaXVar float64, DeltaYVar float64) {	1187	+	func (x ScrollEvent) GetDeltas(DeltaXVar float64, DeltaYVar *float64) {
1188			1188
1189		xScrollEventGetDeltas(x.GoPointer(), DeltaXVar, DeltaYVar)	1189		xScrollEventGetDeltas(x.GoPointer(), DeltaXVar, DeltaYVar)
1190			1190

@@ -1306,10 +1306,10 @@ func TouchpadEventNewFromInternalPtr(ptr uintptr) *TouchpadEvent {
1306		return cls	1306		return cls
1307		}	1307		}
1308			1308
1309	-	var xTouchpadEventGetDeltas func(uintptr, float64, float64)	1309	+	var xTouchpadEventGetDeltas func(uintptr, float64, float64)
1310			1310
1311		// Extracts delta information from a touchpad event.	1311		// Extracts delta information from a touchpad event.
1312	-	func (x *TouchpadEvent) GetDeltas(DxVar float64, DyVar float64) {	1312	+	func (x TouchpadEvent) GetDeltas(DxVar float64, DyVar *float64) {
1313			1313
1314		xTouchpadEventGetDeltas(x.GoPointer(), DxVar, DyVar)	1314		xTouchpadEventGetDeltas(x.GoPointer(), DxVar, DyVar)
1315			1315

M v4/gdk/gdkframeclock.go +2 -2


@@ -193,7 +193,7 @@ func (x *FrameClock) GetHistoryStart() int64 {
193		return cret	193		return cret
194		}	194		}
195			195
196	-	var xFrameClockGetRefreshInfo func(uintptr, int64, int64, int64)	196	+	var xFrameClockGetRefreshInfo func(uintptr, int64, int64, int64)
197			197
198		// Predicts a presentation time, based on history.	198		// Predicts a presentation time, based on history.
199		//	199		//

@@ -202,7 +202,7 @@ var xFrameClockGetRefreshInfo func(uintptr, int64, int64, int64)
202		// presentation times are separated by the refresh interval,	202		// presentation times are separated by the refresh interval,
203		// predicts a presentation time that is a multiple of the refresh	203		// predicts a presentation time that is a multiple of the refresh
204		// interval after the last presentation time, and later than @base_time.	204		// interval after the last presentation time, and later than @base_time.
205	-	func (x *FrameClock) GetRefreshInfo(BaseTimeVar int64, RefreshIntervalReturnVar int64, PresentationTimeReturnVar int64) {	205	+	func (x FrameClock) GetRefreshInfo(BaseTimeVar int64, RefreshIntervalReturnVar int64, PresentationTimeReturnVar *int64) {
206			206
207		xFrameClockGetRefreshInfo(x.GoPointer(), BaseTimeVar, RefreshIntervalReturnVar, PresentationTimeReturnVar)	207		xFrameClockGetRefreshInfo(x.GoPointer(), BaseTimeVar, RefreshIntervalReturnVar, PresentationTimeReturnVar)
208			208

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


@@ -141,7 +141,7 @@ func (x *GLContext) GetForwardCompatible() bool {
141		return cret	141		return cret
142		}	142		}
143			143
144	-	var xGLContextGetRequiredVersion func(uintptr, int, int)	144	+	var xGLContextGetRequiredVersion func(uintptr, int, int)
145			145
146		// Retrieves required OpenGL version set as a requirement for the @context	146		// Retrieves required OpenGL version set as a requirement for the @context
147		// realization. It will not change even if a greater OpenGL version is supported	147		// realization. It will not change even if a greater OpenGL version is supported

@@ -149,7 +149,7 @@ var xGLContextGetRequiredVersion func(uintptr, int, int)
149		// [method@Gdk.GLContext.get_version] for the real version in use.	149		// [method@Gdk.GLContext.get_version] for the real version in use.
150		//	150		//
151		// See [method@Gdk.GLContext.set_required_version].	151		// See [method@Gdk.GLContext.set_required_version].
152	-	func (x *GLContext) GetRequiredVersion(MajorVar int, MinorVar int) {	152	+	func (x GLContext) GetRequiredVersion(MajorVar int, MinorVar *int) {
153			153
154		xGLContextGetRequiredVersion(x.GoPointer(), MajorVar, MinorVar)	154		xGLContextGetRequiredVersion(x.GoPointer(), MajorVar, MinorVar)
155			155

@@ -201,12 +201,12 @@ func (x *GLContext) GetUseEs() bool {
201		return cret	201		return cret
202		}	202		}
203			203
204	-	var xGLContextGetVersion func(uintptr, int, int)	204	+	var xGLContextGetVersion func(uintptr, int, int)
205			205
206		// Retrieves the OpenGL version of the @context.	206		// Retrieves the OpenGL version of the @context.
207		//	207		//
208		// The @context must be realized prior to calling this function.	208		// The @context must be realized prior to calling this function.
209	-	func (x *GLContext) GetVersion(MajorVar int, MinorVar int) {	209	+	func (x GLContext) GetVersion(MajorVar int, MinorVar *int) {
210			210
211		xGLContextGetVersion(x.GoPointer(), MajorVar, MinorVar)	211		xGLContextGetVersion(x.GoPointer(), MajorVar, MinorVar)
212			212

M v4/gdk/gdkgltexture.go +3 -3


@@ -91,7 +91,7 @@ func (c *GLTexture) SetGoPointer(ptr uintptr) {
91		// and @specified_height are known, but it is useful to call this	91		// and @specified_height are known, but it is useful to call this
92		// function in GtkWidget:measure implementations to compute the	92		// function in GtkWidget:measure implementations to compute the
93		// other dimension when only one dimension is given.	93		// other dimension when only one dimension is given.
94	-	func (x *GLTexture) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar float64) {	94	+	func (x GLTexture) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar *float64) {
95			95
96		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)	96		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)
97			97

@@ -274,7 +274,7 @@ func (x *GLTexture) ToString() string {
274			274
275		// Loads a loadable icon. For the asynchronous version of this function,	275		// Loads a loadable icon. For the asynchronous version of this function,
276		// see g_loadable_icon_load_async().	276		// see g_loadable_icon_load_async().
277	-	func (x GLTexture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (*gio.InputStream, error) {	277	+	func (x GLTexture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (gio.InputStream, error) {
278		var cls *gio.InputStream	278		var cls *gio.InputStream
279		var cerr *glib.Error	279		var cerr *glib.Error
280			280

@@ -302,7 +302,7 @@ func (x GLTexture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, Call
302		}	302		}
303			303
304		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().	304		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().
305	-	func (x GLTexture) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (gio.InputStream, error) {	305	+	func (x GLTexture) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (*gio.InputStream, error) {
306		var cls *gio.InputStream	306		var cls *gio.InputStream
307		var cerr *glib.Error	307		var cerr *glib.Error
308			308

M v4/gdk/gdkgltexturebuilder.go +123 -0


@@ -353,6 +353,129 @@ func (c *GLTextureBuilder) SetGoPointer(ptr uintptr) {
353	c.Ptr = ptr	353		c.Ptr = ptr
354	}	354		}
355		355
		356	+	// SetPropertyColorState sets the "color-state" property.
		357	+	// The color state of the texture.
		358	+	func (x *GLTextureBuilder) SetPropertyColorState(value uintptr) {
		359	+	var v gobject.Value
		360	+	v.Init(gobject.TypePointerVal)
		361	+	v.SetPointer(value)
		362	+	x.SetProperty("color-state", &v)
		363	+	}
		364	+
		365	+	// GetPropertyColorState gets the "color-state" property.
		366	+	// The color state of the texture.
		367	+	func (x *GLTextureBuilder) GetPropertyColorState() uintptr {
		368	+	var v gobject.Value
		369	+	x.GetProperty("color-state", &v)
		370	+	return v.GetPointer()
		371	+	}
		372	+
		373	+	// SetPropertyHasMipmap sets the "has-mipmap" property.
		374	+	// If the texture has a mipmap.
		375	+	func (x *GLTextureBuilder) SetPropertyHasMipmap(value bool) {
		376	+	var v gobject.Value
		377	+	v.Init(gobject.TypeBooleanVal)
		378	+	v.SetBoolean(value)
		379	+	x.SetProperty("has-mipmap", &v)
		380	+	}
		381	+
		382	+	// GetPropertyHasMipmap gets the "has-mipmap" property.
		383	+	// If the texture has a mipmap.
		384	+	func (x *GLTextureBuilder) GetPropertyHasMipmap() bool {
		385	+	var v gobject.Value
		386	+	x.GetProperty("has-mipmap", &v)
		387	+	return v.GetBoolean()
		388	+	}
		389	+
		390	+	// SetPropertyHeight sets the "height" property.
		391	+	// The height of the texture.
		392	+	func (x *GLTextureBuilder) SetPropertyHeight(value int) {
		393	+	var v gobject.Value
		394	+	v.Init(gobject.TypeIntVal)
		395	+	v.SetInt(value)
		396	+	x.SetProperty("height", &v)
		397	+	}
		398	+
		399	+	// GetPropertyHeight gets the "height" property.
		400	+	// The height of the texture.
		401	+	func (x *GLTextureBuilder) GetPropertyHeight() int {
		402	+	var v gobject.Value
		403	+	x.GetProperty("height", &v)
		404	+	return v.GetInt()
		405	+	}
		406	+
		407	+	// SetPropertyId sets the "id" property.
		408	+	// The texture ID to use.
		409	+	func (x *GLTextureBuilder) SetPropertyId(value uint) {
		410	+	var v gobject.Value
		411	+	v.Init(gobject.TypeUintVal)
		412	+	v.SetUint(value)
		413	+	x.SetProperty("id", &v)
		414	+	}
		415	+
		416	+	// GetPropertyId gets the "id" property.
		417	+	// The texture ID to use.
		418	+	func (x *GLTextureBuilder) GetPropertyId() uint {
		419	+	var v gobject.Value
		420	+	x.GetProperty("id", &v)
		421	+	return v.GetUint()
		422	+	}
		423	+
		424	+	// SetPropertySync sets the "sync" property.
		425	+	// An optional `GLSync` object.
		426	+	//
		427	+	// If this is set, GTK will wait on it before using the texture.
		428	+	func (x *GLTextureBuilder) SetPropertySync(value uintptr) {
		429	+	var v gobject.Value
		430	+	v.Init(gobject.TypePointerVal)
		431	+	v.SetPointer(value)
		432	+	x.SetProperty("sync", &v)
		433	+	}
		434	+
		435	+	// GetPropertySync gets the "sync" property.
		436	+	// An optional `GLSync` object.
		437	+	//
		438	+	// If this is set, GTK will wait on it before using the texture.
		439	+	func (x *GLTextureBuilder) GetPropertySync() uintptr {
		440	+	var v gobject.Value
		441	+	x.GetProperty("sync", &v)
		442	+	return v.GetPointer()
		443	+	}
		444	+
		445	+	// SetPropertyUpdateRegion sets the "update-region" property.
		446	+	// The update region for [property@Gdk.GLTextureBuilder:update-texture].
		447	+	func (x *GLTextureBuilder) SetPropertyUpdateRegion(value uintptr) {
		448	+	var v gobject.Value
		449	+	v.Init(gobject.TypePointerVal)
		450	+	v.SetPointer(value)
		451	+	x.SetProperty("update-region", &v)
		452	+	}
		453	+
		454	+	// GetPropertyUpdateRegion gets the "update-region" property.
		455	+	// The update region for [property@Gdk.GLTextureBuilder:update-texture].
		456	+	func (x *GLTextureBuilder) GetPropertyUpdateRegion() uintptr {
		457	+	var v gobject.Value
		458	+	x.GetProperty("update-region", &v)
		459	+	return v.GetPointer()
		460	+	}
		461	+
		462	+	// SetPropertyWidth sets the "width" property.
		463	+	// The width of the texture.
		464	+	func (x *GLTextureBuilder) SetPropertyWidth(value int) {
		465	+	var v gobject.Value
		466	+	v.Init(gobject.TypeIntVal)
		467	+	v.SetInt(value)
		468	+	x.SetProperty("width", &v)
		469	+	}
		470	+
		471	+	// GetPropertyWidth gets the "width" property.
		472	+	// The width of the texture.
		473	+	func (x *GLTextureBuilder) GetPropertyWidth() int {
		474	+	var v gobject.Value
		475	+	x.GetProperty("width", &v)
		476	+	return v.GetInt()
		477	+	}
		478	+
356	func init() {	479		func init() {
357	core.SetPackageName("GDK", "gtk4")	480		core.SetPackageName("GDK", "gtk4")
358	core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})	481		core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})

M v4/gdk/gdkkeys.go +2 -2


@@ -6,12 +6,12 @@ import (
6		"github.com/jwijenbergh/puregotk/pkg/core"	6		"github.com/jwijenbergh/puregotk/pkg/core"
7		)	7		)
8			8
9	-	var xKeyvalConvertCase func(uint, uint, uint)	9	+	var xKeyvalConvertCase func(uint, uint, uint)
10			10
11		// Obtains the upper- and lower-case versions of the keyval @symbol.	11		// Obtains the upper- and lower-case versions of the keyval @symbol.
12		//	12		//
13		// Examples of keyvals are `GDK_KEY_a`, `GDK_KEY_Enter`, `GDK_KEY_F1`, etc.	13		// Examples of keyvals are `GDK_KEY_a`, `GDK_KEY_Enter`, `GDK_KEY_F1`, etc.
14	-	func KeyvalConvertCase(SymbolVar uint, LowerVar uint, UpperVar uint) {	14	+	func KeyvalConvertCase(SymbolVar uint, LowerVar uint, UpperVar uint) {
15			15
16		xKeyvalConvertCase(SymbolVar, LowerVar, UpperVar)	16		xKeyvalConvertCase(SymbolVar, LowerVar, UpperVar)
17			17

M v4/gdk/gdkmemorytexture.go +3 -3


@@ -77,7 +77,7 @@ func (c *MemoryTexture) SetGoPointer(ptr uintptr) {
77		// and @specified_height are known, but it is useful to call this	77		// and @specified_height are known, but it is useful to call this
78		// function in GtkWidget:measure implementations to compute the	78		// function in GtkWidget:measure implementations to compute the
79		// other dimension when only one dimension is given.	79		// other dimension when only one dimension is given.
80	-	func (x *MemoryTexture) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar float64) {	80	+	func (x MemoryTexture) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar *float64) {
81			81
82		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)	82		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)
83			83

@@ -260,7 +260,7 @@ func (x *MemoryTexture) ToString() string {
260			260
261		// Loads a loadable icon. For the asynchronous version of this function,	261		// Loads a loadable icon. For the asynchronous version of this function,
262		// see g_loadable_icon_load_async().	262		// see g_loadable_icon_load_async().
263	-	func (x MemoryTexture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (*gio.InputStream, error) {	263	+	func (x MemoryTexture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (gio.InputStream, error) {
264		var cls *gio.InputStream	264		var cls *gio.InputStream
265		var cerr *glib.Error	265		var cerr *glib.Error
266			266

@@ -288,7 +288,7 @@ func (x MemoryTexture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable,
288		}	288		}
289			289
290		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().	290		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().
291	-	func (x MemoryTexture) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (gio.InputStream, error) {	291	+	func (x MemoryTexture) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (*gio.InputStream, error) {
292		var cls *gio.InputStream	292		var cls *gio.InputStream
293		var cerr *glib.Error	293		var cerr *glib.Error
294			294

M v4/gdk/gdkmemorytexturebuilder.go +108 -0


@@ -317,6 +317,114 @@ func (c *MemoryTextureBuilder) SetGoPointer(ptr uintptr) {
317	c.Ptr = ptr	317		c.Ptr = ptr
318	}	318		}
319		319
		320	+	// SetPropertyBytes sets the "bytes" property.
		321	+	// The bytes holding the data.
		322	+	func (x *MemoryTextureBuilder) SetPropertyBytes(value uintptr) {
		323	+	var v gobject.Value
		324	+	v.Init(gobject.TypePointerVal)
		325	+	v.SetPointer(value)
		326	+	x.SetProperty("bytes", &v)
		327	+	}
		328	+
		329	+	// GetPropertyBytes gets the "bytes" property.
		330	+	// The bytes holding the data.
		331	+	func (x *MemoryTextureBuilder) GetPropertyBytes() uintptr {
		332	+	var v gobject.Value
		333	+	x.GetProperty("bytes", &v)
		334	+	return v.GetPointer()
		335	+	}
		336	+
		337	+	// SetPropertyColorState sets the "color-state" property.
		338	+	// The colorstate describing the data.
		339	+	func (x *MemoryTextureBuilder) SetPropertyColorState(value uintptr) {
		340	+	var v gobject.Value
		341	+	v.Init(gobject.TypePointerVal)
		342	+	v.SetPointer(value)
		343	+	x.SetProperty("color-state", &v)
		344	+	}
		345	+
		346	+	// GetPropertyColorState gets the "color-state" property.
		347	+	// The colorstate describing the data.
		348	+	func (x *MemoryTextureBuilder) GetPropertyColorState() uintptr {
		349	+	var v gobject.Value
		350	+	x.GetProperty("color-state", &v)
		351	+	return v.GetPointer()
		352	+	}
		353	+
		354	+	// SetPropertyHeight sets the "height" property.
		355	+	// The height of the texture.
		356	+	func (x *MemoryTextureBuilder) SetPropertyHeight(value int) {
		357	+	var v gobject.Value
		358	+	v.Init(gobject.TypeIntVal)
		359	+	v.SetInt(value)
		360	+	x.SetProperty("height", &v)
		361	+	}
		362	+
		363	+	// GetPropertyHeight gets the "height" property.
		364	+	// The height of the texture.
		365	+	func (x *MemoryTextureBuilder) GetPropertyHeight() int {
		366	+	var v gobject.Value
		367	+	x.GetProperty("height", &v)
		368	+	return v.GetInt()
		369	+	}
		370	+
		371	+	// SetPropertyStride sets the "stride" property.
		372	+	// The rowstride of the texture.
		373	+	//
		374	+	// The rowstride is the number of bytes between the first pixel
		375	+	// in a row of image data, and the first pixel in the next row.
		376	+	func (x *MemoryTextureBuilder) SetPropertyStride(value uint64) {
		377	+	var v gobject.Value
		378	+	v.Init(gobject.TypeUint64Val)
		379	+	v.SetUint64(value)
		380	+	x.SetProperty("stride", &v)
		381	+	}
		382	+
		383	+	// GetPropertyStride gets the "stride" property.
		384	+	// The rowstride of the texture.
		385	+	//
		386	+	// The rowstride is the number of bytes between the first pixel
		387	+	// in a row of image data, and the first pixel in the next row.
		388	+	func (x *MemoryTextureBuilder) GetPropertyStride() uint64 {
		389	+	var v gobject.Value
		390	+	x.GetProperty("stride", &v)
		391	+	return v.GetUint64()
		392	+	}
		393	+
		394	+	// SetPropertyUpdateRegion sets the "update-region" property.
		395	+	// The update region for [property@Gdk.MemoryTextureBuilder:update-texture].
		396	+	func (x *MemoryTextureBuilder) SetPropertyUpdateRegion(value uintptr) {
		397	+	var v gobject.Value
		398	+	v.Init(gobject.TypePointerVal)
		399	+	v.SetPointer(value)
		400	+	x.SetProperty("update-region", &v)
		401	+	}
		402	+
		403	+	// GetPropertyUpdateRegion gets the "update-region" property.
		404	+	// The update region for [property@Gdk.MemoryTextureBuilder:update-texture].
		405	+	func (x *MemoryTextureBuilder) GetPropertyUpdateRegion() uintptr {
		406	+	var v gobject.Value
		407	+	x.GetProperty("update-region", &v)
		408	+	return v.GetPointer()
		409	+	}
		410	+
		411	+	// SetPropertyWidth sets the "width" property.
		412	+	// The width of the texture.
		413	+	func (x *MemoryTextureBuilder) SetPropertyWidth(value int) {
		414	+	var v gobject.Value
		415	+	v.Init(gobject.TypeIntVal)
		416	+	v.SetInt(value)
		417	+	x.SetProperty("width", &v)
		418	+	}
		419	+
		420	+	// GetPropertyWidth gets the "width" property.
		421	+	// The width of the texture.
		422	+	func (x *MemoryTextureBuilder) GetPropertyWidth() int {
		423	+	var v gobject.Value
		424	+	x.GetProperty("width", &v)
		425	+	return v.GetInt()
		426	+	}
		427	+
320	func init() {	428		func init() {
321	core.SetPackageName("GDK", "gtk4")	429		core.SetPackageName("GDK", "gtk4")
322	core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})	430		core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})

M v4/gdk/gdkmonitor.go +91 -0


@@ -241,6 +241,97 @@ func (c *Monitor) SetGoPointer(ptr uintptr) {
241	c.Ptr = ptr	241		c.Ptr = ptr
242	}	242		}
243		243
		244	+	// GetPropertyConnector gets the "connector" property.
		245	+	// The connector name.
		246	+	func (x *Monitor) GetPropertyConnector() string {
		247	+	var v gobject.Value
		248	+	x.GetProperty("connector", &v)
		249	+	return v.GetString()
		250	+	}
		251	+
		252	+	// GetPropertyDescription gets the "description" property.
		253	+	// A short description of the monitor, meant for display to the user.
		254	+	func (x *Monitor) GetPropertyDescription() string {
		255	+	var v gobject.Value
		256	+	x.GetProperty("description", &v)
		257	+	return v.GetString()
		258	+	}
		259	+
		260	+	// GetPropertyGeometry gets the "geometry" property.
		261	+	// The geometry of the monitor.
		262	+	func (x *Monitor) GetPropertyGeometry() uintptr {
		263	+	var v gobject.Value
		264	+	x.GetProperty("geometry", &v)
		265	+	return v.GetPointer()
		266	+	}
		267	+
		268	+	// GetPropertyHeightMm gets the "height-mm" property.
		269	+	// The height of the monitor, in millimeters.
		270	+	func (x *Monitor) GetPropertyHeightMm() int {
		271	+	var v gobject.Value
		272	+	x.GetProperty("height-mm", &v)
		273	+	return v.GetInt()
		274	+	}
		275	+
		276	+	// GetPropertyManufacturer gets the "manufacturer" property.
		277	+	// The manufacturer name.
		278	+	func (x *Monitor) GetPropertyManufacturer() string {
		279	+	var v gobject.Value
		280	+	x.GetProperty("manufacturer", &v)
		281	+	return v.GetString()
		282	+	}
		283	+
		284	+	// GetPropertyModel gets the "model" property.
		285	+	// The model name.
		286	+	func (x *Monitor) GetPropertyModel() string {
		287	+	var v gobject.Value
		288	+	x.GetProperty("model", &v)
		289	+	return v.GetString()
		290	+	}
		291	+
		292	+	// GetPropertyRefreshRate gets the "refresh-rate" property.
		293	+	// The refresh rate, in milli-Hertz.
		294	+	func (x *Monitor) GetPropertyRefreshRate() int {
		295	+	var v gobject.Value
		296	+	x.GetProperty("refresh-rate", &v)
		297	+	return v.GetInt()
		298	+	}
		299	+
		300	+	// GetPropertyScale gets the "scale" property.
		301	+	// The scale of the monitor.
		302	+	func (x *Monitor) GetPropertyScale() float64 {
		303	+	var v gobject.Value
		304	+	x.GetProperty("scale", &v)
		305	+	return v.GetDouble()
		306	+	}
		307	+
		308	+	// GetPropertyScaleFactor gets the "scale-factor" property.
		309	+	// The scale factor.
		310	+	//
		311	+	// The scale factor is the next larger integer,
		312	+	// compared to [property@Gdk.Surface:scale].
		313	+	func (x *Monitor) GetPropertyScaleFactor() int {
		314	+	var v gobject.Value
		315	+	x.GetProperty("scale-factor", &v)
		316	+	return v.GetInt()
		317	+	}
		318	+
		319	+	// GetPropertyValid gets the "valid" property.
		320	+	// Whether the object is still valid.
		321	+	func (x *Monitor) GetPropertyValid() bool {
		322	+	var v gobject.Value
		323	+	x.GetProperty("valid", &v)
		324	+	return v.GetBoolean()
		325	+	}
		326	+
		327	+	// GetPropertyWidthMm gets the "width-mm" property.
		328	+	// The width of the monitor, in millimeters.
		329	+	func (x *Monitor) GetPropertyWidthMm() int {
		330	+	var v gobject.Value
		331	+	x.GetProperty("width-mm", &v)
		332	+	return v.GetInt()
		333	+	}
		334	+
244	// Emitted when the output represented by @monitor gets disconnected.	335		// Emitted when the output represented by @monitor gets disconnected.
245	func (x Monitor) ConnectInvalidate(cb func(Monitor)) uint32 {	336		func (x Monitor) ConnectInvalidate(cb func(Monitor)) uint32 {
246	cbPtr := uintptr(unsafe.Pointer(cb))	337		cbPtr := uintptr(unsafe.Pointer(cb))

M v4/gdk/gdkpaintable.go +15 -15


@@ -41,7 +41,7 @@ func (x *PaintableInterface) GoPointer() uintptr {
41		return uintptr(unsafe.Pointer(x))	41		return uintptr(unsafe.Pointer(x))
42		}	42		}
43			43
44	-	// OverrideSnapshot sets the callback function.	44	+	// OverrideSnapshot sets the "snapshot" callback function.
45		// Snapshot the paintable. The given @width and @height are	45		// Snapshot the paintable. The given @width and @height are
46		//	46		//
47		// guaranteed to be larger than 0.0. The resulting snapshot must modify	47		// guaranteed to be larger than 0.0. The resulting snapshot must modify

@@ -57,7 +57,7 @@ func (x PaintableInterface) OverrideSnapshot(cb func(Paintable, Snapshot, floa
57		}	57		}
58		}	58		}
59			59
60	-	// GetSnapshot gets the callback function.	60	+	// GetSnapshot gets the "snapshot" callback function.
61		// Snapshot the paintable. The given @width and @height are	61		// Snapshot the paintable. The given @width and @height are
62		//	62		//
63		// guaranteed to be larger than 0.0. The resulting snapshot must modify	63		// guaranteed to be larger than 0.0. The resulting snapshot must modify

@@ -74,7 +74,7 @@ func (x PaintableInterface) GetSnapshot() func(Paintable, Snapshot, float64, f
74		}	74		}
75		}	75		}
76			76
77	-	// OverrideGetCurrentImage sets the callback function.	77	+	// OverrideGetCurrentImage sets the "get_current_image" callback function.
78		// return a `GdkPaintable` that does not change over	78		// return a `GdkPaintable` that does not change over
79		//	79		//
80		// time. This means the `GDK_PAINTABLE_STATIC_SIZE` and	80		// time. This means the `GDK_PAINTABLE_STATIC_SIZE` and

@@ -93,7 +93,7 @@ func (x PaintableInterface) OverrideGetCurrentImage(cb func(Paintable) Paintab
93		}	93		}
94		}	94		}
95			95
96	-	// GetGetCurrentImage gets the callback function.	96	+	// GetGetCurrentImage gets the "get_current_image" callback function.
97		// return a `GdkPaintable` that does not change over	97		// return a `GdkPaintable` that does not change over
98		//	98		//
99		// time. This means the `GDK_PAINTABLE_STATIC_SIZE` and	99		// time. This means the `GDK_PAINTABLE_STATIC_SIZE` and

@@ -115,7 +115,7 @@ func (x PaintableInterface) GetGetCurrentImage() func(Paintable) PaintableBase
115		}	115		}
116		}	116		}
117			117
118	-	// OverrideGetFlags sets the callback function.	118	+	// OverrideGetFlags sets the "get_flags" callback function.
119		// Get the flags for this instance. See [flags@Gdk.PaintableFlags]	119		// Get the flags for this instance. See [flags@Gdk.PaintableFlags]
120		//	120		//
121		// for details.	121		// for details.

@@ -129,7 +129,7 @@ func (x *PaintableInterface) OverrideGetFlags(cb func(Paintable) PaintableFlags)
129		}	129		}
130		}	130		}
131			131
132	-	// GetGetFlags gets the callback function.	132	+	// GetGetFlags gets the "get_flags" callback function.
133		// Get the flags for this instance. See [flags@Gdk.PaintableFlags]	133		// Get the flags for this instance. See [flags@Gdk.PaintableFlags]
134		//	134		//
135		// for details.	135		// for details.

@@ -144,7 +144,7 @@ func (x *PaintableInterface) GetGetFlags() func(Paintable) PaintableFlags {
144		}	144		}
145		}	145		}
146			146
147	-	// OverrideGetIntrinsicWidth sets the callback function.	147	+	// OverrideGetIntrinsicWidth sets the "get_intrinsic_width" callback function.
148		// The preferred width for this object to be	148		// The preferred width for this object to be
149		//	149		//
150		// snapshot at or 0 if none. This is purely a hint. The object must still	150		// snapshot at or 0 if none. This is purely a hint. The object must still

@@ -159,7 +159,7 @@ func (x *PaintableInterface) OverrideGetIntrinsicWidth(cb func(Paintable) int) {
159		}	159		}
160		}	160		}
161			161
162	-	// GetGetIntrinsicWidth gets the callback function.	162	+	// GetGetIntrinsicWidth gets the "get_intrinsic_width" callback function.
163		// The preferred width for this object to be	163		// The preferred width for this object to be
164		//	164		//
165		// snapshot at or 0 if none. This is purely a hint. The object must still	165		// snapshot at or 0 if none. This is purely a hint. The object must still

@@ -175,7 +175,7 @@ func (x *PaintableInterface) GetGetIntrinsicWidth() func(Paintable) int {
175		}	175		}
176		}	176		}
177			177
178	-	// OverrideGetIntrinsicHeight sets the callback function.	178	+	// OverrideGetIntrinsicHeight sets the "get_intrinsic_height" callback function.
179		// The preferred height for this object to be	179		// The preferred height for this object to be
180		//	180		//
181		// snapshot at or 0 if none. This is purely a hint. The object must still	181		// snapshot at or 0 if none. This is purely a hint. The object must still

@@ -190,7 +190,7 @@ func (x *PaintableInterface) OverrideGetIntrinsicHeight(cb func(Paintable) int)
190		}	190		}
191		}	191		}
192			192
193	-	// GetGetIntrinsicHeight gets the callback function.	193	+	// GetGetIntrinsicHeight gets the "get_intrinsic_height" callback function.
194		// The preferred height for this object to be	194		// The preferred height for this object to be
195		//	195		//
196		// snapshot at or 0 if none. This is purely a hint. The object must still	196		// snapshot at or 0 if none. This is purely a hint. The object must still

@@ -206,7 +206,7 @@ func (x *PaintableInterface) GetGetIntrinsicHeight() func(Paintable) int {
206		}	206		}
207		}	207		}
208			208
209	-	// OverrideGetIntrinsicAspectRatio sets the callback function.	209	+	// OverrideGetIntrinsicAspectRatio sets the "get_intrinsic_aspect_ratio" callback function.
210		// The preferred aspect ratio for this object	210		// The preferred aspect ratio for this object
211		//	211		//
212		// or 0 if none. If both [vfunc@Gdk.Paintable.get_intrinsic_width]	212		// or 0 if none. If both [vfunc@Gdk.Paintable.get_intrinsic_width]

@@ -222,7 +222,7 @@ func (x *PaintableInterface) OverrideGetIntrinsicAspectRatio(cb func(Paintable)
222		}	222		}
223		}	223		}
224			224
225	-	// GetGetIntrinsicAspectRatio gets the callback function.	225	+	// GetGetIntrinsicAspectRatio gets the "get_intrinsic_aspect_ratio" callback function.
226		// The preferred aspect ratio for this object	226		// The preferred aspect ratio for this object
227		//	227		//
228		// or 0 if none. If both [vfunc@Gdk.Paintable.get_intrinsic_width]	228		// or 0 if none. If both [vfunc@Gdk.Paintable.get_intrinsic_width]

@@ -286,7 +286,7 @@ func (x *PaintableInterface) GetGetIntrinsicAspectRatio() func(Paintable) float6
286		type Paintable interface {	286		type Paintable interface {
287		GoPointer() uintptr	287		GoPointer() uintptr
288		SetGoPointer(uintptr)	288		SetGoPointer(uintptr)
289	-	ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar float64)	289	+	ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar float64)
290		GetCurrentImage() *PaintableBase	290		GetCurrentImage() *PaintableBase
291		GetFlags() PaintableFlags	291		GetFlags() PaintableFlags
292		GetIntrinsicAspectRatio() float64	292		GetIntrinsicAspectRatio() float64

@@ -328,7 +328,7 @@ func (x *PaintableBase) SetGoPointer(ptr uintptr) {
328		// and @specified_height are known, but it is useful to call this	328		// and @specified_height are known, but it is useful to call this
329		// function in GtkWidget:measure implementations to compute the	329		// function in GtkWidget:measure implementations to compute the
330		// other dimension when only one dimension is given.	330		// other dimension when only one dimension is given.
331	-	func (x *PaintableBase) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar float64) {	331	+	func (x PaintableBase) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar *float64) {
332			332
333		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)	333		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)
334			334

@@ -462,7 +462,7 @@ func (x PaintableBase) Snapshot(SnapshotVar Snapshot, WidthVar float64, Height
462			462
463		}	463		}
464			464
465	-	var XGdkPaintableComputeConcreteSize func(uintptr, float64, float64, float64, float64, float64, float64)	465	+	var XGdkPaintableComputeConcreteSize func(uintptr, float64, float64, float64, float64, float64, float64)
466		var XGdkPaintableGetCurrentImage func(uintptr) uintptr	466		var XGdkPaintableGetCurrentImage func(uintptr) uintptr
467		var XGdkPaintableGetFlags func(uintptr) PaintableFlags	467		var XGdkPaintableGetFlags func(uintptr) PaintableFlags
468		var XGdkPaintableGetIntrinsicAspectRatio func(uintptr) float64	468		var XGdkPaintableGetIntrinsicAspectRatio func(uintptr) float64

M v4/gdk/gdkpopup.go +21 -0


@@ -136,6 +136,27 @@ func (x PopupBase) Present(WidthVar int, HeightVar int, LayoutVar PopupLayout)
136	return cret	136		return cret
137	}	137		}
138		138
		139	+	// SetPropertyAutohide sets the "autohide" property.
		140	+	// Whether to hide on outside clicks.
		141	+	func (x *PopupBase) SetPropertyAutohide(value bool) {
		142	+	obj := gobject.Object{}
		143	+	obj.Ptr = x.GoPointer()
		144	+	var v gobject.Value
		145	+	v.Init(gobject.TypeBooleanVal)
		146	+	v.SetBoolean(value)
		147	+	obj.SetProperty("autohide", &v)
		148	+	}
		149	+
		150	+	// GetPropertyAutohide gets the "autohide" property.
		151	+	// Whether to hide on outside clicks.
		152	+	func (x *PopupBase) GetPropertyAutohide() bool {
		153	+	obj := gobject.Object{}
		154	+	obj.Ptr = x.GoPointer()
		155	+	var v gobject.Value
		156	+	obj.GetProperty("autohide", &v)
		157	+	return v.GetBoolean()
		158	+	}
		159	+
139	var XGdkPopupGetAutohide func(uintptr) bool	160		var XGdkPopupGetAutohide func(uintptr) bool
140	var XGdkPopupGetParent func(uintptr) uintptr	161		var XGdkPopupGetParent func(uintptr) uintptr
141	var XGdkPopupGetPositionX func(uintptr) int	162		var XGdkPopupGetPositionX func(uintptr) int

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


@@ -113,10 +113,10 @@ func (x PopupLayout) GetAnchorRect() Rectangle {
113		return cret	113		return cret
114		}	114		}
115			115
116	-	var xPopupLayoutGetOffset func(uintptr, int, int)	116	+	var xPopupLayoutGetOffset func(uintptr, int, int)
117			117
118		// Retrieves the offset for the anchor rectangle.	118		// Retrieves the offset for the anchor rectangle.
119	-	func (x *PopupLayout) GetOffset(DxVar int, DyVar int) {	119	+	func (x PopupLayout) GetOffset(DxVar int, DyVar *int) {
120			120
121		xPopupLayoutGetOffset(x.GoPointer(), DxVar, DyVar)	121		xPopupLayoutGetOffset(x.GoPointer(), DxVar, DyVar)
122			122

@@ -131,10 +131,10 @@ func (x *PopupLayout) GetRectAnchor() Gravity {
131		return cret	131		return cret
132		}	132		}
133			133
134	-	var xPopupLayoutGetShadowWidth func(uintptr, int, int, int, int)	134	+	var xPopupLayoutGetShadowWidth func(uintptr, int, int, int, int)
135			135
136		// Obtains the shadow widths of this layout.	136		// Obtains the shadow widths of this layout.
137	-	func (x *PopupLayout) GetShadowWidth(LeftVar int, RightVar int, TopVar int, BottomVar int) {	137	+	func (x PopupLayout) GetShadowWidth(LeftVar int, RightVar int, TopVar int, BottomVar *int) {
138			138
139		xPopupLayoutGetShadowWidth(x.GoPointer(), LeftVar, RightVar, TopVar, BottomVar)	139		xPopupLayoutGetShadowWidth(x.GoPointer(), LeftVar, RightVar, TopVar, BottomVar)
140			140

M v4/gdk/gdksurface.go +45 -2


@@ -242,13 +242,13 @@ func (x Surface) GetDeviceCursor(DeviceVar Device) *Cursor {
242		return cls	242		return cls
243		}	243		}
244			244
245	-	var xSurfaceGetDevicePosition func(uintptr, uintptr, float64, float64, *ModifierType) bool	245	+	var xSurfaceGetDevicePosition func(uintptr, uintptr, float64, float64, *ModifierType) bool
246			246
247		// Obtains the current device position and modifier state.	247		// Obtains the current device position and modifier state.
248		//	248		//
249		// The position is given in coordinates relative to the upper	249		// The position is given in coordinates relative to the upper
250		// left corner of @surface.	250		// left corner of @surface.
251	-	func (x Surface) GetDevicePosition(DeviceVar Device, XVar float64, YVar float64, MaskVar *ModifierType) bool {	251	+	func (x Surface) GetDevicePosition(DeviceVar Device, XVar float64, YVar float64, MaskVar *ModifierType) bool {
252			252
253		cret := xSurfaceGetDevicePosition(x.GoPointer(), DeviceVar.GoPointer(), XVar, YVar, MaskVar)	253		cret := xSurfaceGetDevicePosition(x.GoPointer(), DeviceVar.GoPointer(), XVar, YVar, MaskVar)
254		return cret	254		return cret

@@ -511,6 +511,49 @@ func (c *Surface) SetGoPointer(ptr uintptr) {
511		c.Ptr = ptr	511		c.Ptr = ptr
512		}	512		}
513			513
			514	+	// GetPropertyHeight gets the "height" property.
			515	+	// The height of the surface, in pixels.
			516	+	func (x *Surface) GetPropertyHeight() int {
			517	+	var v gobject.Value
			518	+	x.GetProperty("height", &v)
			519	+	return v.GetInt()
			520	+	}
			521	+
			522	+	// GetPropertyMapped gets the "mapped" property.
			523	+	// Whether the surface is mapped.
			524	+	func (x *Surface) GetPropertyMapped() bool {
			525	+	var v gobject.Value
			526	+	x.GetProperty("mapped", &v)
			527	+	return v.GetBoolean()
			528	+	}
			529	+
			530	+	// GetPropertyScale gets the "scale" property.
			531	+	// The scale of the surface.
			532	+	func (x *Surface) GetPropertyScale() float64 {
			533	+	var v gobject.Value
			534	+	x.GetProperty("scale", &v)
			535	+	return v.GetDouble()
			536	+	}
			537	+
			538	+	// GetPropertyScaleFactor gets the "scale-factor" property.
			539	+	// The scale factor of the surface.
			540	+	//
			541	+	// The scale factor is the next larger integer,
			542	+	// compared to [property@Gdk.Surface:scale].
			543	+	func (x *Surface) GetPropertyScaleFactor() int {
			544	+	var v gobject.Value
			545	+	x.GetProperty("scale-factor", &v)
			546	+	return v.GetInt()
			547	+	}
			548	+
			549	+	// GetPropertyWidth gets the "width" property.
			550	+	// The width of the surface in pixels.
			551	+	func (x *Surface) GetPropertyWidth() int {
			552	+	var v gobject.Value
			553	+	x.GetProperty("width", &v)
			554	+	return v.GetInt()
			555	+	}
			556	+
514		// Emitted when @surface starts being present on the monitor.	557		// Emitted when @surface starts being present on the monitor.
515		func (x Surface) ConnectEnterMonitor(cb func(Surface, uintptr)) uint32 {	558		func (x Surface) ConnectEnterMonitor(cb func(Surface, uintptr)) uint32 {
516		cbPtr := uintptr(unsafe.Pointer(cb))	559		cbPtr := uintptr(unsafe.Pointer(cb))

M v4/gdk/gdktexture.go +54 -3


@@ -408,6 +408,57 @@ func (c *Texture) SetGoPointer(ptr uintptr) {
408		c.Ptr = ptr	408		c.Ptr = ptr
409		}	409		}
410			410
			411	+	// SetPropertyColorState sets the "color-state" property.
			412	+	// The color state of the texture.
			413	+	func (x *Texture) SetPropertyColorState(value uintptr) {
			414	+	var v gobject.Value
			415	+	v.Init(gobject.TypePointerVal)
			416	+	v.SetPointer(value)
			417	+	x.SetProperty("color-state", &v)
			418	+	}
			419	+
			420	+	// GetPropertyColorState gets the "color-state" property.
			421	+	// The color state of the texture.
			422	+	func (x *Texture) GetPropertyColorState() uintptr {
			423	+	var v gobject.Value
			424	+	x.GetProperty("color-state", &v)
			425	+	return v.GetPointer()
			426	+	}
			427	+
			428	+	// SetPropertyHeight sets the "height" property.
			429	+	// The height of the texture, in pixels.
			430	+	func (x *Texture) SetPropertyHeight(value int) {
			431	+	var v gobject.Value
			432	+	v.Init(gobject.TypeIntVal)
			433	+	v.SetInt(value)
			434	+	x.SetProperty("height", &v)
			435	+	}
			436	+
			437	+	// GetPropertyHeight gets the "height" property.
			438	+	// The height of the texture, in pixels.
			439	+	func (x *Texture) GetPropertyHeight() int {
			440	+	var v gobject.Value
			441	+	x.GetProperty("height", &v)
			442	+	return v.GetInt()
			443	+	}
			444	+
			445	+	// SetPropertyWidth sets the "width" property.
			446	+	// The width of the texture, in pixels.
			447	+	func (x *Texture) SetPropertyWidth(value int) {
			448	+	var v gobject.Value
			449	+	v.Init(gobject.TypeIntVal)
			450	+	v.SetInt(value)
			451	+	x.SetProperty("width", &v)
			452	+	}
			453	+
			454	+	// GetPropertyWidth gets the "width" property.
			455	+	// The width of the texture, in pixels.
			456	+	func (x *Texture) GetPropertyWidth() int {
			457	+	var v gobject.Value
			458	+	x.GetProperty("width", &v)
			459	+	return v.GetInt()
			460	+	}
			461	+
411		// Compute a concrete size for the `GdkPaintable`.	462		// Compute a concrete size for the `GdkPaintable`.
412		//	463		//
413		// Applies the sizing algorithm outlined in the	464		// Applies the sizing algorithm outlined in the

@@ -418,7 +469,7 @@ func (c *Texture) SetGoPointer(ptr uintptr) {
418		// and @specified_height are known, but it is useful to call this	469		// and @specified_height are known, but it is useful to call this
419		// function in GtkWidget:measure implementations to compute the	470		// function in GtkWidget:measure implementations to compute the
420		// other dimension when only one dimension is given.	471		// other dimension when only one dimension is given.
421	-	func (x *Texture) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar float64) {	472	+	func (x Texture) ComputeConcreteSize(SpecifiedWidthVar float64, SpecifiedHeightVar float64, DefaultWidthVar float64, DefaultHeightVar float64, ConcreteWidthVar float64, ConcreteHeightVar *float64) {
422			473
423		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)	474		XGdkPaintableComputeConcreteSize(x.GoPointer(), SpecifiedWidthVar, SpecifiedHeightVar, DefaultWidthVar, DefaultHeightVar, ConcreteWidthVar, ConcreteHeightVar)
424			475

@@ -601,7 +652,7 @@ func (x *Texture) ToString() string {
601			652
602		// Loads a loadable icon. For the asynchronous version of this function,	653		// Loads a loadable icon. For the asynchronous version of this function,
603		// see g_loadable_icon_load_async().	654		// see g_loadable_icon_load_async().
604	-	func (x Texture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (*gio.InputStream, error) {	655	+	func (x Texture) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (gio.InputStream, error) {
605		var cls *gio.InputStream	656		var cls *gio.InputStream
606		var cerr *glib.Error	657		var cerr *glib.Error
607			658

@@ -629,7 +680,7 @@ func (x Texture) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, Callba
629		}	680		}
630			681
631		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().	682		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().
632	-	func (x Texture) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (gio.InputStream, error) {	683	+	func (x Texture) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (*gio.InputStream, error) {
633		var cls *gio.InputStream	684		var cls *gio.InputStream
634		var cerr *glib.Error	685		var cerr *glib.Error
635			686

M v4/gdk/gdktoplevel.go +143 -0


@@ -8,6 +8,7 @@ import (
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
10	"github.com/jwijenbergh/puregotk/v4/glib"	10		"github.com/jwijenbergh/puregotk/v4/glib"
		11	+	"github.com/jwijenbergh/puregotk/v4/gobject"
11	"github.com/jwijenbergh/puregotk/v4/gobject/types"	12		"github.com/jwijenbergh/puregotk/v4/gobject/types"
12	)	13		)
13		14

@@ -318,6 +319,148 @@ func (x *ToplevelBase) TitlebarGesture(GestureVar TitlebarGesture) bool {
318	return cret	319		return cret
319	}	320		}
320		321
		322	+	// SetPropertyDecorated sets the "decorated" property.
		323	+	// Whether the window manager should add decorations.
		324	+	func (x *ToplevelBase) SetPropertyDecorated(value bool) {
		325	+	obj := gobject.Object{}
		326	+	obj.Ptr = x.GoPointer()
		327	+	var v gobject.Value
		328	+	v.Init(gobject.TypeBooleanVal)
		329	+	v.SetBoolean(value)
		330	+	obj.SetProperty("decorated", &v)
		331	+	}
		332	+
		333	+	// GetPropertyDecorated gets the "decorated" property.
		334	+	// Whether the window manager should add decorations.
		335	+	func (x *ToplevelBase) GetPropertyDecorated() bool {
		336	+	obj := gobject.Object{}
		337	+	obj.Ptr = x.GoPointer()
		338	+	var v gobject.Value
		339	+	obj.GetProperty("decorated", &v)
		340	+	return v.GetBoolean()
		341	+	}
		342	+
		343	+	// SetPropertyDeletable sets the "deletable" property.
		344	+	// Whether the window manager should allow to close the surface.
		345	+	func (x *ToplevelBase) SetPropertyDeletable(value bool) {
		346	+	obj := gobject.Object{}
		347	+	obj.Ptr = x.GoPointer()
		348	+	var v gobject.Value
		349	+	v.Init(gobject.TypeBooleanVal)
		350	+	v.SetBoolean(value)
		351	+	obj.SetProperty("deletable", &v)
		352	+	}
		353	+
		354	+	// GetPropertyDeletable gets the "deletable" property.
		355	+	// Whether the window manager should allow to close the surface.
		356	+	func (x *ToplevelBase) GetPropertyDeletable() bool {
		357	+	obj := gobject.Object{}
		358	+	obj.Ptr = x.GoPointer()
		359	+	var v gobject.Value
		360	+	obj.GetProperty("deletable", &v)
		361	+	return v.GetBoolean()
		362	+	}
		363	+
		364	+	// SetPropertyIconList sets the "icon-list" property.
		365	+	// A list of textures to use as icon.
		366	+	func (x *ToplevelBase) SetPropertyIconList(value uintptr) {
		367	+	obj := gobject.Object{}
		368	+	obj.Ptr = x.GoPointer()
		369	+	var v gobject.Value
		370	+	v.Init(gobject.TypePointerVal)
		371	+	v.SetPointer(value)
		372	+	obj.SetProperty("icon-list", &v)
		373	+	}
		374	+
		375	+	// GetPropertyIconList gets the "icon-list" property.
		376	+	// A list of textures to use as icon.
		377	+	func (x *ToplevelBase) GetPropertyIconList() uintptr {
		378	+	obj := gobject.Object{}
		379	+	obj.Ptr = x.GoPointer()
		380	+	var v gobject.Value
		381	+	obj.GetProperty("icon-list", &v)
		382	+	return v.GetPointer()
		383	+	}
		384	+
		385	+	// SetPropertyModal sets the "modal" property.
		386	+	// Whether the surface is modal.
		387	+	func (x *ToplevelBase) SetPropertyModal(value bool) {
		388	+	obj := gobject.Object{}
		389	+	obj.Ptr = x.GoPointer()
		390	+	var v gobject.Value
		391	+	v.Init(gobject.TypeBooleanVal)
		392	+	v.SetBoolean(value)
		393	+	obj.SetProperty("modal", &v)
		394	+	}
		395	+
		396	+	// GetPropertyModal gets the "modal" property.
		397	+	// Whether the surface is modal.
		398	+	func (x *ToplevelBase) GetPropertyModal() bool {
		399	+	obj := gobject.Object{}
		400	+	obj.Ptr = x.GoPointer()
		401	+	var v gobject.Value
		402	+	obj.GetProperty("modal", &v)
		403	+	return v.GetBoolean()
		404	+	}
		405	+
		406	+	// GetPropertyShortcutsInhibited gets the "shortcuts-inhibited" property.
		407	+	// Whether the surface should inhibit keyboard shortcuts.
		408	+	func (x *ToplevelBase) GetPropertyShortcutsInhibited() bool {
		409	+	obj := gobject.Object{}
		410	+	obj.Ptr = x.GoPointer()
		411	+	var v gobject.Value
		412	+	obj.GetProperty("shortcuts-inhibited", &v)
		413	+	return v.GetBoolean()
		414	+	}
		415	+
		416	+	// SetPropertyStartupId sets the "startup-id" property.
		417	+	// The startup ID of the surface.
		418	+	//
		419	+	// See [class@Gdk.AppLaunchContext] for more information about
		420	+	// startup feedback.
		421	+	func (x *ToplevelBase) SetPropertyStartupId(value string) {
		422	+	obj := gobject.Object{}
		423	+	obj.Ptr = x.GoPointer()
		424	+	var v gobject.Value
		425	+	v.Init(gobject.TypeStringVal)
		426	+	v.SetString(value)
		427	+	obj.SetProperty("startup-id", &v)
		428	+	}
		429	+
		430	+	// GetPropertyStartupId gets the "startup-id" property.
		431	+	// The startup ID of the surface.
		432	+	//
		433	+	// See [class@Gdk.AppLaunchContext] for more information about
		434	+	// startup feedback.
		435	+	func (x *ToplevelBase) GetPropertyStartupId() string {
		436	+	obj := gobject.Object{}
		437	+	obj.Ptr = x.GoPointer()
		438	+	var v gobject.Value
		439	+	obj.GetProperty("startup-id", &v)
		440	+	return v.GetString()
		441	+	}
		442	+
		443	+	// SetPropertyTitle sets the "title" property.
		444	+	// The title of the surface.
		445	+	func (x *ToplevelBase) SetPropertyTitle(value string) {
		446	+	obj := gobject.Object{}
		447	+	obj.Ptr = x.GoPointer()
		448	+	var v gobject.Value
		449	+	v.Init(gobject.TypeStringVal)
		450	+	v.SetString(value)
		451	+	obj.SetProperty("title", &v)
		452	+	}
		453	+
		454	+	// GetPropertyTitle gets the "title" property.
		455	+	// The title of the surface.
		456	+	func (x *ToplevelBase) GetPropertyTitle() string {
		457	+	obj := gobject.Object{}
		458	+	obj.Ptr = x.GoPointer()
		459	+	var v gobject.Value
		460	+	obj.GetProperty("title", &v)
		461	+	return v.GetString()
		462	+	}
		463	+
321	var XGdkToplevelBeginMove func(uintptr, uintptr, int, float64, float64, uint32)	464		var XGdkToplevelBeginMove func(uintptr, uintptr, int, float64, float64, uint32)
322	var XGdkToplevelBeginResize func(uintptr, SurfaceEdge, uintptr, int, float64, float64, uint32)	465		var XGdkToplevelBeginResize func(uintptr, SurfaceEdge, uintptr, int, float64, float64, uint32)
323	var XGdkToplevelFocus func(uintptr, uint32)	466		var XGdkToplevelFocus func(uintptr, uint32)

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


@@ -67,12 +67,12 @@ func (x ToplevelLayout) Equal(OtherVar ToplevelLayout) bool {
67		return cret	67		return cret
68		}	68		}
69			69
70	-	var xToplevelLayoutGetFullscreen func(uintptr, bool) bool	70	+	var xToplevelLayoutGetFullscreen func(uintptr, *bool) bool
71			71
72		// If the layout specifies whether to the toplevel should go fullscreen,	72		// If the layout specifies whether to the toplevel should go fullscreen,
73		// the value pointed to by @fullscreen is set to true if it should go	73		// the value pointed to by @fullscreen is set to true if it should go
74		// fullscreen, or false, if it should go unfullscreen.	74		// fullscreen, or false, if it should go unfullscreen.
75	-	func (x *ToplevelLayout) GetFullscreen(FullscreenVar bool) bool {	75	+	func (x ToplevelLayout) GetFullscreen(FullscreenVar bool) bool {
76			76
77		cret := xToplevelLayoutGetFullscreen(x.GoPointer(), FullscreenVar)	77		cret := xToplevelLayoutGetFullscreen(x.GoPointer(), FullscreenVar)
78		return cret	78		return cret

@@ -96,12 +96,12 @@ func (x ToplevelLayout) GetFullscreenMonitor() Monitor {
96		return cls	96		return cls
97		}	97		}
98			98
99	-	var xToplevelLayoutGetMaximized func(uintptr, bool) bool	99	+	var xToplevelLayoutGetMaximized func(uintptr, *bool) bool
100			100
101		// If the layout specifies whether to the toplevel should go maximized,	101		// If the layout specifies whether to the toplevel should go maximized,
102		// the value pointed to by @maximized is set to true if it should go	102		// the value pointed to by @maximized is set to true if it should go
103		// maximized, or false, if it should go unmaximized.	103		// maximized, or false, if it should go unmaximized.
104	-	func (x *ToplevelLayout) GetMaximized(MaximizedVar bool) bool {	104	+	func (x ToplevelLayout) GetMaximized(MaximizedVar bool) bool {
105			105
106		cret := xToplevelLayoutGetMaximized(x.GoPointer(), MaximizedVar)	106		cret := xToplevelLayoutGetMaximized(x.GoPointer(), MaximizedVar)
107		return cret	107		return cret

M v4/gdk/gdktoplevelsize.go +2 -2


@@ -25,7 +25,7 @@ func (x *ToplevelSize) GoPointer() uintptr {
25		return uintptr(unsafe.Pointer(x))	25		return uintptr(unsafe.Pointer(x))
26		}	26		}
27			27
28	-	var xToplevelSizeGetBounds func(uintptr, int, int)	28	+	var xToplevelSizeGetBounds func(uintptr, int, int)
29			29
30		// Retrieves the bounds the toplevel is placed within.	30		// Retrieves the bounds the toplevel is placed within.
31		//	31		//

@@ -34,7 +34,7 @@ var xToplevelSizeGetBounds func(uintptr, int, int)
34		// be equivalent to the dimensions of the work area or the monitor on which the	34		// be equivalent to the dimensions of the work area or the monitor on which the
35		// window is being presented on, or something else that limits the way a	35		// window is being presented on, or something else that limits the way a
36		// toplevel can be presented.	36		// toplevel can be presented.
37	-	func (x *ToplevelSize) GetBounds(BoundsWidthVar int, BoundsHeightVar int) {	37	+	func (x ToplevelSize) GetBounds(BoundsWidthVar int, BoundsHeightVar *int) {
38			38
39		xToplevelSizeGetBounds(x.GoPointer(), BoundsWidthVar, BoundsHeightVar)	39		xToplevelSizeGetBounds(x.GoPointer(), BoundsWidthVar, BoundsHeightVar)
40			40

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


@@ -186,25 +186,25 @@ func (x *ContentFormats) ContainMimeType(MimeTypeVar string) bool {
186		return cret	186		return cret
187		}	187		}
188			188
189	-	var xContentFormatsGetGtypes func(uintptr, uint) uintptr	189	+	var xContentFormatsGetGtypes func(uintptr, *uint) uintptr
190			190
191		// Gets the `GType`s included in @formats.	191		// Gets the `GType`s included in @formats.
192		//	192		//
193		// Note that @formats may not contain any `GType`s, in particular when	193		// Note that @formats may not contain any `GType`s, in particular when
194		// they are empty. In that case %NULL will be returned.	194		// they are empty. In that case %NULL will be returned.
195	-	func (x *ContentFormats) GetGtypes(NGtypesVar uint) uintptr {	195	+	func (x ContentFormats) GetGtypes(NGtypesVar uint) uintptr {
196			196
197		cret := xContentFormatsGetGtypes(x.GoPointer(), NGtypesVar)	197		cret := xContentFormatsGetGtypes(x.GoPointer(), NGtypesVar)
198		return cret	198		return cret
199		}	199		}
200			200
201	-	var xContentFormatsGetMimeTypes func(uintptr, uint) []string	201	+	var xContentFormatsGetMimeTypes func(uintptr, *uint) []string
202			202
203		// Gets the mime types included in @formats.	203		// Gets the mime types included in @formats.
204		//	204		//
205		// Note that @formats may not contain any mime types, in particular	205		// Note that @formats may not contain any mime types, in particular
206		// when they are empty. In that case %NULL will be returned.	206		// when they are empty. In that case %NULL will be returned.
207	-	func (x *ContentFormats) GetMimeTypes(NMimeTypesVar uint) []string {	207	+	func (x ContentFormats) GetMimeTypes(NMimeTypesVar uint) []string {
208			208
209		cret := xContentFormatsGetMimeTypes(x.GoPointer(), NMimeTypesVar)	209		cret := xContentFormatsGetMimeTypes(x.GoPointer(), NMimeTypesVar)
210		return cret	210		return cret

@@ -400,11 +400,11 @@ func (x DmabufFormats) Equal(Formats2Var DmabufFormats) bool {
400		return cret	400		return cret
401		}	401		}
402			402
403	-	var xDmabufFormatsGetFormat func(uintptr, uint, uint32, uint64)	403	+	var xDmabufFormatsGetFormat func(uintptr, uint, uint32, uint64)
404			404
405		// Gets the fourcc code and modifier for a format	405		// Gets the fourcc code and modifier for a format
406		// that is contained in @formats.	406		// that is contained in @formats.
407	-	func (x *DmabufFormats) GetFormat(IdxVar uint, FourccVar uint32, ModifierVar uint64) {	407	+	func (x DmabufFormats) GetFormat(IdxVar uint, FourccVar uint32, ModifierVar *uint64) {
408			408
409		xDmabufFormatsGetFormat(x.GoPointer(), IdxVar, FourccVar, ModifierVar)	409		xDmabufFormatsGetFormat(x.GoPointer(), IdxVar, FourccVar, ModifierVar)
410			410

@@ -592,7 +592,7 @@ func (x TextureDownloader) Copy() TextureDownloader {
592		return cret	592		return cret
593		}	593		}
594			594
595	-	var xTextureDownloaderDownloadBytes func(uintptr, uint) *glib.Bytes	595	+	var xTextureDownloaderDownloadBytes func(uintptr, uint) glib.Bytes
596			596
597		// Downloads the given texture pixels into a `GBytes`. The rowstride will	597		// Downloads the given texture pixels into a `GBytes`. The rowstride will
598		// be stored in the stride value.	598		// be stored in the stride value.

@@ -604,20 +604,20 @@ var xTextureDownloaderDownloadBytes func(uintptr, uint) *glib.Bytes
604		//	604		//
605		// This function cannot be used with a multiplanar format. Use	605		// This function cannot be used with a multiplanar format. Use
606		// [method@Gdk.TextureDownloader.download_bytes_with_planes] for that purpose.	606		// [method@Gdk.TextureDownloader.download_bytes_with_planes] for that purpose.
607	-	func (x TextureDownloader) DownloadBytes(OutStrideVar uint) glib.Bytes {	607	+	func (x TextureDownloader) DownloadBytes(OutStrideVar uint) *glib.Bytes {
608			608
609		cret := xTextureDownloaderDownloadBytes(x.GoPointer(), OutStrideVar)	609		cret := xTextureDownloaderDownloadBytes(x.GoPointer(), OutStrideVar)
610		return cret	610		return cret
611		}	611		}
612			612
613	-	var xTextureDownloaderDownloadBytesWithPlanes func(uintptr, [4]uint, [4]uint) *glib.Bytes	613	+	var xTextureDownloaderDownloadBytesWithPlanes func(uintptr, [4]uint, [4]uint) *glib.Bytes
614			614
615		// Downloads the given texture pixels into a `GBytes`. The offsets and	615		// Downloads the given texture pixels into a `GBytes`. The offsets and
616		// strides of the resulting buffer will be stored in the respective values.	616		// strides of the resulting buffer will be stored in the respective values.
617		//	617		//
618		// If the format does have less than 4 planes, the remaining offsets and strides will be	618		// If the format does have less than 4 planes, the remaining offsets and strides will be
619		// set to `0`.	619		// set to `0`.
620	-	func (x TextureDownloader) DownloadBytesWithPlanes(OutOffsetsVar [4]uint, OutStridesVar [4]uint) glib.Bytes {	620	+	func (x TextureDownloader) DownloadBytesWithPlanes(OutOffsetsVar [4]uint, OutStridesVar [4]uint) glib.Bytes {
621			621
622		cret := xTextureDownloaderDownloadBytesWithPlanes(x.GoPointer(), OutOffsetsVar, OutStridesVar)	622		cret := xTextureDownloaderDownloadBytesWithPlanes(x.GoPointer(), OutOffsetsVar, OutStridesVar)
623		return cret	623		return cret

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


@@ -34,7 +34,7 @@ func (x *PixbufAnimationClass) GoPointer() uintptr {
34		return uintptr(unsafe.Pointer(x))	34		return uintptr(unsafe.Pointer(x))
35		}	35		}
36			36
37	-	// OverrideIsStaticImage sets the callback function.	37	+	// OverrideIsStaticImage sets the "is_static_image" callback function.
38		// returns whether the given animation is just a static image.	38		// returns whether the given animation is just a static image.
39		func (x PixbufAnimationClass) OverrideIsStaticImage(cb func(PixbufAnimation) bool) {	39		func (x PixbufAnimationClass) OverrideIsStaticImage(cb func(PixbufAnimation) bool) {
40		if cb == nil {	40		if cb == nil {

@@ -46,7 +46,7 @@ func (x PixbufAnimationClass) OverrideIsStaticImage(cb func(PixbufAnimation) b
46		}	46		}
47		}	47		}
48			48
49	-	// GetIsStaticImage gets the callback function.	49	+	// GetIsStaticImage gets the "is_static_image" callback function.
50		// returns whether the given animation is just a static image.	50		// returns whether the given animation is just a static image.
51		func (x PixbufAnimationClass) GetIsStaticImage() func(PixbufAnimation) bool {	51		func (x PixbufAnimationClass) GetIsStaticImage() func(PixbufAnimation) bool {
52		if x.xIsStaticImage == 0 {	52		if x.xIsStaticImage == 0 {

@@ -59,7 +59,7 @@ func (x PixbufAnimationClass) GetIsStaticImage() func(PixbufAnimation) bool {
59		}	59		}
60		}	60		}
61			61
62	-	// OverrideGetStaticImage sets the callback function.	62	+	// OverrideGetStaticImage sets the "get_static_image" callback function.
63		// returns a static image representing the given animation.	63		// returns a static image representing the given animation.
64		func (x PixbufAnimationClass) OverrideGetStaticImage(cb func(PixbufAnimation) *Pixbuf) {	64		func (x PixbufAnimationClass) OverrideGetStaticImage(cb func(PixbufAnimation) *Pixbuf) {
65		if cb == nil {	65		if cb == nil {

@@ -75,7 +75,7 @@ func (x PixbufAnimationClass) OverrideGetStaticImage(cb func(PixbufAnimation)
75		}	75		}
76		}	76		}
77			77
78	-	// GetGetStaticImage gets the callback function.	78	+	// GetGetStaticImage gets the "get_static_image" callback function.
79		// returns a static image representing the given animation.	79		// returns a static image representing the given animation.
80		func (x PixbufAnimationClass) GetGetStaticImage() func(PixbufAnimation) *Pixbuf {	80		func (x PixbufAnimationClass) GetGetStaticImage() func(PixbufAnimation) *Pixbuf {
81		if x.xGetStaticImage == 0 {	81		if x.xGetStaticImage == 0 {

@@ -94,7 +94,7 @@ func (x PixbufAnimationClass) GetGetStaticImage() func(PixbufAnimation) *Pixbu
94		}	94		}
95		}	95		}
96			96
97	-	// OverrideGetSize sets the callback function.	97	+	// OverrideGetSize sets the "get_size" callback function.
98		// fills @width and @height with the frame size of the animation.	98		// fills @width and @height with the frame size of the animation.
99		func (x PixbufAnimationClass) OverrideGetSize(cb func(PixbufAnimation, int, int)) {	99		func (x PixbufAnimationClass) OverrideGetSize(cb func(PixbufAnimation, int, int)) {
100		if cb == nil {	100		if cb == nil {

@@ -106,7 +106,7 @@ func (x PixbufAnimationClass) OverrideGetSize(cb func(PixbufAnimation, int, in
106		}	106		}
107		}	107		}
108			108
109	-	// GetGetSize gets the callback function.	109	+	// GetGetSize gets the "get_size" callback function.
110		// fills @width and @height with the frame size of the animation.	110		// fills @width and @height with the frame size of the animation.
111		func (x PixbufAnimationClass) GetGetSize() func(PixbufAnimation, int, int) {	111		func (x PixbufAnimationClass) GetGetSize() func(PixbufAnimation, int, int) {
112		if x.xGetSize == 0 {	112		if x.xGetSize == 0 {

@@ -119,7 +119,7 @@ func (x PixbufAnimationClass) GetGetSize() func(PixbufAnimation, int, int) {
119		}	119		}
120		}	120		}
121			121
122	-	// OverrideGetIter sets the callback function.	122	+	// OverrideGetIter sets the "get_iter" callback function.
123		// returns an iterator for the given animation.	123		// returns an iterator for the given animation.
124		func (x PixbufAnimationClass) OverrideGetIter(cb func(PixbufAnimation, glib.TimeVal) PixbufAnimationIter) {	124		func (x PixbufAnimationClass) OverrideGetIter(cb func(PixbufAnimation, glib.TimeVal) PixbufAnimationIter) {
125		if cb == nil {	125		if cb == nil {

@@ -135,7 +135,7 @@ func (x PixbufAnimationClass) OverrideGetIter(cb func(PixbufAnimation, *glib.T
135		}	135		}
136		}	136		}
137			137
138	-	// GetGetIter gets the callback function.	138	+	// GetGetIter gets the "get_iter" callback function.
139		// returns an iterator for the given animation.	139		// returns an iterator for the given animation.
140		func (x PixbufAnimationClass) GetGetIter() func(PixbufAnimation, glib.TimeVal) PixbufAnimationIter {	140		func (x PixbufAnimationClass) GetGetIter() func(PixbufAnimation, glib.TimeVal) PixbufAnimationIter {
141		if x.xGetIter == 0 {	141		if x.xGetIter == 0 {

@@ -175,7 +175,7 @@ func (x *PixbufAnimationIterClass) GoPointer() uintptr {
175		return uintptr(unsafe.Pointer(x))	175		return uintptr(unsafe.Pointer(x))
176		}	176		}
177			177
178	-	// OverrideGetDelayTime sets the callback function.	178	+	// OverrideGetDelayTime sets the "get_delay_time" callback function.
179		// returns the time in milliseconds that the current frame	179		// returns the time in milliseconds that the current frame
180		//	180		//
181		// should be shown.	181		// should be shown.

@@ -189,7 +189,7 @@ func (x PixbufAnimationIterClass) OverrideGetDelayTime(cb func(PixbufAnimation
189		}	189		}
190		}	190		}
191			191
192	-	// GetGetDelayTime gets the callback function.	192	+	// GetGetDelayTime gets the "get_delay_time" callback function.
193		// returns the time in milliseconds that the current frame	193		// returns the time in milliseconds that the current frame
194		//	194		//
195		// should be shown.	195		// should be shown.

@@ -204,7 +204,7 @@ func (x PixbufAnimationIterClass) GetGetDelayTime() func(PixbufAnimationIter)
204		}	204		}
205		}	205		}
206			206
207	-	// OverrideGetPixbuf sets the callback function.	207	+	// OverrideGetPixbuf sets the "get_pixbuf" callback function.
208		// returns the current frame.	208		// returns the current frame.
209		func (x PixbufAnimationIterClass) OverrideGetPixbuf(cb func(PixbufAnimationIter) *Pixbuf) {	209		func (x PixbufAnimationIterClass) OverrideGetPixbuf(cb func(PixbufAnimationIter) *Pixbuf) {
210		if cb == nil {	210		if cb == nil {

@@ -220,7 +220,7 @@ func (x PixbufAnimationIterClass) OverrideGetPixbuf(cb func(PixbufAnimationIte
220		}	220		}
221		}	221		}
222			222
223	-	// GetGetPixbuf gets the callback function.	223	+	// GetGetPixbuf gets the "get_pixbuf" callback function.
224		// returns the current frame.	224		// returns the current frame.
225		func (x PixbufAnimationIterClass) GetGetPixbuf() func(PixbufAnimationIter) *Pixbuf {	225		func (x PixbufAnimationIterClass) GetGetPixbuf() func(PixbufAnimationIter) *Pixbuf {
226		if x.xGetPixbuf == 0 {	226		if x.xGetPixbuf == 0 {

@@ -239,7 +239,7 @@ func (x PixbufAnimationIterClass) GetGetPixbuf() func(PixbufAnimationIter) *Pi
239		}	239		}
240		}	240		}
241			241
242	-	// OverrideOnCurrentlyLoadingFrame sets the callback function.	242	+	// OverrideOnCurrentlyLoadingFrame sets the "on_currently_loading_frame" callback function.
243		// returns whether the current frame of @iter is	243		// returns whether the current frame of @iter is
244		//	244		//
245		// being loaded.	245		// being loaded.

@@ -253,7 +253,7 @@ func (x PixbufAnimationIterClass) OverrideOnCurrentlyLoadingFrame(cb func(Pixb
253		}	253		}
254		}	254		}
255			255
256	-	// GetOnCurrentlyLoadingFrame gets the callback function.	256	+	// GetOnCurrentlyLoadingFrame gets the "on_currently_loading_frame" callback function.
257		// returns whether the current frame of @iter is	257		// returns whether the current frame of @iter is
258		//	258		//
259		// being loaded.	259		// being loaded.

@@ -268,7 +268,7 @@ func (x PixbufAnimationIterClass) GetOnCurrentlyLoadingFrame() func(PixbufAnim
268		}	268		}
269		}	269		}
270			270
271	-	// OverrideAdvance sets the callback function.	271	+	// OverrideAdvance sets the "advance" callback function.
272		// advances the iterator to @current_time, possibly changing the	272		// advances the iterator to @current_time, possibly changing the
273		//	273		//
274		// current frame.	274		// current frame.

@@ -282,7 +282,7 @@ func (x PixbufAnimationIterClass) OverrideAdvance(cb func(PixbufAnimationIter,
282		}	282		}
283		}	283		}
284			284
285	-	// GetAdvance gets the callback function.	285	+	// GetAdvance gets the "advance" callback function.
286		// advances the iterator to @current_time, possibly changing the	286		// advances the iterator to @current_time, possibly changing the
287		//	287		//
288		// current frame.	288		// current frame.

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


@@ -352,7 +352,7 @@ func (x *PixbufModule) GoPointer() uintptr {
352		return uintptr(unsafe.Pointer(x))	352		return uintptr(unsafe.Pointer(x))
353		}	353		}
354			354
355	-	// OverrideReserved1 sets the callback function.	355	+	// OverrideReserved1 sets the "_reserved1" callback function.
356		func (x *PixbufModule) OverrideReserved1(cb func()) {	356		func (x *PixbufModule) OverrideReserved1(cb func()) {
357		if cb == nil {	357		if cb == nil {
358		x.xReserved1 = 0	358		x.xReserved1 = 0

@@ -363,7 +363,7 @@ func (x *PixbufModule) OverrideReserved1(cb func()) {
363		}	363		}
364		}	364		}
365			365
366	-	// GetReserved1 gets the callback function.	366	+	// GetReserved1 gets the "_reserved1" callback function.
367		func (x *PixbufModule) GetReserved1() func() {	367		func (x *PixbufModule) GetReserved1() func() {
368		if x.xReserved1 == 0 {	368		if x.xReserved1 == 0 {
369		return nil	369		return nil

@@ -375,7 +375,7 @@ func (x *PixbufModule) GetReserved1() func() {
375		}	375		}
376		}	376		}
377			377
378	-	// OverrideReserved2 sets the callback function.	378	+	// OverrideReserved2 sets the "_reserved2" callback function.
379		func (x *PixbufModule) OverrideReserved2(cb func()) {	379		func (x *PixbufModule) OverrideReserved2(cb func()) {
380		if cb == nil {	380		if cb == nil {
381		x.xReserved2 = 0	381		x.xReserved2 = 0

@@ -386,7 +386,7 @@ func (x *PixbufModule) OverrideReserved2(cb func()) {
386		}	386		}
387		}	387		}
388			388
389	-	// GetReserved2 gets the callback function.	389	+	// GetReserved2 gets the "_reserved2" callback function.
390		func (x *PixbufModule) GetReserved2() func() {	390		func (x *PixbufModule) GetReserved2() func() {
391		if x.xReserved2 == 0 {	391		if x.xReserved2 == 0 {
392		return nil	392		return nil

@@ -398,7 +398,7 @@ func (x *PixbufModule) GetReserved2() func() {
398		}	398		}
399		}	399		}
400			400
401	-	// OverrideReserved3 sets the callback function.	401	+	// OverrideReserved3 sets the "_reserved3" callback function.
402		func (x *PixbufModule) OverrideReserved3(cb func()) {	402		func (x *PixbufModule) OverrideReserved3(cb func()) {
403		if cb == nil {	403		if cb == nil {
404		x.xReserved3 = 0	404		x.xReserved3 = 0

@@ -409,7 +409,7 @@ func (x *PixbufModule) OverrideReserved3(cb func()) {
409		}	409		}
410		}	410		}
411			411
412	-	// GetReserved3 gets the callback function.	412	+	// GetReserved3 gets the "_reserved3" callback function.
413		func (x *PixbufModule) GetReserved3() func() {	413		func (x *PixbufModule) GetReserved3() func() {
414		if x.xReserved3 == 0 {	414		if x.xReserved3 == 0 {
415		return nil	415		return nil

@@ -421,7 +421,7 @@ func (x *PixbufModule) GetReserved3() func() {
421		}	421		}
422		}	422		}
423			423
424	-	// OverrideReserved4 sets the callback function.	424	+	// OverrideReserved4 sets the "_reserved4" callback function.
425		func (x *PixbufModule) OverrideReserved4(cb func()) {	425		func (x *PixbufModule) OverrideReserved4(cb func()) {
426		if cb == nil {	426		if cb == nil {
427		x.xReserved4 = 0	427		x.xReserved4 = 0

@@ -432,7 +432,7 @@ func (x *PixbufModule) OverrideReserved4(cb func()) {
432		}	432		}
433		}	433		}
434			434
435	-	// GetReserved4 gets the callback function.	435	+	// GetReserved4 gets the "_reserved4" callback function.
436		func (x *PixbufModule) GetReserved4() func() {	436		func (x *PixbufModule) GetReserved4() func() {
437		if x.xReserved4 == 0 {	437		if x.xReserved4 == 0 {
438		return nil	438		return nil

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


@@ -30,7 +30,7 @@ func (x *PixbufLoaderClass) GoPointer() uintptr {
30		return uintptr(unsafe.Pointer(x))	30		return uintptr(unsafe.Pointer(x))
31		}	31		}
32			32
33	-	// OverrideSizePrepared sets the callback function.	33	+	// OverrideSizePrepared sets the "size_prepared" callback function.
34		func (x PixbufLoaderClass) OverrideSizePrepared(cb func(PixbufLoader, int, int)) {	34		func (x PixbufLoaderClass) OverrideSizePrepared(cb func(PixbufLoader, int, int)) {
35		if cb == nil {	35		if cb == nil {
36		x.xSizePrepared = 0	36		x.xSizePrepared = 0

@@ -41,7 +41,7 @@ func (x PixbufLoaderClass) OverrideSizePrepared(cb func(PixbufLoader, int, int
41		}	41		}
42		}	42		}
43			43
44	-	// GetSizePrepared gets the callback function.	44	+	// GetSizePrepared gets the "size_prepared" callback function.
45		func (x PixbufLoaderClass) GetSizePrepared() func(PixbufLoader, int, int) {	45		func (x PixbufLoaderClass) GetSizePrepared() func(PixbufLoader, int, int) {
46		if x.xSizePrepared == 0 {	46		if x.xSizePrepared == 0 {
47		return nil	47		return nil

@@ -53,7 +53,7 @@ func (x PixbufLoaderClass) GetSizePrepared() func(PixbufLoader, int, int) {
53		}	53		}
54		}	54		}
55			55
56	-	// OverrideAreaPrepared sets the callback function.	56	+	// OverrideAreaPrepared sets the "area_prepared" callback function.
57		func (x PixbufLoaderClass) OverrideAreaPrepared(cb func(PixbufLoader)) {	57		func (x PixbufLoaderClass) OverrideAreaPrepared(cb func(PixbufLoader)) {
58		if cb == nil {	58		if cb == nil {
59		x.xAreaPrepared = 0	59		x.xAreaPrepared = 0

@@ -64,7 +64,7 @@ func (x PixbufLoaderClass) OverrideAreaPrepared(cb func(PixbufLoader)) {
64		}	64		}
65		}	65		}
66			66
67	-	// GetAreaPrepared gets the callback function.	67	+	// GetAreaPrepared gets the "area_prepared" callback function.
68		func (x PixbufLoaderClass) GetAreaPrepared() func(PixbufLoader) {	68		func (x PixbufLoaderClass) GetAreaPrepared() func(PixbufLoader) {
69		if x.xAreaPrepared == 0 {	69		if x.xAreaPrepared == 0 {
70		return nil	70		return nil

@@ -76,7 +76,7 @@ func (x PixbufLoaderClass) GetAreaPrepared() func(PixbufLoader) {
76		}	76		}
77		}	77		}
78			78
79	-	// OverrideAreaUpdated sets the callback function.	79	+	// OverrideAreaUpdated sets the "area_updated" callback function.
80		func (x PixbufLoaderClass) OverrideAreaUpdated(cb func(PixbufLoader, int, int, int, int)) {	80		func (x PixbufLoaderClass) OverrideAreaUpdated(cb func(PixbufLoader, int, int, int, int)) {
81		if cb == nil {	81		if cb == nil {
82		x.xAreaUpdated = 0	82		x.xAreaUpdated = 0

@@ -87,7 +87,7 @@ func (x PixbufLoaderClass) OverrideAreaUpdated(cb func(PixbufLoader, int, int,
87		}	87		}
88		}	88		}
89			89
90	-	// GetAreaUpdated gets the callback function.	90	+	// GetAreaUpdated gets the "area_updated" callback function.
91		func (x PixbufLoaderClass) GetAreaUpdated() func(PixbufLoader, int, int, int, int) {	91		func (x PixbufLoaderClass) GetAreaUpdated() func(PixbufLoader, int, int, int, int) {
92		if x.xAreaUpdated == 0 {	92		if x.xAreaUpdated == 0 {
93		return nil	93		return nil

@@ -99,7 +99,7 @@ func (x PixbufLoaderClass) GetAreaUpdated() func(PixbufLoader, int, int, int,
99		}	99		}
100		}	100		}
101			101
102	-	// OverrideClosed sets the callback function.	102	+	// OverrideClosed sets the "closed" callback function.
103		func (x PixbufLoaderClass) OverrideClosed(cb func(PixbufLoader)) {	103		func (x PixbufLoaderClass) OverrideClosed(cb func(PixbufLoader)) {
104		if cb == nil {	104		if cb == nil {
105		x.xClosed = 0	105		x.xClosed = 0

@@ -110,7 +110,7 @@ func (x PixbufLoaderClass) OverrideClosed(cb func(PixbufLoader)) {
110		}	110		}
111		}	111		}
112			112
113	-	// GetClosed gets the callback function.	113	+	// GetClosed gets the "closed" callback function.
114		func (x PixbufLoaderClass) GetClosed() func(PixbufLoader) {	114		func (x PixbufLoaderClass) GetClosed() func(PixbufLoader) {
115		if x.xClosed == 0 {	115		if x.xClosed == 0 {
116		return nil	116		return nil

M v4/gdkpixbuf/gdk-pixbuf-simple-anim.go +18 -0


@@ -7,6 +7,7 @@ import (
7		7
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
		10	+	"github.com/jwijenbergh/puregotk/v4/gobject"
10	"github.com/jwijenbergh/puregotk/v4/gobject/types"	11		"github.com/jwijenbergh/puregotk/v4/gobject/types"
11	)	12		)
12		13

@@ -91,6 +92,23 @@ func (c *PixbufSimpleAnim) SetGoPointer(ptr uintptr) {
91	c.Ptr = ptr	92		c.Ptr = ptr
92	}	93		}
93		94
		95	+	// SetPropertyLoop sets the "loop" property.
		96	+	// Whether the animation should loop when it reaches the end.
		97	+	func (x *PixbufSimpleAnim) SetPropertyLoop(value bool) {
		98	+	var v gobject.Value
		99	+	v.Init(gobject.TypeBooleanVal)
		100	+	v.SetBoolean(value)
		101	+	x.SetProperty("loop", &v)
		102	+	}
		103	+
		104	+	// GetPropertyLoop gets the "loop" property.
		105	+	// Whether the animation should loop when it reaches the end.
		106	+	func (x *PixbufSimpleAnim) GetPropertyLoop() bool {
		107	+	var v gobject.Value
		108	+	x.GetProperty("loop", &v)
		109	+	return v.GetBoolean()
		110	+	}
		111	+
94	func init() {	112		func init() {
95	core.SetPackageName("GDKPIXBUF", "gdk-pixbuf-2.0")	113		core.SetPackageName("GDKPIXBUF", "gdk-pixbuf-2.0")
96	core.SetSharedLibraries("GDKPIXBUF", []string{"libgdk_pixbuf-2.0.so.0"})	114		core.SetSharedLibraries("GDKPIXBUF", []string{"libgdk_pixbuf-2.0.so.0"})

M v4/gdkpixbuf/gdk-pixbuf.go +162 -12


@@ -859,7 +859,7 @@ func (x *Pixbuf) GetPixels() uintptr {
859		return cret	859		return cret
860		}	860		}
861			861
862	-	var xPixbufGetPixelsWithLength func(uintptr, uint) uintptr	862	+	var xPixbufGetPixelsWithLength func(uintptr, *uint) uintptr
863			863
864		// Queries a pointer to the pixel data of a pixbuf.	864		// Queries a pointer to the pixel data of a pixbuf.
865		//	865		//

@@ -868,7 +868,7 @@ var xPixbufGetPixelsWithLength func(uintptr, uint) uintptr
868		//	868		//
869		// Please see the section on [image data](class.Pixbuf.html#image-data) for information	869		// Please see the section on [image data](class.Pixbuf.html#image-data) for information
870		// about how the pixel data is stored in memory.	870		// about how the pixel data is stored in memory.
871	-	func (x *Pixbuf) GetPixelsWithLength(LengthVar uint) uintptr {	871	+	func (x Pixbuf) GetPixelsWithLength(LengthVar uint) uintptr {
872			872
873		cret := xPixbufGetPixelsWithLength(x.GoPointer(), LengthVar)	873		cret := xPixbufGetPixelsWithLength(x.GoPointer(), LengthVar)
874		return cret	874		return cret

@@ -1088,7 +1088,7 @@ func (x Pixbuf) Save(FilenameVar string, TypeVar string, ErrorVar *glib.Error,
1088		return cret	1088		return cret
1089		}	1089		}
1090			1090
1091	-	var xPixbufSaveToBuffer func(uintptr, []byte, uint, string, **glib.Error, ...interface{}) bool	1091	+	var xPixbufSaveToBuffer func(uintptr, []byte, uint, string, **glib.Error, ...interface{}) bool
1092			1092
1093		// Saves pixbuf to a new buffer in format `type`, which is currently "jpeg",	1093		// Saves pixbuf to a new buffer in format `type`, which is currently "jpeg",
1094		// "png", "tiff", "ico" or "bmp".	1094		// "png", "tiff", "ico" or "bmp".

@@ -1104,13 +1104,13 @@ var xPixbufSaveToBuffer func(uintptr, []byte, uint, string, **glib.Error, ...int
1104		// domain.	1104		// domain.
1105		//	1105		//
1106		// See `gdk_pixbuf_save()` for more details.	1106		// See `gdk_pixbuf_save()` for more details.
1107	-	func (x Pixbuf) SaveToBuffer(BufferVar []byte, BufferSizeVar uint, TypeVar string, ErrorVar *glib.Error, varArgs ...interface{}) bool {	1107	+	func (x Pixbuf) SaveToBuffer(BufferVar []byte, BufferSizeVar uint, TypeVar string, ErrorVar *glib.Error, varArgs ...interface{}) bool {
1108			1108
1109		cret := xPixbufSaveToBuffer(x.GoPointer(), BufferVar, BufferSizeVar, TypeVar, ErrorVar, varArgs...)	1109		cret := xPixbufSaveToBuffer(x.GoPointer(), BufferVar, BufferSizeVar, TypeVar, ErrorVar, varArgs...)
1110		return cret	1110		return cret
1111		}	1111		}
1112			1112
1113	-	var xPixbufSaveToBufferv func(uintptr, []byte, uint, string, []string, []string, **glib.Error) bool	1113	+	var xPixbufSaveToBufferv func(uintptr, []byte, uint, string, []string, []string, **glib.Error) bool
1114			1114
1115		// Vector version of `gdk_pixbuf_save_to_buffer()`.	1115		// Vector version of `gdk_pixbuf_save_to_buffer()`.
1116		//	1116		//

@@ -1118,7 +1118,7 @@ var xPixbufSaveToBufferv func(uintptr, []byte, uint, string, []string, []string,
1118		// "tiff", "png", "ico" or "bmp".	1118		// "tiff", "png", "ico" or "bmp".
1119		//	1119		//
1120		// See [method@GdkPixbuf.Pixbuf.save_to_buffer] for more details.	1120		// See [method@GdkPixbuf.Pixbuf.save_to_buffer] for more details.
1121	-	func (x *Pixbuf) SaveToBufferv(BufferVar []byte, BufferSizeVar uint, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {	1121	+	func (x Pixbuf) SaveToBufferv(BufferVar []byte, BufferSizeVar *uint, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {
1122		var cerr *glib.Error	1122		var cerr *glib.Error
1123			1123
1124		cret := xPixbufSaveToBufferv(x.GoPointer(), BufferVar, BufferSizeVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)	1124		cret := xPixbufSaveToBufferv(x.GoPointer(), BufferVar, BufferSizeVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)

@@ -1347,6 +1347,156 @@ func (c *Pixbuf) SetGoPointer(ptr uintptr) {
1347		c.Ptr = ptr	1347		c.Ptr = ptr
1348		}	1348		}
1349			1349
			1350	+	// SetPropertyBitsPerSample sets the "bits-per-sample" property.
			1351	+	// The number of bits per sample.
			1352	+	//
			1353	+	// Currently only 8 bit per sample are supported.
			1354	+	func (x *Pixbuf) SetPropertyBitsPerSample(value int) {
			1355	+	var v gobject.Value
			1356	+	v.Init(gobject.TypeIntVal)
			1357	+	v.SetInt(value)
			1358	+	x.SetProperty("bits-per-sample", &v)
			1359	+	}
			1360	+
			1361	+	// GetPropertyBitsPerSample gets the "bits-per-sample" property.
			1362	+	// The number of bits per sample.
			1363	+	//
			1364	+	// Currently only 8 bit per sample are supported.
			1365	+	func (x *Pixbuf) GetPropertyBitsPerSample() int {
			1366	+	var v gobject.Value
			1367	+	x.GetProperty("bits-per-sample", &v)
			1368	+	return v.GetInt()
			1369	+	}
			1370	+
			1371	+	// SetPropertyHasAlpha sets the "has-alpha" property.
			1372	+	// Whether the pixbuf has an alpha channel.
			1373	+	func (x *Pixbuf) SetPropertyHasAlpha(value bool) {
			1374	+	var v gobject.Value
			1375	+	v.Init(gobject.TypeBooleanVal)
			1376	+	v.SetBoolean(value)
			1377	+	x.SetProperty("has-alpha", &v)
			1378	+	}
			1379	+
			1380	+	// GetPropertyHasAlpha gets the "has-alpha" property.
			1381	+	// Whether the pixbuf has an alpha channel.
			1382	+	func (x *Pixbuf) GetPropertyHasAlpha() bool {
			1383	+	var v gobject.Value
			1384	+	x.GetProperty("has-alpha", &v)
			1385	+	return v.GetBoolean()
			1386	+	}
			1387	+
			1388	+	// SetPropertyHeight sets the "height" property.
			1389	+	// The number of rows of the pixbuf.
			1390	+	func (x *Pixbuf) SetPropertyHeight(value int) {
			1391	+	var v gobject.Value
			1392	+	v.Init(gobject.TypeIntVal)
			1393	+	v.SetInt(value)
			1394	+	x.SetProperty("height", &v)
			1395	+	}
			1396	+
			1397	+	// GetPropertyHeight gets the "height" property.
			1398	+	// The number of rows of the pixbuf.
			1399	+	func (x *Pixbuf) GetPropertyHeight() int {
			1400	+	var v gobject.Value
			1401	+	x.GetProperty("height", &v)
			1402	+	return v.GetInt()
			1403	+	}
			1404	+
			1405	+	// SetPropertyNChannels sets the "n-channels" property.
			1406	+	// The number of samples per pixel.
			1407	+	//
			1408	+	// Currently, only 3 or 4 samples per pixel are supported.
			1409	+	func (x *Pixbuf) SetPropertyNChannels(value int) {
			1410	+	var v gobject.Value
			1411	+	v.Init(gobject.TypeIntVal)
			1412	+	v.SetInt(value)
			1413	+	x.SetProperty("n-channels", &v)
			1414	+	}
			1415	+
			1416	+	// GetPropertyNChannels gets the "n-channels" property.
			1417	+	// The number of samples per pixel.
			1418	+	//
			1419	+	// Currently, only 3 or 4 samples per pixel are supported.
			1420	+	func (x *Pixbuf) GetPropertyNChannels() int {
			1421	+	var v gobject.Value
			1422	+	x.GetProperty("n-channels", &v)
			1423	+	return v.GetInt()
			1424	+	}
			1425	+
			1426	+	// SetPropertyPixelBytes sets the "pixel-bytes" property.
			1427	+	func (x *Pixbuf) SetPropertyPixelBytes(value uintptr) {
			1428	+	var v gobject.Value
			1429	+	v.Init(gobject.TypePointerVal)
			1430	+	v.SetPointer(value)
			1431	+	x.SetProperty("pixel-bytes", &v)
			1432	+	}
			1433	+
			1434	+	// GetPropertyPixelBytes gets the "pixel-bytes" property.
			1435	+	func (x *Pixbuf) GetPropertyPixelBytes() uintptr {
			1436	+	var v gobject.Value
			1437	+	x.GetProperty("pixel-bytes", &v)
			1438	+	return v.GetPointer()
			1439	+	}
			1440	+
			1441	+	// SetPropertyPixels sets the "pixels" property.
			1442	+	// A pointer to the pixel data of the pixbuf.
			1443	+	func (x *Pixbuf) SetPropertyPixels(value uintptr) {
			1444	+	var v gobject.Value
			1445	+	v.Init(gobject.TypePointerVal)
			1446	+	v.SetPointer(value)
			1447	+	x.SetProperty("pixels", &v)
			1448	+	}
			1449	+
			1450	+	// GetPropertyPixels gets the "pixels" property.
			1451	+	// A pointer to the pixel data of the pixbuf.
			1452	+	func (x *Pixbuf) GetPropertyPixels() uintptr {
			1453	+	var v gobject.Value
			1454	+	x.GetProperty("pixels", &v)
			1455	+	return v.GetPointer()
			1456	+	}
			1457	+
			1458	+	// SetPropertyRowstride sets the "rowstride" property.
			1459	+	// The number of bytes between the start of a row and
			1460	+	// the start of the next row.
			1461	+	//
			1462	+	// This number must (obviously) be at least as large as the
			1463	+	// width of the pixbuf.
			1464	+	func (x *Pixbuf) SetPropertyRowstride(value int) {
			1465	+	var v gobject.Value
			1466	+	v.Init(gobject.TypeIntVal)
			1467	+	v.SetInt(value)
			1468	+	x.SetProperty("rowstride", &v)
			1469	+	}
			1470	+
			1471	+	// GetPropertyRowstride gets the "rowstride" property.
			1472	+	// The number of bytes between the start of a row and
			1473	+	// the start of the next row.
			1474	+	//
			1475	+	// This number must (obviously) be at least as large as the
			1476	+	// width of the pixbuf.
			1477	+	func (x *Pixbuf) GetPropertyRowstride() int {
			1478	+	var v gobject.Value
			1479	+	x.GetProperty("rowstride", &v)
			1480	+	return v.GetInt()
			1481	+	}
			1482	+
			1483	+	// SetPropertyWidth sets the "width" property.
			1484	+	// The number of columns of the pixbuf.
			1485	+	func (x *Pixbuf) SetPropertyWidth(value int) {
			1486	+	var v gobject.Value
			1487	+	v.Init(gobject.TypeIntVal)
			1488	+	v.SetInt(value)
			1489	+	x.SetProperty("width", &v)
			1490	+	}
			1491	+
			1492	+	// GetPropertyWidth gets the "width" property.
			1493	+	// The number of columns of the pixbuf.
			1494	+	func (x *Pixbuf) GetPropertyWidth() int {
			1495	+	var v gobject.Value
			1496	+	x.GetProperty("width", &v)
			1497	+	return v.GetInt()
			1498	+	}
			1499	+
1350		// Checks if two icons are equal.	1500		// Checks if two icons are equal.
1351		func (x *Pixbuf) Equal(Icon2Var gio.Icon) bool {	1501		func (x *Pixbuf) Equal(Icon2Var gio.Icon) bool {
1352			1502

@@ -1396,7 +1546,7 @@ func (x *Pixbuf) ToString() string {
1396			1546
1397		// Loads a loadable icon. For the asynchronous version of this function,	1547		// Loads a loadable icon. For the asynchronous version of this function,
1398		// see g_loadable_icon_load_async().	1548		// see g_loadable_icon_load_async().
1399	-	func (x Pixbuf) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (*gio.InputStream, error) {	1549	+	func (x Pixbuf) Load(SizeVar int, TypeVar string, CancellableVar gio.Cancellable) (gio.InputStream, error) {
1400		var cls *gio.InputStream	1550		var cls *gio.InputStream
1401		var cerr *glib.Error	1551		var cerr *glib.Error
1402			1552

@@ -1424,7 +1574,7 @@ func (x Pixbuf) LoadAsync(SizeVar int, CancellableVar gio.Cancellable, Callbac
1424		}	1574		}
1425			1575
1426		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().	1576		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().
1427	-	func (x Pixbuf) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (gio.InputStream, error) {	1577	+	func (x Pixbuf) LoadFinish(ResVar gio.AsyncResult, TypeVar string) (*gio.InputStream, error) {
1428		var cls *gio.InputStream	1578		var cls *gio.InputStream
1429		var cerr *glib.Error	1579		var cerr *glib.Error
1430			1580

@@ -1455,10 +1605,10 @@ func PixbufCalculateRowstride(ColorspaceVar Colorspace, HasAlphaVar bool, BitsPe
1455		return cret	1605		return cret
1456		}	1606		}
1457			1607
1458	-	var xPixbufGetFileInfo func(string, int, int) *PixbufFormat	1608	+	var xPixbufGetFileInfo func(string, int, int) *PixbufFormat
1459			1609
1460		// Parses an image file far enough to determine its format and size.	1610		// Parses an image file far enough to determine its format and size.
1461	-	func PixbufGetFileInfo(FilenameVar string, WidthVar int, HeightVar int) *PixbufFormat {	1611	+	func PixbufGetFileInfo(FilenameVar string, WidthVar int, HeightVar int) *PixbufFormat {
1462			1612
1463		cret := xPixbufGetFileInfo(FilenameVar, WidthVar, HeightVar)	1613		cret := xPixbufGetFileInfo(FilenameVar, WidthVar, HeightVar)
1464		return cret	1614		return cret

@@ -1481,11 +1631,11 @@ func PixbufGetFileInfoAsync(FilenameVar string, CancellableVar *gio.Cancellable,
1481			1631
1482		}	1632		}
1483			1633
1484	-	var xPixbufGetFileInfoFinish func(uintptr, int, int, *glib.Error) PixbufFormat	1634	+	var xPixbufGetFileInfoFinish func(uintptr, int, int, *glib.Error) PixbufFormat
1485			1635
1486		// Finishes an asynchronous pixbuf parsing operation started with	1636		// Finishes an asynchronous pixbuf parsing operation started with
1487		// gdk_pixbuf_get_file_info_async().	1637		// gdk_pixbuf_get_file_info_async().
1488	-	func PixbufGetFileInfoFinish(AsyncResultVar gio.AsyncResult, WidthVar int, HeightVar int) (*PixbufFormat, error) {	1638	+	func PixbufGetFileInfoFinish(AsyncResultVar gio.AsyncResult, WidthVar int, HeightVar int) (*PixbufFormat, error) {
1489		var cerr *glib.Error	1639		var cerr *glib.Error
1490			1640
1491		cret := xPixbufGetFileInfoFinish(AsyncResultVar.GoPointer(), WidthVar, HeightVar, &cerr)	1641		cret := xPixbufGetFileInfoFinish(AsyncResultVar.GoPointer(), WidthVar, HeightVar, &cerr)

M v4/gio/gaction.go +76 -18

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/pkg/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
+	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gobject/types"
 )
 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGetName sets the callback function.
+// OverrideGetName sets the "get_name" callback function.
 // the virtual function pointer for [method@Gio.Action.get_name]
 func (x *ActionInterface) OverrideGetName(cb func(Action) string) {
 	if cb == nil {
 	}
 }
-// GetGetName gets the callback function.
+// GetGetName gets the "get_name" callback function.
 // the virtual function pointer for [method@Gio.Action.get_name]
 func (x *ActionInterface) GetGetName() func(Action) string {
 	if x.xGetName == 0 {
 	}
 }
-// OverrideGetParameterType sets the callback function.
+// OverrideGetParameterType sets the "get_parameter_type" callback function.
 // the virtual function pointer for [method@Gio.Action.get_parameter_type]
 func (x *ActionInterface) OverrideGetParameterType(cb func(Action) *glib.VariantType) {
 	if cb == nil {
 	}
 }
-// GetGetParameterType gets the callback function.
+// GetGetParameterType gets the "get_parameter_type" callback function.
 // the virtual function pointer for [method@Gio.Action.get_parameter_type]
 func (x *ActionInterface) GetGetParameterType() func(Action) *glib.VariantType {
 	if x.xGetParameterType == 0 {
 	}
 }
-// OverrideGetStateType sets the callback function.
+// OverrideGetStateType sets the "get_state_type" callback function.
 // the virtual function pointer for [method@Gio.Action.get_state_type]
 func (x *ActionInterface) OverrideGetStateType(cb func(Action) *glib.VariantType) {
 	if cb == nil {
 	}
 }
-// GetGetStateType gets the callback function.
+// GetGetStateType gets the "get_state_type" callback function.
 // the virtual function pointer for [method@Gio.Action.get_state_type]
 func (x *ActionInterface) GetGetStateType() func(Action) *glib.VariantType {
 	if x.xGetStateType == 0 {
 	}
 }
-// OverrideGetStateHint sets the callback function.
+// OverrideGetStateHint sets the "get_state_hint" callback function.
 // the virtual function pointer for [method@Gio.Action.get_state_hint]
 func (x *ActionInterface) OverrideGetStateHint(cb func(Action) *glib.Variant) {
 	if cb == nil {
 	}
 }
-// GetGetStateHint gets the callback function.
+// GetGetStateHint gets the "get_state_hint" callback function.
 // the virtual function pointer for [method@Gio.Action.get_state_hint]
 func (x *ActionInterface) GetGetStateHint() func(Action) *glib.Variant {
 	if x.xGetStateHint == 0 {
 	}
 }
-// OverrideGetEnabled sets the callback function.
+// OverrideGetEnabled sets the "get_enabled" callback function.
 // the virtual function pointer for [method@Gio.Action.get_enabled]
 func (x *ActionInterface) OverrideGetEnabled(cb func(Action) bool) {
 	if cb == nil {
 	}
 }
-// GetGetEnabled gets the callback function.
+// GetGetEnabled gets the "get_enabled" callback function.
 // the virtual function pointer for [method@Gio.Action.get_enabled]
 func (x *ActionInterface) GetGetEnabled() func(Action) bool {
 	if x.xGetEnabled == 0 {
 	}
 }
-// OverrideGetState sets the callback function.
+// OverrideGetState sets the "get_state" callback function.
 // the virtual function pointer for [method@Gio.Action.get_state]
 func (x *ActionInterface) OverrideGetState(cb func(Action) *glib.Variant) {
 	if cb == nil {
 	}
 }
-// GetGetState gets the callback function.
+// GetGetState gets the "get_state" callback function.
 // the virtual function pointer for [method@Gio.Action.get_state]
 func (x *ActionInterface) GetGetState() func(Action) *glib.Variant {
 	if x.xGetState == 0 {
 	}
 }
-// OverrideChangeState sets the callback function.
+// OverrideChangeState sets the "change_state" callback function.
 // the virtual function pointer for [method@Gio.Action.change_state]
 func (x *ActionInterface) OverrideChangeState(cb func(Action, *glib.Variant)) {
 	if cb == nil {
 	}
 }
-// GetChangeState gets the callback function.
+// GetChangeState gets the "change_state" callback function.
 // the virtual function pointer for [method@Gio.Action.change_state]
 func (x *ActionInterface) GetChangeState() func(Action, *glib.Variant) {
 	if x.xChangeState == 0 {
 	}
 }
-// OverrideActivate sets the callback function.
+// OverrideActivate sets the "activate" callback function.
 // the virtual function pointer for [method@Gio.Action.activate].  Note that [type@Gio.Action] does not have an
 //
 //	'activate' signal but that implementations of it may have one.
 	}
 }
-// GetActivate gets the callback function.
+// GetActivate gets the "activate" callback function.
 // the virtual function pointer for [method@Gio.Action.activate].  Note that [type@Gio.Action] does not have an
 //
 //	'activate' signal but that implementations of it may have one.
 	return cret
 }
+// GetPropertyEnabled gets the "enabled" property.
+// If @action is currently enabled.
+//
+// If the action is disabled then calls to [method@Gio.Action.activate] and
+// [method@Gio.Action.change_state] have no effect.
+func (x *ActionBase) GetPropertyEnabled() bool {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("enabled", &v)
+	return v.GetBoolean()
+}
+// GetPropertyName gets the "name" property.
+// The name of the action.  This is mostly meaningful for identifying
+// the action once it has been added to a [type@Gio.ActionGroup]. It is immutable.
+func (x *ActionBase) GetPropertyName() string {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("name", &v)
+	return v.GetString()
+}
+// GetPropertyParameterType gets the "parameter-type" property.
+// The type of the parameter that must be given when activating the
+// action. This is immutable, and may be `NULL` if no parameter is needed when
+// activating the action.
+func (x *ActionBase) GetPropertyParameterType() uintptr {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("parameter-type", &v)
+	return v.GetPointer()
+}
+// GetPropertyState gets the "state" property.
+// The state of the action, or `NULL` if the action is stateless.
+func (x *ActionBase) GetPropertyState() uintptr {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("state", &v)
+	return v.GetPointer()
+}
+// GetPropertyStateType gets the "state-type" property.
+// The [type@GLib.VariantType] of the state that the action has, or `NULL` if the
+// action is stateless. This is immutable.
+func (x *ActionBase) GetPropertyStateType() uintptr {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("state-type", &v)
+	return v.GetPointer()
+}
 var XGActionActivate func(uintptr, *glib.Variant)
 var XGActionChangeState func(uintptr, *glib.Variant)
 var XGActionGetEnabled func(uintptr) bool
 	return cret
 }
-var xActionParseDetailedName func(string, string, **glib.Variant, **glib.Error) bool
+var xActionParseDetailedName func(string, *string, **glib.Variant, **glib.Error) bool
 // Parses a detailed action name into its separate name and target
 // components.
 // returned in @target_value, as the @detailed_name may not contain a target.
 //
 // If returned, the [type@GLib.Variant] in @target_value is guaranteed to not be floating.
-func ActionParseDetailedName(DetailedNameVar string, ActionNameVar string, TargetValueVar **glib.Variant) (bool, error) {
+func ActionParseDetailedName(DetailedNameVar string, ActionNameVar *string, TargetValueVar **glib.Variant) (bool, error) {
 	var cerr *glib.Error
 	cret := xActionParseDetailedName(DetailedNameVar, ActionNameVar, TargetValueVar, &cerr)

M v4/gio/gactiongroup.go +36 -36


@@ -50,7 +50,7 @@ func (x *ActionGroupInterface) GoPointer() uintptr {
50		return uintptr(unsafe.Pointer(x))	50		return uintptr(unsafe.Pointer(x))
51		}	51		}
52			52
53	-	// OverrideHasAction sets the callback function.	53	+	// OverrideHasAction sets the "has_action" callback function.
54		// the virtual function pointer for [method@Gio.ActionGroup.has_action]	54		// the virtual function pointer for [method@Gio.ActionGroup.has_action]
55		func (x *ActionGroupInterface) OverrideHasAction(cb func(ActionGroup, string) bool) {	55		func (x *ActionGroupInterface) OverrideHasAction(cb func(ActionGroup, string) bool) {
56		if cb == nil {	56		if cb == nil {

@@ -62,7 +62,7 @@ func (x *ActionGroupInterface) OverrideHasAction(cb func(ActionGroup, string) bo
62		}	62		}
63		}	63		}
64			64
65	-	// GetHasAction gets the callback function.	65	+	// GetHasAction gets the "has_action" callback function.
66		// the virtual function pointer for [method@Gio.ActionGroup.has_action]	66		// the virtual function pointer for [method@Gio.ActionGroup.has_action]
67		func (x *ActionGroupInterface) GetHasAction() func(ActionGroup, string) bool {	67		func (x *ActionGroupInterface) GetHasAction() func(ActionGroup, string) bool {
68		if x.xHasAction == 0 {	68		if x.xHasAction == 0 {

@@ -75,7 +75,7 @@ func (x *ActionGroupInterface) GetHasAction() func(ActionGroup, string) bool {
75		}	75		}
76		}	76		}
77			77
78	-	// OverrideListActions sets the callback function.	78	+	// OverrideListActions sets the "list_actions" callback function.
79		// the virtual function pointer for [method@Gio.ActionGroup.list_actions]	79		// the virtual function pointer for [method@Gio.ActionGroup.list_actions]
80		func (x *ActionGroupInterface) OverrideListActions(cb func(ActionGroup) []string) {	80		func (x *ActionGroupInterface) OverrideListActions(cb func(ActionGroup) []string) {
81		if cb == nil {	81		if cb == nil {

@@ -87,7 +87,7 @@ func (x *ActionGroupInterface) OverrideListActions(cb func(ActionGroup) []string
87		}	87		}
88		}	88		}
89			89
90	-	// GetListActions gets the callback function.	90	+	// GetListActions gets the "list_actions" callback function.
91		// the virtual function pointer for [method@Gio.ActionGroup.list_actions]	91		// the virtual function pointer for [method@Gio.ActionGroup.list_actions]
92		func (x *ActionGroupInterface) GetListActions() func(ActionGroup) []string {	92		func (x *ActionGroupInterface) GetListActions() func(ActionGroup) []string {
93		if x.xListActions == 0 {	93		if x.xListActions == 0 {

@@ -100,7 +100,7 @@ func (x *ActionGroupInterface) GetListActions() func(ActionGroup) []string {
100		}	100		}
101		}	101		}
102			102
103	-	// OverrideGetActionEnabled sets the callback function.	103	+	// OverrideGetActionEnabled sets the "get_action_enabled" callback function.
104		// the virtual function pointer for [method@Gio.ActionGroup.get_action_enabled]	104		// the virtual function pointer for [method@Gio.ActionGroup.get_action_enabled]
105		func (x *ActionGroupInterface) OverrideGetActionEnabled(cb func(ActionGroup, string) bool) {	105		func (x *ActionGroupInterface) OverrideGetActionEnabled(cb func(ActionGroup, string) bool) {
106		if cb == nil {	106		if cb == nil {

@@ -112,7 +112,7 @@ func (x *ActionGroupInterface) OverrideGetActionEnabled(cb func(ActionGroup, str
112		}	112		}
113		}	113		}
114			114
115	-	// GetGetActionEnabled gets the callback function.	115	+	// GetGetActionEnabled gets the "get_action_enabled" callback function.
116		// the virtual function pointer for [method@Gio.ActionGroup.get_action_enabled]	116		// the virtual function pointer for [method@Gio.ActionGroup.get_action_enabled]
117		func (x *ActionGroupInterface) GetGetActionEnabled() func(ActionGroup, string) bool {	117		func (x *ActionGroupInterface) GetGetActionEnabled() func(ActionGroup, string) bool {
118		if x.xGetActionEnabled == 0 {	118		if x.xGetActionEnabled == 0 {

@@ -125,7 +125,7 @@ func (x *ActionGroupInterface) GetGetActionEnabled() func(ActionGroup, string) b
125		}	125		}
126		}	126		}
127			127
128	-	// OverrideGetActionParameterType sets the callback function.	128	+	// OverrideGetActionParameterType sets the "get_action_parameter_type" callback function.
129		// the virtual function pointer for [method@Gio.ActionGroup.get_action_parameter_type]	129		// the virtual function pointer for [method@Gio.ActionGroup.get_action_parameter_type]
130		func (x ActionGroupInterface) OverrideGetActionParameterType(cb func(ActionGroup, string) glib.VariantType) {	130		func (x ActionGroupInterface) OverrideGetActionParameterType(cb func(ActionGroup, string) glib.VariantType) {
131		if cb == nil {	131		if cb == nil {

@@ -137,7 +137,7 @@ func (x *ActionGroupInterface) OverrideGetActionParameterType(cb func(ActionGrou
137		}	137		}
138		}	138		}
139			139
140	-	// GetGetActionParameterType gets the callback function.	140	+	// GetGetActionParameterType gets the "get_action_parameter_type" callback function.
141		// the virtual function pointer for [method@Gio.ActionGroup.get_action_parameter_type]	141		// the virtual function pointer for [method@Gio.ActionGroup.get_action_parameter_type]
142		func (x ActionGroupInterface) GetGetActionParameterType() func(ActionGroup, string) glib.VariantType {	142		func (x ActionGroupInterface) GetGetActionParameterType() func(ActionGroup, string) glib.VariantType {
143		if x.xGetActionParameterType == 0 {	143		if x.xGetActionParameterType == 0 {

@@ -150,7 +150,7 @@ func (x *ActionGroupInterface) GetGetActionParameterType() func(ActionGroup, str
150		}	150		}
151		}	151		}
152			152
153	-	// OverrideGetActionStateType sets the callback function.	153	+	// OverrideGetActionStateType sets the "get_action_state_type" callback function.
154		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state_type]	154		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state_type]
155		func (x ActionGroupInterface) OverrideGetActionStateType(cb func(ActionGroup, string) glib.VariantType) {	155		func (x ActionGroupInterface) OverrideGetActionStateType(cb func(ActionGroup, string) glib.VariantType) {
156		if cb == nil {	156		if cb == nil {

@@ -162,7 +162,7 @@ func (x *ActionGroupInterface) OverrideGetActionStateType(cb func(ActionGroup, s
162		}	162		}
163		}	163		}
164			164
165	-	// GetGetActionStateType gets the callback function.	165	+	// GetGetActionStateType gets the "get_action_state_type" callback function.
166		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state_type]	166		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state_type]
167		func (x ActionGroupInterface) GetGetActionStateType() func(ActionGroup, string) glib.VariantType {	167		func (x ActionGroupInterface) GetGetActionStateType() func(ActionGroup, string) glib.VariantType {
168		if x.xGetActionStateType == 0 {	168		if x.xGetActionStateType == 0 {

@@ -175,7 +175,7 @@ func (x *ActionGroupInterface) GetGetActionStateType() func(ActionGroup, string)
175		}	175		}
176		}	176		}
177			177
178	-	// OverrideGetActionStateHint sets the callback function.	178	+	// OverrideGetActionStateHint sets the "get_action_state_hint" callback function.
179		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state_hint]	179		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state_hint]
180		func (x ActionGroupInterface) OverrideGetActionStateHint(cb func(ActionGroup, string) glib.Variant) {	180		func (x ActionGroupInterface) OverrideGetActionStateHint(cb func(ActionGroup, string) glib.Variant) {
181		if cb == nil {	181		if cb == nil {

@@ -187,7 +187,7 @@ func (x *ActionGroupInterface) OverrideGetActionStateHint(cb func(ActionGroup, s
187		}	187		}
188		}	188		}
189			189
190	-	// GetGetActionStateHint gets the callback function.	190	+	// GetGetActionStateHint gets the "get_action_state_hint" callback function.
191		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state_hint]	191		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state_hint]
192		func (x ActionGroupInterface) GetGetActionStateHint() func(ActionGroup, string) glib.Variant {	192		func (x ActionGroupInterface) GetGetActionStateHint() func(ActionGroup, string) glib.Variant {
193		if x.xGetActionStateHint == 0 {	193		if x.xGetActionStateHint == 0 {

@@ -200,7 +200,7 @@ func (x *ActionGroupInterface) GetGetActionStateHint() func(ActionGroup, string)
200		}	200		}
201		}	201		}
202			202
203	-	// OverrideGetActionState sets the callback function.	203	+	// OverrideGetActionState sets the "get_action_state" callback function.
204		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state]	204		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state]
205		func (x ActionGroupInterface) OverrideGetActionState(cb func(ActionGroup, string) glib.Variant) {	205		func (x ActionGroupInterface) OverrideGetActionState(cb func(ActionGroup, string) glib.Variant) {
206		if cb == nil {	206		if cb == nil {

@@ -212,7 +212,7 @@ func (x *ActionGroupInterface) OverrideGetActionState(cb func(ActionGroup, strin
212		}	212		}
213		}	213		}
214			214
215	-	// GetGetActionState gets the callback function.	215	+	// GetGetActionState gets the "get_action_state" callback function.
216		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state]	216		// the virtual function pointer for [method@Gio.ActionGroup.get_action_state]
217		func (x ActionGroupInterface) GetGetActionState() func(ActionGroup, string) glib.Variant {	217		func (x ActionGroupInterface) GetGetActionState() func(ActionGroup, string) glib.Variant {
218		if x.xGetActionState == 0 {	218		if x.xGetActionState == 0 {

@@ -225,7 +225,7 @@ func (x ActionGroupInterface) GetGetActionState() func(ActionGroup, string) gl
225		}	225		}
226		}	226		}
227			227
228	-	// OverrideChangeActionState sets the callback function.	228	+	// OverrideChangeActionState sets the "change_action_state" callback function.
229		// the virtual function pointer for [method@Gio.ActionGroup.change_action_state]	229		// the virtual function pointer for [method@Gio.ActionGroup.change_action_state]
230		func (x ActionGroupInterface) OverrideChangeActionState(cb func(ActionGroup, string, glib.Variant)) {	230		func (x ActionGroupInterface) OverrideChangeActionState(cb func(ActionGroup, string, glib.Variant)) {
231		if cb == nil {	231		if cb == nil {

@@ -237,7 +237,7 @@ func (x *ActionGroupInterface) OverrideChangeActionState(cb func(ActionGroup, st
237		}	237		}
238		}	238		}
239			239
240	-	// GetChangeActionState gets the callback function.	240	+	// GetChangeActionState gets the "change_action_state" callback function.
241		// the virtual function pointer for [method@Gio.ActionGroup.change_action_state]	241		// the virtual function pointer for [method@Gio.ActionGroup.change_action_state]
242		func (x ActionGroupInterface) GetChangeActionState() func(ActionGroup, string, glib.Variant) {	242		func (x ActionGroupInterface) GetChangeActionState() func(ActionGroup, string, glib.Variant) {
243		if x.xChangeActionState == 0 {	243		if x.xChangeActionState == 0 {

@@ -250,7 +250,7 @@ func (x *ActionGroupInterface) GetChangeActionState() func(ActionGroup, string,
250		}	250		}
251		}	251		}
252			252
253	-	// OverrideActivateAction sets the callback function.	253	+	// OverrideActivateAction sets the "activate_action" callback function.
254		// the virtual function pointer for [method@Gio.ActionGroup.activate_action]	254		// the virtual function pointer for [method@Gio.ActionGroup.activate_action]
255		func (x ActionGroupInterface) OverrideActivateAction(cb func(ActionGroup, string, glib.Variant)) {	255		func (x ActionGroupInterface) OverrideActivateAction(cb func(ActionGroup, string, glib.Variant)) {
256		if cb == nil {	256		if cb == nil {

@@ -262,7 +262,7 @@ func (x *ActionGroupInterface) OverrideActivateAction(cb func(ActionGroup, strin
262		}	262		}
263		}	263		}
264			264
265	-	// GetActivateAction gets the callback function.	265	+	// GetActivateAction gets the "activate_action" callback function.
266		// the virtual function pointer for [method@Gio.ActionGroup.activate_action]	266		// the virtual function pointer for [method@Gio.ActionGroup.activate_action]
267		func (x ActionGroupInterface) GetActivateAction() func(ActionGroup, string, glib.Variant) {	267		func (x ActionGroupInterface) GetActivateAction() func(ActionGroup, string, glib.Variant) {
268		if x.xActivateAction == 0 {	268		if x.xActivateAction == 0 {

@@ -275,7 +275,7 @@ func (x ActionGroupInterface) GetActivateAction() func(ActionGroup, string, gl
275		}	275		}
276		}	276		}
277			277
278	-	// OverrideActionAdded sets the callback function.	278	+	// OverrideActionAdded sets the "action_added" callback function.
279		// the class closure for the [signal@Gio.ActionGroup::action-added] signal	279		// the class closure for the [signal@Gio.ActionGroup::action-added] signal
280		func (x *ActionGroupInterface) OverrideActionAdded(cb func(ActionGroup, string)) {	280		func (x *ActionGroupInterface) OverrideActionAdded(cb func(ActionGroup, string)) {
281		if cb == nil {	281		if cb == nil {

@@ -287,7 +287,7 @@ func (x *ActionGroupInterface) OverrideActionAdded(cb func(ActionGroup, string))
287		}	287		}
288		}	288		}
289			289
290	-	// GetActionAdded gets the callback function.	290	+	// GetActionAdded gets the "action_added" callback function.
291		// the class closure for the [signal@Gio.ActionGroup::action-added] signal	291		// the class closure for the [signal@Gio.ActionGroup::action-added] signal
292		func (x *ActionGroupInterface) GetActionAdded() func(ActionGroup, string) {	292		func (x *ActionGroupInterface) GetActionAdded() func(ActionGroup, string) {
293		if x.xActionAdded == 0 {	293		if x.xActionAdded == 0 {

@@ -300,7 +300,7 @@ func (x *ActionGroupInterface) GetActionAdded() func(ActionGroup, string) {
300		}	300		}
301		}	301		}
302			302
303	-	// OverrideActionRemoved sets the callback function.	303	+	// OverrideActionRemoved sets the "action_removed" callback function.
304		// the class closure for the [signal@Gio.ActionGroup::action-removed] signal	304		// the class closure for the [signal@Gio.ActionGroup::action-removed] signal
305		func (x *ActionGroupInterface) OverrideActionRemoved(cb func(ActionGroup, string)) {	305		func (x *ActionGroupInterface) OverrideActionRemoved(cb func(ActionGroup, string)) {
306		if cb == nil {	306		if cb == nil {

@@ -312,7 +312,7 @@ func (x *ActionGroupInterface) OverrideActionRemoved(cb func(ActionGroup, string
312		}	312		}
313		}	313		}
314			314
315	-	// GetActionRemoved gets the callback function.	315	+	// GetActionRemoved gets the "action_removed" callback function.
316		// the class closure for the [signal@Gio.ActionGroup::action-removed] signal	316		// the class closure for the [signal@Gio.ActionGroup::action-removed] signal
317		func (x *ActionGroupInterface) GetActionRemoved() func(ActionGroup, string) {	317		func (x *ActionGroupInterface) GetActionRemoved() func(ActionGroup, string) {
318		if x.xActionRemoved == 0 {	318		if x.xActionRemoved == 0 {

@@ -325,7 +325,7 @@ func (x *ActionGroupInterface) GetActionRemoved() func(ActionGroup, string) {
325		}	325		}
326		}	326		}
327			327
328	-	// OverrideActionEnabledChanged sets the callback function.	328	+	// OverrideActionEnabledChanged sets the "action_enabled_changed" callback function.
329		// the class closure for the [signal@Gio.ActionGroup::action-enabled-changed] signal	329		// the class closure for the [signal@Gio.ActionGroup::action-enabled-changed] signal
330		func (x *ActionGroupInterface) OverrideActionEnabledChanged(cb func(ActionGroup, string, bool)) {	330		func (x *ActionGroupInterface) OverrideActionEnabledChanged(cb func(ActionGroup, string, bool)) {
331		if cb == nil {	331		if cb == nil {

@@ -337,7 +337,7 @@ func (x *ActionGroupInterface) OverrideActionEnabledChanged(cb func(ActionGroup,
337		}	337		}
338		}	338		}
339			339
340	-	// GetActionEnabledChanged gets the callback function.	340	+	// GetActionEnabledChanged gets the "action_enabled_changed" callback function.
341		// the class closure for the [signal@Gio.ActionGroup::action-enabled-changed] signal	341		// the class closure for the [signal@Gio.ActionGroup::action-enabled-changed] signal
342		func (x *ActionGroupInterface) GetActionEnabledChanged() func(ActionGroup, string, bool) {	342		func (x *ActionGroupInterface) GetActionEnabledChanged() func(ActionGroup, string, bool) {
343		if x.xActionEnabledChanged == 0 {	343		if x.xActionEnabledChanged == 0 {

@@ -350,7 +350,7 @@ func (x *ActionGroupInterface) GetActionEnabledChanged() func(ActionGroup, strin
350		}	350		}
351		}	351		}
352			352
353	-	// OverrideActionStateChanged sets the callback function.	353	+	// OverrideActionStateChanged sets the "action_state_changed" callback function.
354		// the class closure for the [signal@Gio.ActionGroup::action-enabled-changed] signal	354		// the class closure for the [signal@Gio.ActionGroup::action-enabled-changed] signal
355		func (x ActionGroupInterface) OverrideActionStateChanged(cb func(ActionGroup, string, glib.Variant)) {	355		func (x ActionGroupInterface) OverrideActionStateChanged(cb func(ActionGroup, string, glib.Variant)) {
356		if cb == nil {	356		if cb == nil {

@@ -362,7 +362,7 @@ func (x *ActionGroupInterface) OverrideActionStateChanged(cb func(ActionGroup, s
362		}	362		}
363		}	363		}
364			364
365	-	// GetActionStateChanged gets the callback function.	365	+	// GetActionStateChanged gets the "action_state_changed" callback function.
366		// the class closure for the [signal@Gio.ActionGroup::action-enabled-changed] signal	366		// the class closure for the [signal@Gio.ActionGroup::action-enabled-changed] signal
367		func (x ActionGroupInterface) GetActionStateChanged() func(ActionGroup, string, glib.Variant) {	367		func (x ActionGroupInterface) GetActionStateChanged() func(ActionGroup, string, glib.Variant) {
368		if x.xActionStateChanged == 0 {	368		if x.xActionStateChanged == 0 {

@@ -375,27 +375,27 @@ func (x *ActionGroupInterface) GetActionStateChanged() func(ActionGroup, string,
375		}	375		}
376		}	376		}
377			377
378	-	// OverrideQueryAction sets the callback function.	378	+	// OverrideQueryAction sets the "query_action" callback function.
379		// the virtual function pointer for [method@Gio.ActionGroup.query_action]	379		// the virtual function pointer for [method@Gio.ActionGroup.query_action]
380	-	func (x ActionGroupInterface) OverrideQueryAction(cb func(ActionGroup, string, bool, glib.VariantType, glib.VariantType, glib.Variant, *glib.Variant) bool) {	380	+	func (x ActionGroupInterface) OverrideQueryAction(cb func(ActionGroup, string, bool, glib.VariantType, glib.VariantType, glib.Variant, glib.Variant) bool) {
381		if cb == nil {	381		if cb == nil {
382		x.xQueryAction = 0	382		x.xQueryAction = 0
383		} else {	383		} else {
384	-	x.xQueryAction = purego.NewCallback(func(ActionGroupVarp uintptr, ActionNameVarp string, EnabledVarp bool, ParameterTypeVarp glib.VariantType, StateTypeVarp glib.VariantType, StateHintVarp glib.Variant, StateVarp glib.Variant) bool {	384	+	x.xQueryAction = purego.NewCallback(func(ActionGroupVarp uintptr, ActionNameVarp string, EnabledVarp bool, ParameterTypeVarp glib.VariantType, StateTypeVarp glib.VariantType, StateHintVarp glib.Variant, StateVarp *glib.Variant) bool {
385		return cb(&ActionGroupBase{Ptr: ActionGroupVarp}, ActionNameVarp, EnabledVarp, ParameterTypeVarp, StateTypeVarp, StateHintVarp, StateVarp)	385		return cb(&ActionGroupBase{Ptr: ActionGroupVarp}, ActionNameVarp, EnabledVarp, ParameterTypeVarp, StateTypeVarp, StateHintVarp, StateVarp)
386		})	386		})
387		}	387		}
388		}	388		}
389			389
390	-	// GetQueryAction gets the callback function.	390	+	// GetQueryAction gets the "query_action" callback function.
391		// the virtual function pointer for [method@Gio.ActionGroup.query_action]	391		// the virtual function pointer for [method@Gio.ActionGroup.query_action]
392	-	func (x ActionGroupInterface) GetQueryAction() func(ActionGroup, string, bool, glib.VariantType, glib.VariantType, glib.Variant, *glib.Variant) bool {	392	+	func (x ActionGroupInterface) GetQueryAction() func(ActionGroup, string, bool, glib.VariantType, glib.VariantType, glib.Variant, glib.Variant) bool {
393		if x.xQueryAction == 0 {	393		if x.xQueryAction == 0 {
394		return nil	394		return nil
395		}	395		}
396	-	var rawCallback func(ActionGroupVarp uintptr, ActionNameVarp string, EnabledVarp bool, ParameterTypeVarp glib.VariantType, StateTypeVarp glib.VariantType, StateHintVarp glib.Variant, StateVarp glib.Variant) bool	396	+	var rawCallback func(ActionGroupVarp uintptr, ActionNameVarp string, EnabledVarp bool, ParameterTypeVarp glib.VariantType, StateTypeVarp glib.VariantType, StateHintVarp glib.Variant, StateVarp *glib.Variant) bool
397		purego.RegisterFunc(&rawCallback, x.xQueryAction)	397		purego.RegisterFunc(&rawCallback, x.xQueryAction)
398	-	return func(ActionGroupVar ActionGroup, ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar glib.Variant) bool {	398	+	return func(ActionGroupVar ActionGroup, ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar *glib.Variant) bool {
399		return rawCallback(ActionGroupVar.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)	399		return rawCallback(ActionGroupVar.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
400		}	400		}
401		}	401		}

@@ -460,7 +460,7 @@ type ActionGroup interface {
460		GetActionStateType(ActionNameVar string) *glib.VariantType	460		GetActionStateType(ActionNameVar string) *glib.VariantType
461		HasAction(ActionNameVar string) bool	461		HasAction(ActionNameVar string) bool
462		ListActions() []string	462		ListActions() []string
463	-	QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar glib.Variant) bool	463	+	QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar *glib.Variant) bool
464		}	464		}
465			465
466		var xActionGroupGLibType func() types.GType	466		var xActionGroupGLibType func() types.GType

@@ -709,7 +709,7 @@ func (x *ActionGroupBase) ListActions() []string {
709		// fields (as indicated by having a non-`NULL` reference passed in) are	709		// fields (as indicated by having a non-`NULL` reference passed in) are
710		// filled. If the action doesn’t exist, `FALSE` is returned and the	710		// filled. If the action doesn’t exist, `FALSE` is returned and the
711		// fields may or may not have been modified.	711		// fields may or may not have been modified.
712	-	func (x ActionGroupBase) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar *glib.Variant) bool {	712	+	func (x ActionGroupBase) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar glib.Variant) bool {
713			713
714		cret := XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)	714		cret := XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
715		return cret	715		return cret

@@ -728,7 +728,7 @@ var XGActionGroupGetActionStateHint func(uintptr, string) *glib.Variant
728		var XGActionGroupGetActionStateType func(uintptr, string) *glib.VariantType	728		var XGActionGroupGetActionStateType func(uintptr, string) *glib.VariantType
729		var XGActionGroupHasAction func(uintptr, string) bool	729		var XGActionGroupHasAction func(uintptr, string) bool
730		var XGActionGroupListActions func(uintptr) []string	730		var XGActionGroupListActions func(uintptr) []string
731	-	var XGActionGroupQueryAction func(uintptr, string, bool, glib.VariantType, glib.VariantType, glib.Variant, glib.Variant) bool	731	+	var XGActionGroupQueryAction func(uintptr, string, bool, glib.VariantType, glib.VariantType, glib.Variant, *glib.Variant) bool
732			732
733		func init() {	733		func init() {
734		core.SetPackageName("GIO", "gio-2.0")	734		core.SetPackageName("GIO", "gio-2.0")

M v4/gio/gactionmap.go +10 -10


@@ -42,7 +42,7 @@ func (x *ActionEntry) GoPointer() uintptr {
42		return uintptr(unsafe.Pointer(x))	42		return uintptr(unsafe.Pointer(x))
43		}	43		}
44			44
45	-	// OverrideActivate sets the callback function.	45	+	// OverrideActivate sets the "activate" callback function.
46		// the callback to connect to the "activate" signal of the action.	46		// the callback to connect to the "activate" signal of the action.
47		//	47		//
48		// Since GLib 2.40, this can be `NULL` for stateful actions, in which case	48		// Since GLib 2.40, this can be `NULL` for stateful actions, in which case

@@ -60,7 +60,7 @@ func (x ActionEntry) OverrideActivate(cb func(SimpleAction, *glib.Variant, uin
60		}	60		}
61		}	61		}
62			62
63	-	// GetActivate gets the callback function.	63	+	// GetActivate gets the "activate" callback function.
64		// the callback to connect to the "activate" signal of the action.	64		// the callback to connect to the "activate" signal of the action.
65		//	65		//
66		// Since GLib 2.40, this can be `NULL` for stateful actions, in which case	66		// Since GLib 2.40, this can be `NULL` for stateful actions, in which case

@@ -79,7 +79,7 @@ func (x ActionEntry) GetActivate() func(SimpleAction, *glib.Variant, uintptr)
79		}	79		}
80		}	80		}
81			81
82	-	// OverrideChangeState sets the callback function.	82	+	// OverrideChangeState sets the "change_state" callback function.
83		// the callback to connect to the "change-state" signal of the	83		// the callback to connect to the "change-state" signal of the
84		//	84		//
85		// action. All stateful actions should provide a handler here; stateless	85		// action. All stateful actions should provide a handler here; stateless

@@ -94,7 +94,7 @@ func (x ActionEntry) OverrideChangeState(cb func(SimpleAction, *glib.Variant,
94		}	94		}
95		}	95		}
96			96
97	-	// GetChangeState gets the callback function.	97	+	// GetChangeState gets the "change_state" callback function.
98		// the callback to connect to the "change-state" signal of the	98		// the callback to connect to the "change-state" signal of the
99		//	99		//
100		// action. All stateful actions should provide a handler here; stateless	100		// action. All stateful actions should provide a handler here; stateless

@@ -127,7 +127,7 @@ func (x *ActionMapInterface) GoPointer() uintptr {
127		return uintptr(unsafe.Pointer(x))	127		return uintptr(unsafe.Pointer(x))
128		}	128		}
129			129
130	-	// OverrideLookupAction sets the callback function.	130	+	// OverrideLookupAction sets the "lookup_action" callback function.
131		// the virtual function pointer for	131		// the virtual function pointer for
132		//	132		//
133		// [method@Gio.ActionMap.lookup_action]	133		// [method@Gio.ActionMap.lookup_action]

@@ -145,7 +145,7 @@ func (x ActionMapInterface) OverrideLookupAction(cb func(ActionMap, string) Ac
145		}	145		}
146		}	146		}
147			147
148	-	// GetLookupAction gets the callback function.	148	+	// GetLookupAction gets the "lookup_action" callback function.
149		// the virtual function pointer for	149		// the virtual function pointer for
150		//	150		//
151		// [method@Gio.ActionMap.lookup_action]	151		// [method@Gio.ActionMap.lookup_action]

@@ -166,7 +166,7 @@ func (x ActionMapInterface) GetLookupAction() func(ActionMap, string) ActionBa
166		}	166		}
167		}	167		}
168			168
169	-	// OverrideAddAction sets the callback function.	169	+	// OverrideAddAction sets the "add_action" callback function.
170		// the virtual function pointer for	170		// the virtual function pointer for
171		//	171		//
172		// [method@Gio.ActionMap.add_action]	172		// [method@Gio.ActionMap.add_action]

@@ -180,7 +180,7 @@ func (x *ActionMapInterface) OverrideAddAction(cb func(ActionMap, Action)) {
180		}	180		}
181		}	181		}
182			182
183	-	// GetAddAction gets the callback function.	183	+	// GetAddAction gets the "add_action" callback function.
184		// the virtual function pointer for	184		// the virtual function pointer for
185		//	185		//
186		// [method@Gio.ActionMap.add_action]	186		// [method@Gio.ActionMap.add_action]

@@ -195,7 +195,7 @@ func (x *ActionMapInterface) GetAddAction() func(ActionMap, Action) {
195		}	195		}
196		}	196		}
197			197
198	-	// OverrideRemoveAction sets the callback function.	198	+	// OverrideRemoveAction sets the "remove_action" callback function.
199		// the virtual function pointer for	199		// the virtual function pointer for
200		//	200		//
201		// [method@Gio.ActionMap.remove_action]	201		// [method@Gio.ActionMap.remove_action]

@@ -209,7 +209,7 @@ func (x *ActionMapInterface) OverrideRemoveAction(cb func(ActionMap, string)) {
209		}	209		}
210		}	210		}
211			211
212	-	// GetRemoveAction gets the callback function.	212	+	// GetRemoveAction gets the "remove_action" callback function.
213		// the virtual function pointer for	213		// the virtual function pointer for
214		//	214		//
215		// [method@Gio.ActionMap.remove_action]	215		// [method@Gio.ActionMap.remove_action]

M v4/gio/gappinfo.go +66 -66


@@ -73,7 +73,7 @@ func (x *AppInfoIface) GoPointer() uintptr {
73		return uintptr(unsafe.Pointer(x))	73		return uintptr(unsafe.Pointer(x))
74		}	74		}
75			75
76	-	// OverrideDup sets the callback function.	76	+	// OverrideDup sets the "dup" callback function.
77		// Copies a [iface@Gio.AppInfo].	77		// Copies a [iface@Gio.AppInfo].
78		func (x AppInfoIface) OverrideDup(cb func(AppInfo) AppInfoBase) {	78		func (x AppInfoIface) OverrideDup(cb func(AppInfo) AppInfoBase) {
79		if cb == nil {	79		if cb == nil {

@@ -89,7 +89,7 @@ func (x AppInfoIface) OverrideDup(cb func(AppInfo) AppInfoBase) {
89		}	89		}
90		}	90		}
91			91
92	-	// GetDup gets the callback function.	92	+	// GetDup gets the "dup" callback function.
93		// Copies a [iface@Gio.AppInfo].	93		// Copies a [iface@Gio.AppInfo].
94		func (x AppInfoIface) GetDup() func(AppInfo) AppInfoBase {	94		func (x AppInfoIface) GetDup() func(AppInfo) AppInfoBase {
95		if x.xDup == 0 {	95		if x.xDup == 0 {

@@ -108,7 +108,7 @@ func (x AppInfoIface) GetDup() func(AppInfo) AppInfoBase {
108		}	108		}
109		}	109		}
110			110
111	-	// OverrideEqual sets the callback function.	111	+	// OverrideEqual sets the "equal" callback function.
112		// Checks two [iface@Gio.AppInfo]s for equality.	112		// Checks two [iface@Gio.AppInfo]s for equality.
113		func (x *AppInfoIface) OverrideEqual(cb func(AppInfo, AppInfo) bool) {	113		func (x *AppInfoIface) OverrideEqual(cb func(AppInfo, AppInfo) bool) {
114		if cb == nil {	114		if cb == nil {

@@ -120,7 +120,7 @@ func (x *AppInfoIface) OverrideEqual(cb func(AppInfo, AppInfo) bool) {
120		}	120		}
121		}	121		}
122			122
123	-	// GetEqual gets the callback function.	123	+	// GetEqual gets the "equal" callback function.
124		// Checks two [iface@Gio.AppInfo]s for equality.	124		// Checks two [iface@Gio.AppInfo]s for equality.
125		func (x *AppInfoIface) GetEqual() func(AppInfo, AppInfo) bool {	125		func (x *AppInfoIface) GetEqual() func(AppInfo, AppInfo) bool {
126		if x.xEqual == 0 {	126		if x.xEqual == 0 {

@@ -133,7 +133,7 @@ func (x *AppInfoIface) GetEqual() func(AppInfo, AppInfo) bool {
133		}	133		}
134		}	134		}
135			135
136	-	// OverrideGetId sets the callback function.	136	+	// OverrideGetId sets the "get_id" callback function.
137		// Gets a string identifier for a [iface@Gio.AppInfo].	137		// Gets a string identifier for a [iface@Gio.AppInfo].
138		func (x *AppInfoIface) OverrideGetId(cb func(AppInfo) string) {	138		func (x *AppInfoIface) OverrideGetId(cb func(AppInfo) string) {
139		if cb == nil {	139		if cb == nil {

@@ -145,7 +145,7 @@ func (x *AppInfoIface) OverrideGetId(cb func(AppInfo) string) {
145		}	145		}
146		}	146		}
147			147
148	-	// GetGetId gets the callback function.	148	+	// GetGetId gets the "get_id" callback function.
149		// Gets a string identifier for a [iface@Gio.AppInfo].	149		// Gets a string identifier for a [iface@Gio.AppInfo].
150		func (x *AppInfoIface) GetGetId() func(AppInfo) string {	150		func (x *AppInfoIface) GetGetId() func(AppInfo) string {
151		if x.xGetId == 0 {	151		if x.xGetId == 0 {

@@ -158,7 +158,7 @@ func (x *AppInfoIface) GetGetId() func(AppInfo) string {
158		}	158		}
159		}	159		}
160			160
161	-	// OverrideGetName sets the callback function.	161	+	// OverrideGetName sets the "get_name" callback function.
162		// Gets the name of the application for a [iface@Gio.AppInfo].	162		// Gets the name of the application for a [iface@Gio.AppInfo].
163		func (x *AppInfoIface) OverrideGetName(cb func(AppInfo) string) {	163		func (x *AppInfoIface) OverrideGetName(cb func(AppInfo) string) {
164		if cb == nil {	164		if cb == nil {

@@ -170,7 +170,7 @@ func (x *AppInfoIface) OverrideGetName(cb func(AppInfo) string) {
170		}	170		}
171		}	171		}
172			172
173	-	// GetGetName gets the callback function.	173	+	// GetGetName gets the "get_name" callback function.
174		// Gets the name of the application for a [iface@Gio.AppInfo].	174		// Gets the name of the application for a [iface@Gio.AppInfo].
175		func (x *AppInfoIface) GetGetName() func(AppInfo) string {	175		func (x *AppInfoIface) GetGetName() func(AppInfo) string {
176		if x.xGetName == 0 {	176		if x.xGetName == 0 {

@@ -183,7 +183,7 @@ func (x *AppInfoIface) GetGetName() func(AppInfo) string {
183		}	183		}
184		}	184		}
185			185
186	-	// OverrideGetDescription sets the callback function.	186	+	// OverrideGetDescription sets the "get_description" callback function.
187		// Gets a short description for the application described by	187		// Gets a short description for the application described by
188		//	188		//
189		// the [iface@Gio.AppInfo].	189		// the [iface@Gio.AppInfo].

@@ -197,7 +197,7 @@ func (x *AppInfoIface) OverrideGetDescription(cb func(AppInfo) string) {
197		}	197		}
198		}	198		}
199			199
200	-	// GetGetDescription gets the callback function.	200	+	// GetGetDescription gets the "get_description" callback function.
201		// Gets a short description for the application described by	201		// Gets a short description for the application described by
202		//	202		//
203		// the [iface@Gio.AppInfo].	203		// the [iface@Gio.AppInfo].

@@ -212,7 +212,7 @@ func (x *AppInfoIface) GetGetDescription() func(AppInfo) string {
212		}	212		}
213		}	213		}
214			214
215	-	// OverrideGetExecutable sets the callback function.	215	+	// OverrideGetExecutable sets the "get_executable" callback function.
216		// Gets the executable name for the [iface@Gio.AppInfo].	216		// Gets the executable name for the [iface@Gio.AppInfo].
217		func (x *AppInfoIface) OverrideGetExecutable(cb func(AppInfo) string) {	217		func (x *AppInfoIface) OverrideGetExecutable(cb func(AppInfo) string) {
218		if cb == nil {	218		if cb == nil {

@@ -224,7 +224,7 @@ func (x *AppInfoIface) OverrideGetExecutable(cb func(AppInfo) string) {
224		}	224		}
225		}	225		}
226			226
227	-	// GetGetExecutable gets the callback function.	227	+	// GetGetExecutable gets the "get_executable" callback function.
228		// Gets the executable name for the [iface@Gio.AppInfo].	228		// Gets the executable name for the [iface@Gio.AppInfo].
229		func (x *AppInfoIface) GetGetExecutable() func(AppInfo) string {	229		func (x *AppInfoIface) GetGetExecutable() func(AppInfo) string {
230		if x.xGetExecutable == 0 {	230		if x.xGetExecutable == 0 {

@@ -237,7 +237,7 @@ func (x *AppInfoIface) GetGetExecutable() func(AppInfo) string {
237		}	237		}
238		}	238		}
239			239
240	-	// OverrideGetIcon sets the callback function.	240	+	// OverrideGetIcon sets the "get_icon" callback function.
241		// Gets the [iface@Gio.Icon] for the [iface@Gio.AppInfo].	241		// Gets the [iface@Gio.Icon] for the [iface@Gio.AppInfo].
242		func (x AppInfoIface) OverrideGetIcon(cb func(AppInfo) IconBase) {	242		func (x AppInfoIface) OverrideGetIcon(cb func(AppInfo) IconBase) {
243		if cb == nil {	243		if cb == nil {

@@ -253,7 +253,7 @@ func (x AppInfoIface) OverrideGetIcon(cb func(AppInfo) IconBase) {
253		}	253		}
254		}	254		}
255			255
256	-	// GetGetIcon gets the callback function.	256	+	// GetGetIcon gets the "get_icon" callback function.
257		// Gets the [iface@Gio.Icon] for the [iface@Gio.AppInfo].	257		// Gets the [iface@Gio.Icon] for the [iface@Gio.AppInfo].
258		func (x AppInfoIface) GetGetIcon() func(AppInfo) IconBase {	258		func (x AppInfoIface) GetGetIcon() func(AppInfo) IconBase {
259		if x.xGetIcon == 0 {	259		if x.xGetIcon == 0 {

@@ -272,7 +272,7 @@ func (x AppInfoIface) GetGetIcon() func(AppInfo) IconBase {
272		}	272		}
273		}	273		}
274			274
275	-	// OverrideLaunch sets the callback function.	275	+	// OverrideLaunch sets the "launch" callback function.
276		// Launches an application specified by the [iface@Gio.AppInfo].	276		// Launches an application specified by the [iface@Gio.AppInfo].
277		func (x AppInfoIface) OverrideLaunch(cb func(AppInfo, glib.List, *AppLaunchContext) bool) {	277		func (x AppInfoIface) OverrideLaunch(cb func(AppInfo, glib.List, *AppLaunchContext) bool) {
278		if cb == nil {	278		if cb == nil {

@@ -284,7 +284,7 @@ func (x AppInfoIface) OverrideLaunch(cb func(AppInfo, glib.List, *AppLaunchCon
284		}	284		}
285		}	285		}
286			286
287	-	// GetLaunch gets the callback function.	287	+	// GetLaunch gets the "launch" callback function.
288		// Launches an application specified by the [iface@Gio.AppInfo].	288		// Launches an application specified by the [iface@Gio.AppInfo].
289		func (x AppInfoIface) GetLaunch() func(AppInfo, glib.List, *AppLaunchContext) bool {	289		func (x AppInfoIface) GetLaunch() func(AppInfo, glib.List, *AppLaunchContext) bool {
290		if x.xLaunch == 0 {	290		if x.xLaunch == 0 {

@@ -297,7 +297,7 @@ func (x AppInfoIface) GetLaunch() func(AppInfo, glib.List, *AppLaunchContext)
297		}	297		}
298		}	298		}
299			299
300	-	// OverrideSupportsUris sets the callback function.	300	+	// OverrideSupportsUris sets the "supports_uris" callback function.
301		// Indicates whether the application specified supports	301		// Indicates whether the application specified supports
302		//	302		//
303		// launching URIs.	303		// launching URIs.

@@ -311,7 +311,7 @@ func (x *AppInfoIface) OverrideSupportsUris(cb func(AppInfo) bool) {
311		}	311		}
312		}	312		}
313			313
314	-	// GetSupportsUris gets the callback function.	314	+	// GetSupportsUris gets the "supports_uris" callback function.
315		// Indicates whether the application specified supports	315		// Indicates whether the application specified supports
316		//	316		//
317		// launching URIs.	317		// launching URIs.

@@ -326,7 +326,7 @@ func (x *AppInfoIface) GetSupportsUris() func(AppInfo) bool {
326		}	326		}
327		}	327		}
328			328
329	-	// OverrideSupportsFiles sets the callback function.	329	+	// OverrideSupportsFiles sets the "supports_files" callback function.
330		// Indicates whether the application specified accepts	330		// Indicates whether the application specified accepts
331		//	331		//
332		// filename arguments.	332		// filename arguments.

@@ -340,7 +340,7 @@ func (x *AppInfoIface) OverrideSupportsFiles(cb func(AppInfo) bool) {
340		}	340		}
341		}	341		}
342			342
343	-	// GetSupportsFiles gets the callback function.	343	+	// GetSupportsFiles gets the "supports_files" callback function.
344		// Indicates whether the application specified accepts	344		// Indicates whether the application specified accepts
345		//	345		//
346		// filename arguments.	346		// filename arguments.

@@ -355,7 +355,7 @@ func (x *AppInfoIface) GetSupportsFiles() func(AppInfo) bool {
355		}	355		}
356		}	356		}
357			357
358	-	// OverrideLaunchUris sets the callback function.	358	+	// OverrideLaunchUris sets the "launch_uris" callback function.
359		// Launches an application with a list of URIs.	359		// Launches an application with a list of URIs.
360		func (x AppInfoIface) OverrideLaunchUris(cb func(AppInfo, glib.List, *AppLaunchContext) bool) {	360		func (x AppInfoIface) OverrideLaunchUris(cb func(AppInfo, glib.List, *AppLaunchContext) bool) {
361		if cb == nil {	361		if cb == nil {

@@ -367,7 +367,7 @@ func (x AppInfoIface) OverrideLaunchUris(cb func(AppInfo, glib.List, *AppLaunc
367		}	367		}
368		}	368		}
369			369
370	-	// GetLaunchUris gets the callback function.	370	+	// GetLaunchUris gets the "launch_uris" callback function.
371		// Launches an application with a list of URIs.	371		// Launches an application with a list of URIs.
372		func (x AppInfoIface) GetLaunchUris() func(AppInfo, glib.List, *AppLaunchContext) bool {	372		func (x AppInfoIface) GetLaunchUris() func(AppInfo, glib.List, *AppLaunchContext) bool {
373		if x.xLaunchUris == 0 {	373		if x.xLaunchUris == 0 {

@@ -380,7 +380,7 @@ func (x AppInfoIface) GetLaunchUris() func(AppInfo, glib.List, *AppLaunchConte
380		}	380		}
381		}	381		}
382			382
383	-	// OverrideShouldShow sets the callback function.	383	+	// OverrideShouldShow sets the "should_show" callback function.
384		// Returns whether an application should be shown (e.g. when	384		// Returns whether an application should be shown (e.g. when
385		//	385		//
386		// getting a list of installed applications).	386		// getting a list of installed applications).

@@ -395,7 +395,7 @@ func (x *AppInfoIface) OverrideShouldShow(cb func(AppInfo) bool) {
395		}	395		}
396		}	396		}
397			397
398	-	// GetShouldShow gets the callback function.	398	+	// GetShouldShow gets the "should_show" callback function.
399		// Returns whether an application should be shown (e.g. when	399		// Returns whether an application should be shown (e.g. when
400		//	400		//
401		// getting a list of installed applications).	401		// getting a list of installed applications).

@@ -411,7 +411,7 @@ func (x *AppInfoIface) GetShouldShow() func(AppInfo) bool {
411		}	411		}
412		}	412		}
413			413
414	-	// OverrideSetAsDefaultForType sets the callback function.	414	+	// OverrideSetAsDefaultForType sets the "set_as_default_for_type" callback function.
415		// Sets an application as default for a given content	415		// Sets an application as default for a given content
416		//	416		//
417		// type.	417		// type.

@@ -425,7 +425,7 @@ func (x *AppInfoIface) OverrideSetAsDefaultForType(cb func(AppInfo, string) bool
425		}	425		}
426		}	426		}
427			427
428	-	// GetSetAsDefaultForType gets the callback function.	428	+	// GetSetAsDefaultForType gets the "set_as_default_for_type" callback function.
429		// Sets an application as default for a given content	429		// Sets an application as default for a given content
430		//	430		//
431		// type.	431		// type.

@@ -440,7 +440,7 @@ func (x *AppInfoIface) GetSetAsDefaultForType() func(AppInfo, string) bool {
440		}	440		}
441		}	441		}
442			442
443	-	// OverrideSetAsDefaultForExtension sets the callback function.	443	+	// OverrideSetAsDefaultForExtension sets the "set_as_default_for_extension" callback function.
444		// Sets an application as default for a given	444		// Sets an application as default for a given
445		//	445		//
446		// file extension.	446		// file extension.

@@ -454,7 +454,7 @@ func (x *AppInfoIface) OverrideSetAsDefaultForExtension(cb func(AppInfo, string)
454		}	454		}
455		}	455		}
456			456
457	-	// GetSetAsDefaultForExtension gets the callback function.	457	+	// GetSetAsDefaultForExtension gets the "set_as_default_for_extension" callback function.
458		// Sets an application as default for a given	458		// Sets an application as default for a given
459		//	459		//
460		// file extension.	460		// file extension.

@@ -469,7 +469,7 @@ func (x *AppInfoIface) GetSetAsDefaultForExtension() func(AppInfo, string) bool
469		}	469		}
470		}	470		}
471			471
472	-	// OverrideAddSupportsType sets the callback function.	472	+	// OverrideAddSupportsType sets the "add_supports_type" callback function.
473		// Adds to the [iface@Gio.AppInfo] information about	473		// Adds to the [iface@Gio.AppInfo] information about
474		//	474		//
475		// supported file types.	475		// supported file types.

@@ -483,7 +483,7 @@ func (x *AppInfoIface) OverrideAddSupportsType(cb func(AppInfo, string) bool) {
483		}	483		}
484		}	484		}
485			485
486	-	// GetAddSupportsType gets the callback function.	486	+	// GetAddSupportsType gets the "add_supports_type" callback function.
487		// Adds to the [iface@Gio.AppInfo] information about	487		// Adds to the [iface@Gio.AppInfo] information about
488		//	488		//
489		// supported file types.	489		// supported file types.

@@ -498,7 +498,7 @@ func (x *AppInfoIface) GetAddSupportsType() func(AppInfo, string) bool {
498		}	498		}
499		}	499		}
500			500
501	-	// OverrideCanRemoveSupportsType sets the callback function.	501	+	// OverrideCanRemoveSupportsType sets the "can_remove_supports_type" callback function.
502		// Checks for support for removing supported file	502		// Checks for support for removing supported file
503		//	503		//
504		// types from a [iface@Gio.AppInfo].	504		// types from a [iface@Gio.AppInfo].

@@ -512,7 +512,7 @@ func (x *AppInfoIface) OverrideCanRemoveSupportsType(cb func(AppInfo) bool) {
512		}	512		}
513		}	513		}
514			514
515	-	// GetCanRemoveSupportsType gets the callback function.	515	+	// GetCanRemoveSupportsType gets the "can_remove_supports_type" callback function.
516		// Checks for support for removing supported file	516		// Checks for support for removing supported file
517		//	517		//
518		// types from a [iface@Gio.AppInfo].	518		// types from a [iface@Gio.AppInfo].

@@ -527,7 +527,7 @@ func (x *AppInfoIface) GetCanRemoveSupportsType() func(AppInfo) bool {
527		}	527		}
528		}	528		}
529			529
530	-	// OverrideRemoveSupportsType sets the callback function.	530	+	// OverrideRemoveSupportsType sets the "remove_supports_type" callback function.
531		// Removes a supported application type from a	531		// Removes a supported application type from a
532		//	532		//
533		// [iface@Gio.AppInfo].	533		// [iface@Gio.AppInfo].

@@ -541,7 +541,7 @@ func (x *AppInfoIface) OverrideRemoveSupportsType(cb func(AppInfo, string) bool)
541		}	541		}
542		}	542		}
543			543
544	-	// GetRemoveSupportsType gets the callback function.	544	+	// GetRemoveSupportsType gets the "remove_supports_type" callback function.
545		// Removes a supported application type from a	545		// Removes a supported application type from a
546		//	546		//
547		// [iface@Gio.AppInfo].	547		// [iface@Gio.AppInfo].

@@ -556,7 +556,7 @@ func (x *AppInfoIface) GetRemoveSupportsType() func(AppInfo, string) bool {
556		}	556		}
557		}	557		}
558			558
559	-	// OverrideCanDelete sets the callback function.	559	+	// OverrideCanDelete sets the "can_delete" callback function.
560		// Checks if a [iface@Gio.AppInfo] can be deleted. (Since 2.20)	560		// Checks if a [iface@Gio.AppInfo] can be deleted. (Since 2.20)
561		func (x *AppInfoIface) OverrideCanDelete(cb func(AppInfo) bool) {	561		func (x *AppInfoIface) OverrideCanDelete(cb func(AppInfo) bool) {
562		if cb == nil {	562		if cb == nil {

@@ -568,7 +568,7 @@ func (x *AppInfoIface) OverrideCanDelete(cb func(AppInfo) bool) {
568		}	568		}
569		}	569		}
570			570
571	-	// GetCanDelete gets the callback function.	571	+	// GetCanDelete gets the "can_delete" callback function.
572		// Checks if a [iface@Gio.AppInfo] can be deleted. (Since 2.20)	572		// Checks if a [iface@Gio.AppInfo] can be deleted. (Since 2.20)
573		func (x *AppInfoIface) GetCanDelete() func(AppInfo) bool {	573		func (x *AppInfoIface) GetCanDelete() func(AppInfo) bool {
574		if x.xCanDelete == 0 {	574		if x.xCanDelete == 0 {

@@ -581,7 +581,7 @@ func (x *AppInfoIface) GetCanDelete() func(AppInfo) bool {
581		}	581		}
582		}	582		}
583			583
584	-	// OverrideDoDelete sets the callback function.	584	+	// OverrideDoDelete sets the "do_delete" callback function.
585		// Deletes a [iface@Gio.AppInfo]. (Since 2.20)	585		// Deletes a [iface@Gio.AppInfo]. (Since 2.20)
586		func (x *AppInfoIface) OverrideDoDelete(cb func(AppInfo) bool) {	586		func (x *AppInfoIface) OverrideDoDelete(cb func(AppInfo) bool) {
587		if cb == nil {	587		if cb == nil {

@@ -593,7 +593,7 @@ func (x *AppInfoIface) OverrideDoDelete(cb func(AppInfo) bool) {
593		}	593		}
594		}	594		}
595			595
596	-	// GetDoDelete gets the callback function.	596	+	// GetDoDelete gets the "do_delete" callback function.
597		// Deletes a [iface@Gio.AppInfo]. (Since 2.20)	597		// Deletes a [iface@Gio.AppInfo]. (Since 2.20)
598		func (x *AppInfoIface) GetDoDelete() func(AppInfo) bool {	598		func (x *AppInfoIface) GetDoDelete() func(AppInfo) bool {
599		if x.xDoDelete == 0 {	599		if x.xDoDelete == 0 {

@@ -606,7 +606,7 @@ func (x *AppInfoIface) GetDoDelete() func(AppInfo) bool {
606		}	606		}
607		}	607		}
608			608
609	-	// OverrideGetCommandline sets the callback function.	609	+	// OverrideGetCommandline sets the "get_commandline" callback function.
610		// Gets the commandline for the [iface@Gio.AppInfo].	610		// Gets the commandline for the [iface@Gio.AppInfo].
611		//	611		//
612		// (Since 2.20)	612		// (Since 2.20)

@@ -620,7 +620,7 @@ func (x *AppInfoIface) OverrideGetCommandline(cb func(AppInfo) string) {
620		}	620		}
621		}	621		}
622			622
623	-	// GetGetCommandline gets the callback function.	623	+	// GetGetCommandline gets the "get_commandline" callback function.
624		// Gets the commandline for the [iface@Gio.AppInfo].	624		// Gets the commandline for the [iface@Gio.AppInfo].
625		//	625		//
626		// (Since 2.20)	626		// (Since 2.20)

@@ -635,7 +635,7 @@ func (x *AppInfoIface) GetGetCommandline() func(AppInfo) string {
635		}	635		}
636		}	636		}
637			637
638	-	// OverrideGetDisplayName sets the callback function.	638	+	// OverrideGetDisplayName sets the "get_display_name" callback function.
639		// Gets the display name for the [iface@Gio.AppInfo].	639		// Gets the display name for the [iface@Gio.AppInfo].
640		//	640		//
641		// (Since 2.24)	641		// (Since 2.24)

@@ -649,7 +649,7 @@ func (x *AppInfoIface) OverrideGetDisplayName(cb func(AppInfo) string) {
649		}	649		}
650		}	650		}
651			651
652	-	// GetGetDisplayName gets the callback function.	652	+	// GetGetDisplayName gets the "get_display_name" callback function.
653		// Gets the display name for the [iface@Gio.AppInfo].	653		// Gets the display name for the [iface@Gio.AppInfo].
654		//	654		//
655		// (Since 2.24)	655		// (Since 2.24)

@@ -664,7 +664,7 @@ func (x *AppInfoIface) GetGetDisplayName() func(AppInfo) string {
664		}	664		}
665		}	665		}
666			666
667	-	// OverrideSetAsLastUsedForType sets the callback function.	667	+	// OverrideSetAsLastUsedForType sets the "set_as_last_used_for_type" callback function.
668		// Sets the application as the last used. See	668		// Sets the application as the last used. See
669		//	669		//
670		// [method@Gio.AppInfo.set_as_last_used_for_type].	670		// [method@Gio.AppInfo.set_as_last_used_for_type].

@@ -678,7 +678,7 @@ func (x *AppInfoIface) OverrideSetAsLastUsedForType(cb func(AppInfo, string) boo
678		}	678		}
679		}	679		}
680			680
681	-	// GetSetAsLastUsedForType gets the callback function.	681	+	// GetSetAsLastUsedForType gets the "set_as_last_used_for_type" callback function.
682		// Sets the application as the last used. See	682		// Sets the application as the last used. See
683		//	683		//
684		// [method@Gio.AppInfo.set_as_last_used_for_type].	684		// [method@Gio.AppInfo.set_as_last_used_for_type].

@@ -693,7 +693,7 @@ func (x *AppInfoIface) GetSetAsLastUsedForType() func(AppInfo, string) bool {
693		}	693		}
694		}	694		}
695			695
696	-	// OverrideGetSupportedTypes sets the callback function.	696	+	// OverrideGetSupportedTypes sets the "get_supported_types" callback function.
697		// Retrieves the list of content types that @app_info	697		// Retrieves the list of content types that @app_info
698		//	698		//
699		// claims to support.	699		// claims to support.

@@ -707,7 +707,7 @@ func (x *AppInfoIface) OverrideGetSupportedTypes(cb func(AppInfo) []string) {
707		}	707		}
708		}	708		}
709			709
710	-	// GetGetSupportedTypes gets the callback function.	710	+	// GetGetSupportedTypes gets the "get_supported_types" callback function.
711		// Retrieves the list of content types that @app_info	711		// Retrieves the list of content types that @app_info
712		//	712		//
713		// claims to support.	713		// claims to support.

@@ -722,7 +722,7 @@ func (x *AppInfoIface) GetGetSupportedTypes() func(AppInfo) []string {
722		}	722		}
723		}	723		}
724			724
725	-	// OverrideLaunchUrisAsync sets the callback function.	725	+	// OverrideLaunchUrisAsync sets the "launch_uris_async" callback function.
726		// Asynchronously launches an application with a list of	726		// Asynchronously launches an application with a list of
727		//	727		//
728		// URIs. (Since: 2.60)	728		// URIs. (Since: 2.60)

@@ -736,7 +736,7 @@ func (x AppInfoIface) OverrideLaunchUrisAsync(cb func(AppInfo, glib.List, *App
736		}	736		}
737		}	737		}
738			738
739	-	// GetLaunchUrisAsync gets the callback function.	739	+	// GetLaunchUrisAsync gets the "launch_uris_async" callback function.
740		// Asynchronously launches an application with a list of	740		// Asynchronously launches an application with a list of
741		//	741		//
742		// URIs. (Since: 2.60)	742		// URIs. (Since: 2.60)

@@ -751,7 +751,7 @@ func (x AppInfoIface) GetLaunchUrisAsync() func(AppInfo, glib.List, *AppLaunch
751		}	751		}
752		}	752		}
753			753
754	-	// OverrideLaunchUrisFinish sets the callback function.	754	+	// OverrideLaunchUrisFinish sets the "launch_uris_finish" callback function.
755		// Finishes an operation started with @launch_uris_async.	755		// Finishes an operation started with @launch_uris_async.
756		//	756		//
757		// (Since: 2.60)	757		// (Since: 2.60)

@@ -765,7 +765,7 @@ func (x *AppInfoIface) OverrideLaunchUrisFinish(cb func(AppInfo, AsyncResult) bo
765		}	765		}
766		}	766		}
767			767
768	-	// GetLaunchUrisFinish gets the callback function.	768	+	// GetLaunchUrisFinish gets the "launch_uris_finish" callback function.
769		// Finishes an operation started with @launch_uris_async.	769		// Finishes an operation started with @launch_uris_async.
770		//	770		//
771		// (Since: 2.60)	771		// (Since: 2.60)

@@ -806,7 +806,7 @@ func (x *AppLaunchContextClass) GoPointer() uintptr {
806		return uintptr(unsafe.Pointer(x))	806		return uintptr(unsafe.Pointer(x))
807		}	807		}
808			808
809	-	// OverrideGetDisplay sets the callback function.	809	+	// OverrideGetDisplay sets the "get_display" callback function.
810		func (x AppLaunchContextClass) OverrideGetDisplay(cb func(AppLaunchContext, AppInfo, *glib.List) string) {	810		func (x AppLaunchContextClass) OverrideGetDisplay(cb func(AppLaunchContext, AppInfo, *glib.List) string) {
811		if cb == nil {	811		if cb == nil {
812		x.xGetDisplay = 0	812		x.xGetDisplay = 0

@@ -817,7 +817,7 @@ func (x AppLaunchContextClass) OverrideGetDisplay(cb func(AppLaunchContext, Ap
817		}	817		}
818		}	818		}
819			819
820	-	// GetGetDisplay gets the callback function.	820	+	// GetGetDisplay gets the "get_display" callback function.
821		func (x AppLaunchContextClass) GetGetDisplay() func(AppLaunchContext, AppInfo, *glib.List) string {	821		func (x AppLaunchContextClass) GetGetDisplay() func(AppLaunchContext, AppInfo, *glib.List) string {
822		if x.xGetDisplay == 0 {	822		if x.xGetDisplay == 0 {
823		return nil	823		return nil

@@ -829,7 +829,7 @@ func (x AppLaunchContextClass) GetGetDisplay() func(AppLaunchContext, AppInfo,
829		}	829		}
830		}	830		}
831			831
832	-	// OverrideGetStartupNotifyId sets the callback function.	832	+	// OverrideGetStartupNotifyId sets the "get_startup_notify_id" callback function.
833		func (x AppLaunchContextClass) OverrideGetStartupNotifyId(cb func(AppLaunchContext, AppInfo, *glib.List) string) {	833		func (x AppLaunchContextClass) OverrideGetStartupNotifyId(cb func(AppLaunchContext, AppInfo, *glib.List) string) {
834		if cb == nil {	834		if cb == nil {
835		x.xGetStartupNotifyId = 0	835		x.xGetStartupNotifyId = 0

@@ -840,7 +840,7 @@ func (x AppLaunchContextClass) OverrideGetStartupNotifyId(cb func(AppLaunchCon
840		}	840		}
841		}	841		}
842			842
843	-	// GetGetStartupNotifyId gets the callback function.	843	+	// GetGetStartupNotifyId gets the "get_startup_notify_id" callback function.
844		func (x AppLaunchContextClass) GetGetStartupNotifyId() func(AppLaunchContext, AppInfo, *glib.List) string {	844		func (x AppLaunchContextClass) GetGetStartupNotifyId() func(AppLaunchContext, AppInfo, *glib.List) string {
845		if x.xGetStartupNotifyId == 0 {	845		if x.xGetStartupNotifyId == 0 {
846		return nil	846		return nil

@@ -852,7 +852,7 @@ func (x AppLaunchContextClass) GetGetStartupNotifyId() func(AppLaunchContext,
852		}	852		}
853		}	853		}
854			854
855	-	// OverrideLaunchFailed sets the callback function.	855	+	// OverrideLaunchFailed sets the "launch_failed" callback function.
856		func (x AppLaunchContextClass) OverrideLaunchFailed(cb func(AppLaunchContext, string)) {	856		func (x AppLaunchContextClass) OverrideLaunchFailed(cb func(AppLaunchContext, string)) {
857		if cb == nil {	857		if cb == nil {
858		x.xLaunchFailed = 0	858		x.xLaunchFailed = 0

@@ -863,7 +863,7 @@ func (x AppLaunchContextClass) OverrideLaunchFailed(cb func(AppLaunchContext,
863		}	863		}
864		}	864		}
865			865
866	-	// GetLaunchFailed gets the callback function.	866	+	// GetLaunchFailed gets the "launch_failed" callback function.
867		func (x AppLaunchContextClass) GetLaunchFailed() func(AppLaunchContext, string) {	867		func (x AppLaunchContextClass) GetLaunchFailed() func(AppLaunchContext, string) {
868		if x.xLaunchFailed == 0 {	868		if x.xLaunchFailed == 0 {
869		return nil	869		return nil

@@ -875,7 +875,7 @@ func (x AppLaunchContextClass) GetLaunchFailed() func(AppLaunchContext, string
875		}	875		}
876		}	876		}
877			877
878	-	// OverrideLaunched sets the callback function.	878	+	// OverrideLaunched sets the "launched" callback function.
879		func (x AppLaunchContextClass) OverrideLaunched(cb func(AppLaunchContext, AppInfo, *glib.Variant)) {	879		func (x AppLaunchContextClass) OverrideLaunched(cb func(AppLaunchContext, AppInfo, *glib.Variant)) {
880		if cb == nil {	880		if cb == nil {
881		x.xLaunched = 0	881		x.xLaunched = 0

@@ -886,7 +886,7 @@ func (x AppLaunchContextClass) OverrideLaunched(cb func(AppLaunchContext, AppI
886		}	886		}
887		}	887		}
888			888
889	-	// GetLaunched gets the callback function.	889	+	// GetLaunched gets the "launched" callback function.
890		func (x AppLaunchContextClass) GetLaunched() func(AppLaunchContext, AppInfo, *glib.Variant) {	890		func (x AppLaunchContextClass) GetLaunched() func(AppLaunchContext, AppInfo, *glib.Variant) {
891		if x.xLaunched == 0 {	891		if x.xLaunched == 0 {
892		return nil	892		return nil

@@ -898,7 +898,7 @@ func (x AppLaunchContextClass) GetLaunched() func(AppLaunchContext, AppInfo, *
898		}	898		}
899		}	899		}
900			900
901	-	// OverrideLaunchStarted sets the callback function.	901	+	// OverrideLaunchStarted sets the "launch_started" callback function.
902		func (x AppLaunchContextClass) OverrideLaunchStarted(cb func(AppLaunchContext, AppInfo, *glib.Variant)) {	902		func (x AppLaunchContextClass) OverrideLaunchStarted(cb func(AppLaunchContext, AppInfo, *glib.Variant)) {
903		if cb == nil {	903		if cb == nil {
904		x.xLaunchStarted = 0	904		x.xLaunchStarted = 0

@@ -909,7 +909,7 @@ func (x AppLaunchContextClass) OverrideLaunchStarted(cb func(AppLaunchContext,
909		}	909		}
910		}	910		}
911			911
912	-	// GetLaunchStarted gets the callback function.	912	+	// GetLaunchStarted gets the "launch_started" callback function.
913		func (x AppLaunchContextClass) GetLaunchStarted() func(AppLaunchContext, AppInfo, *glib.Variant) {	913		func (x AppLaunchContextClass) GetLaunchStarted() func(AppLaunchContext, AppInfo, *glib.Variant) {
914		if x.xLaunchStarted == 0 {	914		if x.xLaunchStarted == 0 {
915		return nil	915		return nil

@@ -921,7 +921,7 @@ func (x AppLaunchContextClass) GetLaunchStarted() func(AppLaunchContext, AppIn
921		}	921		}
922		}	922		}
923			923
924	-	// OverrideGReserved1 sets the callback function.	924	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
925		func (x *AppLaunchContextClass) OverrideGReserved1(cb func()) {	925		func (x *AppLaunchContextClass) OverrideGReserved1(cb func()) {
926		if cb == nil {	926		if cb == nil {
927		x.xGReserved1 = 0	927		x.xGReserved1 = 0

@@ -932,7 +932,7 @@ func (x *AppLaunchContextClass) OverrideGReserved1(cb func()) {
932		}	932		}
933		}	933		}
934			934
935	-	// GetGReserved1 gets the callback function.	935	+	// GetGReserved1 gets the "_g_reserved1" callback function.
936		func (x *AppLaunchContextClass) GetGReserved1() func() {	936		func (x *AppLaunchContextClass) GetGReserved1() func() {
937		if x.xGReserved1 == 0 {	937		if x.xGReserved1 == 0 {
938		return nil	938		return nil

@@ -944,7 +944,7 @@ func (x *AppLaunchContextClass) GetGReserved1() func() {
944		}	944		}
945		}	945		}
946			946
947	-	// OverrideGReserved2 sets the callback function.	947	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
948		func (x *AppLaunchContextClass) OverrideGReserved2(cb func()) {	948		func (x *AppLaunchContextClass) OverrideGReserved2(cb func()) {
949		if cb == nil {	949		if cb == nil {
950		x.xGReserved2 = 0	950		x.xGReserved2 = 0

@@ -955,7 +955,7 @@ func (x *AppLaunchContextClass) OverrideGReserved2(cb func()) {
955		}	955		}
956		}	956		}
957			957
958	-	// GetGReserved2 gets the callback function.	958	+	// GetGReserved2 gets the "_g_reserved2" callback function.
959		func (x *AppLaunchContextClass) GetGReserved2() func() {	959		func (x *AppLaunchContextClass) GetGReserved2() func() {
960		if x.xGReserved2 == 0 {	960		if x.xGReserved2 == 0 {
961		return nil	961		return nil

@@ -967,7 +967,7 @@ func (x *AppLaunchContextClass) GetGReserved2() func() {
967		}	967		}
968		}	968		}
969			969
970	-	// OverrideGReserved3 sets the callback function.	970	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
971		func (x *AppLaunchContextClass) OverrideGReserved3(cb func()) {	971		func (x *AppLaunchContextClass) OverrideGReserved3(cb func()) {
972		if cb == nil {	972		if cb == nil {
973		x.xGReserved3 = 0	973		x.xGReserved3 = 0

@@ -978,7 +978,7 @@ func (x *AppLaunchContextClass) OverrideGReserved3(cb func()) {
978		}	978		}
979		}	979		}
980			980
981	-	// GetGReserved3 gets the callback function.	981	+	// GetGReserved3 gets the "_g_reserved3" callback function.
982		func (x *AppLaunchContextClass) GetGReserved3() func() {	982		func (x *AppLaunchContextClass) GetGReserved3() func() {
983		if x.xGReserved3 == 0 {	983		if x.xGReserved3 == 0 {
984		return nil	984		return nil

M v4/gio/gapplication.go +129 -36

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideStartup sets the callback function.
+// OverrideStartup sets the "startup" callback function.
 // invoked on the primary instance immediately after registration
 func (x *ApplicationClass) OverrideStartup(cb func(*Application)) {
 	if cb == nil {
 	}
 }
-// GetStartup gets the callback function.
+// GetStartup gets the "startup" callback function.
 // invoked on the primary instance immediately after registration
 func (x *ApplicationClass) GetStartup() func(*Application) {
 	if x.xStartup == 0 {
 	}
 }
-// OverrideActivate sets the callback function.
+// OverrideActivate sets the "activate" callback function.
 // invoked on the primary instance when an activation occurs
 func (x *ApplicationClass) OverrideActivate(cb func(*Application)) {
 	if cb == nil {
 	}
 }
-// GetActivate gets the callback function.
+// GetActivate gets the "activate" callback function.
 // invoked on the primary instance when an activation occurs
 func (x *ApplicationClass) GetActivate() func(*Application) {
 	if x.xActivate == 0 {
 	}
 }
-// OverrideOpen sets the callback function.
+// OverrideOpen sets the "open" callback function.
 // invoked on the primary instance when there are files to open
 func (x *ApplicationClass) OverrideOpen(cb func(*Application, uintptr, int, string)) {
 	if cb == nil {
 	}
 }
-// GetOpen gets the callback function.
+// GetOpen gets the "open" callback function.
 // invoked on the primary instance when there are files to open
 func (x *ApplicationClass) GetOpen() func(*Application, uintptr, int, string) {
 	if x.xOpen == 0 {
 	}
 }
-// OverrideCommandLine sets the callback function.
+// OverrideCommandLine sets the "command_line" callback function.
 // invoked on the primary instance when a command-line is
 //
 //	not handled locally
 	}
 }
-// GetCommandLine gets the callback function.
+// GetCommandLine gets the "command_line" callback function.
 // invoked on the primary instance when a command-line is
 //
 //	not handled locally
 	}
 }
-// OverrideLocalCommandLine sets the callback function.
+// OverrideLocalCommandLine sets the "local_command_line" callback function.
 // invoked (locally). The virtual function has the chance
 //
 //	to inspect (and possibly replace) command line arguments. See
 //	g_application_run() for more information. Also see the
 //	#GApplication::handle-local-options signal, which is a simpler
 //	alternative to handling some commandline options locally
-func (x *ApplicationClass) OverrideLocalCommandLine(cb func(*Application, []string, int) bool) {
+func (x *ApplicationClass) OverrideLocalCommandLine(cb func(*Application, []string, *int) bool) {
 	if cb == nil {
 		x.xLocalCommandLine = 0
 	} else {
-		x.xLocalCommandLine = purego.NewCallback(func(ApplicationVarp uintptr, ArgumentsVarp []string, ExitStatusVarp int) bool {
+		x.xLocalCommandLine = purego.NewCallback(func(ApplicationVarp uintptr, ArgumentsVarp []string, ExitStatusVarp *int) bool {
 			return cb(ApplicationNewFromInternalPtr(ApplicationVarp), ArgumentsVarp, ExitStatusVarp)
 		})
 	}
 }
-// GetLocalCommandLine gets the callback function.
+// GetLocalCommandLine gets the "local_command_line" callback function.
 // invoked (locally). The virtual function has the chance
 //
 //	to inspect (and possibly replace) command line arguments. See
 //	g_application_run() for more information. Also see the
 //	#GApplication::handle-local-options signal, which is a simpler
 //	alternative to handling some commandline options locally
-func (x *ApplicationClass) GetLocalCommandLine() func(*Application, []string, int) bool {
+func (x *ApplicationClass) GetLocalCommandLine() func(*Application, []string, *int) bool {
 	if x.xLocalCommandLine == 0 {
 		return nil
 	}
-	var rawCallback func(ApplicationVarp uintptr, ArgumentsVarp []string, ExitStatusVarp int) bool
+	var rawCallback func(ApplicationVarp uintptr, ArgumentsVarp []string, ExitStatusVarp *int) bool
 	purego.RegisterFunc(&rawCallback, x.xLocalCommandLine)
-	return func(ApplicationVar *Application, ArgumentsVar []string, ExitStatusVar int) bool {
+	return func(ApplicationVar *Application, ArgumentsVar []string, ExitStatusVar *int) bool {
 		return rawCallback(ApplicationVar.GoPointer(), ArgumentsVar, ExitStatusVar)
 	}
 }
-// OverrideBeforeEmit sets the callback function.
+// OverrideBeforeEmit sets the "before_emit" callback function.
 // invoked on the primary instance before 'activate', 'open',
 //
 //	'command-line' or any action invocation, gets the 'platform data' from
 	}
 }
-// GetBeforeEmit gets the callback function.
+// GetBeforeEmit gets the "before_emit" callback function.
 // invoked on the primary instance before 'activate', 'open',
 //
 //	'command-line' or any action invocation, gets the 'platform data' from
 	}
 }
-// OverrideAfterEmit sets the callback function.
+// OverrideAfterEmit sets the "after_emit" callback function.
 // invoked on the primary instance after 'activate', 'open',
 //
 //	'command-line' or any action invocation, gets the 'platform data' from
 	}
 }
-// GetAfterEmit gets the callback function.
+// GetAfterEmit gets the "after_emit" callback function.
 // invoked on the primary instance after 'activate', 'open',
 //
 //	'command-line' or any action invocation, gets the 'platform data' from
 	}
 }
-// OverrideAddPlatformData sets the callback function.
+// OverrideAddPlatformData sets the "add_platform_data" callback function.
 // invoked (locally) to add 'platform data' to be sent to
 //
 //	the primary instance when activating, opening or invoking actions. Must chain up
 	}
 }
-// GetAddPlatformData gets the callback function.
+// GetAddPlatformData gets the "add_platform_data" callback function.
 // invoked (locally) to add 'platform data' to be sent to
 //
 //	the primary instance when activating, opening or invoking actions. Must chain up
 	}
 }
-// OverrideQuitMainloop sets the callback function.
+// OverrideQuitMainloop sets the "quit_mainloop" callback function.
 // Used to be invoked on the primary instance when the use
 //
 //	count of the application drops to zero (and after any inactivity
 	}
 }
-// GetQuitMainloop gets the callback function.
+// GetQuitMainloop gets the "quit_mainloop" callback function.
 // Used to be invoked on the primary instance when the use
 //
 //	count of the application drops to zero (and after any inactivity
 	}
 }
-// OverrideRunMainloop sets the callback function.
+// OverrideRunMainloop sets the "run_mainloop" callback function.
 // Used to be invoked on the primary instance from
 //
 //	g_application_run() if the use-count is non-zero. Since 2.32,
 	}
 }
-// GetRunMainloop gets the callback function.
+// GetRunMainloop gets the "run_mainloop" callback function.
 // Used to be invoked on the primary instance from
 //
 //	g_application_run() if the use-count is non-zero. Since 2.32,
 	}
 }
-// OverrideShutdown sets the callback function.
+// OverrideShutdown sets the "shutdown" callback function.
 // invoked only on the registered primary instance immediately
 //
 //	after the main loop terminates
 	}
 }
-// GetShutdown gets the callback function.
+// GetShutdown gets the "shutdown" callback function.
 // invoked only on the registered primary instance immediately
 //
 //	after the main loop terminates
 	}
 }
-// OverrideDbusRegister sets the callback function.
+// OverrideDbusRegister sets the "dbus_register" callback function.
 // invoked locally during registration, if the application is
 //
 //	using its D-Bus backend. You can use this to export extra objects on the
 	}
 }
-// GetDbusRegister gets the callback function.
+// GetDbusRegister gets the "dbus_register" callback function.
 // invoked locally during registration, if the application is
 //
 //	using its D-Bus backend. You can use this to export extra objects on the
 	}
 }
-// OverrideDbusUnregister sets the callback function.
+// OverrideDbusUnregister sets the "dbus_unregister" callback function.
 // invoked locally during unregistration, if the application
 //
 //	is using its D-Bus backend. Use this to undo anything done by
 	}
 }
-// GetDbusUnregister gets the callback function.
+// GetDbusUnregister gets the "dbus_unregister" callback function.
 // invoked locally during unregistration, if the application
 //
 //	is using its D-Bus backend. Use this to undo anything done by
 	}
 }
-// OverrideHandleLocalOptions sets the callback function.
+// OverrideHandleLocalOptions sets the "handle_local_options" callback function.
 // invoked locally after the parsing of the commandline
 //
 //	options has occurred. Since: 2.40
 	}
 }
-// GetHandleLocalOptions gets the callback function.
+// GetHandleLocalOptions gets the "handle_local_options" callback function.
 // invoked locally after the parsing of the commandline
 //
 //	options has occurred. Since: 2.40
 	}
 }
-// OverrideNameLost sets the callback function.
+// OverrideNameLost sets the "name_lost" callback function.
 // invoked when another instance is taking over the name. Since: 2.60
 func (x *ApplicationClass) OverrideNameLost(cb func(*Application) bool) {
 	if cb == nil {
 	}
 }
-// GetNameLost gets the callback function.
+// GetNameLost gets the "name_lost" callback function.
 // invoked when another instance is taking over the name. Since: 2.60
 func (x *ApplicationClass) GetNameLost() func(*Application) bool {
 	if x.xNameLost == 0 {
 	c.Ptr = ptr
 }
+// SetPropertyApplicationId sets the "application-id" property.
+// The unique identifier for the application.
+func (x *Application) SetPropertyApplicationId(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("application-id", &v)
+}
+// GetPropertyApplicationId gets the "application-id" property.
+// The unique identifier for the application.
+func (x *Application) GetPropertyApplicationId() string {
+	var v gobject.Value
+	x.GetProperty("application-id", &v)
+	return v.GetString()
+}
+// SetPropertyInactivityTimeout sets the "inactivity-timeout" property.
+// Time (in milliseconds) to stay alive after becoming idle.
+func (x *Application) SetPropertyInactivityTimeout(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("inactivity-timeout", &v)
+}
+// GetPropertyInactivityTimeout gets the "inactivity-timeout" property.
+// Time (in milliseconds) to stay alive after becoming idle.
+func (x *Application) GetPropertyInactivityTimeout() uint {
+	var v gobject.Value
+	x.GetProperty("inactivity-timeout", &v)
+	return v.GetUint()
+}
+// GetPropertyIsBusy gets the "is-busy" property.
+// Whether the application is currently marked as busy through
+// g_application_mark_busy() or g_application_bind_busy_property().
+func (x *Application) GetPropertyIsBusy() bool {
+	var v gobject.Value
+	x.GetProperty("is-busy", &v)
+	return v.GetBoolean()
+}
+// GetPropertyIsRegistered gets the "is-registered" property.
+// Whether [method@Gio.Application.register] has been called.
+func (x *Application) GetPropertyIsRegistered() bool {
+	var v gobject.Value
+	x.GetProperty("is-registered", &v)
+	return v.GetBoolean()
+}
+// GetPropertyIsRemote gets the "is-remote" property.
+// Whether this application instance is remote.
+func (x *Application) GetPropertyIsRemote() bool {
+	var v gobject.Value
+	x.GetProperty("is-remote", &v)
+	return v.GetBoolean()
+}
+// SetPropertyResourceBasePath sets the "resource-base-path" property.
+// The base resource path for the application.
+func (x *Application) SetPropertyResourceBasePath(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("resource-base-path", &v)
+}
+// GetPropertyResourceBasePath gets the "resource-base-path" property.
+// The base resource path for the application.
+func (x *Application) GetPropertyResourceBasePath() string {
+	var v gobject.Value
+	x.GetProperty("resource-base-path", &v)
+	return v.GetString()
+}
+// SetPropertyVersion sets the "version" property.
+// The human-readable version number of the application.
+func (x *Application) SetPropertyVersion(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("version", &v)
+}
+// GetPropertyVersion gets the "version" property.
+// The human-readable version number of the application.
+func (x *Application) GetPropertyVersion() string {
+	var v gobject.Value
+	x.GetProperty("version", &v)
+	return v.GetString()
+}
 // The ::activate signal is emitted on the primary instance when an
 // activation occurs. See g_application_activate().
 func (x *Application) ConnectActivate(cb *func(Application)) uint32 {
 // fields (as indicated by having a non-`NULL` reference passed in) are
 // filled.  If the action doesn’t exist, `FALSE` is returned and the
 // fields may or may not have been modified.
-func (x *Application) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar **glib.VariantType, StateTypeVar **glib.VariantType, StateHintVar **glib.Variant, StateVar **glib.Variant) bool {
+func (x *Application) QueryAction(ActionNameVar string, EnabledVar *bool, ParameterTypeVar **glib.VariantType, StateTypeVar **glib.VariantType, StateHintVar **glib.Variant, StateVar **glib.Variant) bool {
 	cret := XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
 	return cret

M v4/gio/gapplicationcommandline.go +46 -10

 	return uintptr(unsafe.Pointer(x))
 }
-// OverridePrintLiteral sets the callback function.
+// OverridePrintLiteral sets the "print_literal" callback function.
 func (x *ApplicationCommandLineClass) OverridePrintLiteral(cb func(*ApplicationCommandLine, string)) {
 	if cb == nil {
 		x.xPrintLiteral = 0
 	}
 }
-// GetPrintLiteral gets the callback function.
+// GetPrintLiteral gets the "print_literal" callback function.
 func (x *ApplicationCommandLineClass) GetPrintLiteral() func(*ApplicationCommandLine, string) {
 	if x.xPrintLiteral == 0 {
 		return nil
 	}
 }
-// OverridePrinterrLiteral sets the callback function.
+// OverridePrinterrLiteral sets the "printerr_literal" callback function.
 func (x *ApplicationCommandLineClass) OverridePrinterrLiteral(cb func(*ApplicationCommandLine, string)) {
 	if cb == nil {
 		x.xPrinterrLiteral = 0
 	}
 }
-// GetPrinterrLiteral gets the callback function.
+// GetPrinterrLiteral gets the "printerr_literal" callback function.
 func (x *ApplicationCommandLineClass) GetPrinterrLiteral() func(*ApplicationCommandLine, string) {
 	if x.xPrinterrLiteral == 0 {
 		return nil
 	}
 }
-// OverrideGetStdin sets the callback function.
+// OverrideGetStdin sets the "get_stdin" callback function.
 func (x *ApplicationCommandLineClass) OverrideGetStdin(cb func(*ApplicationCommandLine) *InputStream) {
 	if cb == nil {
 		x.xGetStdin = 0
 	}
 }
-// GetGetStdin gets the callback function.
+// GetGetStdin gets the "get_stdin" callback function.
 func (x *ApplicationCommandLineClass) GetGetStdin() func(*ApplicationCommandLine) *InputStream {
 	if x.xGetStdin == 0 {
 		return nil
 	}
 }
-// OverrideDone sets the callback function.
+// OverrideDone sets the "done" callback function.
 func (x *ApplicationCommandLineClass) OverrideDone(cb func(*ApplicationCommandLine)) {
 	if cb == nil {
 		x.xDone = 0
 	}
 }
-// GetDone gets the callback function.
+// GetDone gets the "done" callback function.
 func (x *ApplicationCommandLineClass) GetDone() func(*ApplicationCommandLine) {
 	if x.xDone == 0 {
 		return nil
 }
-var xApplicationCommandLineGetArguments func(uintptr, int) []string
+var xApplicationCommandLineGetArguments func(uintptr, *int) []string
 // Gets the list of arguments that was passed on the command line.
 //
 //
 // The return value is %NULL-terminated and should be freed using
 // g_strfreev().
-func (x *ApplicationCommandLine) GetArguments(ArgcVar int) []string {
+func (x *ApplicationCommandLine) GetArguments(ArgcVar *int) []string {
 	cret := xApplicationCommandLineGetArguments(x.GoPointer(), ArgcVar)
 	return cret
 	c.Ptr = ptr
 }
+// SetPropertyArguments sets the "arguments" property.
+// The commandline that caused this [signal@Gio.Application::command-line]
+// signal emission.
+func (x *ApplicationCommandLine) SetPropertyArguments(value uintptr) {
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	x.SetProperty("arguments", &v)
+}
+// GetPropertyIsRemote gets the "is-remote" property.
+// Whether this is a remote commandline.
+func (x *ApplicationCommandLine) GetPropertyIsRemote() bool {
+	var v gobject.Value
+	x.GetProperty("is-remote", &v)
+	return v.GetBoolean()
+}
+// SetPropertyOptions sets the "options" property.
+// The options sent along with the commandline.
+func (x *ApplicationCommandLine) SetPropertyOptions(value uintptr) {
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	x.SetProperty("options", &v)
+}
+// SetPropertyPlatformData sets the "platform-data" property.
+// Platform-specific data for the commandline.
+func (x *ApplicationCommandLine) SetPropertyPlatformData(value uintptr) {
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	x.SetProperty("platform-data", &v)
+}
 func init() {
 	core.SetPackageName("GIO", "gio-2.0")
 	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})

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


@@ -28,7 +28,7 @@ func (x *AsyncInitableIface) GoPointer() uintptr {
28		return uintptr(unsafe.Pointer(x))	28		return uintptr(unsafe.Pointer(x))
29		}	29		}
30			30
31	-	// OverrideInitAsync sets the callback function.	31	+	// OverrideInitAsync sets the "init_async" callback function.
32		// Starts initialization of the object.	32		// Starts initialization of the object.
33		func (x AsyncInitableIface) OverrideInitAsync(cb func(AsyncInitable, int, Cancellable, *AsyncReadyCallback, uintptr)) {	33		func (x AsyncInitableIface) OverrideInitAsync(cb func(AsyncInitable, int, Cancellable, *AsyncReadyCallback, uintptr)) {
34		if cb == nil {	34		if cb == nil {

@@ -40,7 +40,7 @@ func (x AsyncInitableIface) OverrideInitAsync(cb func(AsyncInitable, int, Canc
40		}	40		}
41		}	41		}
42			42
43	-	// GetInitAsync gets the callback function.	43	+	// GetInitAsync gets the "init_async" callback function.
44		// Starts initialization of the object.	44		// Starts initialization of the object.
45		func (x AsyncInitableIface) GetInitAsync() func(AsyncInitable, int, Cancellable, *AsyncReadyCallback, uintptr) {	45		func (x AsyncInitableIface) GetInitAsync() func(AsyncInitable, int, Cancellable, *AsyncReadyCallback, uintptr) {
46		if x.xInitAsync == 0 {	46		if x.xInitAsync == 0 {

@@ -53,7 +53,7 @@ func (x AsyncInitableIface) GetInitAsync() func(AsyncInitable, int, Cancellabl
53		}	53		}
54		}	54		}
55			55
56	-	// OverrideInitFinish sets the callback function.	56	+	// OverrideInitFinish sets the "init_finish" callback function.
57		// Finishes initialization of the object.	57		// Finishes initialization of the object.
58		func (x *AsyncInitableIface) OverrideInitFinish(cb func(AsyncInitable, AsyncResult) bool) {	58		func (x *AsyncInitableIface) OverrideInitFinish(cb func(AsyncInitable, AsyncResult) bool) {
59		if cb == nil {	59		if cb == nil {

@@ -65,7 +65,7 @@ func (x *AsyncInitableIface) OverrideInitFinish(cb func(AsyncInitable, AsyncResu
65		}	65		}
66		}	66		}
67			67
68	-	// GetInitFinish gets the callback function.	68	+	// GetInitFinish gets the "init_finish" callback function.
69		// Finishes initialization of the object.	69		// Finishes initialization of the object.
70		func (x *AsyncInitableIface) GetInitFinish() func(AsyncInitable, AsyncResult) bool {	70		func (x *AsyncInitableIface) GetInitFinish() func(AsyncInitable, AsyncResult) bool {
71		if x.xInitFinish == 0 {	71		if x.xInitFinish == 0 {

M v4/gio/gasyncresult.go +6 -6


@@ -29,7 +29,7 @@ func (x *AsyncResultIface) GoPointer() uintptr {
29		return uintptr(unsafe.Pointer(x))	29		return uintptr(unsafe.Pointer(x))
30		}	30		}
31			31
32	-	// OverrideGetUserData sets the callback function.	32	+	// OverrideGetUserData sets the "get_user_data" callback function.
33		// Gets the user data passed to the callback.	33		// Gets the user data passed to the callback.
34		func (x *AsyncResultIface) OverrideGetUserData(cb func(AsyncResult) uintptr) {	34		func (x *AsyncResultIface) OverrideGetUserData(cb func(AsyncResult) uintptr) {
35		if cb == nil {	35		if cb == nil {

@@ -41,7 +41,7 @@ func (x *AsyncResultIface) OverrideGetUserData(cb func(AsyncResult) uintptr) {
41		}	41		}
42		}	42		}
43			43
44	-	// GetGetUserData gets the callback function.	44	+	// GetGetUserData gets the "get_user_data" callback function.
45		// Gets the user data passed to the callback.	45		// Gets the user data passed to the callback.
46		func (x *AsyncResultIface) GetGetUserData() func(AsyncResult) uintptr {	46		func (x *AsyncResultIface) GetGetUserData() func(AsyncResult) uintptr {
47		if x.xGetUserData == 0 {	47		if x.xGetUserData == 0 {

@@ -54,7 +54,7 @@ func (x *AsyncResultIface) GetGetUserData() func(AsyncResult) uintptr {
54		}	54		}
55		}	55		}
56			56
57	-	// OverrideGetSourceObject sets the callback function.	57	+	// OverrideGetSourceObject sets the "get_source_object" callback function.
58		// Gets the source object that issued the asynchronous operation.	58		// Gets the source object that issued the asynchronous operation.
59		func (x AsyncResultIface) OverrideGetSourceObject(cb func(AsyncResult) gobject.Object) {	59		func (x AsyncResultIface) OverrideGetSourceObject(cb func(AsyncResult) gobject.Object) {
60		if cb == nil {	60		if cb == nil {

@@ -70,7 +70,7 @@ func (x AsyncResultIface) OverrideGetSourceObject(cb func(AsyncResult) gobject
70		}	70		}
71		}	71		}
72			72
73	-	// GetGetSourceObject gets the callback function.	73	+	// GetGetSourceObject gets the "get_source_object" callback function.
74		// Gets the source object that issued the asynchronous operation.	74		// Gets the source object that issued the asynchronous operation.
75		func (x AsyncResultIface) GetGetSourceObject() func(AsyncResult) gobject.Object {	75		func (x AsyncResultIface) GetGetSourceObject() func(AsyncResult) gobject.Object {
76		if x.xGetSourceObject == 0 {	76		if x.xGetSourceObject == 0 {

@@ -89,7 +89,7 @@ func (x AsyncResultIface) GetGetSourceObject() func(AsyncResult) gobject.Objec
89		}	89		}
90		}	90		}
91			91
92	-	// OverrideIsTagged sets the callback function.	92	+	// OverrideIsTagged sets the "is_tagged" callback function.
93		// Checks if a result is tagged with a particular source.	93		// Checks if a result is tagged with a particular source.
94		func (x *AsyncResultIface) OverrideIsTagged(cb func(AsyncResult, uintptr) bool) {	94		func (x *AsyncResultIface) OverrideIsTagged(cb func(AsyncResult, uintptr) bool) {
95		if cb == nil {	95		if cb == nil {

@@ -101,7 +101,7 @@ func (x *AsyncResultIface) OverrideIsTagged(cb func(AsyncResult, uintptr) bool)
101		}	101		}
102		}	102		}
103			103
104	-	// GetIsTagged gets the callback function.	104	+	// GetIsTagged gets the "is_tagged" callback function.
105		// Checks if a result is tagged with a particular source.	105		// Checks if a result is tagged with a particular source.
106		func (x *AsyncResultIface) GetIsTagged() func(AsyncResult, uintptr) bool {	106		func (x *AsyncResultIface) GetIsTagged() func(AsyncResult, uintptr) bool {
107		if x.xIsTagged == 0 {	107		if x.xIsTagged == 0 {

M v4/gio/gbufferedinputstream.go +36 -18

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/pkg/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
+	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gobject/types"
 )
 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideFill sets the callback function.
+// OverrideFill sets the "fill" callback function.
 func (x *BufferedInputStreamClass) OverrideFill(cb func(*BufferedInputStream, int, *Cancellable) int) {
 	if cb == nil {
 		x.xFill = 0
 	}
 }
-// GetFill gets the callback function.
+// GetFill gets the "fill" callback function.
 func (x *BufferedInputStreamClass) GetFill() func(*BufferedInputStream, int, *Cancellable) int {
 	if x.xFill == 0 {
 		return nil
 	}
 }
-// OverrideFillAsync sets the callback function.
+// OverrideFillAsync sets the "fill_async" callback function.
 func (x *BufferedInputStreamClass) OverrideFillAsync(cb func(*BufferedInputStream, int, int, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xFillAsync = 0
 	}
 }
-// GetFillAsync gets the callback function.
+// GetFillAsync gets the "fill_async" callback function.
 func (x *BufferedInputStreamClass) GetFillAsync() func(*BufferedInputStream, int, int, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xFillAsync == 0 {
 		return nil
 	}
 }
-// OverrideFillFinish sets the callback function.
+// OverrideFillFinish sets the "fill_finish" callback function.
 func (x *BufferedInputStreamClass) OverrideFillFinish(cb func(*BufferedInputStream, AsyncResult) int) {
 	if cb == nil {
 		x.xFillFinish = 0
 	}
 }
-// GetFillFinish gets the callback function.
+// GetFillFinish gets the "fill_finish" callback function.
 func (x *BufferedInputStreamClass) GetFillFinish() func(*BufferedInputStream, AsyncResult) int {
 	if x.xFillFinish == 0 {
 		return nil
 	}
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *BufferedInputStreamClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *BufferedInputStreamClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *BufferedInputStreamClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *BufferedInputStreamClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *BufferedInputStreamClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *BufferedInputStreamClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *BufferedInputStreamClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *BufferedInputStreamClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *BufferedInputStreamClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *BufferedInputStreamClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	return cret
 }
-var xBufferedInputStreamPeekBuffer func(uintptr, uint) uintptr
+var xBufferedInputStreamPeekBuffer func(uintptr, *uint) uintptr
 // Returns the buffer with the currently available bytes. The returned
 // buffer must not be modified and will become invalid when reading from
 // the stream or filling the buffer.
-func (x *BufferedInputStream) PeekBuffer(CountVar uint) uintptr {
+func (x *BufferedInputStream) PeekBuffer(CountVar *uint) uintptr {
 	cret := xBufferedInputStreamPeekBuffer(x.GoPointer(), CountVar)
 	return cret
 	c.Ptr = ptr
 }
+// SetPropertyBufferSize sets the "buffer-size" property.
+// The size of the backend buffer, in bytes.
+func (x *BufferedInputStream) SetPropertyBufferSize(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("buffer-size", &v)
+}
+// GetPropertyBufferSize gets the "buffer-size" property.
+// The size of the backend buffer, in bytes.
+func (x *BufferedInputStream) GetPropertyBufferSize() uint {
+	var v gobject.Value
+	x.GetProperty("buffer-size", &v)
+	return v.GetUint()
+}
 // Tests if the stream supports the #GSeekableIface.
 func (x *BufferedInputStream) CanSeek() bool {

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

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/pkg/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
+	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gobject/types"
 )
 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *BufferedOutputStreamClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *BufferedOutputStreamClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *BufferedOutputStreamClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *BufferedOutputStreamClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyAutoGrow sets the "auto-grow" property.
+// Whether the buffer should automatically grow.
+func (x *BufferedOutputStream) SetPropertyAutoGrow(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("auto-grow", &v)
+}
+// GetPropertyAutoGrow gets the "auto-grow" property.
+// Whether the buffer should automatically grow.
+func (x *BufferedOutputStream) GetPropertyAutoGrow() bool {
+	var v gobject.Value
+	x.GetProperty("auto-grow", &v)
+	return v.GetBoolean()
+}
+// SetPropertyBufferSize sets the "buffer-size" property.
+// The size of the backend buffer, in bytes.
+func (x *BufferedOutputStream) SetPropertyBufferSize(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("buffer-size", &v)
+}
+// GetPropertyBufferSize gets the "buffer-size" property.
+// The size of the backend buffer, in bytes.
+func (x *BufferedOutputStream) GetPropertyBufferSize() uint {
+	var v gobject.Value
+	x.GetProperty("buffer-size", &v)
+	return v.GetUint()
+}
 // Tests if the stream supports the #GSeekableIface.
 func (x *BufferedOutputStream) CanSeek() bool {

M v4/gio/gbytesicon.go +19 -2

 	c.Ptr = ptr
 }
+// SetPropertyBytes sets the "bytes" property.
+// The bytes containing the icon.
+func (x *BytesIcon) SetPropertyBytes(value uintptr) {
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	x.SetProperty("bytes", &v)
+}
+// GetPropertyBytes gets the "bytes" property.
+// The bytes containing the icon.
+func (x *BytesIcon) GetPropertyBytes() uintptr {
+	var v gobject.Value
+	x.GetProperty("bytes", &v)
+	return v.GetPointer()
+}
 // Checks if two icons are equal.
 func (x *BytesIcon) Equal(Icon2Var Icon) bool {
 // Loads a loadable icon. For the asynchronous version of this function,
 // see g_loadable_icon_load_async().
-func (x *BytesIcon) Load(SizeVar int, TypeVar string, CancellableVar *Cancellable) (*InputStream, error) {
+func (x *BytesIcon) Load(SizeVar int, TypeVar *string, CancellableVar *Cancellable) (*InputStream, error) {
 	var cls *InputStream
 	var cerr *glib.Error
 }
 // Finishes an asynchronous icon load started in g_loadable_icon_load_async().
-func (x *BytesIcon) LoadFinish(ResVar AsyncResult, TypeVar string) (*InputStream, error) {
+func (x *BytesIcon) LoadFinish(ResVar AsyncResult, TypeVar *string) (*InputStream, error) {
 	var cls *InputStream
 	var cerr *glib.Error

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


@@ -34,7 +34,7 @@ func (x *CancellableClass) GoPointer() uintptr {
34		return uintptr(unsafe.Pointer(x))	34		return uintptr(unsafe.Pointer(x))
35		}	35		}
36			36
37	-	// OverrideCancelled sets the callback function.	37	+	// OverrideCancelled sets the "cancelled" callback function.
38		func (x CancellableClass) OverrideCancelled(cb func(Cancellable)) {	38		func (x CancellableClass) OverrideCancelled(cb func(Cancellable)) {
39		if cb == nil {	39		if cb == nil {
40		x.xCancelled = 0	40		x.xCancelled = 0

@@ -45,7 +45,7 @@ func (x CancellableClass) OverrideCancelled(cb func(Cancellable)) {
45		}	45		}
46		}	46		}
47			47
48	-	// GetCancelled gets the callback function.	48	+	// GetCancelled gets the "cancelled" callback function.
49		func (x CancellableClass) GetCancelled() func(Cancellable) {	49		func (x CancellableClass) GetCancelled() func(Cancellable) {
50		if x.xCancelled == 0 {	50		if x.xCancelled == 0 {
51		return nil	51		return nil

@@ -57,7 +57,7 @@ func (x CancellableClass) GetCancelled() func(Cancellable) {
57		}	57		}
58		}	58		}
59			59
60	-	// OverrideGReserved1 sets the callback function.	60	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
61		func (x *CancellableClass) OverrideGReserved1(cb func()) {	61		func (x *CancellableClass) OverrideGReserved1(cb func()) {
62		if cb == nil {	62		if cb == nil {
63		x.xGReserved1 = 0	63		x.xGReserved1 = 0

@@ -68,7 +68,7 @@ func (x *CancellableClass) OverrideGReserved1(cb func()) {
68		}	68		}
69		}	69		}
70			70
71	-	// GetGReserved1 gets the callback function.	71	+	// GetGReserved1 gets the "_g_reserved1" callback function.
72		func (x *CancellableClass) GetGReserved1() func() {	72		func (x *CancellableClass) GetGReserved1() func() {
73		if x.xGReserved1 == 0 {	73		if x.xGReserved1 == 0 {
74		return nil	74		return nil

@@ -80,7 +80,7 @@ func (x *CancellableClass) GetGReserved1() func() {
80		}	80		}
81		}	81		}
82			82
83	-	// OverrideGReserved2 sets the callback function.	83	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
84		func (x *CancellableClass) OverrideGReserved2(cb func()) {	84		func (x *CancellableClass) OverrideGReserved2(cb func()) {
85		if cb == nil {	85		if cb == nil {
86		x.xGReserved2 = 0	86		x.xGReserved2 = 0

@@ -91,7 +91,7 @@ func (x *CancellableClass) OverrideGReserved2(cb func()) {
91		}	91		}
92		}	92		}
93			93
94	-	// GetGReserved2 gets the callback function.	94	+	// GetGReserved2 gets the "_g_reserved2" callback function.
95		func (x *CancellableClass) GetGReserved2() func() {	95		func (x *CancellableClass) GetGReserved2() func() {
96		if x.xGReserved2 == 0 {	96		if x.xGReserved2 == 0 {
97		return nil	97		return nil

@@ -103,7 +103,7 @@ func (x *CancellableClass) GetGReserved2() func() {
103		}	103		}
104		}	104		}
105			105
106	-	// OverrideGReserved3 sets the callback function.	106	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
107		func (x *CancellableClass) OverrideGReserved3(cb func()) {	107		func (x *CancellableClass) OverrideGReserved3(cb func()) {
108		if cb == nil {	108		if cb == nil {
109		x.xGReserved3 = 0	109		x.xGReserved3 = 0

@@ -114,7 +114,7 @@ func (x *CancellableClass) OverrideGReserved3(cb func()) {
114		}	114		}
115		}	115		}
116			116
117	-	// GetGReserved3 gets the callback function.	117	+	// GetGReserved3 gets the "_g_reserved3" callback function.
118		func (x *CancellableClass) GetGReserved3() func() {	118		func (x *CancellableClass) GetGReserved3() func() {
119		if x.xGReserved3 == 0 {	119		if x.xGReserved3 == 0 {
120		return nil	120		return nil

@@ -126,7 +126,7 @@ func (x *CancellableClass) GetGReserved3() func() {
126		}	126		}
127		}	127		}
128			128
129	-	// OverrideGReserved4 sets the callback function.	129	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
130		func (x *CancellableClass) OverrideGReserved4(cb func()) {	130		func (x *CancellableClass) OverrideGReserved4(cb func()) {
131		if cb == nil {	131		if cb == nil {
132		x.xGReserved4 = 0	132		x.xGReserved4 = 0

@@ -137,7 +137,7 @@ func (x *CancellableClass) OverrideGReserved4(cb func()) {
137		}	137		}
138		}	138		}
139			139
140	-	// GetGReserved4 gets the callback function.	140	+	// GetGReserved4 gets the "_g_reserved4" callback function.
141		func (x *CancellableClass) GetGReserved4() func() {	141		func (x *CancellableClass) GetGReserved4() func() {
142		if x.xGReserved4 == 0 {	142		if x.xGReserved4 == 0 {
143		return nil	143		return nil

@@ -149,7 +149,7 @@ func (x *CancellableClass) GetGReserved4() func() {
149		}	149		}
150		}	150		}
151			151
152	-	// OverrideGReserved5 sets the callback function.	152	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
153		func (x *CancellableClass) OverrideGReserved5(cb func()) {	153		func (x *CancellableClass) OverrideGReserved5(cb func()) {
154		if cb == nil {	154		if cb == nil {
155		x.xGReserved5 = 0	155		x.xGReserved5 = 0

@@ -160,7 +160,7 @@ func (x *CancellableClass) OverrideGReserved5(cb func()) {
160		}	160		}
161		}	161		}
162			162
163	-	// GetGReserved5 gets the callback function.	163	+	// GetGReserved5 gets the "_g_reserved5" callback function.
164		func (x *CancellableClass) GetGReserved5() func() {	164		func (x *CancellableClass) GetGReserved5() func() {
165		if x.xGReserved5 == 0 {	165		if x.xGReserved5 == 0 {
166		return nil	166		return nil

M v4/gio/gcharsetconverter.go +52 -1


@@ -99,6 +99,57 @@ func (c *CharsetConverter) SetGoPointer(ptr uintptr) {
99		c.Ptr = ptr	99		c.Ptr = ptr
100		}	100		}
101			101
			102	+	// SetPropertyFromCharset sets the "from-charset" property.
			103	+	// The character encoding to convert from.
			104	+	func (x *CharsetConverter) SetPropertyFromCharset(value string) {
			105	+	var v gobject.Value
			106	+	v.Init(gobject.TypeStringVal)
			107	+	v.SetString(value)
			108	+	x.SetProperty("from-charset", &v)
			109	+	}
			110	+
			111	+	// GetPropertyFromCharset gets the "from-charset" property.
			112	+	// The character encoding to convert from.
			113	+	func (x *CharsetConverter) GetPropertyFromCharset() string {
			114	+	var v gobject.Value
			115	+	x.GetProperty("from-charset", &v)
			116	+	return v.GetString()
			117	+	}
			118	+
			119	+	// SetPropertyToCharset sets the "to-charset" property.
			120	+	// The character encoding to convert to.
			121	+	func (x *CharsetConverter) SetPropertyToCharset(value string) {
			122	+	var v gobject.Value
			123	+	v.Init(gobject.TypeStringVal)
			124	+	v.SetString(value)
			125	+	x.SetProperty("to-charset", &v)
			126	+	}
			127	+
			128	+	// GetPropertyToCharset gets the "to-charset" property.
			129	+	// The character encoding to convert to.
			130	+	func (x *CharsetConverter) GetPropertyToCharset() string {
			131	+	var v gobject.Value
			132	+	x.GetProperty("to-charset", &v)
			133	+	return v.GetString()
			134	+	}
			135	+
			136	+	// SetPropertyUseFallback sets the "use-fallback" property.
			137	+	// Use fallback (of form `\<hexval>`) for invalid bytes.
			138	+	func (x *CharsetConverter) SetPropertyUseFallback(value bool) {
			139	+	var v gobject.Value
			140	+	v.Init(gobject.TypeBooleanVal)
			141	+	v.SetBoolean(value)
			142	+	x.SetProperty("use-fallback", &v)
			143	+	}
			144	+
			145	+	// GetPropertyUseFallback gets the "use-fallback" property.
			146	+	// Use fallback (of form `\<hexval>`) for invalid bytes.
			147	+	func (x *CharsetConverter) GetPropertyUseFallback() bool {
			148	+	var v gobject.Value
			149	+	x.GetProperty("use-fallback", &v)
			150	+	return v.GetBoolean()
			151	+	}
			152	+
102		// This is the main operation used when converting data. It is to be called	153		// This is the main operation used when converting data. It is to be called
103		// multiple times in a loop, and each time it will do some work, i.e.	154		// multiple times in a loop, and each time it will do some work, i.e.
104		// producing some output (in @outbuf) or consuming some input (from @inbuf) or	155		// producing some output (in @outbuf) or consuming some input (from @inbuf) or

@@ -181,7 +232,7 @@ func (c *CharsetConverter) SetGoPointer(ptr uintptr) {
181		// at a partial multibyte sequence). Converters are supposed to try	232		// at a partial multibyte sequence). Converters are supposed to try
182		// to produce as much output as possible and then return an error	233		// to produce as much output as possible and then return an error
183		// (typically %G_IO_ERROR_PARTIAL_INPUT).	234		// (typically %G_IO_ERROR_PARTIAL_INPUT).
184	-	func (x *CharsetConverter) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar uint) (ConverterResult, error) {	235	+	func (x CharsetConverter) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar *uint) (ConverterResult, error) {
185		var cerr *glib.Error	236		var cerr *glib.Error
186			237
187		cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)	238		cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)

M v4/gio/gcontenttype.go +2 -2


@@ -108,13 +108,13 @@ func ContentTypeGetSymbolicIcon(TypeVar string) *IconBase {
108		return cls	108		return cls
109		}	109		}
110			110
111	-	var xContentTypeGuess func(string, []byte, uint, bool) string	111	+	var xContentTypeGuess func(string, []byte, uint, *bool) string
112			112
113		// Guesses the content type based on example data. If the function is	113		// Guesses the content type based on example data. If the function is
114		// uncertain, @result_uncertain will be set to %TRUE. Either @filename	114		// uncertain, @result_uncertain will be set to %TRUE. Either @filename
115		// or @data may be %NULL, in which case the guess will be based solely	115		// or @data may be %NULL, in which case the guess will be based solely
116		// on the other argument.	116		// on the other argument.
117	-	func ContentTypeGuess(FilenameVar string, DataVar []byte, DataSizeVar uint, ResultUncertainVar bool) string {	117	+	func ContentTypeGuess(FilenameVar string, DataVar []byte, DataSizeVar uint, ResultUncertainVar *bool) string {
118			118
119		cret := xContentTypeGuess(FilenameVar, DataVar, DataSizeVar, ResultUncertainVar)	119		cret := xContentTypeGuess(FilenameVar, DataVar, DataSizeVar, ResultUncertainVar)
120		return cret	120		return cret

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


@@ -28,32 +28,32 @@ func (x *ConverterIface) GoPointer() uintptr {
28		return uintptr(unsafe.Pointer(x))	28		return uintptr(unsafe.Pointer(x))
29		}	29		}
30			30
31	-	// OverrideConvert sets the callback function.	31	+	// OverrideConvert sets the "convert" callback function.
32		// Converts data.	32		// Converts data.
33	-	func (x *ConverterIface) OverrideConvert(cb func(Converter, []byte, uint, []byte, uint, ConverterFlags, uint, uint) ConverterResult) {	33	+	func (x ConverterIface) OverrideConvert(cb func(Converter, []byte, uint, []byte, uint, ConverterFlags, uint, *uint) ConverterResult) {
34		if cb == nil {	34		if cb == nil {
35		x.xConvert = 0	35		x.xConvert = 0
36		} else {	36		} else {
37	-	x.xConvert = purego.NewCallback(func(ConverterVarp uintptr, InbufVarp []byte, InbufSizeVarp uint, OutbufVarp []byte, OutbufSizeVarp uint, FlagsVarp ConverterFlags, BytesReadVarp uint, BytesWrittenVarp uint) ConverterResult {	37	+	x.xConvert = purego.NewCallback(func(ConverterVarp uintptr, InbufVarp []byte, InbufSizeVarp uint, OutbufVarp []byte, OutbufSizeVarp uint, FlagsVarp ConverterFlags, BytesReadVarp uint, BytesWrittenVarp uint) ConverterResult {
38		return cb(&ConverterBase{Ptr: ConverterVarp}, InbufVarp, InbufSizeVarp, OutbufVarp, OutbufSizeVarp, FlagsVarp, BytesReadVarp, BytesWrittenVarp)	38		return cb(&ConverterBase{Ptr: ConverterVarp}, InbufVarp, InbufSizeVarp, OutbufVarp, OutbufSizeVarp, FlagsVarp, BytesReadVarp, BytesWrittenVarp)
39		})	39		})
40		}	40		}
41		}	41		}
42			42
43	-	// GetConvert gets the callback function.	43	+	// GetConvert gets the "convert" callback function.
44		// Converts data.	44		// Converts data.
45	-	func (x *ConverterIface) GetConvert() func(Converter, []byte, uint, []byte, uint, ConverterFlags, uint, uint) ConverterResult {	45	+	func (x ConverterIface) GetConvert() func(Converter, []byte, uint, []byte, uint, ConverterFlags, uint, *uint) ConverterResult {
46		if x.xConvert == 0 {	46		if x.xConvert == 0 {
47		return nil	47		return nil
48		}	48		}
49	-	var rawCallback func(ConverterVarp uintptr, InbufVarp []byte, InbufSizeVarp uint, OutbufVarp []byte, OutbufSizeVarp uint, FlagsVarp ConverterFlags, BytesReadVarp uint, BytesWrittenVarp uint) ConverterResult	49	+	var rawCallback func(ConverterVarp uintptr, InbufVarp []byte, InbufSizeVarp uint, OutbufVarp []byte, OutbufSizeVarp uint, FlagsVarp ConverterFlags, BytesReadVarp uint, BytesWrittenVarp uint) ConverterResult
50		purego.RegisterFunc(&rawCallback, x.xConvert)	50		purego.RegisterFunc(&rawCallback, x.xConvert)
51	-	return func(ConverterVar Converter, InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar uint) ConverterResult {	51	+	return func(ConverterVar Converter, InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar uint) ConverterResult {
52		return rawCallback(ConverterVar.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar)	52		return rawCallback(ConverterVar.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar)
53		}	53		}
54		}	54		}
55			55
56	-	// OverrideReset sets the callback function.	56	+	// OverrideReset sets the "reset" callback function.
57		// Reverts the internal state of the converter to its initial state.	57		// Reverts the internal state of the converter to its initial state.
58		func (x *ConverterIface) OverrideReset(cb func(Converter)) {	58		func (x *ConverterIface) OverrideReset(cb func(Converter)) {
59		if cb == nil {	59		if cb == nil {

@@ -65,7 +65,7 @@ func (x *ConverterIface) OverrideReset(cb func(Converter)) {
65		}	65		}
66		}	66		}
67			67
68	-	// GetReset gets the callback function.	68	+	// GetReset gets the "reset" callback function.
69		// Reverts the internal state of the converter to its initial state.	69		// Reverts the internal state of the converter to its initial state.
70		func (x *ConverterIface) GetReset() func(Converter) {	70		func (x *ConverterIface) GetReset() func(Converter) {
71		if x.xReset == 0 {	71		if x.xReset == 0 {

@@ -90,7 +90,7 @@ func (x *ConverterIface) GetReset() func(Converter) {
90		type Converter interface {	90		type Converter interface {
91		GoPointer() uintptr	91		GoPointer() uintptr
92		SetGoPointer(uintptr)	92		SetGoPointer(uintptr)
93	-	Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar uint) (ConverterResult, error)	93	+	Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar uint) (ConverterResult, error)
94		ConvertBytes(BytesVar glib.Bytes) (glib.Bytes, error)	94		ConvertBytes(BytesVar glib.Bytes) (glib.Bytes, error)
95		Reset()	95		Reset()
96		}	96		}

@@ -198,7 +198,7 @@ func (x *ConverterBase) SetGoPointer(ptr uintptr) {
198		// at a partial multibyte sequence). Converters are supposed to try	198		// at a partial multibyte sequence). Converters are supposed to try
199		// to produce as much output as possible and then return an error	199		// to produce as much output as possible and then return an error
200		// (typically %G_IO_ERROR_PARTIAL_INPUT).	200		// (typically %G_IO_ERROR_PARTIAL_INPUT).
201	-	func (x *ConverterBase) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar uint) (ConverterResult, error) {	201	+	func (x ConverterBase) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar *uint) (ConverterResult, error) {
202		var cerr *glib.Error	202		var cerr *glib.Error
203			203
204		cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)	204		cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)

@@ -230,7 +230,7 @@ func (x *ConverterBase) Reset() {
230			230
231		}	231		}
232			232
233	-	var XGConverterConvert func(uintptr, []byte, uint, []byte, uint, ConverterFlags, uint, uint, **glib.Error) ConverterResult	233	+	var XGConverterConvert func(uintptr, []byte, uint, []byte, uint, ConverterFlags, uint, uint, **glib.Error) ConverterResult
234		var XGConverterConvertBytes func(uintptr, glib.Bytes, glib.Error) glib.Bytes	234		var XGConverterConvertBytes func(uintptr, glib.Bytes, glib.Error) glib.Bytes
235		var XGConverterReset func(uintptr)	235		var XGConverterReset func(uintptr)
236			236

M v4/gio/gconverterinputstream.go +11 -11


@@ -32,7 +32,7 @@ func (x *ConverterInputStreamClass) GoPointer() uintptr {
32		return uintptr(unsafe.Pointer(x))	32		return uintptr(unsafe.Pointer(x))
33		}	33		}
34			34
35	-	// OverrideGReserved1 sets the callback function.	35	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
36		func (x *ConverterInputStreamClass) OverrideGReserved1(cb func()) {	36		func (x *ConverterInputStreamClass) OverrideGReserved1(cb func()) {
37		if cb == nil {	37		if cb == nil {
38		x.xGReserved1 = 0	38		x.xGReserved1 = 0

@@ -43,7 +43,7 @@ func (x *ConverterInputStreamClass) OverrideGReserved1(cb func()) {
43		}	43		}
44		}	44		}
45			45
46	-	// GetGReserved1 gets the callback function.	46	+	// GetGReserved1 gets the "_g_reserved1" callback function.
47		func (x *ConverterInputStreamClass) GetGReserved1() func() {	47		func (x *ConverterInputStreamClass) GetGReserved1() func() {
48		if x.xGReserved1 == 0 {	48		if x.xGReserved1 == 0 {
49		return nil	49		return nil

@@ -55,7 +55,7 @@ func (x *ConverterInputStreamClass) GetGReserved1() func() {
55		}	55		}
56		}	56		}
57			57
58	-	// OverrideGReserved2 sets the callback function.	58	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
59		func (x *ConverterInputStreamClass) OverrideGReserved2(cb func()) {	59		func (x *ConverterInputStreamClass) OverrideGReserved2(cb func()) {
60		if cb == nil {	60		if cb == nil {
61		x.xGReserved2 = 0	61		x.xGReserved2 = 0

@@ -66,7 +66,7 @@ func (x *ConverterInputStreamClass) OverrideGReserved2(cb func()) {
66		}	66		}
67		}	67		}
68			68
69	-	// GetGReserved2 gets the callback function.	69	+	// GetGReserved2 gets the "_g_reserved2" callback function.
70		func (x *ConverterInputStreamClass) GetGReserved2() func() {	70		func (x *ConverterInputStreamClass) GetGReserved2() func() {
71		if x.xGReserved2 == 0 {	71		if x.xGReserved2 == 0 {
72		return nil	72		return nil

@@ -78,7 +78,7 @@ func (x *ConverterInputStreamClass) GetGReserved2() func() {
78		}	78		}
79		}	79		}
80			80
81	-	// OverrideGReserved3 sets the callback function.	81	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
82		func (x *ConverterInputStreamClass) OverrideGReserved3(cb func()) {	82		func (x *ConverterInputStreamClass) OverrideGReserved3(cb func()) {
83		if cb == nil {	83		if cb == nil {
84		x.xGReserved3 = 0	84		x.xGReserved3 = 0

@@ -89,7 +89,7 @@ func (x *ConverterInputStreamClass) OverrideGReserved3(cb func()) {
89		}	89		}
90		}	90		}
91			91
92	-	// GetGReserved3 gets the callback function.	92	+	// GetGReserved3 gets the "_g_reserved3" callback function.
93		func (x *ConverterInputStreamClass) GetGReserved3() func() {	93		func (x *ConverterInputStreamClass) GetGReserved3() func() {
94		if x.xGReserved3 == 0 {	94		if x.xGReserved3 == 0 {
95		return nil	95		return nil

@@ -101,7 +101,7 @@ func (x *ConverterInputStreamClass) GetGReserved3() func() {
101		}	101		}
102		}	102		}
103			103
104	-	// OverrideGReserved4 sets the callback function.	104	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
105		func (x *ConverterInputStreamClass) OverrideGReserved4(cb func()) {	105		func (x *ConverterInputStreamClass) OverrideGReserved4(cb func()) {
106		if cb == nil {	106		if cb == nil {
107		x.xGReserved4 = 0	107		x.xGReserved4 = 0

@@ -112,7 +112,7 @@ func (x *ConverterInputStreamClass) OverrideGReserved4(cb func()) {
112		}	112		}
113		}	113		}
114			114
115	-	// GetGReserved4 gets the callback function.	115	+	// GetGReserved4 gets the "_g_reserved4" callback function.
116		func (x *ConverterInputStreamClass) GetGReserved4() func() {	116		func (x *ConverterInputStreamClass) GetGReserved4() func() {
117		if x.xGReserved4 == 0 {	117		if x.xGReserved4 == 0 {
118		return nil	118		return nil

@@ -124,7 +124,7 @@ func (x *ConverterInputStreamClass) GetGReserved4() func() {
124		}	124		}
125		}	125		}
126			126
127	-	// OverrideGReserved5 sets the callback function.	127	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
128		func (x *ConverterInputStreamClass) OverrideGReserved5(cb func()) {	128		func (x *ConverterInputStreamClass) OverrideGReserved5(cb func()) {
129		if cb == nil {	129		if cb == nil {
130		x.xGReserved5 = 0	130		x.xGReserved5 = 0

@@ -135,7 +135,7 @@ func (x *ConverterInputStreamClass) OverrideGReserved5(cb func()) {
135		}	135		}
136		}	136		}
137			137
138	-	// GetGReserved5 gets the callback function.	138	+	// GetGReserved5 gets the "_g_reserved5" callback function.
139		func (x *ConverterInputStreamClass) GetGReserved5() func() {	139		func (x *ConverterInputStreamClass) GetGReserved5() func() {
140		if x.xGReserved5 == 0 {	140		if x.xGReserved5 == 0 {
141		return nil	141		return nil

@@ -281,7 +281,7 @@ func (x *ConverterInputStream) IsReadable() bool {
281		//	281		//
282		// The behaviour of this method is undefined if	282		// The behaviour of this method is undefined if
283		// g_pollable_input_stream_can_poll() returns %FALSE for @stream.	283		// g_pollable_input_stream_can_poll() returns %FALSE for @stream.
284	-	func (x ConverterInputStream) ReadNonblocking(BufferVar []byte, CountVar uint, CancellableVar Cancellable) (int, error) {	284	+	func (x ConverterInputStream) ReadNonblocking(BufferVar []byte, CountVar uint, CancellableVar *Cancellable) (int, error) {
285		var cerr *glib.Error	285		var cerr *glib.Error
286			286
287		cret := XGPollableInputStreamReadNonblocking(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)	287		cret := XGPollableInputStreamReadNonblocking(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)

M v4/gio/gconverteroutputstream.go +11 -11


@@ -32,7 +32,7 @@ func (x *ConverterOutputStreamClass) GoPointer() uintptr {
32		return uintptr(unsafe.Pointer(x))	32		return uintptr(unsafe.Pointer(x))
33		}	33		}
34			34
35	-	// OverrideGReserved1 sets the callback function.	35	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
36		func (x *ConverterOutputStreamClass) OverrideGReserved1(cb func()) {	36		func (x *ConverterOutputStreamClass) OverrideGReserved1(cb func()) {
37		if cb == nil {	37		if cb == nil {
38		x.xGReserved1 = 0	38		x.xGReserved1 = 0

@@ -43,7 +43,7 @@ func (x *ConverterOutputStreamClass) OverrideGReserved1(cb func()) {
43		}	43		}
44		}	44		}
45			45
46	-	// GetGReserved1 gets the callback function.	46	+	// GetGReserved1 gets the "_g_reserved1" callback function.
47		func (x *ConverterOutputStreamClass) GetGReserved1() func() {	47		func (x *ConverterOutputStreamClass) GetGReserved1() func() {
48		if x.xGReserved1 == 0 {	48		if x.xGReserved1 == 0 {
49		return nil	49		return nil

@@ -55,7 +55,7 @@ func (x *ConverterOutputStreamClass) GetGReserved1() func() {
55		}	55		}
56		}	56		}
57			57
58	-	// OverrideGReserved2 sets the callback function.	58	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
59		func (x *ConverterOutputStreamClass) OverrideGReserved2(cb func()) {	59		func (x *ConverterOutputStreamClass) OverrideGReserved2(cb func()) {
60		if cb == nil {	60		if cb == nil {
61		x.xGReserved2 = 0	61		x.xGReserved2 = 0

@@ -66,7 +66,7 @@ func (x *ConverterOutputStreamClass) OverrideGReserved2(cb func()) {
66		}	66		}
67		}	67		}
68			68
69	-	// GetGReserved2 gets the callback function.	69	+	// GetGReserved2 gets the "_g_reserved2" callback function.
70		func (x *ConverterOutputStreamClass) GetGReserved2() func() {	70		func (x *ConverterOutputStreamClass) GetGReserved2() func() {
71		if x.xGReserved2 == 0 {	71		if x.xGReserved2 == 0 {
72		return nil	72		return nil

@@ -78,7 +78,7 @@ func (x *ConverterOutputStreamClass) GetGReserved2() func() {
78		}	78		}
79		}	79		}
80			80
81	-	// OverrideGReserved3 sets the callback function.	81	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
82		func (x *ConverterOutputStreamClass) OverrideGReserved3(cb func()) {	82		func (x *ConverterOutputStreamClass) OverrideGReserved3(cb func()) {
83		if cb == nil {	83		if cb == nil {
84		x.xGReserved3 = 0	84		x.xGReserved3 = 0

@@ -89,7 +89,7 @@ func (x *ConverterOutputStreamClass) OverrideGReserved3(cb func()) {
89		}	89		}
90		}	90		}
91			91
92	-	// GetGReserved3 gets the callback function.	92	+	// GetGReserved3 gets the "_g_reserved3" callback function.
93		func (x *ConverterOutputStreamClass) GetGReserved3() func() {	93		func (x *ConverterOutputStreamClass) GetGReserved3() func() {
94		if x.xGReserved3 == 0 {	94		if x.xGReserved3 == 0 {
95		return nil	95		return nil

@@ -101,7 +101,7 @@ func (x *ConverterOutputStreamClass) GetGReserved3() func() {
101		}	101		}
102		}	102		}
103			103
104	-	// OverrideGReserved4 sets the callback function.	104	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
105		func (x *ConverterOutputStreamClass) OverrideGReserved4(cb func()) {	105		func (x *ConverterOutputStreamClass) OverrideGReserved4(cb func()) {
106		if cb == nil {	106		if cb == nil {
107		x.xGReserved4 = 0	107		x.xGReserved4 = 0

@@ -112,7 +112,7 @@ func (x *ConverterOutputStreamClass) OverrideGReserved4(cb func()) {
112		}	112		}
113		}	113		}
114			114
115	-	// GetGReserved4 gets the callback function.	115	+	// GetGReserved4 gets the "_g_reserved4" callback function.
116		func (x *ConverterOutputStreamClass) GetGReserved4() func() {	116		func (x *ConverterOutputStreamClass) GetGReserved4() func() {
117		if x.xGReserved4 == 0 {	117		if x.xGReserved4 == 0 {
118		return nil	118		return nil

@@ -124,7 +124,7 @@ func (x *ConverterOutputStreamClass) GetGReserved4() func() {
124		}	124		}
125		}	125		}
126			126
127	-	// OverrideGReserved5 sets the callback function.	127	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
128		func (x *ConverterOutputStreamClass) OverrideGReserved5(cb func()) {	128		func (x *ConverterOutputStreamClass) OverrideGReserved5(cb func()) {
129		if cb == nil {	129		if cb == nil {
130		x.xGReserved5 = 0	130		x.xGReserved5 = 0

@@ -135,7 +135,7 @@ func (x *ConverterOutputStreamClass) OverrideGReserved5(cb func()) {
135		}	135		}
136		}	136		}
137			137
138	-	// GetGReserved5 gets the callback function.	138	+	// GetGReserved5 gets the "_g_reserved5" callback function.
139		func (x *ConverterOutputStreamClass) GetGReserved5() func() {	139		func (x *ConverterOutputStreamClass) GetGReserved5() func() {
140		if x.xGReserved5 == 0 {	140		if x.xGReserved5 == 0 {
141		return nil	141		return nil

@@ -315,7 +315,7 @@ func (x *ConverterOutputStream) WriteNonblocking(BufferVar []byte, CountVar uint
315		//	315		//
316		// The behaviour of this method is undefined if	316		// The behaviour of this method is undefined if
317		// g_pollable_output_stream_can_poll() returns %FALSE for @stream.	317		// g_pollable_output_stream_can_poll() returns %FALSE for @stream.
318	-	func (x ConverterOutputStream) WritevNonblocking(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar Cancellable) (PollableReturn, error) {	318	+	func (x ConverterOutputStream) WritevNonblocking(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar *Cancellable) (PollableReturn, error) {
319		var cerr *glib.Error	319		var cerr *glib.Error
320			320
321		cret := XGPollableOutputStreamWritevNonblocking(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)	321		cret := XGPollableOutputStreamWritevNonblocking(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)

M v4/gio/gdatagrambased.go +10 -10


@@ -36,7 +36,7 @@ func (x *DatagramBasedInterface) GoPointer() uintptr {
36		return uintptr(unsafe.Pointer(x))	36		return uintptr(unsafe.Pointer(x))
37		}	37		}
38			38
39	-	// OverrideReceiveMessages sets the callback function.	39	+	// OverrideReceiveMessages sets the "receive_messages" callback function.
40		// Virtual method for g_datagram_based_receive_messages().	40		// Virtual method for g_datagram_based_receive_messages().
41		func (x DatagramBasedInterface) OverrideReceiveMessages(cb func(DatagramBased, []InputMessage, uint, int, int64, Cancellable) int) {	41		func (x DatagramBasedInterface) OverrideReceiveMessages(cb func(DatagramBased, []InputMessage, uint, int, int64, Cancellable) int) {
42		if cb == nil {	42		if cb == nil {

@@ -48,7 +48,7 @@ func (x *DatagramBasedInterface) OverrideReceiveMessages(cb func(DatagramBased,
48		}	48		}
49		}	49		}
50			50
51	-	// GetReceiveMessages gets the callback function.	51	+	// GetReceiveMessages gets the "receive_messages" callback function.
52		// Virtual method for g_datagram_based_receive_messages().	52		// Virtual method for g_datagram_based_receive_messages().
53		func (x DatagramBasedInterface) GetReceiveMessages() func(DatagramBased, []InputMessage, uint, int, int64, Cancellable) int {	53		func (x DatagramBasedInterface) GetReceiveMessages() func(DatagramBased, []InputMessage, uint, int, int64, Cancellable) int {
54		if x.xReceiveMessages == 0 {	54		if x.xReceiveMessages == 0 {

@@ -61,7 +61,7 @@ func (x *DatagramBasedInterface) GetReceiveMessages() func(DatagramBased, []Inpu
61		}	61		}
62		}	62		}
63			63
64	-	// OverrideSendMessages sets the callback function.	64	+	// OverrideSendMessages sets the "send_messages" callback function.
65		// Virtual method for g_datagram_based_send_messages().	65		// Virtual method for g_datagram_based_send_messages().
66		func (x DatagramBasedInterface) OverrideSendMessages(cb func(DatagramBased, []OutputMessage, uint, int, int64, Cancellable) int) {	66		func (x DatagramBasedInterface) OverrideSendMessages(cb func(DatagramBased, []OutputMessage, uint, int, int64, Cancellable) int) {
67		if cb == nil {	67		if cb == nil {

@@ -73,7 +73,7 @@ func (x *DatagramBasedInterface) OverrideSendMessages(cb func(DatagramBased, []O
73		}	73		}
74		}	74		}
75			75
76	-	// GetSendMessages gets the callback function.	76	+	// GetSendMessages gets the "send_messages" callback function.
77		// Virtual method for g_datagram_based_send_messages().	77		// Virtual method for g_datagram_based_send_messages().
78		func (x DatagramBasedInterface) GetSendMessages() func(DatagramBased, []OutputMessage, uint, int, int64, Cancellable) int {	78		func (x DatagramBasedInterface) GetSendMessages() func(DatagramBased, []OutputMessage, uint, int, int64, Cancellable) int {
79		if x.xSendMessages == 0 {	79		if x.xSendMessages == 0 {

@@ -86,7 +86,7 @@ func (x *DatagramBasedInterface) GetSendMessages() func(DatagramBased, []OutputM
86		}	86		}
87		}	87		}
88			88
89	-	// OverrideCreateSource sets the callback function.	89	+	// OverrideCreateSource sets the "create_source" callback function.
90		// Virtual method for g_datagram_based_create_source().	90		// Virtual method for g_datagram_based_create_source().
91		func (x DatagramBasedInterface) OverrideCreateSource(cb func(DatagramBased, glib.IOCondition, Cancellable) *glib.Source) {	91		func (x DatagramBasedInterface) OverrideCreateSource(cb func(DatagramBased, glib.IOCondition, Cancellable) *glib.Source) {
92		if cb == nil {	92		if cb == nil {

@@ -98,7 +98,7 @@ func (x *DatagramBasedInterface) OverrideCreateSource(cb func(DatagramBased, gli
98		}	98		}
99		}	99		}
100			100
101	-	// GetCreateSource gets the callback function.	101	+	// GetCreateSource gets the "create_source" callback function.
102		// Virtual method for g_datagram_based_create_source().	102		// Virtual method for g_datagram_based_create_source().
103		func (x DatagramBasedInterface) GetCreateSource() func(DatagramBased, glib.IOCondition, Cancellable) *glib.Source {	103		func (x DatagramBasedInterface) GetCreateSource() func(DatagramBased, glib.IOCondition, Cancellable) *glib.Source {
104		if x.xCreateSource == 0 {	104		if x.xCreateSource == 0 {

@@ -111,7 +111,7 @@ func (x *DatagramBasedInterface) GetCreateSource() func(DatagramBased, glib.IOCo
111		}	111		}
112		}	112		}
113			113
114	-	// OverrideConditionCheck sets the callback function.	114	+	// OverrideConditionCheck sets the "condition_check" callback function.
115		// Virtual method for g_datagram_based_condition_check().	115		// Virtual method for g_datagram_based_condition_check().
116		func (x *DatagramBasedInterface) OverrideConditionCheck(cb func(DatagramBased, glib.IOCondition) glib.IOCondition) {	116		func (x *DatagramBasedInterface) OverrideConditionCheck(cb func(DatagramBased, glib.IOCondition) glib.IOCondition) {
117		if cb == nil {	117		if cb == nil {

@@ -123,7 +123,7 @@ func (x *DatagramBasedInterface) OverrideConditionCheck(cb func(DatagramBased, g
123		}	123		}
124		}	124		}
125			125
126	-	// GetConditionCheck gets the callback function.	126	+	// GetConditionCheck gets the "condition_check" callback function.
127		// Virtual method for g_datagram_based_condition_check().	127		// Virtual method for g_datagram_based_condition_check().
128		func (x *DatagramBasedInterface) GetConditionCheck() func(DatagramBased, glib.IOCondition) glib.IOCondition {	128		func (x *DatagramBasedInterface) GetConditionCheck() func(DatagramBased, glib.IOCondition) glib.IOCondition {
129		if x.xConditionCheck == 0 {	129		if x.xConditionCheck == 0 {

@@ -136,7 +136,7 @@ func (x *DatagramBasedInterface) GetConditionCheck() func(DatagramBased, glib.IO
136		}	136		}
137		}	137		}
138			138
139	-	// OverrideConditionWait sets the callback function.	139	+	// OverrideConditionWait sets the "condition_wait" callback function.
140		// Virtual method for	140		// Virtual method for
141		//	141		//
142		// g_datagram_based_condition_wait().	142		// g_datagram_based_condition_wait().

@@ -150,7 +150,7 @@ func (x *DatagramBasedInterface) OverrideConditionWait(cb func(DatagramBased, gl
150		}	150		}
151		}	151		}
152			152
153	-	// GetConditionWait gets the callback function.	153	+	// GetConditionWait gets the "condition_wait" callback function.
154		// Virtual method for	154		// Virtual method for
155		//	155		//
156		// g_datagram_based_condition_wait().	156		// g_datagram_based_condition_wait().

M v4/gio/gdatainputstream.go +26 -26


@@ -31,7 +31,7 @@ func (x *DataInputStreamClass) GoPointer() uintptr {
31		return uintptr(unsafe.Pointer(x))	31		return uintptr(unsafe.Pointer(x))
32		}	32		}
33			33
34	-	// OverrideGReserved1 sets the callback function.	34	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
35		func (x *DataInputStreamClass) OverrideGReserved1(cb func()) {	35		func (x *DataInputStreamClass) OverrideGReserved1(cb func()) {
36		if cb == nil {	36		if cb == nil {
37		x.xGReserved1 = 0	37		x.xGReserved1 = 0

@@ -42,7 +42,7 @@ func (x *DataInputStreamClass) OverrideGReserved1(cb func()) {
42		}	42		}
43		}	43		}
44			44
45	-	// GetGReserved1 gets the callback function.	45	+	// GetGReserved1 gets the "_g_reserved1" callback function.
46		func (x *DataInputStreamClass) GetGReserved1() func() {	46		func (x *DataInputStreamClass) GetGReserved1() func() {
47		if x.xGReserved1 == 0 {	47		if x.xGReserved1 == 0 {
48		return nil	48		return nil

@@ -54,7 +54,7 @@ func (x *DataInputStreamClass) GetGReserved1() func() {
54		}	54		}
55		}	55		}
56			56
57	-	// OverrideGReserved2 sets the callback function.	57	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
58		func (x *DataInputStreamClass) OverrideGReserved2(cb func()) {	58		func (x *DataInputStreamClass) OverrideGReserved2(cb func()) {
59		if cb == nil {	59		if cb == nil {
60		x.xGReserved2 = 0	60		x.xGReserved2 = 0

@@ -65,7 +65,7 @@ func (x *DataInputStreamClass) OverrideGReserved2(cb func()) {
65		}	65		}
66		}	66		}
67			67
68	-	// GetGReserved2 gets the callback function.	68	+	// GetGReserved2 gets the "_g_reserved2" callback function.
69		func (x *DataInputStreamClass) GetGReserved2() func() {	69		func (x *DataInputStreamClass) GetGReserved2() func() {
70		if x.xGReserved2 == 0 {	70		if x.xGReserved2 == 0 {
71		return nil	71		return nil

@@ -77,7 +77,7 @@ func (x *DataInputStreamClass) GetGReserved2() func() {
77		}	77		}
78		}	78		}
79			79
80	-	// OverrideGReserved3 sets the callback function.	80	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
81		func (x *DataInputStreamClass) OverrideGReserved3(cb func()) {	81		func (x *DataInputStreamClass) OverrideGReserved3(cb func()) {
82		if cb == nil {	82		if cb == nil {
83		x.xGReserved3 = 0	83		x.xGReserved3 = 0

@@ -88,7 +88,7 @@ func (x *DataInputStreamClass) OverrideGReserved3(cb func()) {
88		}	88		}
89		}	89		}
90			90
91	-	// GetGReserved3 gets the callback function.	91	+	// GetGReserved3 gets the "_g_reserved3" callback function.
92		func (x *DataInputStreamClass) GetGReserved3() func() {	92		func (x *DataInputStreamClass) GetGReserved3() func() {
93		if x.xGReserved3 == 0 {	93		if x.xGReserved3 == 0 {
94		return nil	94		return nil

@@ -100,7 +100,7 @@ func (x *DataInputStreamClass) GetGReserved3() func() {
100		}	100		}
101		}	101		}
102			102
103	-	// OverrideGReserved4 sets the callback function.	103	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
104		func (x *DataInputStreamClass) OverrideGReserved4(cb func()) {	104		func (x *DataInputStreamClass) OverrideGReserved4(cb func()) {
105		if cb == nil {	105		if cb == nil {
106		x.xGReserved4 = 0	106		x.xGReserved4 = 0

@@ -111,7 +111,7 @@ func (x *DataInputStreamClass) OverrideGReserved4(cb func()) {
111		}	111		}
112		}	112		}
113			113
114	-	// GetGReserved4 gets the callback function.	114	+	// GetGReserved4 gets the "_g_reserved4" callback function.
115		func (x *DataInputStreamClass) GetGReserved4() func() {	115		func (x *DataInputStreamClass) GetGReserved4() func() {
116		if x.xGReserved4 == 0 {	116		if x.xGReserved4 == 0 {
117		return nil	117		return nil

@@ -123,7 +123,7 @@ func (x *DataInputStreamClass) GetGReserved4() func() {
123		}	123		}
124		}	124		}
125			125
126	-	// OverrideGReserved5 sets the callback function.	126	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
127		func (x *DataInputStreamClass) OverrideGReserved5(cb func()) {	127		func (x *DataInputStreamClass) OverrideGReserved5(cb func()) {
128		if cb == nil {	128		if cb == nil {
129		x.xGReserved5 = 0	129		x.xGReserved5 = 0

@@ -134,7 +134,7 @@ func (x *DataInputStreamClass) OverrideGReserved5(cb func()) {
134		}	134		}
135		}	135		}
136			136
137	-	// GetGReserved5 gets the callback function.	137	+	// GetGReserved5 gets the "_g_reserved5" callback function.
138		func (x *DataInputStreamClass) GetGReserved5() func() {	138		func (x *DataInputStreamClass) GetGReserved5() func() {
139		if x.xGReserved5 == 0 {	139		if x.xGReserved5 == 0 {
140		return nil	140		return nil

@@ -279,7 +279,7 @@ func (x DataInputStream) ReadInt64(CancellableVar Cancellable) (int64, error)
279			279
280		}	280		}
281			281
282	-	var xDataInputStreamReadLine func(uintptr, uint, uintptr, **glib.Error) uintptr	282	+	var xDataInputStreamReadLine func(uintptr, uint, uintptr, *glib.Error) uintptr
283			283
284		// Reads a line from the data input stream. Note that no encoding	284		// Reads a line from the data input stream. Note that no encoding
285		// checks or conversion is performed; the input is not guaranteed to	285		// checks or conversion is performed; the input is not guaranteed to

@@ -288,7 +288,7 @@ var xDataInputStreamReadLine func(uintptr, uint, uintptr, **glib.Error) uintptr
288		// If @cancellable is not %NULL, then the operation can be cancelled by	288		// If @cancellable is not %NULL, then the operation can be cancelled by
289		// triggering the cancellable object from another thread. If the operation	289		// triggering the cancellable object from another thread. If the operation
290		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.	290		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
291	-	func (x DataInputStream) ReadLine(LengthVar uint, CancellableVar Cancellable) (uintptr, error) {	291	+	func (x DataInputStream) ReadLine(LengthVar uint, CancellableVar *Cancellable) (uintptr, error) {
292		var cerr *glib.Error	292		var cerr *glib.Error
293			293
294		cret := xDataInputStreamReadLine(x.GoPointer(), LengthVar, CancellableVar.GoPointer(), &cerr)	294		cret := xDataInputStreamReadLine(x.GoPointer(), LengthVar, CancellableVar.GoPointer(), &cerr)

@@ -313,13 +313,13 @@ func (x DataInputStream) ReadLineAsync(IoPriorityVar int, CancellableVar Cance
313			313
314		}	314		}
315			315
316	-	var xDataInputStreamReadLineFinish func(uintptr, uintptr, uint, **glib.Error) uintptr	316	+	var xDataInputStreamReadLineFinish func(uintptr, uintptr, uint, *glib.Error) uintptr
317			317
318		// Finish an asynchronous call started by	318		// Finish an asynchronous call started by
319		// g_data_input_stream_read_line_async(). Note the warning about	319		// g_data_input_stream_read_line_async(). Note the warning about
320		// string encoding in g_data_input_stream_read_line() applies here as	320		// string encoding in g_data_input_stream_read_line() applies here as
321		// well.	321		// well.
322	-	func (x *DataInputStream) ReadLineFinish(ResultVar AsyncResult, LengthVar uint) (uintptr, error) {	322	+	func (x DataInputStream) ReadLineFinish(ResultVar AsyncResult, LengthVar uint) (uintptr, error) {
323		var cerr *glib.Error	323		var cerr *glib.Error
324			324
325		cret := xDataInputStreamReadLineFinish(x.GoPointer(), ResultVar.GoPointer(), LengthVar, &cerr)	325		cret := xDataInputStreamReadLineFinish(x.GoPointer(), ResultVar.GoPointer(), LengthVar, &cerr)

@@ -330,11 +330,11 @@ func (x *DataInputStream) ReadLineFinish(ResultVar AsyncResult, LengthVar uint)
330			330
331		}	331		}
332			332
333	-	var xDataInputStreamReadLineFinishUtf8 func(uintptr, uintptr, uint, **glib.Error) string	333	+	var xDataInputStreamReadLineFinishUtf8 func(uintptr, uintptr, uint, *glib.Error) string
334			334
335		// Finish an asynchronous call started by	335		// Finish an asynchronous call started by
336		// g_data_input_stream_read_line_async().	336		// g_data_input_stream_read_line_async().
337	-	func (x *DataInputStream) ReadLineFinishUtf8(ResultVar AsyncResult, LengthVar uint) (string, error) {	337	+	func (x DataInputStream) ReadLineFinishUtf8(ResultVar AsyncResult, LengthVar uint) (string, error) {
338		var cerr *glib.Error	338		var cerr *glib.Error
339			339
340		cret := xDataInputStreamReadLineFinishUtf8(x.GoPointer(), ResultVar.GoPointer(), LengthVar, &cerr)	340		cret := xDataInputStreamReadLineFinishUtf8(x.GoPointer(), ResultVar.GoPointer(), LengthVar, &cerr)

@@ -345,14 +345,14 @@ func (x *DataInputStream) ReadLineFinishUtf8(ResultVar AsyncResult, LengthVar ui
345			345
346		}	346		}
347			347
348	-	var xDataInputStreamReadLineUtf8 func(uintptr, uint, uintptr, **glib.Error) string	348	+	var xDataInputStreamReadLineUtf8 func(uintptr, uint, uintptr, *glib.Error) string
349			349
350		// Reads a UTF-8 encoded line from the data input stream.	350		// Reads a UTF-8 encoded line from the data input stream.
351		//	351		//
352		// If @cancellable is not %NULL, then the operation can be cancelled by	352		// If @cancellable is not %NULL, then the operation can be cancelled by
353		// triggering the cancellable object from another thread. If the operation	353		// triggering the cancellable object from another thread. If the operation
354		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.	354		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
355	-	func (x DataInputStream) ReadLineUtf8(LengthVar uint, CancellableVar Cancellable) (string, error) {	355	+	func (x DataInputStream) ReadLineUtf8(LengthVar uint, CancellableVar *Cancellable) (string, error) {
356		var cerr *glib.Error	356		var cerr *glib.Error
357			357
358		cret := xDataInputStreamReadLineUtf8(x.GoPointer(), LengthVar, CancellableVar.GoPointer(), &cerr)	358		cret := xDataInputStreamReadLineUtf8(x.GoPointer(), LengthVar, CancellableVar.GoPointer(), &cerr)

@@ -422,7 +422,7 @@ func (x DataInputStream) ReadUint64(CancellableVar Cancellable) (uint64, error
422			422
423		}	423		}
424			424
425	-	var xDataInputStreamReadUntil func(uintptr, string, uint, uintptr, **glib.Error) string	425	+	var xDataInputStreamReadUntil func(uintptr, string, uint, uintptr, *glib.Error) string
426			426
427		// Reads a string from the data input stream, up to the first	427		// Reads a string from the data input stream, up to the first
428		// occurrence of any of the stop characters.	428		// occurrence of any of the stop characters.

@@ -435,7 +435,7 @@ var xDataInputStreamReadUntil func(uintptr, string, uint, uintptr, **glib.Error)
435		// functions will be marked as deprecated in a future release. Use	435		// functions will be marked as deprecated in a future release. Use
436		// g_data_input_stream_read_upto() instead, but note that that function	436		// g_data_input_stream_read_upto() instead, but note that that function
437		// does not consume the stop character.	437		// does not consume the stop character.
438	-	func (x DataInputStream) ReadUntil(StopCharsVar string, LengthVar uint, CancellableVar Cancellable) (string, error) {	438	+	func (x DataInputStream) ReadUntil(StopCharsVar string, LengthVar uint, CancellableVar *Cancellable) (string, error) {
439		var cerr *glib.Error	439		var cerr *glib.Error
440			440
441		cret := xDataInputStreamReadUntil(x.GoPointer(), StopCharsVar, LengthVar, CancellableVar.GoPointer(), &cerr)	441		cret := xDataInputStreamReadUntil(x.GoPointer(), StopCharsVar, LengthVar, CancellableVar.GoPointer(), &cerr)

@@ -469,11 +469,11 @@ func (x *DataInputStream) ReadUntilAsync(StopCharsVar string, IoPriorityVar int,
469			469
470		}	470		}
471			471
472	-	var xDataInputStreamReadUntilFinish func(uintptr, uintptr, uint, **glib.Error) string	472	+	var xDataInputStreamReadUntilFinish func(uintptr, uintptr, uint, *glib.Error) string
473			473
474		// Finish an asynchronous call started by	474		// Finish an asynchronous call started by
475		// g_data_input_stream_read_until_async().	475		// g_data_input_stream_read_until_async().
476	-	func (x *DataInputStream) ReadUntilFinish(ResultVar AsyncResult, LengthVar uint) (string, error) {	476	+	func (x DataInputStream) ReadUntilFinish(ResultVar AsyncResult, LengthVar uint) (string, error) {
477		var cerr *glib.Error	477		var cerr *glib.Error
478			478
479		cret := xDataInputStreamReadUntilFinish(x.GoPointer(), ResultVar.GoPointer(), LengthVar, &cerr)	479		cret := xDataInputStreamReadUntilFinish(x.GoPointer(), ResultVar.GoPointer(), LengthVar, &cerr)

@@ -484,7 +484,7 @@ func (x *DataInputStream) ReadUntilFinish(ResultVar AsyncResult, LengthVar uint)
484			484
485		}	485		}
486			486
487	-	var xDataInputStreamReadUpto func(uintptr, string, int, uint, uintptr, **glib.Error) string	487	+	var xDataInputStreamReadUpto func(uintptr, string, int, uint, uintptr, *glib.Error) string
488			488
489		// Reads a string from the data input stream, up to the first	489		// Reads a string from the data input stream, up to the first
490		// occurrence of any of the stop characters.	490		// occurrence of any of the stop characters.

@@ -498,7 +498,7 @@ var xDataInputStreamReadUpto func(uintptr, string, int, uint, uintptr, **glib.Er
498		// specified.	498		// specified.
499		//	499		//
500		// The returned string will always be nul-terminated on success.	500		// The returned string will always be nul-terminated on success.
501	-	func (x DataInputStream) ReadUpto(StopCharsVar string, StopCharsLenVar int, LengthVar uint, CancellableVar Cancellable) (string, error) {	501	+	func (x DataInputStream) ReadUpto(StopCharsVar string, StopCharsLenVar int, LengthVar uint, CancellableVar *Cancellable) (string, error) {
502		var cerr *glib.Error	502		var cerr *glib.Error
503			503
504		cret := xDataInputStreamReadUpto(x.GoPointer(), StopCharsVar, StopCharsLenVar, LengthVar, CancellableVar.GoPointer(), &cerr)	504		cret := xDataInputStreamReadUpto(x.GoPointer(), StopCharsVar, StopCharsLenVar, LengthVar, CancellableVar.GoPointer(), &cerr)

@@ -531,7 +531,7 @@ func (x *DataInputStream) ReadUptoAsync(StopCharsVar string, StopCharsLenVar int
531			531
532		}	532		}
533			533
534	-	var xDataInputStreamReadUptoFinish func(uintptr, uintptr, uint, **glib.Error) string	534	+	var xDataInputStreamReadUptoFinish func(uintptr, uintptr, uint, *glib.Error) string
535			535
536		// Finish an asynchronous call started by	536		// Finish an asynchronous call started by
537		// g_data_input_stream_read_upto_async().	537		// g_data_input_stream_read_upto_async().

@@ -541,7 +541,7 @@ var xDataInputStreamReadUptoFinish func(uintptr, uintptr, uint, **glib.Error) st
541		// g_data_input_stream_read_upto_async() again.	541		// g_data_input_stream_read_upto_async() again.
542		//	542		//
543		// The returned string will always be nul-terminated on success.	543		// The returned string will always be nul-terminated on success.
544	-	func (x *DataInputStream) ReadUptoFinish(ResultVar AsyncResult, LengthVar uint) (string, error) {	544	+	func (x DataInputStream) ReadUptoFinish(ResultVar AsyncResult, LengthVar uint) (string, error) {
545		var cerr *glib.Error	545		var cerr *glib.Error
546			546
547		cret := xDataInputStreamReadUptoFinish(x.GoPointer(), ResultVar.GoPointer(), LengthVar, &cerr)	547		cret := xDataInputStreamReadUptoFinish(x.GoPointer(), ResultVar.GoPointer(), LengthVar, &cerr)

M v4/gio/gdataoutputstream.go +10 -10


@@ -31,7 +31,7 @@ func (x *DataOutputStreamClass) GoPointer() uintptr {
31		return uintptr(unsafe.Pointer(x))	31		return uintptr(unsafe.Pointer(x))
32		}	32		}
33			33
34	-	// OverrideGReserved1 sets the callback function.	34	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
35		func (x *DataOutputStreamClass) OverrideGReserved1(cb func()) {	35		func (x *DataOutputStreamClass) OverrideGReserved1(cb func()) {
36		if cb == nil {	36		if cb == nil {
37		x.xGReserved1 = 0	37		x.xGReserved1 = 0

@@ -42,7 +42,7 @@ func (x *DataOutputStreamClass) OverrideGReserved1(cb func()) {
42		}	42		}
43		}	43		}
44			44
45	-	// GetGReserved1 gets the callback function.	45	+	// GetGReserved1 gets the "_g_reserved1" callback function.
46		func (x *DataOutputStreamClass) GetGReserved1() func() {	46		func (x *DataOutputStreamClass) GetGReserved1() func() {
47		if x.xGReserved1 == 0 {	47		if x.xGReserved1 == 0 {
48		return nil	48		return nil

@@ -54,7 +54,7 @@ func (x *DataOutputStreamClass) GetGReserved1() func() {
54		}	54		}
55		}	55		}
56			56
57	-	// OverrideGReserved2 sets the callback function.	57	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
58		func (x *DataOutputStreamClass) OverrideGReserved2(cb func()) {	58		func (x *DataOutputStreamClass) OverrideGReserved2(cb func()) {
59		if cb == nil {	59		if cb == nil {
60		x.xGReserved2 = 0	60		x.xGReserved2 = 0

@@ -65,7 +65,7 @@ func (x *DataOutputStreamClass) OverrideGReserved2(cb func()) {
65		}	65		}
66		}	66		}
67			67
68	-	// GetGReserved2 gets the callback function.	68	+	// GetGReserved2 gets the "_g_reserved2" callback function.
69		func (x *DataOutputStreamClass) GetGReserved2() func() {	69		func (x *DataOutputStreamClass) GetGReserved2() func() {
70		if x.xGReserved2 == 0 {	70		if x.xGReserved2 == 0 {
71		return nil	71		return nil

@@ -77,7 +77,7 @@ func (x *DataOutputStreamClass) GetGReserved2() func() {
77		}	77		}
78		}	78		}
79			79
80	-	// OverrideGReserved3 sets the callback function.	80	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
81		func (x *DataOutputStreamClass) OverrideGReserved3(cb func()) {	81		func (x *DataOutputStreamClass) OverrideGReserved3(cb func()) {
82		if cb == nil {	82		if cb == nil {
83		x.xGReserved3 = 0	83		x.xGReserved3 = 0

@@ -88,7 +88,7 @@ func (x *DataOutputStreamClass) OverrideGReserved3(cb func()) {
88		}	88		}
89		}	89		}
90			90
91	-	// GetGReserved3 gets the callback function.	91	+	// GetGReserved3 gets the "_g_reserved3" callback function.
92		func (x *DataOutputStreamClass) GetGReserved3() func() {	92		func (x *DataOutputStreamClass) GetGReserved3() func() {
93		if x.xGReserved3 == 0 {	93		if x.xGReserved3 == 0 {
94		return nil	94		return nil

@@ -100,7 +100,7 @@ func (x *DataOutputStreamClass) GetGReserved3() func() {
100		}	100		}
101		}	101		}
102			102
103	-	// OverrideGReserved4 sets the callback function.	103	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
104		func (x *DataOutputStreamClass) OverrideGReserved4(cb func()) {	104		func (x *DataOutputStreamClass) OverrideGReserved4(cb func()) {
105		if cb == nil {	105		if cb == nil {
106		x.xGReserved4 = 0	106		x.xGReserved4 = 0

@@ -111,7 +111,7 @@ func (x *DataOutputStreamClass) OverrideGReserved4(cb func()) {
111		}	111		}
112		}	112		}
113			113
114	-	// GetGReserved4 gets the callback function.	114	+	// GetGReserved4 gets the "_g_reserved4" callback function.
115		func (x *DataOutputStreamClass) GetGReserved4() func() {	115		func (x *DataOutputStreamClass) GetGReserved4() func() {
116		if x.xGReserved4 == 0 {	116		if x.xGReserved4 == 0 {
117		return nil	117		return nil

@@ -123,7 +123,7 @@ func (x *DataOutputStreamClass) GetGReserved4() func() {
123		}	123		}
124		}	124		}
125			125
126	-	// OverrideGReserved5 sets the callback function.	126	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
127		func (x *DataOutputStreamClass) OverrideGReserved5(cb func()) {	127		func (x *DataOutputStreamClass) OverrideGReserved5(cb func()) {
128		if cb == nil {	128		if cb == nil {
129		x.xGReserved5 = 0	129		x.xGReserved5 = 0

@@ -134,7 +134,7 @@ func (x *DataOutputStreamClass) OverrideGReserved5(cb func()) {
134		}	134		}
135		}	135		}
136			136
137	-	// GetGReserved5 gets the callback function.	137	+	// GetGReserved5 gets the "_g_reserved5" callback function.
138		func (x *DataOutputStreamClass) GetGReserved5() func() {	138		func (x *DataOutputStreamClass) GetGReserved5() func() {
139		if x.xGReserved5 == 0 {	139		if x.xGReserved5 == 0 {
140		return nil	140		return nil

M v4/gio/gdbusactiongroup.go +1 -1


@@ -266,7 +266,7 @@ func (x *DBusActionGroup) ListActions() []string {
266		// fields (as indicated by having a non-`NULL` reference passed in) are	266		// fields (as indicated by having a non-`NULL` reference passed in) are
267		// filled. If the action doesn’t exist, `FALSE` is returned and the	267		// filled. If the action doesn’t exist, `FALSE` is returned and the
268		// fields may or may not have been modified.	268		// fields may or may not have been modified.
269	-	func (x DBusActionGroup) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar *glib.Variant) bool {	269	+	func (x DBusActionGroup) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar glib.Variant) bool {
270			270
271		cret := XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)	271		cret := XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
272		return cret	272		return cret

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


@@ -60,13 +60,13 @@ func DbusAddressGetStream(AddressVar string, CancellableVar *Cancellable, Callba
60			60
61		}	61		}
62			62
63	-	var xDbusAddressGetStreamFinish func(uintptr, string, **glib.Error) uintptr	63	+	var xDbusAddressGetStreamFinish func(uintptr, string, *glib.Error) uintptr
64			64
65		// Finishes an operation started with g_dbus_address_get_stream().	65		// Finishes an operation started with g_dbus_address_get_stream().
66		//	66		//
67		// A server is not required to set a GUID, so @out_guid may be set to %NULL	67		// A server is not required to set a GUID, so @out_guid may be set to %NULL
68		// even on success.	68		// even on success.
69	-	func DbusAddressGetStreamFinish(ResVar AsyncResult, OutGuidVar string) (*IOStream, error) {	69	+	func DbusAddressGetStreamFinish(ResVar AsyncResult, OutGuidVar string) (IOStream, error) {
70		var cls *IOStream	70		var cls *IOStream
71		var cerr *glib.Error	71		var cerr *glib.Error
72			72

@@ -84,7 +84,7 @@ func DbusAddressGetStreamFinish(ResVar AsyncResult, OutGuidVar string) (*IOStrea
84			84
85		}	85		}
86			86
87	-	var xDbusAddressGetStreamSync func(string, string, uintptr, **glib.Error) uintptr	87	+	var xDbusAddressGetStreamSync func(string, string, uintptr, *glib.Error) uintptr
88			88
89		// Synchronously connects to an endpoint specified by @address and	89		// Synchronously connects to an endpoint specified by @address and
90		// sets up the connection so it is in a state to run the client-side	90		// sets up the connection so it is in a state to run the client-side

@@ -96,7 +96,7 @@ var xDbusAddressGetStreamSync func(string, string, uintptr, **glib.Error) uintpt
96		//	96		//
97		// This is a synchronous failable function. See	97		// This is a synchronous failable function. See
98		// g_dbus_address_get_stream() for the asynchronous version.	98		// g_dbus_address_get_stream() for the asynchronous version.
99	-	func DbusAddressGetStreamSync(AddressVar string, OutGuidVar string, CancellableVar Cancellable) (IOStream, error) {	99	+	func DbusAddressGetStreamSync(AddressVar string, OutGuidVar string, CancellableVar Cancellable) (*IOStream, error) {
100		var cls *IOStream	100		var cls *IOStream
101		var cerr *glib.Error	101		var cerr *glib.Error
102			102

M v4/gio/gdbusconnection.go +123 -10


@@ -659,7 +659,7 @@ func (x *DBusConnection) CallWithUnixFdList(BusNameVar string, ObjectPathVar str
659			659
660		}	660		}
661			661
662	-	var xDBusConnectionCallWithUnixFdListFinish func(uintptr, uintptr, uintptr, *glib.Error) glib.Variant	662	+	var xDBusConnectionCallWithUnixFdListFinish func(uintptr, UnixFDList, uintptr, glib.Error) *glib.Variant
663			663
664		// Finishes an operation started with g_dbus_connection_call_with_unix_fd_list().	664		// Finishes an operation started with g_dbus_connection_call_with_unix_fd_list().
665		//	665		//

@@ -676,7 +676,7 @@ var xDBusConnectionCallWithUnixFdListFinish func(uintptr, uintptr, uintptr, **gl
676		func (x DBusConnection) CallWithUnixFdListFinish(OutFdListVar UnixFDList, ResVar AsyncResult) (glib.Variant, error) {	676		func (x DBusConnection) CallWithUnixFdListFinish(OutFdListVar UnixFDList, ResVar AsyncResult) (glib.Variant, error) {
677		var cerr *glib.Error	677		var cerr *glib.Error
678			678
679	-	cret := xDBusConnectionCallWithUnixFdListFinish(x.GoPointer(), *gobject.ConvertPtr(OutFdListVar), ResVar.GoPointer(), &cerr)	679	+	cret := xDBusConnectionCallWithUnixFdListFinish(x.GoPointer(), OutFdListVar, ResVar.GoPointer(), &cerr)
680		if cerr == nil {	680		if cerr == nil {
681		return cret, nil	681		return cret, nil
682		}	682		}

@@ -684,7 +684,7 @@ func (x DBusConnection) CallWithUnixFdListFinish(OutFdListVar *UnixFDList, Res
684			684
685		}	685		}
686			686
687	-	var xDBusConnectionCallWithUnixFdListSync func(uintptr, string, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, uintptr, uintptr, *glib.Error) glib.Variant	687	+	var xDBusConnectionCallWithUnixFdListSync func(uintptr, string, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, UnixFDList, uintptr, glib.Error) *glib.Variant
688			688
689		// Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.	689		// Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
690		// See g_dbus_connection_call_with_unix_fd_list() and	690		// See g_dbus_connection_call_with_unix_fd_list() and

@@ -694,7 +694,7 @@ var xDBusConnectionCallWithUnixFdListSync func(uintptr, string, string, string,
694		func (x DBusConnection) CallWithUnixFdListSync(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar UnixFDList, OutFdListVar *UnixFDList, CancellableVar Cancellable) (*glib.Variant, error) {	694		func (x DBusConnection) CallWithUnixFdListSync(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar UnixFDList, OutFdListVar *UnixFDList, CancellableVar Cancellable) (*glib.Variant, error) {
695		var cerr *glib.Error	695		var cerr *glib.Error
696			696
697	-	cret := xDBusConnectionCallWithUnixFdListSync(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), *gobject.ConvertPtr(OutFdListVar), CancellableVar.GoPointer(), &cerr)	697	+	cret := xDBusConnectionCallWithUnixFdListSync(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), OutFdListVar, CancellableVar.GoPointer(), &cerr)
698		if cerr == nil {	698		if cerr == nil {
699		return cret, nil	699		return cret, nil
700		}	700		}

@@ -1179,7 +1179,7 @@ func (x *DBusConnection) RemoveFilter(FilterIdVar uint) {
1179			1179
1180		}	1180		}
1181			1181
1182	-	var xDBusConnectionSendMessage func(uintptr, uintptr, DBusSendMessageFlags, uint32, **glib.Error) bool	1182	+	var xDBusConnectionSendMessage func(uintptr, uintptr, DBusSendMessageFlags, uint32, *glib.Error) bool
1183			1183
1184		// Asynchronously sends @message to the peer represented by @connection.	1184		// Asynchronously sends @message to the peer represented by @connection.
1185		//	1185		//

@@ -1203,7 +1203,7 @@ var xDBusConnectionSendMessage func(uintptr, uintptr, DBusSendMessageFlags, uint
1203		//	1203		//
1204		// Note that @message must be unlocked, unless @flags contain the	1204		// Note that @message must be unlocked, unless @flags contain the
1205		// %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.	1205		// %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
1206	-	func (x DBusConnection) SendMessage(MessageVar DBusMessage, FlagsVar DBusSendMessageFlags, OutSerialVar uint32) (bool, error) {	1206	+	func (x DBusConnection) SendMessage(MessageVar DBusMessage, FlagsVar DBusSendMessageFlags, OutSerialVar *uint32) (bool, error) {
1207		var cerr *glib.Error	1207		var cerr *glib.Error
1208			1208
1209		cret := xDBusConnectionSendMessage(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, OutSerialVar, &cerr)	1209		cret := xDBusConnectionSendMessage(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, OutSerialVar, &cerr)

@@ -1214,7 +1214,7 @@ func (x DBusConnection) SendMessage(MessageVar DBusMessage, FlagsVar DBusSendM
1214			1214
1215		}	1215		}
1216			1216
1217	-	var xDBusConnectionSendMessageWithReply func(uintptr, uintptr, DBusSendMessageFlags, int, uint32, uintptr, uintptr, uintptr)	1217	+	var xDBusConnectionSendMessageWithReply func(uintptr, uintptr, DBusSendMessageFlags, int, *uint32, uintptr, uintptr, uintptr)
1218			1218
1219		// Asynchronously sends @message to the peer represented by @connection.	1219		// Asynchronously sends @message to the peer represented by @connection.
1220		//	1220		//

@@ -1246,7 +1246,7 @@ var xDBusConnectionSendMessageWithReply func(uintptr, uintptr, DBusSendMessageFl
1246		// and [client][class@Gio.DBusConnection#an-example-for-file-descriptor-passing]	1246		// and [client][class@Gio.DBusConnection#an-example-for-file-descriptor-passing]
1247		// for an example of how to use this low-level API to send and receive	1247		// for an example of how to use this low-level API to send and receive
1248		// UNIX file descriptors.	1248		// UNIX file descriptors.
1249	-	func (x DBusConnection) SendMessageWithReply(MessageVar DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar uint32, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1249	+	func (x DBusConnection) SendMessageWithReply(MessageVar DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar uint32, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1250			1250
1251		xDBusConnectionSendMessageWithReply(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, TimeoutMsecVar, OutSerialVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1251		xDBusConnectionSendMessageWithReply(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, TimeoutMsecVar, OutSerialVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
1252			1252

@@ -1283,7 +1283,7 @@ func (x DBusConnection) SendMessageWithReplyFinish(ResVar AsyncResult) (DBusMe
1283			1283
1284		}	1284		}
1285			1285
1286	-	var xDBusConnectionSendMessageWithReplySync func(uintptr, uintptr, DBusSendMessageFlags, int, uint32, uintptr, **glib.Error) uintptr	1286	+	var xDBusConnectionSendMessageWithReplySync func(uintptr, uintptr, DBusSendMessageFlags, int, uint32, uintptr, *glib.Error) uintptr
1287			1287
1288		// Synchronously sends @message to the peer represented by @connection	1288		// Synchronously sends @message to the peer represented by @connection
1289		// and blocks the calling thread until a reply is received or the	1289		// and blocks the calling thread until a reply is received or the

@@ -1316,7 +1316,7 @@ var xDBusConnectionSendMessageWithReplySync func(uintptr, uintptr, DBusSendMessa
1316		//	1316		//
1317		// Note that @message must be unlocked, unless @flags contain the	1317		// Note that @message must be unlocked, unless @flags contain the
1318		// %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.	1318		// %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
1319	-	func (x DBusConnection) SendMessageWithReplySync(MessageVar DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar uint32, CancellableVar Cancellable) (DBusMessage, error) {	1319	+	func (x DBusConnection) SendMessageWithReplySync(MessageVar DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar uint32, CancellableVar Cancellable) (*DBusMessage, error) {
1320		var cls *DBusMessage	1320		var cls *DBusMessage
1321		var cerr *glib.Error	1321		var cerr *glib.Error
1322			1322

@@ -1498,6 +1498,119 @@ func (c *DBusConnection) SetGoPointer(ptr uintptr) {
1498		c.Ptr = ptr	1498		c.Ptr = ptr
1499		}	1499		}
1500			1500
			1501	+	// SetPropertyAddress sets the "address" property.
			1502	+	// A D-Bus address specifying potential endpoints that can be used
			1503	+	// when establishing the connection.
			1504	+	func (x *DBusConnection) SetPropertyAddress(value string) {
			1505	+	var v gobject.Value
			1506	+	v.Init(gobject.TypeStringVal)
			1507	+	v.SetString(value)
			1508	+	x.SetProperty("address", &v)
			1509	+	}
			1510	+
			1511	+	// GetPropertyClosed gets the "closed" property.
			1512	+	// A boolean specifying whether the connection has been closed.
			1513	+	func (x *DBusConnection) GetPropertyClosed() bool {
			1514	+	var v gobject.Value
			1515	+	x.GetProperty("closed", &v)
			1516	+	return v.GetBoolean()
			1517	+	}
			1518	+
			1519	+	// SetPropertyExitOnClose sets the "exit-on-close" property.
			1520	+	// A boolean specifying whether the process will be terminated (by
			1521	+	// calling `raise(SIGTERM)`) if the connection is closed by the
			1522	+	// remote peer.
			1523	+	//
			1524	+	// Note that #GDBusConnection objects returned by g_bus_get_finish()
			1525	+	// and g_bus_get_sync() will (usually) have this property set to %TRUE.
			1526	+	func (x *DBusConnection) SetPropertyExitOnClose(value bool) {
			1527	+	var v gobject.Value
			1528	+	v.Init(gobject.TypeBooleanVal)
			1529	+	v.SetBoolean(value)
			1530	+	x.SetProperty("exit-on-close", &v)
			1531	+	}
			1532	+
			1533	+	// GetPropertyExitOnClose gets the "exit-on-close" property.
			1534	+	// A boolean specifying whether the process will be terminated (by
			1535	+	// calling `raise(SIGTERM)`) if the connection is closed by the
			1536	+	// remote peer.
			1537	+	//
			1538	+	// Note that #GDBusConnection objects returned by g_bus_get_finish()
			1539	+	// and g_bus_get_sync() will (usually) have this property set to %TRUE.
			1540	+	func (x *DBusConnection) GetPropertyExitOnClose() bool {
			1541	+	var v gobject.Value
			1542	+	x.GetProperty("exit-on-close", &v)
			1543	+	return v.GetBoolean()
			1544	+	}
			1545	+
			1546	+	// SetPropertyGuid sets the "guid" property.
			1547	+	// The GUID of the peer performing the role of server when
			1548	+	// authenticating.
			1549	+	//
			1550	+	// If you are constructing a #GDBusConnection and pass
			1551	+	// %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER in the
			1552	+	// #GDBusConnection:flags property then you must also set this
			1553	+	// property to a valid guid.
			1554	+	//
			1555	+	// If you are constructing a #GDBusConnection and pass
			1556	+	// %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT in the
			1557	+	// #GDBusConnection:flags property you will be able to read the GUID
			1558	+	// of the other peer here after the connection has been successfully
			1559	+	// initialized.
			1560	+	//
			1561	+	// Note that the
			1562	+	// [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses)
			1563	+	// uses the term ‘UUID’ to refer to this, whereas GLib consistently uses the
			1564	+	// term ‘GUID’ for historical reasons.
			1565	+	//
			1566	+	// Despite its name, the format of #GDBusConnection:guid does not follow
			1567	+	// [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122) or the Microsoft
			1568	+	// GUID format.
			1569	+	func (x *DBusConnection) SetPropertyGuid(value string) {
			1570	+	var v gobject.Value
			1571	+	v.Init(gobject.TypeStringVal)
			1572	+	v.SetString(value)
			1573	+	x.SetProperty("guid", &v)
			1574	+	}
			1575	+
			1576	+	// GetPropertyGuid gets the "guid" property.
			1577	+	// The GUID of the peer performing the role of server when
			1578	+	// authenticating.
			1579	+	//
			1580	+	// If you are constructing a #GDBusConnection and pass
			1581	+	// %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER in the
			1582	+	// #GDBusConnection:flags property then you must also set this
			1583	+	// property to a valid guid.
			1584	+	//
			1585	+	// If you are constructing a #GDBusConnection and pass
			1586	+	// %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT in the
			1587	+	// #GDBusConnection:flags property you will be able to read the GUID
			1588	+	// of the other peer here after the connection has been successfully
			1589	+	// initialized.
			1590	+	//
			1591	+	// Note that the
			1592	+	// [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses)
			1593	+	// uses the term ‘UUID’ to refer to this, whereas GLib consistently uses the
			1594	+	// term ‘GUID’ for historical reasons.
			1595	+	//
			1596	+	// Despite its name, the format of #GDBusConnection:guid does not follow
			1597	+	// [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122) or the Microsoft
			1598	+	// GUID format.
			1599	+	func (x *DBusConnection) GetPropertyGuid() string {
			1600	+	var v gobject.Value
			1601	+	x.GetProperty("guid", &v)
			1602	+	return v.GetString()
			1603	+	}
			1604	+
			1605	+	// GetPropertyUniqueName gets the "unique-name" property.
			1606	+	// The unique name as assigned by the message bus or %NULL if the
			1607	+	// connection is not open or not a message bus connection.
			1608	+	func (x *DBusConnection) GetPropertyUniqueName() string {
			1609	+	var v gobject.Value
			1610	+	x.GetProperty("unique-name", &v)
			1611	+	return v.GetString()
			1612	+	}
			1613	+
1501		// Emitted when the connection is closed.	1614		// Emitted when the connection is closed.
1502		//	1615		//
1503		// # The cause of this event can be	1616		// # The cause of this event can be

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


@@ -30,7 +30,7 @@ func (x *DBusInterfaceIface) GoPointer() uintptr {
30		return uintptr(unsafe.Pointer(x))	30		return uintptr(unsafe.Pointer(x))
31		}	31		}
32			32
33	-	// OverrideGetInfo sets the callback function.	33	+	// OverrideGetInfo sets the "get_info" callback function.
34		// Returns a #GDBusInterfaceInfo. See g_dbus_interface_get_info().	34		// Returns a #GDBusInterfaceInfo. See g_dbus_interface_get_info().
35		func (x DBusInterfaceIface) OverrideGetInfo(cb func(DBusInterface) DBusInterfaceInfo) {	35		func (x DBusInterfaceIface) OverrideGetInfo(cb func(DBusInterface) DBusInterfaceInfo) {
36		if cb == nil {	36		if cb == nil {

@@ -42,7 +42,7 @@ func (x DBusInterfaceIface) OverrideGetInfo(cb func(DBusInterface) DBusInterfa
42		}	42		}
43		}	43		}
44			44
45	-	// GetGetInfo gets the callback function.	45	+	// GetGetInfo gets the "get_info" callback function.
46		// Returns a #GDBusInterfaceInfo. See g_dbus_interface_get_info().	46		// Returns a #GDBusInterfaceInfo. See g_dbus_interface_get_info().
47		func (x DBusInterfaceIface) GetGetInfo() func(DBusInterface) DBusInterfaceInfo {	47		func (x DBusInterfaceIface) GetGetInfo() func(DBusInterface) DBusInterfaceInfo {
48		if x.xGetInfo == 0 {	48		if x.xGetInfo == 0 {

@@ -55,7 +55,7 @@ func (x DBusInterfaceIface) GetGetInfo() func(DBusInterface) DBusInterfaceInfo
55		}	55		}
56		}	56		}
57			57
58	-	// OverrideGetObject sets the callback function.	58	+	// OverrideGetObject sets the "get_object" callback function.
59		// Gets the enclosing #GDBusObject. See g_dbus_interface_get_object().	59		// Gets the enclosing #GDBusObject. See g_dbus_interface_get_object().
60		func (x DBusInterfaceIface) OverrideGetObject(cb func(DBusInterface) DBusObjectBase) {	60		func (x DBusInterfaceIface) OverrideGetObject(cb func(DBusInterface) DBusObjectBase) {
61		if cb == nil {	61		if cb == nil {

@@ -71,7 +71,7 @@ func (x DBusInterfaceIface) OverrideGetObject(cb func(DBusInterface) DBusObjec
71		}	71		}
72		}	72		}
73			73
74	-	// GetGetObject gets the callback function.	74	+	// GetGetObject gets the "get_object" callback function.
75		// Gets the enclosing #GDBusObject. See g_dbus_interface_get_object().	75		// Gets the enclosing #GDBusObject. See g_dbus_interface_get_object().
76		func (x DBusInterfaceIface) GetGetObject() func(DBusInterface) DBusObjectBase {	76		func (x DBusInterfaceIface) GetGetObject() func(DBusInterface) DBusObjectBase {
77		if x.xGetObject == 0 {	77		if x.xGetObject == 0 {

@@ -90,7 +90,7 @@ func (x DBusInterfaceIface) GetGetObject() func(DBusInterface) DBusObjectBase
90		}	90		}
91		}	91		}
92			92
93	-	// OverrideSetObject sets the callback function.	93	+	// OverrideSetObject sets the "set_object" callback function.
94		// Sets the enclosing #GDBusObject. See g_dbus_interface_set_object().	94		// Sets the enclosing #GDBusObject. See g_dbus_interface_set_object().
95		func (x *DBusInterfaceIface) OverrideSetObject(cb func(DBusInterface, DBusObject)) {	95		func (x *DBusInterfaceIface) OverrideSetObject(cb func(DBusInterface, DBusObject)) {
96		if cb == nil {	96		if cb == nil {

@@ -102,7 +102,7 @@ func (x *DBusInterfaceIface) OverrideSetObject(cb func(DBusInterface, DBusObject
102		}	102		}
103		}	103		}
104			104
105	-	// GetSetObject gets the callback function.	105	+	// GetSetObject gets the "set_object" callback function.
106		// Sets the enclosing #GDBusObject. See g_dbus_interface_set_object().	106		// Sets the enclosing #GDBusObject. See g_dbus_interface_set_object().
107		func (x *DBusInterfaceIface) GetSetObject() func(DBusInterface, DBusObject) {	107		func (x *DBusInterfaceIface) GetSetObject() func(DBusInterface, DBusObject) {
108		if x.xSetObject == 0 {	108		if x.xSetObject == 0 {

@@ -115,7 +115,7 @@ func (x *DBusInterfaceIface) GetSetObject() func(DBusInterface, DBusObject) {
115		}	115		}
116		}	116		}
117			117
118	-	// OverrideDupObject sets the callback function.	118	+	// OverrideDupObject sets the "dup_object" callback function.
119		// Gets a reference to the enclosing #GDBusObject. See g_dbus_interface_dup_object(). Added in 2.32.	119		// Gets a reference to the enclosing #GDBusObject. See g_dbus_interface_dup_object(). Added in 2.32.
120		func (x DBusInterfaceIface) OverrideDupObject(cb func(DBusInterface) DBusObjectBase) {	120		func (x DBusInterfaceIface) OverrideDupObject(cb func(DBusInterface) DBusObjectBase) {
121		if cb == nil {	121		if cb == nil {

@@ -131,7 +131,7 @@ func (x DBusInterfaceIface) OverrideDupObject(cb func(DBusInterface) DBusObjec
131		}	131		}
132		}	132		}
133			133
134	-	// GetDupObject gets the callback function.	134	+	// GetDupObject gets the "dup_object" callback function.
135		// Gets a reference to the enclosing #GDBusObject. See g_dbus_interface_dup_object(). Added in 2.32.	135		// Gets a reference to the enclosing #GDBusObject. See g_dbus_interface_dup_object(). Added in 2.32.
136		func (x DBusInterfaceIface) GetDupObject() func(DBusInterface) DBusObjectBase {	136		func (x DBusInterfaceIface) GetDupObject() func(DBusInterface) DBusObjectBase {
137		if x.xDupObject == 0 {	137		if x.xDupObject == 0 {

M v4/gio/gdbusinterfaceskeleton.go +10 -10


@@ -37,7 +37,7 @@ func (x *DBusInterfaceSkeletonClass) GoPointer() uintptr {
37		return uintptr(unsafe.Pointer(x))	37		return uintptr(unsafe.Pointer(x))
38		}	38		}
39			39
40	-	// OverrideGetInfo sets the callback function.	40	+	// OverrideGetInfo sets the "get_info" callback function.
41		// Returns a #GDBusInterfaceInfo. See g_dbus_interface_skeleton_get_info() for details.	41		// Returns a #GDBusInterfaceInfo. See g_dbus_interface_skeleton_get_info() for details.
42		func (x DBusInterfaceSkeletonClass) OverrideGetInfo(cb func(DBusInterfaceSkeleton) *DBusInterfaceInfo) {	42		func (x DBusInterfaceSkeletonClass) OverrideGetInfo(cb func(DBusInterfaceSkeleton) *DBusInterfaceInfo) {
43		if cb == nil {	43		if cb == nil {

@@ -49,7 +49,7 @@ func (x DBusInterfaceSkeletonClass) OverrideGetInfo(cb func(DBusInterfaceSkele
49		}	49		}
50		}	50		}
51			51
52	-	// GetGetInfo gets the callback function.	52	+	// GetGetInfo gets the "get_info" callback function.
53		// Returns a #GDBusInterfaceInfo. See g_dbus_interface_skeleton_get_info() for details.	53		// Returns a #GDBusInterfaceInfo. See g_dbus_interface_skeleton_get_info() for details.
54		func (x DBusInterfaceSkeletonClass) GetGetInfo() func(DBusInterfaceSkeleton) *DBusInterfaceInfo {	54		func (x DBusInterfaceSkeletonClass) GetGetInfo() func(DBusInterfaceSkeleton) *DBusInterfaceInfo {
55		if x.xGetInfo == 0 {	55		if x.xGetInfo == 0 {

@@ -62,7 +62,7 @@ func (x DBusInterfaceSkeletonClass) GetGetInfo() func(DBusInterfaceSkeleton) *
62		}	62		}
63		}	63		}
64			64
65	-	// OverrideGetVtable sets the callback function.	65	+	// OverrideGetVtable sets the "get_vtable" callback function.
66		// Returns a #GDBusInterfaceVTable. See g_dbus_interface_skeleton_get_vtable() for details.	66		// Returns a #GDBusInterfaceVTable. See g_dbus_interface_skeleton_get_vtable() for details.
67		func (x DBusInterfaceSkeletonClass) OverrideGetVtable(cb func(DBusInterfaceSkeleton) *DBusInterfaceVTable) {	67		func (x DBusInterfaceSkeletonClass) OverrideGetVtable(cb func(DBusInterfaceSkeleton) *DBusInterfaceVTable) {
68		if cb == nil {	68		if cb == nil {

@@ -74,7 +74,7 @@ func (x DBusInterfaceSkeletonClass) OverrideGetVtable(cb func(DBusInterfaceSke
74		}	74		}
75		}	75		}
76			76
77	-	// GetGetVtable gets the callback function.	77	+	// GetGetVtable gets the "get_vtable" callback function.
78		// Returns a #GDBusInterfaceVTable. See g_dbus_interface_skeleton_get_vtable() for details.	78		// Returns a #GDBusInterfaceVTable. See g_dbus_interface_skeleton_get_vtable() for details.
79		func (x DBusInterfaceSkeletonClass) GetGetVtable() func(DBusInterfaceSkeleton) *DBusInterfaceVTable {	79		func (x DBusInterfaceSkeletonClass) GetGetVtable() func(DBusInterfaceSkeleton) *DBusInterfaceVTable {
80		if x.xGetVtable == 0 {	80		if x.xGetVtable == 0 {

@@ -87,7 +87,7 @@ func (x DBusInterfaceSkeletonClass) GetGetVtable() func(DBusInterfaceSkeleton)
87		}	87		}
88		}	88		}
89			89
90	-	// OverrideGetProperties sets the callback function.	90	+	// OverrideGetProperties sets the "get_properties" callback function.
91		// Returns a #GVariant with all properties. See g_dbus_interface_skeleton_get_properties().	91		// Returns a #GVariant with all properties. See g_dbus_interface_skeleton_get_properties().
92		func (x DBusInterfaceSkeletonClass) OverrideGetProperties(cb func(DBusInterfaceSkeleton) *glib.Variant) {	92		func (x DBusInterfaceSkeletonClass) OverrideGetProperties(cb func(DBusInterfaceSkeleton) *glib.Variant) {
93		if cb == nil {	93		if cb == nil {

@@ -99,7 +99,7 @@ func (x DBusInterfaceSkeletonClass) OverrideGetProperties(cb func(DBusInterfac
99		}	99		}
100		}	100		}
101			101
102	-	// GetGetProperties gets the callback function.	102	+	// GetGetProperties gets the "get_properties" callback function.
103		// Returns a #GVariant with all properties. See g_dbus_interface_skeleton_get_properties().	103		// Returns a #GVariant with all properties. See g_dbus_interface_skeleton_get_properties().
104		func (x DBusInterfaceSkeletonClass) GetGetProperties() func(DBusInterfaceSkeleton) *glib.Variant {	104		func (x DBusInterfaceSkeletonClass) GetGetProperties() func(DBusInterfaceSkeleton) *glib.Variant {
105		if x.xGetProperties == 0 {	105		if x.xGetProperties == 0 {

@@ -112,7 +112,7 @@ func (x DBusInterfaceSkeletonClass) GetGetProperties() func(DBusInterfaceSkele
112		}	112		}
113		}	113		}
114			114
115	-	// OverrideFlush sets the callback function.	115	+	// OverrideFlush sets the "flush" callback function.
116		// Emits outstanding changes, if any. See g_dbus_interface_skeleton_flush().	116		// Emits outstanding changes, if any. See g_dbus_interface_skeleton_flush().
117		func (x DBusInterfaceSkeletonClass) OverrideFlush(cb func(DBusInterfaceSkeleton)) {	117		func (x DBusInterfaceSkeletonClass) OverrideFlush(cb func(DBusInterfaceSkeleton)) {
118		if cb == nil {	118		if cb == nil {

@@ -124,7 +124,7 @@ func (x DBusInterfaceSkeletonClass) OverrideFlush(cb func(DBusInterfaceSkeleto
124		}	124		}
125		}	125		}
126			126
127	-	// GetFlush gets the callback function.	127	+	// GetFlush gets the "flush" callback function.
128		// Emits outstanding changes, if any. See g_dbus_interface_skeleton_flush().	128		// Emits outstanding changes, if any. See g_dbus_interface_skeleton_flush().
129		func (x DBusInterfaceSkeletonClass) GetFlush() func(DBusInterfaceSkeleton) {	129		func (x DBusInterfaceSkeletonClass) GetFlush() func(DBusInterfaceSkeleton) {
130		if x.xFlush == 0 {	130		if x.xFlush == 0 {

@@ -137,7 +137,7 @@ func (x DBusInterfaceSkeletonClass) GetFlush() func(DBusInterfaceSkeleton) {
137		}	137		}
138		}	138		}
139			139
140	-	// OverrideGAuthorizeMethod sets the callback function.	140	+	// OverrideGAuthorizeMethod sets the "g_authorize_method" callback function.
141		// Signal class handler for the #GDBusInterfaceSkeleton::g-authorize-method signal.	141		// Signal class handler for the #GDBusInterfaceSkeleton::g-authorize-method signal.
142		func (x DBusInterfaceSkeletonClass) OverrideGAuthorizeMethod(cb func(DBusInterfaceSkeleton, *DBusMethodInvocation) bool) {	142		func (x DBusInterfaceSkeletonClass) OverrideGAuthorizeMethod(cb func(DBusInterfaceSkeleton, *DBusMethodInvocation) bool) {
143		if cb == nil {	143		if cb == nil {

@@ -149,7 +149,7 @@ func (x DBusInterfaceSkeletonClass) OverrideGAuthorizeMethod(cb func(DBusInter
149		}	149		}
150		}	150		}
151			151
152	-	// GetGAuthorizeMethod gets the callback function.	152	+	// GetGAuthorizeMethod gets the "g_authorize_method" callback function.
153		// Signal class handler for the #GDBusInterfaceSkeleton::g-authorize-method signal.	153		// Signal class handler for the #GDBusInterfaceSkeleton::g-authorize-method signal.
154		func (x DBusInterfaceSkeletonClass) GetGAuthorizeMethod() func(DBusInterfaceSkeleton, *DBusMethodInvocation) bool {	154		func (x DBusInterfaceSkeletonClass) GetGAuthorizeMethod() func(DBusInterfaceSkeleton, *DBusMethodInvocation) bool {
155		if x.xGAuthorizeMethod == 0 {	155		if x.xGAuthorizeMethod == 0 {

M v4/gio/gdbusmessage.go +9 -2

 }
-var xDBusMessageToBlob func(uintptr, uint, DBusCapabilityFlags, **glib.Error) uintptr
+var xDBusMessageToBlob func(uintptr, *uint, DBusCapabilityFlags, **glib.Error) uintptr
 // Serializes @message to a blob. The byte order returned by
 // g_dbus_message_get_byte_order() will be used.
-func (x *DBusMessage) ToBlob(OutSizeVar uint, CapabilitiesVar DBusCapabilityFlags) (uintptr, error) {
+func (x *DBusMessage) ToBlob(OutSizeVar *uint, CapabilitiesVar DBusCapabilityFlags) (uintptr, error) {
 	var cerr *glib.Error
 	cret := xDBusMessageToBlob(x.GoPointer(), OutSizeVar, CapabilitiesVar, &cerr)
 	c.Ptr = ptr
 }
+// GetPropertyLocked gets the "locked" property.
+func (x *DBusMessage) GetPropertyLocked() bool {
+	var v gobject.Value
+	x.GetProperty("locked", &v)
+	return v.GetBoolean()
+}
 var xDBusMessageBytesNeeded func([]byte, uint, **glib.Error) int
 // Utility function to calculate how many bytes are needed to

M v4/gio/gdbusobject.go +10 -10


@@ -32,7 +32,7 @@ func (x *DBusObjectIface) GoPointer() uintptr {
32		return uintptr(unsafe.Pointer(x))	32		return uintptr(unsafe.Pointer(x))
33		}	33		}
34			34
35	-	// OverrideGetObjectPath sets the callback function.	35	+	// OverrideGetObjectPath sets the "get_object_path" callback function.
36		// Returns the object path. See g_dbus_object_get_object_path().	36		// Returns the object path. See g_dbus_object_get_object_path().
37		func (x *DBusObjectIface) OverrideGetObjectPath(cb func(DBusObject) string) {	37		func (x *DBusObjectIface) OverrideGetObjectPath(cb func(DBusObject) string) {
38		if cb == nil {	38		if cb == nil {

@@ -44,7 +44,7 @@ func (x *DBusObjectIface) OverrideGetObjectPath(cb func(DBusObject) string) {
44		}	44		}
45		}	45		}
46			46
47	-	// GetGetObjectPath gets the callback function.	47	+	// GetGetObjectPath gets the "get_object_path" callback function.
48		// Returns the object path. See g_dbus_object_get_object_path().	48		// Returns the object path. See g_dbus_object_get_object_path().
49		func (x *DBusObjectIface) GetGetObjectPath() func(DBusObject) string {	49		func (x *DBusObjectIface) GetGetObjectPath() func(DBusObject) string {
50		if x.xGetObjectPath == 0 {	50		if x.xGetObjectPath == 0 {

@@ -57,7 +57,7 @@ func (x *DBusObjectIface) GetGetObjectPath() func(DBusObject) string {
57		}	57		}
58		}	58		}
59			59
60	-	// OverrideGetInterfaces sets the callback function.	60	+	// OverrideGetInterfaces sets the "get_interfaces" callback function.
61		// Returns all interfaces. See g_dbus_object_get_interfaces().	61		// Returns all interfaces. See g_dbus_object_get_interfaces().
62		func (x DBusObjectIface) OverrideGetInterfaces(cb func(DBusObject) glib.List) {	62		func (x DBusObjectIface) OverrideGetInterfaces(cb func(DBusObject) glib.List) {
63		if cb == nil {	63		if cb == nil {

@@ -69,7 +69,7 @@ func (x DBusObjectIface) OverrideGetInterfaces(cb func(DBusObject) glib.List)
69		}	69		}
70		}	70		}
71			71
72	-	// GetGetInterfaces gets the callback function.	72	+	// GetGetInterfaces gets the "get_interfaces" callback function.
73		// Returns all interfaces. See g_dbus_object_get_interfaces().	73		// Returns all interfaces. See g_dbus_object_get_interfaces().
74		func (x DBusObjectIface) GetGetInterfaces() func(DBusObject) glib.List {	74		func (x DBusObjectIface) GetGetInterfaces() func(DBusObject) glib.List {
75		if x.xGetInterfaces == 0 {	75		if x.xGetInterfaces == 0 {

@@ -82,7 +82,7 @@ func (x DBusObjectIface) GetGetInterfaces() func(DBusObject) glib.List {
82		}	82		}
83		}	83		}
84			84
85	-	// OverrideGetInterface sets the callback function.	85	+	// OverrideGetInterface sets the "get_interface" callback function.
86		// Returns an interface by name. See g_dbus_object_get_interface().	86		// Returns an interface by name. See g_dbus_object_get_interface().
87		func (x DBusObjectIface) OverrideGetInterface(cb func(DBusObject, string) DBusInterfaceBase) {	87		func (x DBusObjectIface) OverrideGetInterface(cb func(DBusObject, string) DBusInterfaceBase) {
88		if cb == nil {	88		if cb == nil {

@@ -98,7 +98,7 @@ func (x DBusObjectIface) OverrideGetInterface(cb func(DBusObject, string) DBus
98		}	98		}
99		}	99		}
100			100
101	-	// GetGetInterface gets the callback function.	101	+	// GetGetInterface gets the "get_interface" callback function.
102		// Returns an interface by name. See g_dbus_object_get_interface().	102		// Returns an interface by name. See g_dbus_object_get_interface().
103		func (x DBusObjectIface) GetGetInterface() func(DBusObject, string) DBusInterfaceBase {	103		func (x DBusObjectIface) GetGetInterface() func(DBusObject, string) DBusInterfaceBase {
104		if x.xGetInterface == 0 {	104		if x.xGetInterface == 0 {

@@ -117,7 +117,7 @@ func (x DBusObjectIface) GetGetInterface() func(DBusObject, string) DBusInterf
117		}	117		}
118		}	118		}
119			119
120	-	// OverrideInterfaceAdded sets the callback function.	120	+	// OverrideInterfaceAdded sets the "interface_added" callback function.
121		// Signal handler for the #GDBusObject::interface-added signal.	121		// Signal handler for the #GDBusObject::interface-added signal.
122		func (x *DBusObjectIface) OverrideInterfaceAdded(cb func(DBusObject, DBusInterface)) {	122		func (x *DBusObjectIface) OverrideInterfaceAdded(cb func(DBusObject, DBusInterface)) {
123		if cb == nil {	123		if cb == nil {

@@ -129,7 +129,7 @@ func (x *DBusObjectIface) OverrideInterfaceAdded(cb func(DBusObject, DBusInterfa
129		}	129		}
130		}	130		}
131			131
132	-	// GetInterfaceAdded gets the callback function.	132	+	// GetInterfaceAdded gets the "interface_added" callback function.
133		// Signal handler for the #GDBusObject::interface-added signal.	133		// Signal handler for the #GDBusObject::interface-added signal.
134		func (x *DBusObjectIface) GetInterfaceAdded() func(DBusObject, DBusInterface) {	134		func (x *DBusObjectIface) GetInterfaceAdded() func(DBusObject, DBusInterface) {
135		if x.xInterfaceAdded == 0 {	135		if x.xInterfaceAdded == 0 {

@@ -142,7 +142,7 @@ func (x *DBusObjectIface) GetInterfaceAdded() func(DBusObject, DBusInterface) {
142		}	142		}
143		}	143		}
144			144
145	-	// OverrideInterfaceRemoved sets the callback function.	145	+	// OverrideInterfaceRemoved sets the "interface_removed" callback function.
146		// Signal handler for the #GDBusObject::interface-removed signal.	146		// Signal handler for the #GDBusObject::interface-removed signal.
147		func (x *DBusObjectIface) OverrideInterfaceRemoved(cb func(DBusObject, DBusInterface)) {	147		func (x *DBusObjectIface) OverrideInterfaceRemoved(cb func(DBusObject, DBusInterface)) {
148		if cb == nil {	148		if cb == nil {

@@ -154,7 +154,7 @@ func (x *DBusObjectIface) OverrideInterfaceRemoved(cb func(DBusObject, DBusInter
154		}	154		}
155		}	155		}
156			156
157	-	// GetInterfaceRemoved gets the callback function.	157	+	// GetInterfaceRemoved gets the "interface_removed" callback function.
158		// Signal handler for the #GDBusObject::interface-removed signal.	158		// Signal handler for the #GDBusObject::interface-removed signal.
159		func (x *DBusObjectIface) GetInterfaceRemoved() func(DBusObject, DBusInterface) {	159		func (x *DBusObjectIface) GetInterfaceRemoved() func(DBusObject, DBusInterface) {
160		if x.xInterfaceRemoved == 0 {	160		if x.xInterfaceRemoved == 0 {

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


@@ -38,7 +38,7 @@ func (x *DBusObjectManagerIface) GoPointer() uintptr {
38		return uintptr(unsafe.Pointer(x))	38		return uintptr(unsafe.Pointer(x))
39		}	39		}
40			40
41	-	// OverrideGetObjectPath sets the callback function.	41	+	// OverrideGetObjectPath sets the "get_object_path" callback function.
42		// Virtual function for g_dbus_object_manager_get_object_path().	42		// Virtual function for g_dbus_object_manager_get_object_path().
43		func (x *DBusObjectManagerIface) OverrideGetObjectPath(cb func(DBusObjectManager) string) {	43		func (x *DBusObjectManagerIface) OverrideGetObjectPath(cb func(DBusObjectManager) string) {
44		if cb == nil {	44		if cb == nil {

@@ -50,7 +50,7 @@ func (x *DBusObjectManagerIface) OverrideGetObjectPath(cb func(DBusObjectManager
50		}	50		}
51		}	51		}
52			52
53	-	// GetGetObjectPath gets the callback function.	53	+	// GetGetObjectPath gets the "get_object_path" callback function.
54		// Virtual function for g_dbus_object_manager_get_object_path().	54		// Virtual function for g_dbus_object_manager_get_object_path().
55		func (x *DBusObjectManagerIface) GetGetObjectPath() func(DBusObjectManager) string {	55		func (x *DBusObjectManagerIface) GetGetObjectPath() func(DBusObjectManager) string {
56		if x.xGetObjectPath == 0 {	56		if x.xGetObjectPath == 0 {

@@ -63,7 +63,7 @@ func (x *DBusObjectManagerIface) GetGetObjectPath() func(DBusObjectManager) stri
63		}	63		}
64		}	64		}
65			65
66	-	// OverrideGetObjects sets the callback function.	66	+	// OverrideGetObjects sets the "get_objects" callback function.
67		// Virtual function for g_dbus_object_manager_get_objects().	67		// Virtual function for g_dbus_object_manager_get_objects().
68		func (x DBusObjectManagerIface) OverrideGetObjects(cb func(DBusObjectManager) glib.List) {	68		func (x DBusObjectManagerIface) OverrideGetObjects(cb func(DBusObjectManager) glib.List) {
69		if cb == nil {	69		if cb == nil {

@@ -75,7 +75,7 @@ func (x DBusObjectManagerIface) OverrideGetObjects(cb func(DBusObjectManager)
75		}	75		}
76		}	76		}
77			77
78	-	// GetGetObjects gets the callback function.	78	+	// GetGetObjects gets the "get_objects" callback function.
79		// Virtual function for g_dbus_object_manager_get_objects().	79		// Virtual function for g_dbus_object_manager_get_objects().
80		func (x DBusObjectManagerIface) GetGetObjects() func(DBusObjectManager) glib.List {	80		func (x DBusObjectManagerIface) GetGetObjects() func(DBusObjectManager) glib.List {
81		if x.xGetObjects == 0 {	81		if x.xGetObjects == 0 {

@@ -88,7 +88,7 @@ func (x DBusObjectManagerIface) GetGetObjects() func(DBusObjectManager) glib.L
88		}	88		}
89		}	89		}
90			90
91	-	// OverrideGetObject sets the callback function.	91	+	// OverrideGetObject sets the "get_object" callback function.
92		// Virtual function for g_dbus_object_manager_get_object().	92		// Virtual function for g_dbus_object_manager_get_object().
93		func (x DBusObjectManagerIface) OverrideGetObject(cb func(DBusObjectManager, string) DBusObjectBase) {	93		func (x DBusObjectManagerIface) OverrideGetObject(cb func(DBusObjectManager, string) DBusObjectBase) {
94		if cb == nil {	94		if cb == nil {

@@ -104,7 +104,7 @@ func (x *DBusObjectManagerIface) OverrideGetObject(cb func(DBusObjectManager, st
104		}	104		}
105		}	105		}
106			106
107	-	// GetGetObject gets the callback function.	107	+	// GetGetObject gets the "get_object" callback function.
108		// Virtual function for g_dbus_object_manager_get_object().	108		// Virtual function for g_dbus_object_manager_get_object().
109		func (x DBusObjectManagerIface) GetGetObject() func(DBusObjectManager, string) DBusObjectBase {	109		func (x DBusObjectManagerIface) GetGetObject() func(DBusObjectManager, string) DBusObjectBase {
110		if x.xGetObject == 0 {	110		if x.xGetObject == 0 {

@@ -123,7 +123,7 @@ func (x *DBusObjectManagerIface) GetGetObject() func(DBusObjectManager, string)
123		}	123		}
124		}	124		}
125			125
126	-	// OverrideGetInterface sets the callback function.	126	+	// OverrideGetInterface sets the "get_interface" callback function.
127		// Virtual function for g_dbus_object_manager_get_interface().	127		// Virtual function for g_dbus_object_manager_get_interface().
128		func (x DBusObjectManagerIface) OverrideGetInterface(cb func(DBusObjectManager, string, string) DBusInterfaceBase) {	128		func (x DBusObjectManagerIface) OverrideGetInterface(cb func(DBusObjectManager, string, string) DBusInterfaceBase) {
129		if cb == nil {	129		if cb == nil {

@@ -139,7 +139,7 @@ func (x *DBusObjectManagerIface) OverrideGetInterface(cb func(DBusObjectManager,
139		}	139		}
140		}	140		}
141			141
142	-	// GetGetInterface gets the callback function.	142	+	// GetGetInterface gets the "get_interface" callback function.
143		// Virtual function for g_dbus_object_manager_get_interface().	143		// Virtual function for g_dbus_object_manager_get_interface().
144		func (x DBusObjectManagerIface) GetGetInterface() func(DBusObjectManager, string, string) DBusInterfaceBase {	144		func (x DBusObjectManagerIface) GetGetInterface() func(DBusObjectManager, string, string) DBusInterfaceBase {
145		if x.xGetInterface == 0 {	145		if x.xGetInterface == 0 {

@@ -158,7 +158,7 @@ func (x *DBusObjectManagerIface) GetGetInterface() func(DBusObjectManager, strin
158		}	158		}
159		}	159		}
160			160
161	-	// OverrideObjectAdded sets the callback function.	161	+	// OverrideObjectAdded sets the "object_added" callback function.
162		// Signal handler for the #GDBusObjectManager::object-added signal.	162		// Signal handler for the #GDBusObjectManager::object-added signal.
163		func (x *DBusObjectManagerIface) OverrideObjectAdded(cb func(DBusObjectManager, DBusObject)) {	163		func (x *DBusObjectManagerIface) OverrideObjectAdded(cb func(DBusObjectManager, DBusObject)) {
164		if cb == nil {	164		if cb == nil {

@@ -170,7 +170,7 @@ func (x *DBusObjectManagerIface) OverrideObjectAdded(cb func(DBusObjectManager,
170		}	170		}
171		}	171		}
172			172
173	-	// GetObjectAdded gets the callback function.	173	+	// GetObjectAdded gets the "object_added" callback function.
174		// Signal handler for the #GDBusObjectManager::object-added signal.	174		// Signal handler for the #GDBusObjectManager::object-added signal.
175		func (x *DBusObjectManagerIface) GetObjectAdded() func(DBusObjectManager, DBusObject) {	175		func (x *DBusObjectManagerIface) GetObjectAdded() func(DBusObjectManager, DBusObject) {
176		if x.xObjectAdded == 0 {	176		if x.xObjectAdded == 0 {

@@ -183,7 +183,7 @@ func (x *DBusObjectManagerIface) GetObjectAdded() func(DBusObjectManager, DBusOb
183		}	183		}
184		}	184		}
185			185
186	-	// OverrideObjectRemoved sets the callback function.	186	+	// OverrideObjectRemoved sets the "object_removed" callback function.
187		// Signal handler for the #GDBusObjectManager::object-removed signal.	187		// Signal handler for the #GDBusObjectManager::object-removed signal.
188		func (x *DBusObjectManagerIface) OverrideObjectRemoved(cb func(DBusObjectManager, DBusObject)) {	188		func (x *DBusObjectManagerIface) OverrideObjectRemoved(cb func(DBusObjectManager, DBusObject)) {
189		if cb == nil {	189		if cb == nil {

@@ -195,7 +195,7 @@ func (x *DBusObjectManagerIface) OverrideObjectRemoved(cb func(DBusObjectManager
195		}	195		}
196		}	196		}
197			197
198	-	// GetObjectRemoved gets the callback function.	198	+	// GetObjectRemoved gets the "object_removed" callback function.
199		// Signal handler for the #GDBusObjectManager::object-removed signal.	199		// Signal handler for the #GDBusObjectManager::object-removed signal.
200		func (x *DBusObjectManagerIface) GetObjectRemoved() func(DBusObjectManager, DBusObject) {	200		func (x *DBusObjectManagerIface) GetObjectRemoved() func(DBusObjectManager, DBusObject) {
201		if x.xObjectRemoved == 0 {	201		if x.xObjectRemoved == 0 {

@@ -208,7 +208,7 @@ func (x *DBusObjectManagerIface) GetObjectRemoved() func(DBusObjectManager, DBus
208		}	208		}
209		}	209		}
210			210
211	-	// OverrideInterfaceAdded sets the callback function.	211	+	// OverrideInterfaceAdded sets the "interface_added" callback function.
212		// Signal handler for the #GDBusObjectManager::interface-added signal.	212		// Signal handler for the #GDBusObjectManager::interface-added signal.
213		func (x *DBusObjectManagerIface) OverrideInterfaceAdded(cb func(DBusObjectManager, DBusObject, DBusInterface)) {	213		func (x *DBusObjectManagerIface) OverrideInterfaceAdded(cb func(DBusObjectManager, DBusObject, DBusInterface)) {
214		if cb == nil {	214		if cb == nil {

@@ -220,7 +220,7 @@ func (x *DBusObjectManagerIface) OverrideInterfaceAdded(cb func(DBusObjectManage
220		}	220		}
221		}	221		}
222			222
223	-	// GetInterfaceAdded gets the callback function.	223	+	// GetInterfaceAdded gets the "interface_added" callback function.
224		// Signal handler for the #GDBusObjectManager::interface-added signal.	224		// Signal handler for the #GDBusObjectManager::interface-added signal.
225		func (x *DBusObjectManagerIface) GetInterfaceAdded() func(DBusObjectManager, DBusObject, DBusInterface) {	225		func (x *DBusObjectManagerIface) GetInterfaceAdded() func(DBusObjectManager, DBusObject, DBusInterface) {
226		if x.xInterfaceAdded == 0 {	226		if x.xInterfaceAdded == 0 {

@@ -233,7 +233,7 @@ func (x *DBusObjectManagerIface) GetInterfaceAdded() func(DBusObjectManager, DBu
233		}	233		}
234		}	234		}
235			235
236	-	// OverrideInterfaceRemoved sets the callback function.	236	+	// OverrideInterfaceRemoved sets the "interface_removed" callback function.
237		// Signal handler for the #GDBusObjectManager::interface-removed signal.	237		// Signal handler for the #GDBusObjectManager::interface-removed signal.
238		func (x *DBusObjectManagerIface) OverrideInterfaceRemoved(cb func(DBusObjectManager, DBusObject, DBusInterface)) {	238		func (x *DBusObjectManagerIface) OverrideInterfaceRemoved(cb func(DBusObjectManager, DBusObject, DBusInterface)) {
239		if cb == nil {	239		if cb == nil {

@@ -245,7 +245,7 @@ func (x *DBusObjectManagerIface) OverrideInterfaceRemoved(cb func(DBusObjectMana
245		}	245		}
246		}	246		}
247			247
248	-	// GetInterfaceRemoved gets the callback function.	248	+	// GetInterfaceRemoved gets the "interface_removed" callback function.
249		// Signal handler for the #GDBusObjectManager::interface-removed signal.	249		// Signal handler for the #GDBusObjectManager::interface-removed signal.
250		func (x *DBusObjectManagerIface) GetInterfaceRemoved() func(DBusObjectManager, DBusObject, DBusInterface) {	250		func (x *DBusObjectManagerIface) GetInterfaceRemoved() func(DBusObjectManager, DBusObject, DBusInterface) {
251		if x.xInterfaceRemoved == 0 {	251		if x.xInterfaceRemoved == 0 {

M v4/gio/gdbusobjectmanagerclient.go +101 -4


@@ -29,7 +29,7 @@ func (x *DBusObjectManagerClientClass) GoPointer() uintptr {
29		return uintptr(unsafe.Pointer(x))	29		return uintptr(unsafe.Pointer(x))
30		}	30		}
31			31
32	-	// OverrideInterfaceProxySignal sets the callback function.	32	+	// OverrideInterfaceProxySignal sets the "interface_proxy_signal" callback function.
33		// Signal class handler for the #GDBusObjectManagerClient::interface-proxy-signal signal.	33		// Signal class handler for the #GDBusObjectManagerClient::interface-proxy-signal signal.
34		func (x DBusObjectManagerClientClass) OverrideInterfaceProxySignal(cb func(DBusObjectManagerClient, DBusObjectProxy, DBusProxy, string, string, *glib.Variant)) {	34		func (x DBusObjectManagerClientClass) OverrideInterfaceProxySignal(cb func(DBusObjectManagerClient, DBusObjectProxy, DBusProxy, string, string, *glib.Variant)) {
35		if cb == nil {	35		if cb == nil {

@@ -41,7 +41,7 @@ func (x DBusObjectManagerClientClass) OverrideInterfaceProxySignal(cb func(DBu
41		}	41		}
42		}	42		}
43			43
44	-	// GetInterfaceProxySignal gets the callback function.	44	+	// GetInterfaceProxySignal gets the "interface_proxy_signal" callback function.
45		// Signal class handler for the #GDBusObjectManagerClient::interface-proxy-signal signal.	45		// Signal class handler for the #GDBusObjectManagerClient::interface-proxy-signal signal.
46		func (x DBusObjectManagerClientClass) GetInterfaceProxySignal() func(DBusObjectManagerClient, DBusObjectProxy, DBusProxy, string, string, *glib.Variant) {	46		func (x DBusObjectManagerClientClass) GetInterfaceProxySignal() func(DBusObjectManagerClient, DBusObjectProxy, DBusProxy, string, string, *glib.Variant) {
47		if x.xInterfaceProxySignal == 0 {	47		if x.xInterfaceProxySignal == 0 {

@@ -54,7 +54,7 @@ func (x DBusObjectManagerClientClass) GetInterfaceProxySignal() func(DBusObjec
54		}	54		}
55		}	55		}
56			56
57	-	// OverrideInterfaceProxyPropertiesChanged sets the callback function.	57	+	// OverrideInterfaceProxyPropertiesChanged sets the "interface_proxy_properties_changed" callback function.
58		// Signal class handler for the #GDBusObjectManagerClient::interface-proxy-properties-changed signal.	58		// Signal class handler for the #GDBusObjectManagerClient::interface-proxy-properties-changed signal.
59		func (x DBusObjectManagerClientClass) OverrideInterfaceProxyPropertiesChanged(cb func(DBusObjectManagerClient, DBusObjectProxy, DBusProxy, *glib.Variant, string)) {	59		func (x DBusObjectManagerClientClass) OverrideInterfaceProxyPropertiesChanged(cb func(DBusObjectManagerClient, DBusObjectProxy, DBusProxy, *glib.Variant, string)) {
60		if cb == nil {	60		if cb == nil {

@@ -66,7 +66,7 @@ func (x *DBusObjectManagerClientClass) OverrideInterfaceProxyPropertiesChanged(c
66		}	66		}
67		}	67		}
68			68
69	-	// GetInterfaceProxyPropertiesChanged gets the callback function.	69	+	// GetInterfaceProxyPropertiesChanged gets the "interface_proxy_properties_changed" callback function.
70		// Signal class handler for the #GDBusObjectManagerClient::interface-proxy-properties-changed signal.	70		// Signal class handler for the #GDBusObjectManagerClient::interface-proxy-properties-changed signal.
71		func (x DBusObjectManagerClientClass) GetInterfaceProxyPropertiesChanged() func(DBusObjectManagerClient, DBusObjectProxy, DBusProxy, *glib.Variant, string) {	71		func (x DBusObjectManagerClientClass) GetInterfaceProxyPropertiesChanged() func(DBusObjectManagerClient, DBusObjectProxy, DBusProxy, *glib.Variant, string) {
72		if x.xInterfaceProxyPropertiesChanged == 0 {	72		if x.xInterfaceProxyPropertiesChanged == 0 {

@@ -333,6 +333,103 @@ func (c *DBusObjectManagerClient) SetGoPointer(ptr uintptr) {
333		c.Ptr = ptr	333		c.Ptr = ptr
334		}	334		}
335			335
			336	+	// SetPropertyGetProxyTypeDestroyNotify sets the "get-proxy-type-destroy-notify" property.
			337	+	// A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data.
			338	+	func (x *DBusObjectManagerClient) SetPropertyGetProxyTypeDestroyNotify(value uintptr) {
			339	+	var v gobject.Value
			340	+	v.Init(gobject.TypePointerVal)
			341	+	v.SetPointer(value)
			342	+	x.SetProperty("get-proxy-type-destroy-notify", &v)
			343	+	}
			344	+
			345	+	// GetPropertyGetProxyTypeDestroyNotify gets the "get-proxy-type-destroy-notify" property.
			346	+	// A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data.
			347	+	func (x *DBusObjectManagerClient) GetPropertyGetProxyTypeDestroyNotify() uintptr {
			348	+	var v gobject.Value
			349	+	x.GetProperty("get-proxy-type-destroy-notify", &v)
			350	+	return v.GetPointer()
			351	+	}
			352	+
			353	+	// SetPropertyGetProxyTypeFunc sets the "get-proxy-type-func" property.
			354	+	// The #GDBusProxyTypeFunc to use when determining what #GType to
			355	+	// use for interface proxies or %NULL.
			356	+	func (x *DBusObjectManagerClient) SetPropertyGetProxyTypeFunc(value uintptr) {
			357	+	var v gobject.Value
			358	+	v.Init(gobject.TypePointerVal)
			359	+	v.SetPointer(value)
			360	+	x.SetProperty("get-proxy-type-func", &v)
			361	+	}
			362	+
			363	+	// GetPropertyGetProxyTypeFunc gets the "get-proxy-type-func" property.
			364	+	// The #GDBusProxyTypeFunc to use when determining what #GType to
			365	+	// use for interface proxies or %NULL.
			366	+	func (x *DBusObjectManagerClient) GetPropertyGetProxyTypeFunc() uintptr {
			367	+	var v gobject.Value
			368	+	x.GetProperty("get-proxy-type-func", &v)
			369	+	return v.GetPointer()
			370	+	}
			371	+
			372	+	// SetPropertyGetProxyTypeUserData sets the "get-proxy-type-user-data" property.
			373	+	// The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func.
			374	+	func (x *DBusObjectManagerClient) SetPropertyGetProxyTypeUserData(value uintptr) {
			375	+	var v gobject.Value
			376	+	v.Init(gobject.TypePointerVal)
			377	+	v.SetPointer(value)
			378	+	x.SetProperty("get-proxy-type-user-data", &v)
			379	+	}
			380	+
			381	+	// GetPropertyGetProxyTypeUserData gets the "get-proxy-type-user-data" property.
			382	+	// The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func.
			383	+	func (x *DBusObjectManagerClient) GetPropertyGetProxyTypeUserData() uintptr {
			384	+	var v gobject.Value
			385	+	x.GetProperty("get-proxy-type-user-data", &v)
			386	+	return v.GetPointer()
			387	+	}
			388	+
			389	+	// SetPropertyName sets the "name" property.
			390	+	// The well-known name or unique name that the manager is for.
			391	+	func (x *DBusObjectManagerClient) SetPropertyName(value string) {
			392	+	var v gobject.Value
			393	+	v.Init(gobject.TypeStringVal)
			394	+	v.SetString(value)
			395	+	x.SetProperty("name", &v)
			396	+	}
			397	+
			398	+	// GetPropertyName gets the "name" property.
			399	+	// The well-known name or unique name that the manager is for.
			400	+	func (x *DBusObjectManagerClient) GetPropertyName() string {
			401	+	var v gobject.Value
			402	+	x.GetProperty("name", &v)
			403	+	return v.GetString()
			404	+	}
			405	+
			406	+	// GetPropertyNameOwner gets the "name-owner" property.
			407	+	// The unique name that owns #GDBusObjectManagerClient:name or %NULL if
			408	+	// no-one is currently owning the name. Connect to the
			409	+	// #GObject::notify signal to track changes to this property.
			410	+	func (x *DBusObjectManagerClient) GetPropertyNameOwner() string {
			411	+	var v gobject.Value
			412	+	x.GetProperty("name-owner", &v)
			413	+	return v.GetString()
			414	+	}
			415	+
			416	+	// SetPropertyObjectPath sets the "object-path" property.
			417	+	// The object path the manager is for.
			418	+	func (x *DBusObjectManagerClient) SetPropertyObjectPath(value string) {
			419	+	var v gobject.Value
			420	+	v.Init(gobject.TypeStringVal)
			421	+	v.SetString(value)
			422	+	x.SetProperty("object-path", &v)
			423	+	}
			424	+
			425	+	// GetPropertyObjectPath gets the "object-path" property.
			426	+	// The object path the manager is for.
			427	+	func (x *DBusObjectManagerClient) GetPropertyObjectPath() string {
			428	+	var v gobject.Value
			429	+	x.GetProperty("object-path", &v)
			430	+	return v.GetString()
			431	+	}
			432	+
336		// Emitted when one or more D-Bus properties on proxy changes. The	433		// Emitted when one or more D-Bus properties on proxy changes. The
337		// local cache has already been updated when this signal fires. Note	434		// local cache has already been updated when this signal fires. Note
338		// that both @changed_properties and @invalidated_properties are	435		// that both @changed_properties and @invalidated_properties are

M v4/gio/gdbusobjectmanagerserver.go +17 -0


@@ -181,6 +181,23 @@ func (c *DBusObjectManagerServer) SetGoPointer(ptr uintptr) {
181	c.Ptr = ptr	181		c.Ptr = ptr
182	}	182		}
183		183
		184	+	// SetPropertyObjectPath sets the "object-path" property.
		185	+	// The object path to register the manager object at.
		186	+	func (x *DBusObjectManagerServer) SetPropertyObjectPath(value string) {
		187	+	var v gobject.Value
		188	+	v.Init(gobject.TypeStringVal)
		189	+	v.SetString(value)
		190	+	x.SetProperty("object-path", &v)
		191	+	}
		192	+
		193	+	// GetPropertyObjectPath gets the "object-path" property.
		194	+	// The object path to register the manager object at.
		195	+	func (x *DBusObjectManagerServer) GetPropertyObjectPath() string {
		196	+	var v gobject.Value
		197	+	x.GetProperty("object-path", &v)
		198	+	return v.GetString()
		199	+	}
		200	+
184	// Gets the interface proxy for @interface_name at @object_path, if	201		// Gets the interface proxy for @interface_name at @object_path, if
185	// any.	202		// any.
186	func (x DBusObjectManagerServer) GetInterface(ObjectPathVar string, InterfaceNameVar string) DBusInterfaceBase {	203		func (x DBusObjectManagerServer) GetInterface(ObjectPathVar string, InterfaceNameVar string) DBusInterfaceBase {

M v4/gio/gdbusobjectproxy.go +17 -0


@@ -98,6 +98,23 @@ func (c *DBusObjectProxy) SetGoPointer(ptr uintptr) {
98	c.Ptr = ptr	98		c.Ptr = ptr
99	}	99		}
100		100
		101	+	// SetPropertyGObjectPath sets the "g-object-path" property.
		102	+	// The object path of the proxy.
		103	+	func (x *DBusObjectProxy) SetPropertyGObjectPath(value string) {
		104	+	var v gobject.Value
		105	+	v.Init(gobject.TypeStringVal)
		106	+	v.SetString(value)
		107	+	x.SetProperty("g-object-path", &v)
		108	+	}
		109	+
		110	+	// GetPropertyGObjectPath gets the "g-object-path" property.
		111	+	// The object path of the proxy.
		112	+	func (x *DBusObjectProxy) GetPropertyGObjectPath() string {
		113	+	var v gobject.Value
		114	+	x.GetProperty("g-object-path", &v)
		115	+	return v.GetString()
		116	+	}
		117	+
101	// Gets the D-Bus interface with name @interface_name associated with	118		// Gets the D-Bus interface with name @interface_name associated with
102	// @object, if any.	119		// @object, if any.
103	func (x DBusObjectProxy) GetInterface(InterfaceNameVar string) DBusInterfaceBase {	120		func (x DBusObjectProxy) GetInterface(InterfaceNameVar string) DBusInterfaceBase {

M v4/gio/gdbusobjectskeleton.go +19 -2

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideAuthorizeMethod sets the callback function.
+// OverrideAuthorizeMethod sets the "authorize_method" callback function.
 // Signal class handler for the #GDBusObjectSkeleton::authorize-method signal.
 func (x *DBusObjectSkeletonClass) OverrideAuthorizeMethod(cb func(*DBusObjectSkeleton, *DBusInterfaceSkeleton, *DBusMethodInvocation) bool) {
 	if cb == nil {
 	}
 }
-// GetAuthorizeMethod gets the callback function.
+// GetAuthorizeMethod gets the "authorize_method" callback function.
 // Signal class handler for the #GDBusObjectSkeleton::authorize-method signal.
 func (x *DBusObjectSkeletonClass) GetAuthorizeMethod() func(*DBusObjectSkeleton, *DBusInterfaceSkeleton, *DBusMethodInvocation) bool {
 	if x.xAuthorizeMethod == 0 {
 	c.Ptr = ptr
 }
+// SetPropertyGObjectPath sets the "g-object-path" property.
+// The object path where the object is exported.
+func (x *DBusObjectSkeleton) SetPropertyGObjectPath(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("g-object-path", &v)
+}
+// GetPropertyGObjectPath gets the "g-object-path" property.
+// The object path where the object is exported.
+func (x *DBusObjectSkeleton) GetPropertyGObjectPath() string {
+	var v gobject.Value
+	x.GetProperty("g-object-path", &v)
+	return v.GetString()
+}
 // Emitted when a method is invoked by a remote caller and used to
 // determine if the method call is authorized.
 //

M v4/gio/gdbusproxy.go +165 -8


@@ -29,7 +29,7 @@ func (x *DBusProxyClass) GoPointer() uintptr {
29		return uintptr(unsafe.Pointer(x))	29		return uintptr(unsafe.Pointer(x))
30		}	30		}
31			31
32	-	// OverrideGPropertiesChanged sets the callback function.	32	+	// OverrideGPropertiesChanged sets the "g_properties_changed" callback function.
33		// Signal class handler for the #GDBusProxy::g-properties-changed signal.	33		// Signal class handler for the #GDBusProxy::g-properties-changed signal.
34		func (x DBusProxyClass) OverrideGPropertiesChanged(cb func(DBusProxy, *glib.Variant, string)) {	34		func (x DBusProxyClass) OverrideGPropertiesChanged(cb func(DBusProxy, *glib.Variant, string)) {
35		if cb == nil {	35		if cb == nil {

@@ -41,7 +41,7 @@ func (x DBusProxyClass) OverrideGPropertiesChanged(cb func(DBusProxy, *glib.Va
41		}	41		}
42		}	42		}
43			43
44	-	// GetGPropertiesChanged gets the callback function.	44	+	// GetGPropertiesChanged gets the "g_properties_changed" callback function.
45		// Signal class handler for the #GDBusProxy::g-properties-changed signal.	45		// Signal class handler for the #GDBusProxy::g-properties-changed signal.
46		func (x DBusProxyClass) GetGPropertiesChanged() func(DBusProxy, *glib.Variant, string) {	46		func (x DBusProxyClass) GetGPropertiesChanged() func(DBusProxy, *glib.Variant, string) {
47		if x.xGPropertiesChanged == 0 {	47		if x.xGPropertiesChanged == 0 {

@@ -54,7 +54,7 @@ func (x DBusProxyClass) GetGPropertiesChanged() func(DBusProxy, *glib.Variant,
54		}	54		}
55		}	55		}
56			56
57	-	// OverrideGSignal sets the callback function.	57	+	// OverrideGSignal sets the "g_signal" callback function.
58		// Signal class handler for the #GDBusProxy::g-signal signal.	58		// Signal class handler for the #GDBusProxy::g-signal signal.
59		func (x DBusProxyClass) OverrideGSignal(cb func(DBusProxy, string, string, *glib.Variant)) {	59		func (x DBusProxyClass) OverrideGSignal(cb func(DBusProxy, string, string, *glib.Variant)) {
60		if cb == nil {	60		if cb == nil {

@@ -66,7 +66,7 @@ func (x DBusProxyClass) OverrideGSignal(cb func(DBusProxy, string, string, *gl
66		}	66		}
67		}	67		}
68			68
69	-	// GetGSignal gets the callback function.	69	+	// GetGSignal gets the "g_signal" callback function.
70		// Signal class handler for the #GDBusProxy::g-signal signal.	70		// Signal class handler for the #GDBusProxy::g-signal signal.
71		func (x DBusProxyClass) GetGSignal() func(DBusProxy, string, string, *glib.Variant) {	71		func (x DBusProxyClass) GetGSignal() func(DBusProxy, string, string, *glib.Variant) {
72		if x.xGSignal == 0 {	72		if x.xGSignal == 0 {

@@ -383,13 +383,13 @@ func (x DBusProxy) CallWithUnixFdList(MethodNameVar string, ParametersVar glib
383			383
384		}	384		}
385			385
386	-	var xDBusProxyCallWithUnixFdListFinish func(uintptr, uintptr, uintptr, *glib.Error) glib.Variant	386	+	var xDBusProxyCallWithUnixFdListFinish func(uintptr, UnixFDList, uintptr, glib.Error) *glib.Variant
387			387
388		// Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list().	388		// Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list().
389		func (x DBusProxy) CallWithUnixFdListFinish(OutFdListVar UnixFDList, ResVar AsyncResult) (glib.Variant, error) {	389		func (x DBusProxy) CallWithUnixFdListFinish(OutFdListVar UnixFDList, ResVar AsyncResult) (glib.Variant, error) {
390		var cerr *glib.Error	390		var cerr *glib.Error
391			391
392	-	cret := xDBusProxyCallWithUnixFdListFinish(x.GoPointer(), *gobject.ConvertPtr(OutFdListVar), ResVar.GoPointer(), &cerr)	392	+	cret := xDBusProxyCallWithUnixFdListFinish(x.GoPointer(), OutFdListVar, ResVar.GoPointer(), &cerr)
393		if cerr == nil {	393		if cerr == nil {
394		return cret, nil	394		return cret, nil
395		}	395		}

@@ -397,7 +397,7 @@ func (x DBusProxy) CallWithUnixFdListFinish(OutFdListVar *UnixFDList, ResVar A
397			397
398		}	398		}
399			399
400	-	var xDBusProxyCallWithUnixFdListSync func(uintptr, string, glib.Variant, DBusCallFlags, int, uintptr, uintptr, uintptr, glib.Error) glib.Variant	400	+	var xDBusProxyCallWithUnixFdListSync func(uintptr, string, glib.Variant, DBusCallFlags, int, uintptr, UnixFDList, uintptr, glib.Error) glib.Variant
401			401
402		// Like g_dbus_proxy_call_sync() but also takes and returns #GUnixFDList objects.	402		// Like g_dbus_proxy_call_sync() but also takes and returns #GUnixFDList objects.
403		//	403		//

@@ -405,7 +405,7 @@ var xDBusProxyCallWithUnixFdListSync func(uintptr, string, *glib.Variant, DBusCa
405		func (x DBusProxy) CallWithUnixFdListSync(MethodNameVar string, ParametersVar glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar UnixFDList, OutFdListVar UnixFDList, CancellableVar Cancellable) (*glib.Variant, error) {	405		func (x DBusProxy) CallWithUnixFdListSync(MethodNameVar string, ParametersVar glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar UnixFDList, OutFdListVar UnixFDList, CancellableVar Cancellable) (*glib.Variant, error) {
406		var cerr *glib.Error	406		var cerr *glib.Error
407			407
408	-	cret := xDBusProxyCallWithUnixFdListSync(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), *gobject.ConvertPtr(OutFdListVar), CancellableVar.GoPointer(), &cerr)	408	+	cret := xDBusProxyCallWithUnixFdListSync(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), OutFdListVar, CancellableVar.GoPointer(), &cerr)
409		if cerr == nil {	409		if cerr == nil {
410		return cret, nil	410		return cret, nil
411		}	411		}

@@ -607,6 +607,163 @@ func (c *DBusProxy) SetGoPointer(ptr uintptr) {
607		c.Ptr = ptr	607		c.Ptr = ptr
608		}	608		}
609			609
			610	+	// SetPropertyGDefaultTimeout sets the "g-default-timeout" property.
			611	+	// The timeout to use if -1 (specifying default timeout) is passed
			612	+	// as @timeout_msec in the g_dbus_proxy_call() and
			613	+	// g_dbus_proxy_call_sync() functions.
			614	+	//
			615	+	// This allows applications to set a proxy-wide timeout for all
			616	+	// remote method invocations on the proxy. If this property is -1,
			617	+	// the default timeout (typically 25 seconds) is used. If set to
			618	+	// %G_MAXINT, then no timeout is used.
			619	+	func (x *DBusProxy) SetPropertyGDefaultTimeout(value int) {
			620	+	var v gobject.Value
			621	+	v.Init(gobject.TypeIntVal)
			622	+	v.SetInt(value)
			623	+	x.SetProperty("g-default-timeout", &v)
			624	+	}
			625	+
			626	+	// GetPropertyGDefaultTimeout gets the "g-default-timeout" property.
			627	+	// The timeout to use if -1 (specifying default timeout) is passed
			628	+	// as @timeout_msec in the g_dbus_proxy_call() and
			629	+	// g_dbus_proxy_call_sync() functions.
			630	+	//
			631	+	// This allows applications to set a proxy-wide timeout for all
			632	+	// remote method invocations on the proxy. If this property is -1,
			633	+	// the default timeout (typically 25 seconds) is used. If set to
			634	+	// %G_MAXINT, then no timeout is used.
			635	+	func (x *DBusProxy) GetPropertyGDefaultTimeout() int {
			636	+	var v gobject.Value
			637	+	x.GetProperty("g-default-timeout", &v)
			638	+	return v.GetInt()
			639	+	}
			640	+
			641	+	// SetPropertyGInterfaceInfo sets the "g-interface-info" property.
			642	+	// Ensure that interactions with this proxy conform to the given
			643	+	// interface. This is mainly to ensure that malformed data received
			644	+	// from the other peer is ignored. The given #GDBusInterfaceInfo is
			645	+	// said to be the "expected interface".
			646	+	//
			647	+	// The checks performed are:
			648	+	//
			649	+	// - When completing a method call, if the type signature of
			650	+	// the reply message isn't what's expected, the reply is
			651	+	// discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT.
			652	+	//
			653	+	// - Received signals that have a type signature mismatch are dropped and
			654	+	// a warning is logged via g_warning().
			655	+	//
			656	+	// - Properties received via the initial `GetAll()` call or via the
			657	+	// `::PropertiesChanged` signal (on the
			658	+	// [org.freedesktop.DBus.Properties](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties)
			659	+	// interface) or set using g_dbus_proxy_set_cached_property()
			660	+	// with a type signature mismatch are ignored and a warning is
			661	+	// logged via g_warning().
			662	+	//
			663	+	// Note that these checks are never done on methods, signals and
			664	+	// properties that are not referenced in the given
			665	+	// #GDBusInterfaceInfo, since extending a D-Bus interface on the
			666	+	// service-side is not considered an ABI break.
			667	+	func (x *DBusProxy) SetPropertyGInterfaceInfo(value uintptr) {
			668	+	var v gobject.Value
			669	+	v.Init(gobject.TypePointerVal)
			670	+	v.SetPointer(value)
			671	+	x.SetProperty("g-interface-info", &v)
			672	+	}
			673	+
			674	+	// GetPropertyGInterfaceInfo gets the "g-interface-info" property.
			675	+	// Ensure that interactions with this proxy conform to the given
			676	+	// interface. This is mainly to ensure that malformed data received
			677	+	// from the other peer is ignored. The given #GDBusInterfaceInfo is
			678	+	// said to be the "expected interface".
			679	+	//
			680	+	// The checks performed are:
			681	+	//
			682	+	// - When completing a method call, if the type signature of
			683	+	// the reply message isn't what's expected, the reply is
			684	+	// discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT.
			685	+	//
			686	+	// - Received signals that have a type signature mismatch are dropped and
			687	+	// a warning is logged via g_warning().
			688	+	//
			689	+	// - Properties received via the initial `GetAll()` call or via the
			690	+	// `::PropertiesChanged` signal (on the
			691	+	// [org.freedesktop.DBus.Properties](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties)
			692	+	// interface) or set using g_dbus_proxy_set_cached_property()
			693	+	// with a type signature mismatch are ignored and a warning is
			694	+	// logged via g_warning().
			695	+	//
			696	+	// Note that these checks are never done on methods, signals and
			697	+	// properties that are not referenced in the given
			698	+	// #GDBusInterfaceInfo, since extending a D-Bus interface on the
			699	+	// service-side is not considered an ABI break.
			700	+	func (x *DBusProxy) GetPropertyGInterfaceInfo() uintptr {
			701	+	var v gobject.Value
			702	+	x.GetProperty("g-interface-info", &v)
			703	+	return v.GetPointer()
			704	+	}
			705	+
			706	+	// SetPropertyGInterfaceName sets the "g-interface-name" property.
			707	+	// The D-Bus interface name the proxy is for.
			708	+	func (x *DBusProxy) SetPropertyGInterfaceName(value string) {
			709	+	var v gobject.Value
			710	+	v.Init(gobject.TypeStringVal)
			711	+	v.SetString(value)
			712	+	x.SetProperty("g-interface-name", &v)
			713	+	}
			714	+
			715	+	// GetPropertyGInterfaceName gets the "g-interface-name" property.
			716	+	// The D-Bus interface name the proxy is for.
			717	+	func (x *DBusProxy) GetPropertyGInterfaceName() string {
			718	+	var v gobject.Value
			719	+	x.GetProperty("g-interface-name", &v)
			720	+	return v.GetString()
			721	+	}
			722	+
			723	+	// SetPropertyGName sets the "g-name" property.
			724	+	// The well-known or unique name that the proxy is for.
			725	+	func (x *DBusProxy) SetPropertyGName(value string) {
			726	+	var v gobject.Value
			727	+	v.Init(gobject.TypeStringVal)
			728	+	v.SetString(value)
			729	+	x.SetProperty("g-name", &v)
			730	+	}
			731	+
			732	+	// GetPropertyGName gets the "g-name" property.
			733	+	// The well-known or unique name that the proxy is for.
			734	+	func (x *DBusProxy) GetPropertyGName() string {
			735	+	var v gobject.Value
			736	+	x.GetProperty("g-name", &v)
			737	+	return v.GetString()
			738	+	}
			739	+
			740	+	// GetPropertyGNameOwner gets the "g-name-owner" property.
			741	+	// The unique name that owns #GDBusProxy:g-name or %NULL if no-one
			742	+	// currently owns that name. You may connect to #GObject::notify signal to
			743	+	// track changes to this property.
			744	+	func (x *DBusProxy) GetPropertyGNameOwner() string {
			745	+	var v gobject.Value
			746	+	x.GetProperty("g-name-owner", &v)
			747	+	return v.GetString()
			748	+	}
			749	+
			750	+	// SetPropertyGObjectPath sets the "g-object-path" property.
			751	+	// The object path the proxy is for.
			752	+	func (x *DBusProxy) SetPropertyGObjectPath(value string) {
			753	+	var v gobject.Value
			754	+	v.Init(gobject.TypeStringVal)
			755	+	v.SetString(value)
			756	+	x.SetProperty("g-object-path", &v)
			757	+	}
			758	+
			759	+	// GetPropertyGObjectPath gets the "g-object-path" property.
			760	+	// The object path the proxy is for.
			761	+	func (x *DBusProxy) GetPropertyGObjectPath() string {
			762	+	var v gobject.Value
			763	+	x.GetProperty("g-object-path", &v)
			764	+	return v.GetString()
			765	+	}
			766	+
610		// Emitted when one or more D-Bus properties on @proxy changes. The	767		// Emitted when one or more D-Bus properties on @proxy changes. The
611		// local cache has already been updated when this signal fires. Note	768		// local cache has already been updated when this signal fires. Note
612		// that both @changed_properties and @invalidated_properties are	769		// that both @changed_properties and @invalidated_properties are

M v4/gio/gdbusserver.go +54 -0


@@ -156,6 +156,60 @@ func (c *DBusServer) SetGoPointer(ptr uintptr) {
156	c.Ptr = ptr	156		c.Ptr = ptr
157	}	157		}
158		158
		159	+	// GetPropertyActive gets the "active" property.
		160	+	// Whether the server is currently active.
		161	+	func (x *DBusServer) GetPropertyActive() bool {
		162	+	var v gobject.Value
		163	+	x.GetProperty("active", &v)
		164	+	return v.GetBoolean()
		165	+	}
		166	+
		167	+	// SetPropertyAddress sets the "address" property.
		168	+	// The D-Bus address to listen on.
		169	+	func (x *DBusServer) SetPropertyAddress(value string) {
		170	+	var v gobject.Value
		171	+	v.Init(gobject.TypeStringVal)
		172	+	v.SetString(value)
		173	+	x.SetProperty("address", &v)
		174	+	}
		175	+
		176	+	// GetPropertyAddress gets the "address" property.
		177	+	// The D-Bus address to listen on.
		178	+	func (x *DBusServer) GetPropertyAddress() string {
		179	+	var v gobject.Value
		180	+	x.GetProperty("address", &v)
		181	+	return v.GetString()
		182	+	}
		183	+
		184	+	// GetPropertyClientAddress gets the "client-address" property.
		185	+	// The D-Bus address that clients can use.
		186	+	func (x *DBusServer) GetPropertyClientAddress() string {
		187	+	var v gobject.Value
		188	+	x.GetProperty("client-address", &v)
		189	+	return v.GetString()
		190	+	}
		191	+
		192	+	// SetPropertyGuid sets the "guid" property.
		193	+	// The GUID of the server.
		194	+	//
		195	+	// See #GDBusConnection:guid for more details.
		196	+	func (x *DBusServer) SetPropertyGuid(value string) {
		197	+	var v gobject.Value
		198	+	v.Init(gobject.TypeStringVal)
		199	+	v.SetString(value)
		200	+	x.SetProperty("guid", &v)
		201	+	}
		202	+
		203	+	// GetPropertyGuid gets the "guid" property.
		204	+	// The GUID of the server.
		205	+	//
		206	+	// See #GDBusConnection:guid for more details.
		207	+	func (x *DBusServer) GetPropertyGuid() string {
		208	+	var v gobject.Value
		209	+	x.GetProperty("guid", &v)
		210	+	return v.GetString()
		211	+	}
		212	+
159	// Emitted when a new authenticated connection has been made. Use	213		// Emitted when a new authenticated connection has been made. Use
160	// g_dbus_connection_get_peer_credentials() to figure out what	214		// g_dbus_connection_get_peer_credentials() to figure out what
161	// identity (if any), was authenticated.	215		// identity (if any), was authenticated.

M v4/gio/gdebugcontroller.go +24 -0


@@ -7,6 +7,7 @@ import (
7		7
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
		10	+	"github.com/jwijenbergh/puregotk/v4/gobject"
10	"github.com/jwijenbergh/puregotk/v4/gobject/types"	11		"github.com/jwijenbergh/puregotk/v4/gobject/types"
11	)	12		)
12		13

@@ -79,6 +80,29 @@ func (x *DebugControllerBase) SetDebugEnabled(DebugEnabledVar bool) {
79		80
80	}	81		}
81		82
		83	+	// SetPropertyDebugEnabled sets the "debug-enabled" property.
		84	+	// %TRUE if debug output should be exposed (for example by forwarding it to
		85	+	// the journal), %FALSE otherwise.
		86	+	func (x *DebugControllerBase) SetPropertyDebugEnabled(value bool) {
		87	+	obj := gobject.Object{}
		88	+	obj.Ptr = x.GoPointer()
		89	+	var v gobject.Value
		90	+	v.Init(gobject.TypeBooleanVal)
		91	+	v.SetBoolean(value)
		92	+	obj.SetProperty("debug-enabled", &v)
		93	+	}
		94	+
		95	+	// GetPropertyDebugEnabled gets the "debug-enabled" property.
		96	+	// %TRUE if debug output should be exposed (for example by forwarding it to
		97	+	// the journal), %FALSE otherwise.
		98	+	func (x *DebugControllerBase) GetPropertyDebugEnabled() bool {
		99	+	obj := gobject.Object{}
		100	+	obj.Ptr = x.GoPointer()
		101	+	var v gobject.Value
		102	+	obj.GetProperty("debug-enabled", &v)
		103	+	return v.GetBoolean()
		104	+	}
		105	+
82	var XGDebugControllerGetDebugEnabled func(uintptr) bool	106		var XGDebugControllerGetDebugEnabled func(uintptr) bool
83	var XGDebugControllerSetDebugEnabled func(uintptr, bool)	107		var XGDebugControllerSetDebugEnabled func(uintptr, bool)
84		108

M v4/gio/gdebugcontrollerdbus.go +2 -2


@@ -27,7 +27,7 @@ func (x *DebugControllerDBusClass) GoPointer() uintptr {
27		return uintptr(unsafe.Pointer(x))	27		return uintptr(unsafe.Pointer(x))
28		}	28		}
29			29
30	-	// OverrideAuthorize sets the callback function.	30	+	// OverrideAuthorize sets the "authorize" callback function.
31		// Default handler for the #GDebugControllerDBus::authorize signal.	31		// Default handler for the #GDebugControllerDBus::authorize signal.
32		func (x DebugControllerDBusClass) OverrideAuthorize(cb func(DebugControllerDBus, *DBusMethodInvocation) bool) {	32		func (x DebugControllerDBusClass) OverrideAuthorize(cb func(DebugControllerDBus, *DBusMethodInvocation) bool) {
33		if cb == nil {	33		if cb == nil {

@@ -39,7 +39,7 @@ func (x DebugControllerDBusClass) OverrideAuthorize(cb func(DebugControllerDBu
39		}	39		}
40		}	40		}
41			41
42	-	// GetAuthorize gets the callback function.	42	+	// GetAuthorize gets the "authorize" callback function.
43		// Default handler for the #GDebugControllerDBus::authorize signal.	43		// Default handler for the #GDebugControllerDBus::authorize signal.
44		func (x DebugControllerDBusClass) GetAuthorize() func(DebugControllerDBus, *DBusMethodInvocation) bool {	44		func (x DebugControllerDBusClass) GetAuthorize() func(DebugControllerDBus, *DBusMethodInvocation) bool {
45		if x.xAuthorize == 0 {	45		if x.xAuthorize == 0 {

M v4/gio/gdrive.go +64 -64


@@ -86,7 +86,7 @@ func (x *DriveIface) GoPointer() uintptr {
86		return uintptr(unsafe.Pointer(x))	86		return uintptr(unsafe.Pointer(x))
87		}	87		}
88			88
89	-	// OverrideChanged sets the callback function.	89	+	// OverrideChanged sets the "changed" callback function.
90		// Signal emitted when the drive is changed.	90		// Signal emitted when the drive is changed.
91		func (x *DriveIface) OverrideChanged(cb func(Drive)) {	91		func (x *DriveIface) OverrideChanged(cb func(Drive)) {
92		if cb == nil {	92		if cb == nil {

@@ -98,7 +98,7 @@ func (x *DriveIface) OverrideChanged(cb func(Drive)) {
98		}	98		}
99		}	99		}
100			100
101	-	// GetChanged gets the callback function.	101	+	// GetChanged gets the "changed" callback function.
102		// Signal emitted when the drive is changed.	102		// Signal emitted when the drive is changed.
103		func (x *DriveIface) GetChanged() func(Drive) {	103		func (x *DriveIface) GetChanged() func(Drive) {
104		if x.xChanged == 0 {	104		if x.xChanged == 0 {

@@ -111,7 +111,7 @@ func (x *DriveIface) GetChanged() func(Drive) {
111		}	111		}
112		}	112		}
113			113
114	-	// OverrideDisconnected sets the callback function.	114	+	// OverrideDisconnected sets the "disconnected" callback function.
115		// The removed signal that is emitted when the #GDrive have been disconnected. If the recipient is holding references to the object they should release them so the object can be finalized.	115		// The removed signal that is emitted when the #GDrive have been disconnected. If the recipient is holding references to the object they should release them so the object can be finalized.
116		func (x *DriveIface) OverrideDisconnected(cb func(Drive)) {	116		func (x *DriveIface) OverrideDisconnected(cb func(Drive)) {
117		if cb == nil {	117		if cb == nil {

@@ -123,7 +123,7 @@ func (x *DriveIface) OverrideDisconnected(cb func(Drive)) {
123		}	123		}
124		}	124		}
125			125
126	-	// GetDisconnected gets the callback function.	126	+	// GetDisconnected gets the "disconnected" callback function.
127		// The removed signal that is emitted when the #GDrive have been disconnected. If the recipient is holding references to the object they should release them so the object can be finalized.	127		// The removed signal that is emitted when the #GDrive have been disconnected. If the recipient is holding references to the object they should release them so the object can be finalized.
128		func (x *DriveIface) GetDisconnected() func(Drive) {	128		func (x *DriveIface) GetDisconnected() func(Drive) {
129		if x.xDisconnected == 0 {	129		if x.xDisconnected == 0 {

@@ -136,7 +136,7 @@ func (x *DriveIface) GetDisconnected() func(Drive) {
136		}	136		}
137		}	137		}
138			138
139	-	// OverrideEjectButton sets the callback function.	139	+	// OverrideEjectButton sets the "eject_button" callback function.
140		// Signal emitted when the physical eject button (if any) of a drive have been pressed.	140		// Signal emitted when the physical eject button (if any) of a drive have been pressed.
141		func (x *DriveIface) OverrideEjectButton(cb func(Drive)) {	141		func (x *DriveIface) OverrideEjectButton(cb func(Drive)) {
142		if cb == nil {	142		if cb == nil {

@@ -148,7 +148,7 @@ func (x *DriveIface) OverrideEjectButton(cb func(Drive)) {
148		}	148		}
149		}	149		}
150			150
151	-	// GetEjectButton gets the callback function.	151	+	// GetEjectButton gets the "eject_button" callback function.
152		// Signal emitted when the physical eject button (if any) of a drive have been pressed.	152		// Signal emitted when the physical eject button (if any) of a drive have been pressed.
153		func (x *DriveIface) GetEjectButton() func(Drive) {	153		func (x *DriveIface) GetEjectButton() func(Drive) {
154		if x.xEjectButton == 0 {	154		if x.xEjectButton == 0 {

@@ -161,7 +161,7 @@ func (x *DriveIface) GetEjectButton() func(Drive) {
161		}	161		}
162		}	162		}
163			163
164	-	// OverrideGetName sets the callback function.	164	+	// OverrideGetName sets the "get_name" callback function.
165		// Returns the name for the given #GDrive.	165		// Returns the name for the given #GDrive.
166		func (x *DriveIface) OverrideGetName(cb func(Drive) string) {	166		func (x *DriveIface) OverrideGetName(cb func(Drive) string) {
167		if cb == nil {	167		if cb == nil {

@@ -173,7 +173,7 @@ func (x *DriveIface) OverrideGetName(cb func(Drive) string) {
173		}	173		}
174		}	174		}
175			175
176	-	// GetGetName gets the callback function.	176	+	// GetGetName gets the "get_name" callback function.
177		// Returns the name for the given #GDrive.	177		// Returns the name for the given #GDrive.
178		func (x *DriveIface) GetGetName() func(Drive) string {	178		func (x *DriveIface) GetGetName() func(Drive) string {
179		if x.xGetName == 0 {	179		if x.xGetName == 0 {

@@ -186,7 +186,7 @@ func (x *DriveIface) GetGetName() func(Drive) string {
186		}	186		}
187		}	187		}
188			188
189	-	// OverrideGetIcon sets the callback function.	189	+	// OverrideGetIcon sets the "get_icon" callback function.
190		// Returns a #GIcon for the given #GDrive.	190		// Returns a #GIcon for the given #GDrive.
191		func (x DriveIface) OverrideGetIcon(cb func(Drive) IconBase) {	191		func (x DriveIface) OverrideGetIcon(cb func(Drive) IconBase) {
192		if cb == nil {	192		if cb == nil {

@@ -202,7 +202,7 @@ func (x DriveIface) OverrideGetIcon(cb func(Drive) IconBase) {
202		}	202		}
203		}	203		}
204			204
205	-	// GetGetIcon gets the callback function.	205	+	// GetGetIcon gets the "get_icon" callback function.
206		// Returns a #GIcon for the given #GDrive.	206		// Returns a #GIcon for the given #GDrive.
207		func (x DriveIface) GetGetIcon() func(Drive) IconBase {	207		func (x DriveIface) GetGetIcon() func(Drive) IconBase {
208		if x.xGetIcon == 0 {	208		if x.xGetIcon == 0 {

@@ -221,7 +221,7 @@ func (x DriveIface) GetGetIcon() func(Drive) IconBase {
221		}	221		}
222		}	222		}
223			223
224	-	// OverrideHasVolumes sets the callback function.	224	+	// OverrideHasVolumes sets the "has_volumes" callback function.
225		// Returns %TRUE if the #GDrive has mountable volumes.	225		// Returns %TRUE if the #GDrive has mountable volumes.
226		func (x *DriveIface) OverrideHasVolumes(cb func(Drive) bool) {	226		func (x *DriveIface) OverrideHasVolumes(cb func(Drive) bool) {
227		if cb == nil {	227		if cb == nil {

@@ -233,7 +233,7 @@ func (x *DriveIface) OverrideHasVolumes(cb func(Drive) bool) {
233		}	233		}
234		}	234		}
235			235
236	-	// GetHasVolumes gets the callback function.	236	+	// GetHasVolumes gets the "has_volumes" callback function.
237		// Returns %TRUE if the #GDrive has mountable volumes.	237		// Returns %TRUE if the #GDrive has mountable volumes.
238		func (x *DriveIface) GetHasVolumes() func(Drive) bool {	238		func (x *DriveIface) GetHasVolumes() func(Drive) bool {
239		if x.xHasVolumes == 0 {	239		if x.xHasVolumes == 0 {

@@ -246,7 +246,7 @@ func (x *DriveIface) GetHasVolumes() func(Drive) bool {
246		}	246		}
247		}	247		}
248			248
249	-	// OverrideGetVolumes sets the callback function.	249	+	// OverrideGetVolumes sets the "get_volumes" callback function.
250		// Returns a list #GList of #GVolume for the #GDrive.	250		// Returns a list #GList of #GVolume for the #GDrive.
251		func (x DriveIface) OverrideGetVolumes(cb func(Drive) glib.List) {	251		func (x DriveIface) OverrideGetVolumes(cb func(Drive) glib.List) {
252		if cb == nil {	252		if cb == nil {

@@ -258,7 +258,7 @@ func (x DriveIface) OverrideGetVolumes(cb func(Drive) glib.List) {
258		}	258		}
259		}	259		}
260			260
261	-	// GetGetVolumes gets the callback function.	261	+	// GetGetVolumes gets the "get_volumes" callback function.
262		// Returns a list #GList of #GVolume for the #GDrive.	262		// Returns a list #GList of #GVolume for the #GDrive.
263		func (x DriveIface) GetGetVolumes() func(Drive) glib.List {	263		func (x DriveIface) GetGetVolumes() func(Drive) glib.List {
264		if x.xGetVolumes == 0 {	264		if x.xGetVolumes == 0 {

@@ -271,7 +271,7 @@ func (x DriveIface) GetGetVolumes() func(Drive) glib.List {
271		}	271		}
272		}	272		}
273			273
274	-	// OverrideIsMediaRemovable sets the callback function.	274	+	// OverrideIsMediaRemovable sets the "is_media_removable" callback function.
275		// Returns %TRUE if the #GDrive supports removal and insertion of media.	275		// Returns %TRUE if the #GDrive supports removal and insertion of media.
276		func (x *DriveIface) OverrideIsMediaRemovable(cb func(Drive) bool) {	276		func (x *DriveIface) OverrideIsMediaRemovable(cb func(Drive) bool) {
277		if cb == nil {	277		if cb == nil {

@@ -283,7 +283,7 @@ func (x *DriveIface) OverrideIsMediaRemovable(cb func(Drive) bool) {
283		}	283		}
284		}	284		}
285			285
286	-	// GetIsMediaRemovable gets the callback function.	286	+	// GetIsMediaRemovable gets the "is_media_removable" callback function.
287		// Returns %TRUE if the #GDrive supports removal and insertion of media.	287		// Returns %TRUE if the #GDrive supports removal and insertion of media.
288		func (x *DriveIface) GetIsMediaRemovable() func(Drive) bool {	288		func (x *DriveIface) GetIsMediaRemovable() func(Drive) bool {
289		if x.xIsMediaRemovable == 0 {	289		if x.xIsMediaRemovable == 0 {

@@ -296,7 +296,7 @@ func (x *DriveIface) GetIsMediaRemovable() func(Drive) bool {
296		}	296		}
297		}	297		}
298			298
299	-	// OverrideHasMedia sets the callback function.	299	+	// OverrideHasMedia sets the "has_media" callback function.
300		// Returns %TRUE if the #GDrive has media inserted.	300		// Returns %TRUE if the #GDrive has media inserted.
301		func (x *DriveIface) OverrideHasMedia(cb func(Drive) bool) {	301		func (x *DriveIface) OverrideHasMedia(cb func(Drive) bool) {
302		if cb == nil {	302		if cb == nil {

@@ -308,7 +308,7 @@ func (x *DriveIface) OverrideHasMedia(cb func(Drive) bool) {
308		}	308		}
309		}	309		}
310			310
311	-	// GetHasMedia gets the callback function.	311	+	// GetHasMedia gets the "has_media" callback function.
312		// Returns %TRUE if the #GDrive has media inserted.	312		// Returns %TRUE if the #GDrive has media inserted.
313		func (x *DriveIface) GetHasMedia() func(Drive) bool {	313		func (x *DriveIface) GetHasMedia() func(Drive) bool {
314		if x.xHasMedia == 0 {	314		if x.xHasMedia == 0 {

@@ -321,7 +321,7 @@ func (x *DriveIface) GetHasMedia() func(Drive) bool {
321		}	321		}
322		}	322		}
323			323
324	-	// OverrideIsMediaCheckAutomatic sets the callback function.	324	+	// OverrideIsMediaCheckAutomatic sets the "is_media_check_automatic" callback function.
325		// Returns %TRUE if the #GDrive is capable of automatically detecting media changes.	325		// Returns %TRUE if the #GDrive is capable of automatically detecting media changes.
326		func (x *DriveIface) OverrideIsMediaCheckAutomatic(cb func(Drive) bool) {	326		func (x *DriveIface) OverrideIsMediaCheckAutomatic(cb func(Drive) bool) {
327		if cb == nil {	327		if cb == nil {

@@ -333,7 +333,7 @@ func (x *DriveIface) OverrideIsMediaCheckAutomatic(cb func(Drive) bool) {
333		}	333		}
334		}	334		}
335			335
336	-	// GetIsMediaCheckAutomatic gets the callback function.	336	+	// GetIsMediaCheckAutomatic gets the "is_media_check_automatic" callback function.
337		// Returns %TRUE if the #GDrive is capable of automatically detecting media changes.	337		// Returns %TRUE if the #GDrive is capable of automatically detecting media changes.
338		func (x *DriveIface) GetIsMediaCheckAutomatic() func(Drive) bool {	338		func (x *DriveIface) GetIsMediaCheckAutomatic() func(Drive) bool {
339		if x.xIsMediaCheckAutomatic == 0 {	339		if x.xIsMediaCheckAutomatic == 0 {

@@ -346,7 +346,7 @@ func (x *DriveIface) GetIsMediaCheckAutomatic() func(Drive) bool {
346		}	346		}
347		}	347		}
348			348
349	-	// OverrideCanEject sets the callback function.	349	+	// OverrideCanEject sets the "can_eject" callback function.
350		// Returns %TRUE if the #GDrive can eject media.	350		// Returns %TRUE if the #GDrive can eject media.
351		func (x *DriveIface) OverrideCanEject(cb func(Drive) bool) {	351		func (x *DriveIface) OverrideCanEject(cb func(Drive) bool) {
352		if cb == nil {	352		if cb == nil {

@@ -358,7 +358,7 @@ func (x *DriveIface) OverrideCanEject(cb func(Drive) bool) {
358		}	358		}
359		}	359		}
360			360
361	-	// GetCanEject gets the callback function.	361	+	// GetCanEject gets the "can_eject" callback function.
362		// Returns %TRUE if the #GDrive can eject media.	362		// Returns %TRUE if the #GDrive can eject media.
363		func (x *DriveIface) GetCanEject() func(Drive) bool {	363		func (x *DriveIface) GetCanEject() func(Drive) bool {
364		if x.xCanEject == 0 {	364		if x.xCanEject == 0 {

@@ -371,7 +371,7 @@ func (x *DriveIface) GetCanEject() func(Drive) bool {
371		}	371		}
372		}	372		}
373			373
374	-	// OverrideCanPollForMedia sets the callback function.	374	+	// OverrideCanPollForMedia sets the "can_poll_for_media" callback function.
375		// Returns %TRUE if the #GDrive is capable of manually polling for media change.	375		// Returns %TRUE if the #GDrive is capable of manually polling for media change.
376		func (x *DriveIface) OverrideCanPollForMedia(cb func(Drive) bool) {	376		func (x *DriveIface) OverrideCanPollForMedia(cb func(Drive) bool) {
377		if cb == nil {	377		if cb == nil {

@@ -383,7 +383,7 @@ func (x *DriveIface) OverrideCanPollForMedia(cb func(Drive) bool) {
383		}	383		}
384		}	384		}
385			385
386	-	// GetCanPollForMedia gets the callback function.	386	+	// GetCanPollForMedia gets the "can_poll_for_media" callback function.
387		// Returns %TRUE if the #GDrive is capable of manually polling for media change.	387		// Returns %TRUE if the #GDrive is capable of manually polling for media change.
388		func (x *DriveIface) GetCanPollForMedia() func(Drive) bool {	388		func (x *DriveIface) GetCanPollForMedia() func(Drive) bool {
389		if x.xCanPollForMedia == 0 {	389		if x.xCanPollForMedia == 0 {

@@ -396,7 +396,7 @@ func (x *DriveIface) GetCanPollForMedia() func(Drive) bool {
396		}	396		}
397		}	397		}
398			398
399	-	// OverrideEject sets the callback function.	399	+	// OverrideEject sets the "eject" callback function.
400		// Ejects a #GDrive.	400		// Ejects a #GDrive.
401		func (x DriveIface) OverrideEject(cb func(Drive, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {	401		func (x DriveIface) OverrideEject(cb func(Drive, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {
402		if cb == nil {	402		if cb == nil {

@@ -408,7 +408,7 @@ func (x DriveIface) OverrideEject(cb func(Drive, MountUnmountFlags, Cancellabl
408		}	408		}
409		}	409		}
410			410
411	-	// GetEject gets the callback function.	411	+	// GetEject gets the "eject" callback function.
412		// Ejects a #GDrive.	412		// Ejects a #GDrive.
413		func (x DriveIface) GetEject() func(Drive, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {	413		func (x DriveIface) GetEject() func(Drive, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {
414		if x.xEject == 0 {	414		if x.xEject == 0 {

@@ -421,7 +421,7 @@ func (x DriveIface) GetEject() func(Drive, MountUnmountFlags, Cancellable, *As
421		}	421		}
422		}	422		}
423			423
424	-	// OverrideEjectFinish sets the callback function.	424	+	// OverrideEjectFinish sets the "eject_finish" callback function.
425		// Finishes an eject operation.	425		// Finishes an eject operation.
426		func (x *DriveIface) OverrideEjectFinish(cb func(Drive, AsyncResult) bool) {	426		func (x *DriveIface) OverrideEjectFinish(cb func(Drive, AsyncResult) bool) {
427		if cb == nil {	427		if cb == nil {

@@ -433,7 +433,7 @@ func (x *DriveIface) OverrideEjectFinish(cb func(Drive, AsyncResult) bool) {
433		}	433		}
434		}	434		}
435			435
436	-	// GetEjectFinish gets the callback function.	436	+	// GetEjectFinish gets the "eject_finish" callback function.
437		// Finishes an eject operation.	437		// Finishes an eject operation.
438		func (x *DriveIface) GetEjectFinish() func(Drive, AsyncResult) bool {	438		func (x *DriveIface) GetEjectFinish() func(Drive, AsyncResult) bool {
439		if x.xEjectFinish == 0 {	439		if x.xEjectFinish == 0 {

@@ -446,7 +446,7 @@ func (x *DriveIface) GetEjectFinish() func(Drive, AsyncResult) bool {
446		}	446		}
447		}	447		}
448			448
449	-	// OverridePollForMedia sets the callback function.	449	+	// OverridePollForMedia sets the "poll_for_media" callback function.
450		// Poll for media insertion/removal on a #GDrive.	450		// Poll for media insertion/removal on a #GDrive.
451		func (x DriveIface) OverridePollForMedia(cb func(Drive, Cancellable, *AsyncReadyCallback, uintptr)) {	451		func (x DriveIface) OverridePollForMedia(cb func(Drive, Cancellable, *AsyncReadyCallback, uintptr)) {
452		if cb == nil {	452		if cb == nil {

@@ -458,7 +458,7 @@ func (x DriveIface) OverridePollForMedia(cb func(Drive, Cancellable, *AsyncRea
458		}	458		}
459		}	459		}
460			460
461	-	// GetPollForMedia gets the callback function.	461	+	// GetPollForMedia gets the "poll_for_media" callback function.
462		// Poll for media insertion/removal on a #GDrive.	462		// Poll for media insertion/removal on a #GDrive.
463		func (x DriveIface) GetPollForMedia() func(Drive, Cancellable, *AsyncReadyCallback, uintptr) {	463		func (x DriveIface) GetPollForMedia() func(Drive, Cancellable, *AsyncReadyCallback, uintptr) {
464		if x.xPollForMedia == 0 {	464		if x.xPollForMedia == 0 {

@@ -471,7 +471,7 @@ func (x DriveIface) GetPollForMedia() func(Drive, Cancellable, *AsyncReadyCall
471		}	471		}
472		}	472		}
473			473
474	-	// OverridePollForMediaFinish sets the callback function.	474	+	// OverridePollForMediaFinish sets the "poll_for_media_finish" callback function.
475		// Finishes a media poll operation.	475		// Finishes a media poll operation.
476		func (x *DriveIface) OverridePollForMediaFinish(cb func(Drive, AsyncResult) bool) {	476		func (x *DriveIface) OverridePollForMediaFinish(cb func(Drive, AsyncResult) bool) {
477		if cb == nil {	477		if cb == nil {

@@ -483,7 +483,7 @@ func (x *DriveIface) OverridePollForMediaFinish(cb func(Drive, AsyncResult) bool
483		}	483		}
484		}	484		}
485			485
486	-	// GetPollForMediaFinish gets the callback function.	486	+	// GetPollForMediaFinish gets the "poll_for_media_finish" callback function.
487		// Finishes a media poll operation.	487		// Finishes a media poll operation.
488		func (x *DriveIface) GetPollForMediaFinish() func(Drive, AsyncResult) bool {	488		func (x *DriveIface) GetPollForMediaFinish() func(Drive, AsyncResult) bool {
489		if x.xPollForMediaFinish == 0 {	489		if x.xPollForMediaFinish == 0 {

@@ -496,7 +496,7 @@ func (x *DriveIface) GetPollForMediaFinish() func(Drive, AsyncResult) bool {
496		}	496		}
497		}	497		}
498			498
499	-	// OverrideGetIdentifier sets the callback function.	499	+	// OverrideGetIdentifier sets the "get_identifier" callback function.
500		// Returns the identifier of the given kind, or %NULL if	500		// Returns the identifier of the given kind, or %NULL if
501		//	501		//
502		// the #GDrive doesn't have one.	502		// the #GDrive doesn't have one.

@@ -510,7 +510,7 @@ func (x *DriveIface) OverrideGetIdentifier(cb func(Drive, string) string) {
510		}	510		}
511		}	511		}
512			512
513	-	// GetGetIdentifier gets the callback function.	513	+	// GetGetIdentifier gets the "get_identifier" callback function.
514		// Returns the identifier of the given kind, or %NULL if	514		// Returns the identifier of the given kind, or %NULL if
515		//	515		//
516		// the #GDrive doesn't have one.	516		// the #GDrive doesn't have one.

@@ -525,7 +525,7 @@ func (x *DriveIface) GetGetIdentifier() func(Drive, string) string {
525		}	525		}
526		}	526		}
527			527
528	-	// OverrideEnumerateIdentifiers sets the callback function.	528	+	// OverrideEnumerateIdentifiers sets the "enumerate_identifiers" callback function.
529		// Returns an array strings listing the kinds	529		// Returns an array strings listing the kinds
530		//	530		//
531		// of identifiers which the #GDrive has.	531		// of identifiers which the #GDrive has.

@@ -539,7 +539,7 @@ func (x *DriveIface) OverrideEnumerateIdentifiers(cb func(Drive) []string) {
539		}	539		}
540		}	540		}
541			541
542	-	// GetEnumerateIdentifiers gets the callback function.	542	+	// GetEnumerateIdentifiers gets the "enumerate_identifiers" callback function.
543		// Returns an array strings listing the kinds	543		// Returns an array strings listing the kinds
544		//	544		//
545		// of identifiers which the #GDrive has.	545		// of identifiers which the #GDrive has.

@@ -554,7 +554,7 @@ func (x *DriveIface) GetEnumerateIdentifiers() func(Drive) []string {
554		}	554		}
555		}	555		}
556			556
557	-	// OverrideGetStartStopType sets the callback function.	557	+	// OverrideGetStartStopType sets the "get_start_stop_type" callback function.
558		// Gets a #GDriveStartStopType with details about starting/stopping the drive. Since 2.22.	558		// Gets a #GDriveStartStopType with details about starting/stopping the drive. Since 2.22.
559		func (x *DriveIface) OverrideGetStartStopType(cb func(Drive) DriveStartStopType) {	559		func (x *DriveIface) OverrideGetStartStopType(cb func(Drive) DriveStartStopType) {
560		if cb == nil {	560		if cb == nil {

@@ -566,7 +566,7 @@ func (x *DriveIface) OverrideGetStartStopType(cb func(Drive) DriveStartStopType)
566		}	566		}
567		}	567		}
568			568
569	-	// GetGetStartStopType gets the callback function.	569	+	// GetGetStartStopType gets the "get_start_stop_type" callback function.
570		// Gets a #GDriveStartStopType with details about starting/stopping the drive. Since 2.22.	570		// Gets a #GDriveStartStopType with details about starting/stopping the drive. Since 2.22.
571		func (x *DriveIface) GetGetStartStopType() func(Drive) DriveStartStopType {	571		func (x *DriveIface) GetGetStartStopType() func(Drive) DriveStartStopType {
572		if x.xGetStartStopType == 0 {	572		if x.xGetStartStopType == 0 {

@@ -579,7 +579,7 @@ func (x *DriveIface) GetGetStartStopType() func(Drive) DriveStartStopType {
579		}	579		}
580		}	580		}
581			581
582	-	// OverrideCanStart sets the callback function.	582	+	// OverrideCanStart sets the "can_start" callback function.
583		// Returns %TRUE if a #GDrive can be started. Since 2.22.	583		// Returns %TRUE if a #GDrive can be started. Since 2.22.
584		func (x *DriveIface) OverrideCanStart(cb func(Drive) bool) {	584		func (x *DriveIface) OverrideCanStart(cb func(Drive) bool) {
585		if cb == nil {	585		if cb == nil {

@@ -591,7 +591,7 @@ func (x *DriveIface) OverrideCanStart(cb func(Drive) bool) {
591		}	591		}
592		}	592		}
593			593
594	-	// GetCanStart gets the callback function.	594	+	// GetCanStart gets the "can_start" callback function.
595		// Returns %TRUE if a #GDrive can be started. Since 2.22.	595		// Returns %TRUE if a #GDrive can be started. Since 2.22.
596		func (x *DriveIface) GetCanStart() func(Drive) bool {	596		func (x *DriveIface) GetCanStart() func(Drive) bool {
597		if x.xCanStart == 0 {	597		if x.xCanStart == 0 {

@@ -604,7 +604,7 @@ func (x *DriveIface) GetCanStart() func(Drive) bool {
604		}	604		}
605		}	605		}
606			606
607	-	// OverrideCanStartDegraded sets the callback function.	607	+	// OverrideCanStartDegraded sets the "can_start_degraded" callback function.
608		// Returns %TRUE if a #GDrive can be started degraded. Since 2.22.	608		// Returns %TRUE if a #GDrive can be started degraded. Since 2.22.
609		func (x *DriveIface) OverrideCanStartDegraded(cb func(Drive) bool) {	609		func (x *DriveIface) OverrideCanStartDegraded(cb func(Drive) bool) {
610		if cb == nil {	610		if cb == nil {

@@ -616,7 +616,7 @@ func (x *DriveIface) OverrideCanStartDegraded(cb func(Drive) bool) {
616		}	616		}
617		}	617		}
618			618
619	-	// GetCanStartDegraded gets the callback function.	619	+	// GetCanStartDegraded gets the "can_start_degraded" callback function.
620		// Returns %TRUE if a #GDrive can be started degraded. Since 2.22.	620		// Returns %TRUE if a #GDrive can be started degraded. Since 2.22.
621		func (x *DriveIface) GetCanStartDegraded() func(Drive) bool {	621		func (x *DriveIface) GetCanStartDegraded() func(Drive) bool {
622		if x.xCanStartDegraded == 0 {	622		if x.xCanStartDegraded == 0 {

@@ -629,7 +629,7 @@ func (x *DriveIface) GetCanStartDegraded() func(Drive) bool {
629		}	629		}
630		}	630		}
631			631
632	-	// OverrideStart sets the callback function.	632	+	// OverrideStart sets the "start" callback function.
633		// Starts a #GDrive. Since 2.22.	633		// Starts a #GDrive. Since 2.22.
634		func (x DriveIface) OverrideStart(cb func(Drive, DriveStartFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	634		func (x DriveIface) OverrideStart(cb func(Drive, DriveStartFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
635		if cb == nil {	635		if cb == nil {

@@ -641,7 +641,7 @@ func (x DriveIface) OverrideStart(cb func(Drive, DriveStartFlags, MountOperati
641		}	641		}
642		}	642		}
643			643
644	-	// GetStart gets the callback function.	644	+	// GetStart gets the "start" callback function.
645		// Starts a #GDrive. Since 2.22.	645		// Starts a #GDrive. Since 2.22.
646		func (x DriveIface) GetStart() func(Drive, DriveStartFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	646		func (x DriveIface) GetStart() func(Drive, DriveStartFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
647		if x.xStart == 0 {	647		if x.xStart == 0 {

@@ -654,7 +654,7 @@ func (x DriveIface) GetStart() func(Drive, DriveStartFlags, MountOperation, *C
654		}	654		}
655		}	655		}
656			656
657	-	// OverrideStartFinish sets the callback function.	657	+	// OverrideStartFinish sets the "start_finish" callback function.
658		// Finishes a start operation. Since 2.22.	658		// Finishes a start operation. Since 2.22.
659		func (x *DriveIface) OverrideStartFinish(cb func(Drive, AsyncResult) bool) {	659		func (x *DriveIface) OverrideStartFinish(cb func(Drive, AsyncResult) bool) {
660		if cb == nil {	660		if cb == nil {

@@ -666,7 +666,7 @@ func (x *DriveIface) OverrideStartFinish(cb func(Drive, AsyncResult) bool) {
666		}	666		}
667		}	667		}
668			668
669	-	// GetStartFinish gets the callback function.	669	+	// GetStartFinish gets the "start_finish" callback function.
670		// Finishes a start operation. Since 2.22.	670		// Finishes a start operation. Since 2.22.
671		func (x *DriveIface) GetStartFinish() func(Drive, AsyncResult) bool {	671		func (x *DriveIface) GetStartFinish() func(Drive, AsyncResult) bool {
672		if x.xStartFinish == 0 {	672		if x.xStartFinish == 0 {

@@ -679,7 +679,7 @@ func (x *DriveIface) GetStartFinish() func(Drive, AsyncResult) bool {
679		}	679		}
680		}	680		}
681			681
682	-	// OverrideCanStop sets the callback function.	682	+	// OverrideCanStop sets the "can_stop" callback function.
683		// Returns %TRUE if a #GDrive can be stopped. Since 2.22.	683		// Returns %TRUE if a #GDrive can be stopped. Since 2.22.
684		func (x *DriveIface) OverrideCanStop(cb func(Drive) bool) {	684		func (x *DriveIface) OverrideCanStop(cb func(Drive) bool) {
685		if cb == nil {	685		if cb == nil {

@@ -691,7 +691,7 @@ func (x *DriveIface) OverrideCanStop(cb func(Drive) bool) {
691		}	691		}
692		}	692		}
693			693
694	-	// GetCanStop gets the callback function.	694	+	// GetCanStop gets the "can_stop" callback function.
695		// Returns %TRUE if a #GDrive can be stopped. Since 2.22.	695		// Returns %TRUE if a #GDrive can be stopped. Since 2.22.
696		func (x *DriveIface) GetCanStop() func(Drive) bool {	696		func (x *DriveIface) GetCanStop() func(Drive) bool {
697		if x.xCanStop == 0 {	697		if x.xCanStop == 0 {

@@ -704,7 +704,7 @@ func (x *DriveIface) GetCanStop() func(Drive) bool {
704		}	704		}
705		}	705		}
706			706
707	-	// OverrideStop sets the callback function.	707	+	// OverrideStop sets the "stop" callback function.
708		// Stops a #GDrive. Since 2.22.	708		// Stops a #GDrive. Since 2.22.
709		func (x DriveIface) OverrideStop(cb func(Drive, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	709		func (x DriveIface) OverrideStop(cb func(Drive, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
710		if cb == nil {	710		if cb == nil {

@@ -716,7 +716,7 @@ func (x DriveIface) OverrideStop(cb func(Drive, MountUnmountFlags, MountOperat
716		}	716		}
717		}	717		}
718			718
719	-	// GetStop gets the callback function.	719	+	// GetStop gets the "stop" callback function.
720		// Stops a #GDrive. Since 2.22.	720		// Stops a #GDrive. Since 2.22.
721		func (x DriveIface) GetStop() func(Drive, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	721		func (x DriveIface) GetStop() func(Drive, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
722		if x.xStop == 0 {	722		if x.xStop == 0 {

@@ -729,7 +729,7 @@ func (x DriveIface) GetStop() func(Drive, MountUnmountFlags, MountOperation, *
729		}	729		}
730		}	730		}
731			731
732	-	// OverrideStopFinish sets the callback function.	732	+	// OverrideStopFinish sets the "stop_finish" callback function.
733		// Finishes a stop operation. Since 2.22.	733		// Finishes a stop operation. Since 2.22.
734		func (x *DriveIface) OverrideStopFinish(cb func(Drive, AsyncResult) bool) {	734		func (x *DriveIface) OverrideStopFinish(cb func(Drive, AsyncResult) bool) {
735		if cb == nil {	735		if cb == nil {

@@ -741,7 +741,7 @@ func (x *DriveIface) OverrideStopFinish(cb func(Drive, AsyncResult) bool) {
741		}	741		}
742		}	742		}
743			743
744	-	// GetStopFinish gets the callback function.	744	+	// GetStopFinish gets the "stop_finish" callback function.
745		// Finishes a stop operation. Since 2.22.	745		// Finishes a stop operation. Since 2.22.
746		func (x *DriveIface) GetStopFinish() func(Drive, AsyncResult) bool {	746		func (x *DriveIface) GetStopFinish() func(Drive, AsyncResult) bool {
747		if x.xStopFinish == 0 {	747		if x.xStopFinish == 0 {

@@ -754,7 +754,7 @@ func (x *DriveIface) GetStopFinish() func(Drive, AsyncResult) bool {
754		}	754		}
755		}	755		}
756			756
757	-	// OverrideStopButton sets the callback function.	757	+	// OverrideStopButton sets the "stop_button" callback function.
758		// Signal emitted when the physical stop button (if any) of a drive have been pressed. Since 2.22.	758		// Signal emitted when the physical stop button (if any) of a drive have been pressed. Since 2.22.
759		func (x *DriveIface) OverrideStopButton(cb func(Drive)) {	759		func (x *DriveIface) OverrideStopButton(cb func(Drive)) {
760		if cb == nil {	760		if cb == nil {

@@ -766,7 +766,7 @@ func (x *DriveIface) OverrideStopButton(cb func(Drive)) {
766		}	766		}
767		}	767		}
768			768
769	-	// GetStopButton gets the callback function.	769	+	// GetStopButton gets the "stop_button" callback function.
770		// Signal emitted when the physical stop button (if any) of a drive have been pressed. Since 2.22.	770		// Signal emitted when the physical stop button (if any) of a drive have been pressed. Since 2.22.
771		func (x *DriveIface) GetStopButton() func(Drive) {	771		func (x *DriveIface) GetStopButton() func(Drive) {
772		if x.xStopButton == 0 {	772		if x.xStopButton == 0 {

@@ -779,7 +779,7 @@ func (x *DriveIface) GetStopButton() func(Drive) {
779		}	779		}
780		}	780		}
781			781
782	-	// OverrideEjectWithOperation sets the callback function.	782	+	// OverrideEjectWithOperation sets the "eject_with_operation" callback function.
783		// Starts ejecting a #GDrive using a #GMountOperation. Since 2.22.	783		// Starts ejecting a #GDrive using a #GMountOperation. Since 2.22.
784		func (x DriveIface) OverrideEjectWithOperation(cb func(Drive, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	784		func (x DriveIface) OverrideEjectWithOperation(cb func(Drive, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
785		if cb == nil {	785		if cb == nil {

@@ -791,7 +791,7 @@ func (x *DriveIface) OverrideEjectWithOperation(cb func(Drive, MountUnmountFlags
791		}	791		}
792		}	792		}
793			793
794	-	// GetEjectWithOperation gets the callback function.	794	+	// GetEjectWithOperation gets the "eject_with_operation" callback function.
795		// Starts ejecting a #GDrive using a #GMountOperation. Since 2.22.	795		// Starts ejecting a #GDrive using a #GMountOperation. Since 2.22.
796		func (x DriveIface) GetEjectWithOperation() func(Drive, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	796		func (x DriveIface) GetEjectWithOperation() func(Drive, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
797		if x.xEjectWithOperation == 0 {	797		if x.xEjectWithOperation == 0 {

@@ -804,7 +804,7 @@ func (x DriveIface) GetEjectWithOperation() func(Drive, MountUnmountFlags, Mou
804		}	804		}
805		}	805		}
806			806
807	-	// OverrideEjectWithOperationFinish sets the callback function.	807	+	// OverrideEjectWithOperationFinish sets the "eject_with_operation_finish" callback function.
808		// Finishes an eject operation using a #GMountOperation. Since 2.22.	808		// Finishes an eject operation using a #GMountOperation. Since 2.22.
809		func (x *DriveIface) OverrideEjectWithOperationFinish(cb func(Drive, AsyncResult) bool) {	809		func (x *DriveIface) OverrideEjectWithOperationFinish(cb func(Drive, AsyncResult) bool) {
810		if cb == nil {	810		if cb == nil {

@@ -816,7 +816,7 @@ func (x *DriveIface) OverrideEjectWithOperationFinish(cb func(Drive, AsyncResult
816		}	816		}
817		}	817		}
818			818
819	-	// GetEjectWithOperationFinish gets the callback function.	819	+	// GetEjectWithOperationFinish gets the "eject_with_operation_finish" callback function.
820		// Finishes an eject operation using a #GMountOperation. Since 2.22.	820		// Finishes an eject operation using a #GMountOperation. Since 2.22.
821		func (x *DriveIface) GetEjectWithOperationFinish() func(Drive, AsyncResult) bool {	821		func (x *DriveIface) GetEjectWithOperationFinish() func(Drive, AsyncResult) bool {
822		if x.xEjectWithOperationFinish == 0 {	822		if x.xEjectWithOperationFinish == 0 {

@@ -829,7 +829,7 @@ func (x *DriveIface) GetEjectWithOperationFinish() func(Drive, AsyncResult) bool
829		}	829		}
830		}	830		}
831			831
832	-	// OverrideGetSortKey sets the callback function.	832	+	// OverrideGetSortKey sets the "get_sort_key" callback function.
833		// Gets a key used for sorting #GDrive instances or %NULL if no such key exists. Since 2.32.	833		// Gets a key used for sorting #GDrive instances or %NULL if no such key exists. Since 2.32.
834		func (x *DriveIface) OverrideGetSortKey(cb func(Drive) string) {	834		func (x *DriveIface) OverrideGetSortKey(cb func(Drive) string) {
835		if cb == nil {	835		if cb == nil {

@@ -841,7 +841,7 @@ func (x *DriveIface) OverrideGetSortKey(cb func(Drive) string) {
841		}	841		}
842		}	842		}
843			843
844	-	// GetGetSortKey gets the callback function.	844	+	// GetGetSortKey gets the "get_sort_key" callback function.
845		// Gets a key used for sorting #GDrive instances or %NULL if no such key exists. Since 2.32.	845		// Gets a key used for sorting #GDrive instances or %NULL if no such key exists. Since 2.32.
846		func (x *DriveIface) GetGetSortKey() func(Drive) string {	846		func (x *DriveIface) GetGetSortKey() func(Drive) string {
847		if x.xGetSortKey == 0 {	847		if x.xGetSortKey == 0 {

@@ -854,7 +854,7 @@ func (x *DriveIface) GetGetSortKey() func(Drive) string {
854		}	854		}
855		}	855		}
856			856
857	-	// OverrideGetSymbolicIcon sets the callback function.	857	+	// OverrideGetSymbolicIcon sets the "get_symbolic_icon" callback function.
858		// Returns a symbolic #GIcon for the given #GDrive. Since 2.34.	858		// Returns a symbolic #GIcon for the given #GDrive. Since 2.34.
859		func (x DriveIface) OverrideGetSymbolicIcon(cb func(Drive) IconBase) {	859		func (x DriveIface) OverrideGetSymbolicIcon(cb func(Drive) IconBase) {
860		if cb == nil {	860		if cb == nil {

@@ -870,7 +870,7 @@ func (x DriveIface) OverrideGetSymbolicIcon(cb func(Drive) IconBase) {
870		}	870		}
871		}	871		}
872			872
873	-	// GetGetSymbolicIcon gets the callback function.	873	+	// GetGetSymbolicIcon gets the "get_symbolic_icon" callback function.
874		// Returns a symbolic #GIcon for the given #GDrive. Since 2.34.	874		// Returns a symbolic #GIcon for the given #GDrive. Since 2.34.
875		func (x DriveIface) GetGetSymbolicIcon() func(Drive) IconBase {	875		func (x DriveIface) GetGetSymbolicIcon() func(Drive) IconBase {
876		if x.xGetSymbolicIcon == 0 {	876		if x.xGetSymbolicIcon == 0 {

@@ -889,7 +889,7 @@ func (x DriveIface) GetGetSymbolicIcon() func(Drive) IconBase {
889		}	889		}
890		}	890		}
891			891
892	-	// OverrideIsRemovable sets the callback function.	892	+	// OverrideIsRemovable sets the "is_removable" callback function.
893		// Returns %TRUE if the #GDrive and/or its media is considered removable by the user. Since 2.50.	893		// Returns %TRUE if the #GDrive and/or its media is considered removable by the user. Since 2.50.
894		func (x *DriveIface) OverrideIsRemovable(cb func(Drive) bool) {	894		func (x *DriveIface) OverrideIsRemovable(cb func(Drive) bool) {
895		if cb == nil {	895		if cb == nil {

@@ -901,7 +901,7 @@ func (x *DriveIface) OverrideIsRemovable(cb func(Drive) bool) {
901		}	901		}
902		}	902		}
903			903
904	-	// GetIsRemovable gets the callback function.	904	+	// GetIsRemovable gets the "is_removable" callback function.
905		// Returns %TRUE if the #GDrive and/or its media is considered removable by the user. Since 2.50.	905		// Returns %TRUE if the #GDrive and/or its media is considered removable by the user. Since 2.50.
906		func (x *DriveIface) GetIsRemovable() func(Drive) bool {	906		func (x *DriveIface) GetIsRemovable() func(Drive) bool {
907		if x.xIsRemovable == 0 {	907		if x.xIsRemovable == 0 {

M v4/gio/gdtlsconnection.go +92 -23

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideAcceptCertificate sets the callback function.
+// OverrideAcceptCertificate sets the "accept_certificate" callback function.
 // Check whether to accept a certificate.
 func (x *DtlsConnectionInterface) OverrideAcceptCertificate(cb func(DtlsConnection, *TlsCertificate, TlsCertificateFlags) bool) {
 	if cb == nil {
 	}
 }
-// GetAcceptCertificate gets the callback function.
+// GetAcceptCertificate gets the "accept_certificate" callback function.
 // Check whether to accept a certificate.
 func (x *DtlsConnectionInterface) GetAcceptCertificate() func(DtlsConnection, *TlsCertificate, TlsCertificateFlags) bool {
 	if x.xAcceptCertificate == 0 {
 	}
 }
-// OverrideHandshake sets the callback function.
+// OverrideHandshake sets the "handshake" callback function.
 // Perform a handshake operation.
 func (x *DtlsConnectionInterface) OverrideHandshake(cb func(DtlsConnection, *Cancellable) bool) {
 	if cb == nil {
 	}
 }
-// GetHandshake gets the callback function.
+// GetHandshake gets the "handshake" callback function.
 // Perform a handshake operation.
 func (x *DtlsConnectionInterface) GetHandshake() func(DtlsConnection, *Cancellable) bool {
 	if x.xHandshake == 0 {
 	}
 }
-// OverrideHandshakeAsync sets the callback function.
+// OverrideHandshakeAsync sets the "handshake_async" callback function.
 // Start an asynchronous handshake operation.
 func (x *DtlsConnectionInterface) OverrideHandshakeAsync(cb func(DtlsConnection, int, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 	}
 }
-// GetHandshakeAsync gets the callback function.
+// GetHandshakeAsync gets the "handshake_async" callback function.
 // Start an asynchronous handshake operation.
 func (x *DtlsConnectionInterface) GetHandshakeAsync() func(DtlsConnection, int, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xHandshakeAsync == 0 {
 	}
 }
-// OverrideHandshakeFinish sets the callback function.
+// OverrideHandshakeFinish sets the "handshake_finish" callback function.
 // Finish an asynchronous handshake operation.
 func (x *DtlsConnectionInterface) OverrideHandshakeFinish(cb func(DtlsConnection, AsyncResult) bool) {
 	if cb == nil {
 	}
 }
-// GetHandshakeFinish gets the callback function.
+// GetHandshakeFinish gets the "handshake_finish" callback function.
 // Finish an asynchronous handshake operation.
 func (x *DtlsConnectionInterface) GetHandshakeFinish() func(DtlsConnection, AsyncResult) bool {
 	if x.xHandshakeFinish == 0 {
 	}
 }
-// OverrideShutdown sets the callback function.
+// OverrideShutdown sets the "shutdown" callback function.
 // Shut down one or both directions of the connection.
 func (x *DtlsConnectionInterface) OverrideShutdown(cb func(DtlsConnection, bool, bool, *Cancellable) bool) {
 	if cb == nil {
 	}
 }
-// GetShutdown gets the callback function.
+// GetShutdown gets the "shutdown" callback function.
 // Shut down one or both directions of the connection.
 func (x *DtlsConnectionInterface) GetShutdown() func(DtlsConnection, bool, bool, *Cancellable) bool {
 	if x.xShutdown == 0 {
 	}
 }
-// OverrideShutdownAsync sets the callback function.
+// OverrideShutdownAsync sets the "shutdown_async" callback function.
 // Start an asynchronous shutdown operation.
 func (x *DtlsConnectionInterface) OverrideShutdownAsync(cb func(DtlsConnection, bool, bool, int, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 	}
 }
-// GetShutdownAsync gets the callback function.
+// GetShutdownAsync gets the "shutdown_async" callback function.
 // Start an asynchronous shutdown operation.
 func (x *DtlsConnectionInterface) GetShutdownAsync() func(DtlsConnection, bool, bool, int, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xShutdownAsync == 0 {
 	}
 }
-// OverrideShutdownFinish sets the callback function.
+// OverrideShutdownFinish sets the "shutdown_finish" callback function.
 // Finish an asynchronous shutdown operation.
 func (x *DtlsConnectionInterface) OverrideShutdownFinish(cb func(DtlsConnection, AsyncResult) bool) {
 	if cb == nil {
 	}
 }
-// GetShutdownFinish gets the callback function.
+// GetShutdownFinish gets the "shutdown_finish" callback function.
 // Finish an asynchronous shutdown operation.
 func (x *DtlsConnectionInterface) GetShutdownFinish() func(DtlsConnection, AsyncResult) bool {
 	if x.xShutdownFinish == 0 {
 	}
 }
-// OverrideSetAdvertisedProtocols sets the callback function.
+// OverrideSetAdvertisedProtocols sets the "set_advertised_protocols" callback function.
 // Set APLN protocol list (Since: 2.60)
 func (x *DtlsConnectionInterface) OverrideSetAdvertisedProtocols(cb func(DtlsConnection, []string)) {
 	if cb == nil {
 	}
 }
-// GetSetAdvertisedProtocols gets the callback function.
+// GetSetAdvertisedProtocols gets the "set_advertised_protocols" callback function.
 // Set APLN protocol list (Since: 2.60)
 func (x *DtlsConnectionInterface) GetSetAdvertisedProtocols() func(DtlsConnection, []string) {
 	if x.xSetAdvertisedProtocols == 0 {
 	}
 }
-// OverrideGetNegotiatedProtocol sets the callback function.
+// OverrideGetNegotiatedProtocol sets the "get_negotiated_protocol" callback function.
 // Get ALPN-negotiated protocol (Since: 2.60)
 func (x *DtlsConnectionInterface) OverrideGetNegotiatedProtocol(cb func(DtlsConnection) string) {
 	if cb == nil {
 	}
 }
-// GetGetNegotiatedProtocol gets the callback function.
+// GetGetNegotiatedProtocol gets the "get_negotiated_protocol" callback function.
 // Get ALPN-negotiated protocol (Since: 2.60)
 func (x *DtlsConnectionInterface) GetGetNegotiatedProtocol() func(DtlsConnection) string {
 	if x.xGetNegotiatedProtocol == 0 {
 	}
 }
-// OverrideGetBindingData sets the callback function.
+// OverrideGetBindingData sets the "get_binding_data" callback function.
 // Retrieve TLS channel binding data (Since: 2.66)
 func (x *DtlsConnectionInterface) OverrideGetBindingData(cb func(DtlsConnection, TlsChannelBindingType, []byte) bool) {
 	if cb == nil {
 	}
 }
-// GetGetBindingData gets the callback function.
+// GetGetBindingData gets the "get_binding_data" callback function.
 // Retrieve TLS channel binding data (Since: 2.66)
 func (x *DtlsConnectionInterface) GetGetBindingData() func(DtlsConnection, TlsChannelBindingType, []byte) bool {
 	if x.xGetBindingData == 0 {
 	CloseFinish(ResultVar AsyncResult) (bool, error)
 	EmitAcceptCertificate(PeerCertVar *TlsCertificate, ErrorsVar TlsCertificateFlags) bool
 	GetCertificate() *TlsCertificate
-	GetChannelBindingData(TypeVar TlsChannelBindingType, DataVar []byte) (bool, error)
+	GetChannelBindingData(TypeVar TlsChannelBindingType, DataVar *[]byte) (bool, error)
 	GetCiphersuiteName() string
 	GetDatabase() *TlsDatabase
 	GetInteraction() *TlsInteraction
 // will be available though.  That could happen if TLS connection does not
 // support @type or the binding data is not available yet due to additional
 // negotiation or input required.
-func (x *DtlsConnectionBase) GetChannelBindingData(TypeVar TlsChannelBindingType, DataVar []byte) (bool, error) {
+func (x *DtlsConnectionBase) GetChannelBindingData(TypeVar TlsChannelBindingType, DataVar *[]byte) (bool, error) {
 	var cerr *glib.Error
 	cret := XGDtlsConnectionGetChannelBindingData(x.GoPointer(), TypeVar, DataVar, &cerr)
 }
+// SetPropertyAdvertisedProtocols sets the "advertised-protocols" property.
+// The list of application-layer protocols that the connection
+// advertises that it is willing to speak. See
+// g_dtls_connection_set_advertised_protocols().
+func (x *DtlsConnectionBase) SetPropertyAdvertisedProtocols(value []string) {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	v.Init(glib.StrvGetType())
+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
+	obj.SetProperty("advertised-protocols", &v)
+}
+// GetPropertyAdvertisedProtocols gets the "advertised-protocols" property.
+// The list of application-layer protocols that the connection
+// advertises that it is willing to speak. See
+// g_dtls_connection_set_advertised_protocols().
+func (x *DtlsConnectionBase) GetPropertyAdvertisedProtocols() []string {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("advertised-protocols", &v)
+	return core.GoStringSlice(v.GetBoxed())
+}
+// GetPropertyCiphersuiteName gets the "ciphersuite-name" property.
+// The name of the DTLS ciphersuite in use. See g_dtls_connection_get_ciphersuite_name().
+func (x *DtlsConnectionBase) GetPropertyCiphersuiteName() string {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("ciphersuite-name", &v)
+	return v.GetString()
+}
+// GetPropertyNegotiatedProtocol gets the "negotiated-protocol" property.
+// The application-layer protocol negotiated during the TLS
+// handshake. See g_dtls_connection_get_negotiated_protocol().
+func (x *DtlsConnectionBase) GetPropertyNegotiatedProtocol() string {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("negotiated-protocol", &v)
+	return v.GetString()
+}
+// SetPropertyRequireCloseNotify sets the "require-close-notify" property.
+// Whether or not proper TLS close notification is required.
+// See g_dtls_connection_set_require_close_notify().
+func (x *DtlsConnectionBase) SetPropertyRequireCloseNotify(value bool) {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	obj.SetProperty("require-close-notify", &v)
+}
+// GetPropertyRequireCloseNotify gets the "require-close-notify" property.
+// Whether or not proper TLS close notification is required.
+// See g_dtls_connection_set_require_close_notify().
+func (x *DtlsConnectionBase) GetPropertyRequireCloseNotify() bool {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("require-close-notify", &v)
+	return v.GetBoolean()
+}
 var XGDtlsConnectionClose func(uintptr, uintptr, **glib.Error) bool
 var XGDtlsConnectionCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
 var XGDtlsConnectionCloseFinish func(uintptr, uintptr, **glib.Error) bool
 var XGDtlsConnectionEmitAcceptCertificate func(uintptr, uintptr, TlsCertificateFlags) bool
 var XGDtlsConnectionGetCertificate func(uintptr) uintptr
-var XGDtlsConnectionGetChannelBindingData func(uintptr, TlsChannelBindingType, []byte, **glib.Error) bool
+var XGDtlsConnectionGetChannelBindingData func(uintptr, TlsChannelBindingType, *[]byte, **glib.Error) bool
 var XGDtlsConnectionGetCiphersuiteName func(uintptr) string
 var XGDtlsConnectionGetDatabase func(uintptr) uintptr
 var XGDtlsConnectionGetInteraction func(uintptr) uintptr

M v4/gio/gfile.go +253 -253


@@ -231,7 +231,7 @@ func (x *FileIface) GoPointer() uintptr {
231		return uintptr(unsafe.Pointer(x))	231		return uintptr(unsafe.Pointer(x))
232		}	232		}
233			233
234	-	// OverrideDup sets the callback function.	234	+	// OverrideDup sets the "dup" callback function.
235		// Duplicates a #GFile.	235		// Duplicates a #GFile.
236		func (x FileIface) OverrideDup(cb func(File) FileBase) {	236		func (x FileIface) OverrideDup(cb func(File) FileBase) {
237		if cb == nil {	237		if cb == nil {

@@ -247,7 +247,7 @@ func (x FileIface) OverrideDup(cb func(File) FileBase) {
247		}	247		}
248		}	248		}
249			249
250	-	// GetDup gets the callback function.	250	+	// GetDup gets the "dup" callback function.
251		// Duplicates a #GFile.	251		// Duplicates a #GFile.
252		func (x FileIface) GetDup() func(File) FileBase {	252		func (x FileIface) GetDup() func(File) FileBase {
253		if x.xDup == 0 {	253		if x.xDup == 0 {

@@ -266,7 +266,7 @@ func (x FileIface) GetDup() func(File) FileBase {
266		}	266		}
267		}	267		}
268			268
269	-	// OverrideHash sets the callback function.	269	+	// OverrideHash sets the "hash" callback function.
270		// Creates a hash of a #GFile.	270		// Creates a hash of a #GFile.
271		func (x *FileIface) OverrideHash(cb func(File) uint) {	271		func (x *FileIface) OverrideHash(cb func(File) uint) {
272		if cb == nil {	272		if cb == nil {

@@ -278,7 +278,7 @@ func (x *FileIface) OverrideHash(cb func(File) uint) {
278		}	278		}
279		}	279		}
280			280
281	-	// GetHash gets the callback function.	281	+	// GetHash gets the "hash" callback function.
282		// Creates a hash of a #GFile.	282		// Creates a hash of a #GFile.
283		func (x *FileIface) GetHash() func(File) uint {	283		func (x *FileIface) GetHash() func(File) uint {
284		if x.xHash == 0 {	284		if x.xHash == 0 {

@@ -291,7 +291,7 @@ func (x *FileIface) GetHash() func(File) uint {
291		}	291		}
292		}	292		}
293			293
294	-	// OverrideEqual sets the callback function.	294	+	// OverrideEqual sets the "equal" callback function.
295		// Checks equality of two given #GFiles.	295		// Checks equality of two given #GFiles.
296		func (x *FileIface) OverrideEqual(cb func(File, File) bool) {	296		func (x *FileIface) OverrideEqual(cb func(File, File) bool) {
297		if cb == nil {	297		if cb == nil {

@@ -303,7 +303,7 @@ func (x *FileIface) OverrideEqual(cb func(File, File) bool) {
303		}	303		}
304		}	304		}
305			305
306	-	// GetEqual gets the callback function.	306	+	// GetEqual gets the "equal" callback function.
307		// Checks equality of two given #GFiles.	307		// Checks equality of two given #GFiles.
308		func (x *FileIface) GetEqual() func(File, File) bool {	308		func (x *FileIface) GetEqual() func(File, File) bool {
309		if x.xEqual == 0 {	309		if x.xEqual == 0 {

@@ -316,7 +316,7 @@ func (x *FileIface) GetEqual() func(File, File) bool {
316		}	316		}
317		}	317		}
318			318
319	-	// OverrideIsNative sets the callback function.	319	+	// OverrideIsNative sets the "is_native" callback function.
320		// Checks to see if a file is native to the system.	320		// Checks to see if a file is native to the system.
321		func (x *FileIface) OverrideIsNative(cb func(File) bool) {	321		func (x *FileIface) OverrideIsNative(cb func(File) bool) {
322		if cb == nil {	322		if cb == nil {

@@ -328,7 +328,7 @@ func (x *FileIface) OverrideIsNative(cb func(File) bool) {
328		}	328		}
329		}	329		}
330			330
331	-	// GetIsNative gets the callback function.	331	+	// GetIsNative gets the "is_native" callback function.
332		// Checks to see if a file is native to the system.	332		// Checks to see if a file is native to the system.
333		func (x *FileIface) GetIsNative() func(File) bool {	333		func (x *FileIface) GetIsNative() func(File) bool {
334		if x.xIsNative == 0 {	334		if x.xIsNative == 0 {

@@ -341,7 +341,7 @@ func (x *FileIface) GetIsNative() func(File) bool {
341		}	341		}
342		}	342		}
343			343
344	-	// OverrideHasUriScheme sets the callback function.	344	+	// OverrideHasUriScheme sets the "has_uri_scheme" callback function.
345		// Checks to see if a #GFile has a given URI scheme.	345		// Checks to see if a #GFile has a given URI scheme.
346		func (x *FileIface) OverrideHasUriScheme(cb func(File, string) bool) {	346		func (x *FileIface) OverrideHasUriScheme(cb func(File, string) bool) {
347		if cb == nil {	347		if cb == nil {

@@ -353,7 +353,7 @@ func (x *FileIface) OverrideHasUriScheme(cb func(File, string) bool) {
353		}	353		}
354		}	354		}
355			355
356	-	// GetHasUriScheme gets the callback function.	356	+	// GetHasUriScheme gets the "has_uri_scheme" callback function.
357		// Checks to see if a #GFile has a given URI scheme.	357		// Checks to see if a #GFile has a given URI scheme.
358		func (x *FileIface) GetHasUriScheme() func(File, string) bool {	358		func (x *FileIface) GetHasUriScheme() func(File, string) bool {
359		if x.xHasUriScheme == 0 {	359		if x.xHasUriScheme == 0 {

@@ -366,7 +366,7 @@ func (x *FileIface) GetHasUriScheme() func(File, string) bool {
366		}	366		}
367		}	367		}
368			368
369	-	// OverrideGetUriScheme sets the callback function.	369	+	// OverrideGetUriScheme sets the "get_uri_scheme" callback function.
370		// Gets the URI scheme for a #GFile.	370		// Gets the URI scheme for a #GFile.
371		func (x *FileIface) OverrideGetUriScheme(cb func(File) string) {	371		func (x *FileIface) OverrideGetUriScheme(cb func(File) string) {
372		if cb == nil {	372		if cb == nil {

@@ -378,7 +378,7 @@ func (x *FileIface) OverrideGetUriScheme(cb func(File) string) {
378		}	378		}
379		}	379		}
380			380
381	-	// GetGetUriScheme gets the callback function.	381	+	// GetGetUriScheme gets the "get_uri_scheme" callback function.
382		// Gets the URI scheme for a #GFile.	382		// Gets the URI scheme for a #GFile.
383		func (x *FileIface) GetGetUriScheme() func(File) string {	383		func (x *FileIface) GetGetUriScheme() func(File) string {
384		if x.xGetUriScheme == 0 {	384		if x.xGetUriScheme == 0 {

@@ -391,7 +391,7 @@ func (x *FileIface) GetGetUriScheme() func(File) string {
391		}	391		}
392		}	392		}
393			393
394	-	// OverrideGetBasename sets the callback function.	394	+	// OverrideGetBasename sets the "get_basename" callback function.
395		// Gets the basename for a given #GFile.	395		// Gets the basename for a given #GFile.
396		func (x *FileIface) OverrideGetBasename(cb func(File) string) {	396		func (x *FileIface) OverrideGetBasename(cb func(File) string) {
397		if cb == nil {	397		if cb == nil {

@@ -403,7 +403,7 @@ func (x *FileIface) OverrideGetBasename(cb func(File) string) {
403		}	403		}
404		}	404		}
405			405
406	-	// GetGetBasename gets the callback function.	406	+	// GetGetBasename gets the "get_basename" callback function.
407		// Gets the basename for a given #GFile.	407		// Gets the basename for a given #GFile.
408		func (x *FileIface) GetGetBasename() func(File) string {	408		func (x *FileIface) GetGetBasename() func(File) string {
409		if x.xGetBasename == 0 {	409		if x.xGetBasename == 0 {

@@ -416,7 +416,7 @@ func (x *FileIface) GetGetBasename() func(File) string {
416		}	416		}
417		}	417		}
418			418
419	-	// OverrideGetPath sets the callback function.	419	+	// OverrideGetPath sets the "get_path" callback function.
420		// Gets the current path within a #GFile.	420		// Gets the current path within a #GFile.
421		func (x *FileIface) OverrideGetPath(cb func(File) string) {	421		func (x *FileIface) OverrideGetPath(cb func(File) string) {
422		if cb == nil {	422		if cb == nil {

@@ -428,7 +428,7 @@ func (x *FileIface) OverrideGetPath(cb func(File) string) {
428		}	428		}
429		}	429		}
430			430
431	-	// GetGetPath gets the callback function.	431	+	// GetGetPath gets the "get_path" callback function.
432		// Gets the current path within a #GFile.	432		// Gets the current path within a #GFile.
433		func (x *FileIface) GetGetPath() func(File) string {	433		func (x *FileIface) GetGetPath() func(File) string {
434		if x.xGetPath == 0 {	434		if x.xGetPath == 0 {

@@ -441,7 +441,7 @@ func (x *FileIface) GetGetPath() func(File) string {
441		}	441		}
442		}	442		}
443			443
444	-	// OverrideGetUri sets the callback function.	444	+	// OverrideGetUri sets the "get_uri" callback function.
445		// Gets a URI for the path within a #GFile.	445		// Gets a URI for the path within a #GFile.
446		func (x *FileIface) OverrideGetUri(cb func(File) string) {	446		func (x *FileIface) OverrideGetUri(cb func(File) string) {
447		if cb == nil {	447		if cb == nil {

@@ -453,7 +453,7 @@ func (x *FileIface) OverrideGetUri(cb func(File) string) {
453		}	453		}
454		}	454		}
455			455
456	-	// GetGetUri gets the callback function.	456	+	// GetGetUri gets the "get_uri" callback function.
457		// Gets a URI for the path within a #GFile.	457		// Gets a URI for the path within a #GFile.
458		func (x *FileIface) GetGetUri() func(File) string {	458		func (x *FileIface) GetGetUri() func(File) string {
459		if x.xGetUri == 0 {	459		if x.xGetUri == 0 {

@@ -466,7 +466,7 @@ func (x *FileIface) GetGetUri() func(File) string {
466		}	466		}
467		}	467		}
468			468
469	-	// OverrideGetParseName sets the callback function.	469	+	// OverrideGetParseName sets the "get_parse_name" callback function.
470		// Gets the parsed name for the #GFile.	470		// Gets the parsed name for the #GFile.
471		func (x *FileIface) OverrideGetParseName(cb func(File) string) {	471		func (x *FileIface) OverrideGetParseName(cb func(File) string) {
472		if cb == nil {	472		if cb == nil {

@@ -478,7 +478,7 @@ func (x *FileIface) OverrideGetParseName(cb func(File) string) {
478		}	478		}
479		}	479		}
480			480
481	-	// GetGetParseName gets the callback function.	481	+	// GetGetParseName gets the "get_parse_name" callback function.
482		// Gets the parsed name for the #GFile.	482		// Gets the parsed name for the #GFile.
483		func (x *FileIface) GetGetParseName() func(File) string {	483		func (x *FileIface) GetGetParseName() func(File) string {
484		if x.xGetParseName == 0 {	484		if x.xGetParseName == 0 {

@@ -491,7 +491,7 @@ func (x *FileIface) GetGetParseName() func(File) string {
491		}	491		}
492		}	492		}
493			493
494	-	// OverrideGetParent sets the callback function.	494	+	// OverrideGetParent sets the "get_parent" callback function.
495		// Gets the parent directory for the #GFile.	495		// Gets the parent directory for the #GFile.
496		func (x FileIface) OverrideGetParent(cb func(File) FileBase) {	496		func (x FileIface) OverrideGetParent(cb func(File) FileBase) {
497		if cb == nil {	497		if cb == nil {

@@ -507,7 +507,7 @@ func (x FileIface) OverrideGetParent(cb func(File) FileBase) {
507		}	507		}
508		}	508		}
509			509
510	-	// GetGetParent gets the callback function.	510	+	// GetGetParent gets the "get_parent" callback function.
511		// Gets the parent directory for the #GFile.	511		// Gets the parent directory for the #GFile.
512		func (x FileIface) GetGetParent() func(File) FileBase {	512		func (x FileIface) GetGetParent() func(File) FileBase {
513		if x.xGetParent == 0 {	513		if x.xGetParent == 0 {

@@ -526,7 +526,7 @@ func (x FileIface) GetGetParent() func(File) FileBase {
526		}	526		}
527		}	527		}
528			528
529	-	// OverridePrefixMatches sets the callback function.	529	+	// OverridePrefixMatches sets the "prefix_matches" callback function.
530		// Checks whether a #GFile contains a specified file.	530		// Checks whether a #GFile contains a specified file.
531		func (x *FileIface) OverridePrefixMatches(cb func(File, File) bool) {	531		func (x *FileIface) OverridePrefixMatches(cb func(File, File) bool) {
532		if cb == nil {	532		if cb == nil {

@@ -538,7 +538,7 @@ func (x *FileIface) OverridePrefixMatches(cb func(File, File) bool) {
538		}	538		}
539		}	539		}
540			540
541	-	// GetPrefixMatches gets the callback function.	541	+	// GetPrefixMatches gets the "prefix_matches" callback function.
542		// Checks whether a #GFile contains a specified file.	542		// Checks whether a #GFile contains a specified file.
543		func (x *FileIface) GetPrefixMatches() func(File, File) bool {	543		func (x *FileIface) GetPrefixMatches() func(File, File) bool {
544		if x.xPrefixMatches == 0 {	544		if x.xPrefixMatches == 0 {

@@ -551,7 +551,7 @@ func (x *FileIface) GetPrefixMatches() func(File, File) bool {
551		}	551		}
552		}	552		}
553			553
554	-	// OverrideGetRelativePath sets the callback function.	554	+	// OverrideGetRelativePath sets the "get_relative_path" callback function.
555		// Gets the path for a #GFile relative to a given path.	555		// Gets the path for a #GFile relative to a given path.
556		func (x *FileIface) OverrideGetRelativePath(cb func(File, File) string) {	556		func (x *FileIface) OverrideGetRelativePath(cb func(File, File) string) {
557		if cb == nil {	557		if cb == nil {

@@ -563,7 +563,7 @@ func (x *FileIface) OverrideGetRelativePath(cb func(File, File) string) {
563		}	563		}
564		}	564		}
565			565
566	-	// GetGetRelativePath gets the callback function.	566	+	// GetGetRelativePath gets the "get_relative_path" callback function.
567		// Gets the path for a #GFile relative to a given path.	567		// Gets the path for a #GFile relative to a given path.
568		func (x *FileIface) GetGetRelativePath() func(File, File) string {	568		func (x *FileIface) GetGetRelativePath() func(File, File) string {
569		if x.xGetRelativePath == 0 {	569		if x.xGetRelativePath == 0 {

@@ -576,7 +576,7 @@ func (x *FileIface) GetGetRelativePath() func(File, File) string {
576		}	576		}
577		}	577		}
578			578
579	-	// OverrideResolveRelativePath sets the callback function.	579	+	// OverrideResolveRelativePath sets the "resolve_relative_path" callback function.
580		// Resolves a relative path for a #GFile to an absolute path.	580		// Resolves a relative path for a #GFile to an absolute path.
581		func (x FileIface) OverrideResolveRelativePath(cb func(File, string) FileBase) {	581		func (x FileIface) OverrideResolveRelativePath(cb func(File, string) FileBase) {
582		if cb == nil {	582		if cb == nil {

@@ -592,7 +592,7 @@ func (x FileIface) OverrideResolveRelativePath(cb func(File, string) FileBase)
592		}	592		}
593		}	593		}
594			594
595	-	// GetResolveRelativePath gets the callback function.	595	+	// GetResolveRelativePath gets the "resolve_relative_path" callback function.
596		// Resolves a relative path for a #GFile to an absolute path.	596		// Resolves a relative path for a #GFile to an absolute path.
597		func (x FileIface) GetResolveRelativePath() func(File, string) FileBase {	597		func (x FileIface) GetResolveRelativePath() func(File, string) FileBase {
598		if x.xResolveRelativePath == 0 {	598		if x.xResolveRelativePath == 0 {

@@ -611,7 +611,7 @@ func (x FileIface) GetResolveRelativePath() func(File, string) FileBase {
611		}	611		}
612		}	612		}
613			613
614	-	// OverrideGetChildForDisplayName sets the callback function.	614	+	// OverrideGetChildForDisplayName sets the "get_child_for_display_name" callback function.
615		// Gets the child #GFile for a given display name.	615		// Gets the child #GFile for a given display name.
616		func (x FileIface) OverrideGetChildForDisplayName(cb func(File, string) FileBase) {	616		func (x FileIface) OverrideGetChildForDisplayName(cb func(File, string) FileBase) {
617		if cb == nil {	617		if cb == nil {

@@ -627,7 +627,7 @@ func (x FileIface) OverrideGetChildForDisplayName(cb func(File, string) FileBa
627		}	627		}
628		}	628		}
629			629
630	-	// GetGetChildForDisplayName gets the callback function.	630	+	// GetGetChildForDisplayName gets the "get_child_for_display_name" callback function.
631		// Gets the child #GFile for a given display name.	631		// Gets the child #GFile for a given display name.
632		func (x FileIface) GetGetChildForDisplayName() func(File, string) FileBase {	632		func (x FileIface) GetGetChildForDisplayName() func(File, string) FileBase {
633		if x.xGetChildForDisplayName == 0 {	633		if x.xGetChildForDisplayName == 0 {

@@ -646,7 +646,7 @@ func (x FileIface) GetGetChildForDisplayName() func(File, string) FileBase {
646		}	646		}
647		}	647		}
648			648
649	-	// OverrideEnumerateChildren sets the callback function.	649	+	// OverrideEnumerateChildren sets the "enumerate_children" callback function.
650		// Gets a #GFileEnumerator with the children of a #GFile.	650		// Gets a #GFileEnumerator with the children of a #GFile.
651		func (x FileIface) OverrideEnumerateChildren(cb func(File, string, FileQueryInfoFlags, Cancellable) *FileEnumerator) {	651		func (x FileIface) OverrideEnumerateChildren(cb func(File, string, FileQueryInfoFlags, Cancellable) *FileEnumerator) {
652		if cb == nil {	652		if cb == nil {

@@ -662,7 +662,7 @@ func (x *FileIface) OverrideEnumerateChildren(cb func(File, string, FileQueryInf
662		}	662		}
663		}	663		}
664			664
665	-	// GetEnumerateChildren gets the callback function.	665	+	// GetEnumerateChildren gets the "enumerate_children" callback function.
666		// Gets a #GFileEnumerator with the children of a #GFile.	666		// Gets a #GFileEnumerator with the children of a #GFile.
667		func (x FileIface) GetEnumerateChildren() func(File, string, FileQueryInfoFlags, Cancellable) *FileEnumerator {	667		func (x FileIface) GetEnumerateChildren() func(File, string, FileQueryInfoFlags, Cancellable) *FileEnumerator {
668		if x.xEnumerateChildren == 0 {	668		if x.xEnumerateChildren == 0 {

@@ -681,7 +681,7 @@ func (x *FileIface) GetEnumerateChildren() func(File, string, FileQueryInfoFlags
681		}	681		}
682		}	682		}
683			683
684	-	// OverrideEnumerateChildrenAsync sets the callback function.	684	+	// OverrideEnumerateChildrenAsync sets the "enumerate_children_async" callback function.
685		// Asynchronously gets a #GFileEnumerator with the children of a #GFile.	685		// Asynchronously gets a #GFileEnumerator with the children of a #GFile.
686		func (x FileIface) OverrideEnumerateChildrenAsync(cb func(File, string, FileQueryInfoFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {	686		func (x FileIface) OverrideEnumerateChildrenAsync(cb func(File, string, FileQueryInfoFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {
687		if cb == nil {	687		if cb == nil {

@@ -693,7 +693,7 @@ func (x *FileIface) OverrideEnumerateChildrenAsync(cb func(File, string, FileQue
693		}	693		}
694		}	694		}
695			695
696	-	// GetEnumerateChildrenAsync gets the callback function.	696	+	// GetEnumerateChildrenAsync gets the "enumerate_children_async" callback function.
697		// Asynchronously gets a #GFileEnumerator with the children of a #GFile.	697		// Asynchronously gets a #GFileEnumerator with the children of a #GFile.
698		func (x FileIface) GetEnumerateChildrenAsync() func(File, string, FileQueryInfoFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {	698		func (x FileIface) GetEnumerateChildrenAsync() func(File, string, FileQueryInfoFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {
699		if x.xEnumerateChildrenAsync == 0 {	699		if x.xEnumerateChildrenAsync == 0 {

@@ -706,7 +706,7 @@ func (x *FileIface) GetEnumerateChildrenAsync() func(File, string, FileQueryInfo
706		}	706		}
707		}	707		}
708			708
709	-	// OverrideEnumerateChildrenFinish sets the callback function.	709	+	// OverrideEnumerateChildrenFinish sets the "enumerate_children_finish" callback function.
710		// Finishes asynchronously enumerating the children.	710		// Finishes asynchronously enumerating the children.
711		func (x FileIface) OverrideEnumerateChildrenFinish(cb func(File, AsyncResult) FileEnumerator) {	711		func (x FileIface) OverrideEnumerateChildrenFinish(cb func(File, AsyncResult) FileEnumerator) {
712		if cb == nil {	712		if cb == nil {

@@ -722,7 +722,7 @@ func (x FileIface) OverrideEnumerateChildrenFinish(cb func(File, AsyncResult)
722		}	722		}
723		}	723		}
724			724
725	-	// GetEnumerateChildrenFinish gets the callback function.	725	+	// GetEnumerateChildrenFinish gets the "enumerate_children_finish" callback function.
726		// Finishes asynchronously enumerating the children.	726		// Finishes asynchronously enumerating the children.
727		func (x FileIface) GetEnumerateChildrenFinish() func(File, AsyncResult) FileEnumerator {	727		func (x FileIface) GetEnumerateChildrenFinish() func(File, AsyncResult) FileEnumerator {
728		if x.xEnumerateChildrenFinish == 0 {	728		if x.xEnumerateChildrenFinish == 0 {

@@ -741,7 +741,7 @@ func (x FileIface) GetEnumerateChildrenFinish() func(File, AsyncResult) FileEn
741		}	741		}
742		}	742		}
743			743
744	-	// OverrideQueryInfo sets the callback function.	744	+	// OverrideQueryInfo sets the "query_info" callback function.
745		// Gets the #GFileInfo for a #GFile.	745		// Gets the #GFileInfo for a #GFile.
746		func (x FileIface) OverrideQueryInfo(cb func(File, string, FileQueryInfoFlags, Cancellable) *FileInfo) {	746		func (x FileIface) OverrideQueryInfo(cb func(File, string, FileQueryInfoFlags, Cancellable) *FileInfo) {
747		if cb == nil {	747		if cb == nil {

@@ -757,7 +757,7 @@ func (x *FileIface) OverrideQueryInfo(cb func(File, string, FileQueryInfoFlags,
757		}	757		}
758		}	758		}
759			759
760	-	// GetQueryInfo gets the callback function.	760	+	// GetQueryInfo gets the "query_info" callback function.
761		// Gets the #GFileInfo for a #GFile.	761		// Gets the #GFileInfo for a #GFile.
762		func (x FileIface) GetQueryInfo() func(File, string, FileQueryInfoFlags, Cancellable) *FileInfo {	762		func (x FileIface) GetQueryInfo() func(File, string, FileQueryInfoFlags, Cancellable) *FileInfo {
763		if x.xQueryInfo == 0 {	763		if x.xQueryInfo == 0 {

@@ -776,7 +776,7 @@ func (x FileIface) GetQueryInfo() func(File, string, FileQueryInfoFlags, Cance
776		}	776		}
777		}	777		}
778			778
779	-	// OverrideQueryInfoAsync sets the callback function.	779	+	// OverrideQueryInfoAsync sets the "query_info_async" callback function.
780		// Asynchronously gets the #GFileInfo for a #GFile.	780		// Asynchronously gets the #GFileInfo for a #GFile.
781		func (x FileIface) OverrideQueryInfoAsync(cb func(File, string, FileQueryInfoFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {	781		func (x FileIface) OverrideQueryInfoAsync(cb func(File, string, FileQueryInfoFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {
782		if cb == nil {	782		if cb == nil {

@@ -788,7 +788,7 @@ func (x *FileIface) OverrideQueryInfoAsync(cb func(File, string, FileQueryInfoFl
788		}	788		}
789		}	789		}
790			790
791	-	// GetQueryInfoAsync gets the callback function.	791	+	// GetQueryInfoAsync gets the "query_info_async" callback function.
792		// Asynchronously gets the #GFileInfo for a #GFile.	792		// Asynchronously gets the #GFileInfo for a #GFile.
793		func (x FileIface) GetQueryInfoAsync() func(File, string, FileQueryInfoFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {	793		func (x FileIface) GetQueryInfoAsync() func(File, string, FileQueryInfoFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {
794		if x.xQueryInfoAsync == 0 {	794		if x.xQueryInfoAsync == 0 {

@@ -801,7 +801,7 @@ func (x *FileIface) GetQueryInfoAsync() func(File, string, FileQueryInfoFlags, i
801		}	801		}
802		}	802		}
803			803
804	-	// OverrideQueryInfoFinish sets the callback function.	804	+	// OverrideQueryInfoFinish sets the "query_info_finish" callback function.
805		// Finishes an asynchronous query info operation.	805		// Finishes an asynchronous query info operation.
806		func (x FileIface) OverrideQueryInfoFinish(cb func(File, AsyncResult) FileInfo) {	806		func (x FileIface) OverrideQueryInfoFinish(cb func(File, AsyncResult) FileInfo) {
807		if cb == nil {	807		if cb == nil {

@@ -817,7 +817,7 @@ func (x FileIface) OverrideQueryInfoFinish(cb func(File, AsyncResult) FileInfo
817		}	817		}
818		}	818		}
819			819
820	-	// GetQueryInfoFinish gets the callback function.	820	+	// GetQueryInfoFinish gets the "query_info_finish" callback function.
821		// Finishes an asynchronous query info operation.	821		// Finishes an asynchronous query info operation.
822		func (x FileIface) GetQueryInfoFinish() func(File, AsyncResult) FileInfo {	822		func (x FileIface) GetQueryInfoFinish() func(File, AsyncResult) FileInfo {
823		if x.xQueryInfoFinish == 0 {	823		if x.xQueryInfoFinish == 0 {

@@ -836,7 +836,7 @@ func (x FileIface) GetQueryInfoFinish() func(File, AsyncResult) FileInfo {
836		}	836		}
837		}	837		}
838			838
839	-	// OverrideQueryFilesystemInfo sets the callback function.	839	+	// OverrideQueryFilesystemInfo sets the "query_filesystem_info" callback function.
840		// Gets a #GFileInfo for the file system #GFile is on.	840		// Gets a #GFileInfo for the file system #GFile is on.
841		func (x FileIface) OverrideQueryFilesystemInfo(cb func(File, string, Cancellable) *FileInfo) {	841		func (x FileIface) OverrideQueryFilesystemInfo(cb func(File, string, Cancellable) *FileInfo) {
842		if cb == nil {	842		if cb == nil {

@@ -852,7 +852,7 @@ func (x FileIface) OverrideQueryFilesystemInfo(cb func(File, string, Cancellab
852		}	852		}
853		}	853		}
854			854
855	-	// GetQueryFilesystemInfo gets the callback function.	855	+	// GetQueryFilesystemInfo gets the "query_filesystem_info" callback function.
856		// Gets a #GFileInfo for the file system #GFile is on.	856		// Gets a #GFileInfo for the file system #GFile is on.
857		func (x FileIface) GetQueryFilesystemInfo() func(File, string, Cancellable) *FileInfo {	857		func (x FileIface) GetQueryFilesystemInfo() func(File, string, Cancellable) *FileInfo {
858		if x.xQueryFilesystemInfo == 0 {	858		if x.xQueryFilesystemInfo == 0 {

@@ -871,7 +871,7 @@ func (x FileIface) GetQueryFilesystemInfo() func(File, string, Cancellable) *F
871		}	871		}
872		}	872		}
873			873
874	-	// OverrideQueryFilesystemInfoAsync sets the callback function.	874	+	// OverrideQueryFilesystemInfoAsync sets the "query_filesystem_info_async" callback function.
875		// Asynchronously gets a #GFileInfo for the file system #GFile is on.	875		// Asynchronously gets a #GFileInfo for the file system #GFile is on.
876		func (x FileIface) OverrideQueryFilesystemInfoAsync(cb func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr)) {	876		func (x FileIface) OverrideQueryFilesystemInfoAsync(cb func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr)) {
877		if cb == nil {	877		if cb == nil {

@@ -883,7 +883,7 @@ func (x *FileIface) OverrideQueryFilesystemInfoAsync(cb func(File, string, int,
883		}	883		}
884		}	884		}
885			885
886	-	// GetQueryFilesystemInfoAsync gets the callback function.	886	+	// GetQueryFilesystemInfoAsync gets the "query_filesystem_info_async" callback function.
887		// Asynchronously gets a #GFileInfo for the file system #GFile is on.	887		// Asynchronously gets a #GFileInfo for the file system #GFile is on.
888		func (x FileIface) GetQueryFilesystemInfoAsync() func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr) {	888		func (x FileIface) GetQueryFilesystemInfoAsync() func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr) {
889		if x.xQueryFilesystemInfoAsync == 0 {	889		if x.xQueryFilesystemInfoAsync == 0 {

@@ -896,7 +896,7 @@ func (x FileIface) GetQueryFilesystemInfoAsync() func(File, string, int, Cance
896		}	896		}
897		}	897		}
898			898
899	-	// OverrideQueryFilesystemInfoFinish sets the callback function.	899	+	// OverrideQueryFilesystemInfoFinish sets the "query_filesystem_info_finish" callback function.
900		// Finishes asynchronously getting the file system info.	900		// Finishes asynchronously getting the file system info.
901		func (x FileIface) OverrideQueryFilesystemInfoFinish(cb func(File, AsyncResult) FileInfo) {	901		func (x FileIface) OverrideQueryFilesystemInfoFinish(cb func(File, AsyncResult) FileInfo) {
902		if cb == nil {	902		if cb == nil {

@@ -912,7 +912,7 @@ func (x *FileIface) OverrideQueryFilesystemInfoFinish(cb func(File, AsyncResult)
912		}	912		}
913		}	913		}
914			914
915	-	// GetQueryFilesystemInfoFinish gets the callback function.	915	+	// GetQueryFilesystemInfoFinish gets the "query_filesystem_info_finish" callback function.
916		// Finishes asynchronously getting the file system info.	916		// Finishes asynchronously getting the file system info.
917		func (x FileIface) GetQueryFilesystemInfoFinish() func(File, AsyncResult) FileInfo {	917		func (x FileIface) GetQueryFilesystemInfoFinish() func(File, AsyncResult) FileInfo {
918		if x.xQueryFilesystemInfoFinish == 0 {	918		if x.xQueryFilesystemInfoFinish == 0 {

@@ -931,7 +931,7 @@ func (x FileIface) GetQueryFilesystemInfoFinish() func(File, AsyncResult) File
931		}	931		}
932		}	932		}
933			933
934	-	// OverrideFindEnclosingMount sets the callback function.	934	+	// OverrideFindEnclosingMount sets the "find_enclosing_mount" callback function.
935		// Gets a #GMount for the #GFile.	935		// Gets a #GMount for the #GFile.
936		func (x FileIface) OverrideFindEnclosingMount(cb func(File, Cancellable) *MountBase) {	936		func (x FileIface) OverrideFindEnclosingMount(cb func(File, Cancellable) *MountBase) {
937		if cb == nil {	937		if cb == nil {

@@ -947,7 +947,7 @@ func (x FileIface) OverrideFindEnclosingMount(cb func(File, Cancellable) *Moun
947		}	947		}
948		}	948		}
949			949
950	-	// GetFindEnclosingMount gets the callback function.	950	+	// GetFindEnclosingMount gets the "find_enclosing_mount" callback function.
951		// Gets a #GMount for the #GFile.	951		// Gets a #GMount for the #GFile.
952		func (x FileIface) GetFindEnclosingMount() func(File, Cancellable) *MountBase {	952		func (x FileIface) GetFindEnclosingMount() func(File, Cancellable) *MountBase {
953		if x.xFindEnclosingMount == 0 {	953		if x.xFindEnclosingMount == 0 {

@@ -966,7 +966,7 @@ func (x FileIface) GetFindEnclosingMount() func(File, Cancellable) *MountBase
966		}	966		}
967		}	967		}
968			968
969	-	// OverrideFindEnclosingMountAsync sets the callback function.	969	+	// OverrideFindEnclosingMountAsync sets the "find_enclosing_mount_async" callback function.
970		// Asynchronously gets the #GMount for a #GFile.	970		// Asynchronously gets the #GMount for a #GFile.
971		func (x FileIface) OverrideFindEnclosingMountAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {	971		func (x FileIface) OverrideFindEnclosingMountAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {
972		if cb == nil {	972		if cb == nil {

@@ -978,7 +978,7 @@ func (x FileIface) OverrideFindEnclosingMountAsync(cb func(File, int, Cancella
978		}	978		}
979		}	979		}
980			980
981	-	// GetFindEnclosingMountAsync gets the callback function.	981	+	// GetFindEnclosingMountAsync gets the "find_enclosing_mount_async" callback function.
982		// Asynchronously gets the #GMount for a #GFile.	982		// Asynchronously gets the #GMount for a #GFile.
983		func (x FileIface) GetFindEnclosingMountAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {	983		func (x FileIface) GetFindEnclosingMountAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {
984		if x.xFindEnclosingMountAsync == 0 {	984		if x.xFindEnclosingMountAsync == 0 {

@@ -991,7 +991,7 @@ func (x FileIface) GetFindEnclosingMountAsync() func(File, int, Cancellable, *
991		}	991		}
992		}	992		}
993			993
994	-	// OverrideFindEnclosingMountFinish sets the callback function.	994	+	// OverrideFindEnclosingMountFinish sets the "find_enclosing_mount_finish" callback function.
995		// Finishes asynchronously getting the volume.	995		// Finishes asynchronously getting the volume.
996		func (x FileIface) OverrideFindEnclosingMountFinish(cb func(File, AsyncResult) MountBase) {	996		func (x FileIface) OverrideFindEnclosingMountFinish(cb func(File, AsyncResult) MountBase) {
997		if cb == nil {	997		if cb == nil {

@@ -1007,7 +1007,7 @@ func (x *FileIface) OverrideFindEnclosingMountFinish(cb func(File, AsyncResult)
1007		}	1007		}
1008		}	1008		}
1009			1009
1010	-	// GetFindEnclosingMountFinish gets the callback function.	1010	+	// GetFindEnclosingMountFinish gets the "find_enclosing_mount_finish" callback function.
1011		// Finishes asynchronously getting the volume.	1011		// Finishes asynchronously getting the volume.
1012		func (x FileIface) GetFindEnclosingMountFinish() func(File, AsyncResult) MountBase {	1012		func (x FileIface) GetFindEnclosingMountFinish() func(File, AsyncResult) MountBase {
1013		if x.xFindEnclosingMountFinish == 0 {	1013		if x.xFindEnclosingMountFinish == 0 {

@@ -1026,7 +1026,7 @@ func (x FileIface) GetFindEnclosingMountFinish() func(File, AsyncResult) Mount
1026		}	1026		}
1027		}	1027		}
1028			1028
1029	-	// OverrideSetDisplayName sets the callback function.	1029	+	// OverrideSetDisplayName sets the "set_display_name" callback function.
1030		// Sets the display name for a #GFile.	1030		// Sets the display name for a #GFile.
1031		func (x FileIface) OverrideSetDisplayName(cb func(File, string, Cancellable) *FileBase) {	1031		func (x FileIface) OverrideSetDisplayName(cb func(File, string, Cancellable) *FileBase) {
1032		if cb == nil {	1032		if cb == nil {

@@ -1042,7 +1042,7 @@ func (x FileIface) OverrideSetDisplayName(cb func(File, string, Cancellable) *
1042		}	1042		}
1043		}	1043		}
1044			1044
1045	-	// GetSetDisplayName gets the callback function.	1045	+	// GetSetDisplayName gets the "set_display_name" callback function.
1046		// Sets the display name for a #GFile.	1046		// Sets the display name for a #GFile.
1047		func (x FileIface) GetSetDisplayName() func(File, string, Cancellable) *FileBase {	1047		func (x FileIface) GetSetDisplayName() func(File, string, Cancellable) *FileBase {
1048		if x.xSetDisplayName == 0 {	1048		if x.xSetDisplayName == 0 {

@@ -1061,7 +1061,7 @@ func (x FileIface) GetSetDisplayName() func(File, string, Cancellable) *FileBa
1061		}	1061		}
1062		}	1062		}
1063			1063
1064	-	// OverrideSetDisplayNameAsync sets the callback function.	1064	+	// OverrideSetDisplayNameAsync sets the "set_display_name_async" callback function.
1065		// Asynchronously sets a #GFile's display name.	1065		// Asynchronously sets a #GFile's display name.
1066		func (x FileIface) OverrideSetDisplayNameAsync(cb func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr)) {	1066		func (x FileIface) OverrideSetDisplayNameAsync(cb func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr)) {
1067		if cb == nil {	1067		if cb == nil {

@@ -1073,7 +1073,7 @@ func (x FileIface) OverrideSetDisplayNameAsync(cb func(File, string, int, Canc
1073		}	1073		}
1074		}	1074		}
1075			1075
1076	-	// GetSetDisplayNameAsync gets the callback function.	1076	+	// GetSetDisplayNameAsync gets the "set_display_name_async" callback function.
1077		// Asynchronously sets a #GFile's display name.	1077		// Asynchronously sets a #GFile's display name.
1078		func (x FileIface) GetSetDisplayNameAsync() func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr) {	1078		func (x FileIface) GetSetDisplayNameAsync() func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr) {
1079		if x.xSetDisplayNameAsync == 0 {	1079		if x.xSetDisplayNameAsync == 0 {

@@ -1086,7 +1086,7 @@ func (x FileIface) GetSetDisplayNameAsync() func(File, string, int, Cancellabl
1086		}	1086		}
1087		}	1087		}
1088			1088
1089	-	// OverrideSetDisplayNameFinish sets the callback function.	1089	+	// OverrideSetDisplayNameFinish sets the "set_display_name_finish" callback function.
1090		// Finishes asynchronously setting a #GFile's display name.	1090		// Finishes asynchronously setting a #GFile's display name.
1091		func (x FileIface) OverrideSetDisplayNameFinish(cb func(File, AsyncResult) FileBase) {	1091		func (x FileIface) OverrideSetDisplayNameFinish(cb func(File, AsyncResult) FileBase) {
1092		if cb == nil {	1092		if cb == nil {

@@ -1102,7 +1102,7 @@ func (x FileIface) OverrideSetDisplayNameFinish(cb func(File, AsyncResult) Fil
1102		}	1102		}
1103		}	1103		}
1104			1104
1105	-	// GetSetDisplayNameFinish gets the callback function.	1105	+	// GetSetDisplayNameFinish gets the "set_display_name_finish" callback function.
1106		// Finishes asynchronously setting a #GFile's display name.	1106		// Finishes asynchronously setting a #GFile's display name.
1107		func (x FileIface) GetSetDisplayNameFinish() func(File, AsyncResult) FileBase {	1107		func (x FileIface) GetSetDisplayNameFinish() func(File, AsyncResult) FileBase {
1108		if x.xSetDisplayNameFinish == 0 {	1108		if x.xSetDisplayNameFinish == 0 {

@@ -1121,7 +1121,7 @@ func (x FileIface) GetSetDisplayNameFinish() func(File, AsyncResult) FileBase
1121		}	1121		}
1122		}	1122		}
1123			1123
1124	-	// OverrideQuerySettableAttributes sets the callback function.	1124	+	// OverrideQuerySettableAttributes sets the "query_settable_attributes" callback function.
1125		// Returns a list of #GFileAttributeInfos that can be set.	1125		// Returns a list of #GFileAttributeInfos that can be set.
1126		func (x FileIface) OverrideQuerySettableAttributes(cb func(File, Cancellable) *FileAttributeInfoList) {	1126		func (x FileIface) OverrideQuerySettableAttributes(cb func(File, Cancellable) *FileAttributeInfoList) {
1127		if cb == nil {	1127		if cb == nil {

@@ -1133,7 +1133,7 @@ func (x FileIface) OverrideQuerySettableAttributes(cb func(File, Cancellable)
1133		}	1133		}
1134		}	1134		}
1135			1135
1136	-	// GetQuerySettableAttributes gets the callback function.	1136	+	// GetQuerySettableAttributes gets the "query_settable_attributes" callback function.
1137		// Returns a list of #GFileAttributeInfos that can be set.	1137		// Returns a list of #GFileAttributeInfos that can be set.
1138		func (x FileIface) GetQuerySettableAttributes() func(File, Cancellable) *FileAttributeInfoList {	1138		func (x FileIface) GetQuerySettableAttributes() func(File, Cancellable) *FileAttributeInfoList {
1139		if x.xQuerySettableAttributes == 0 {	1139		if x.xQuerySettableAttributes == 0 {

@@ -1146,7 +1146,7 @@ func (x FileIface) GetQuerySettableAttributes() func(File, Cancellable) *FileA
1146		}	1146		}
1147		}	1147		}
1148			1148
1149	-	// OverrideQuerySettableAttributesAsync sets the callback function.	1149	+	// OverrideQuerySettableAttributesAsync sets the "_query_settable_attributes_async" callback function.
1150		// Asynchronously gets a list of #GFileAttributeInfos that can be set.	1150		// Asynchronously gets a list of #GFileAttributeInfos that can be set.
1151		func (x *FileIface) OverrideQuerySettableAttributesAsync(cb func()) {	1151		func (x *FileIface) OverrideQuerySettableAttributesAsync(cb func()) {
1152		if cb == nil {	1152		if cb == nil {

@@ -1158,7 +1158,7 @@ func (x *FileIface) OverrideQuerySettableAttributesAsync(cb func()) {
1158		}	1158		}
1159		}	1159		}
1160			1160
1161	-	// GetQuerySettableAttributesAsync gets the callback function.	1161	+	// GetQuerySettableAttributesAsync gets the "_query_settable_attributes_async" callback function.
1162		// Asynchronously gets a list of #GFileAttributeInfos that can be set.	1162		// Asynchronously gets a list of #GFileAttributeInfos that can be set.
1163		func (x *FileIface) GetQuerySettableAttributesAsync() func() {	1163		func (x *FileIface) GetQuerySettableAttributesAsync() func() {
1164		if x.xQuerySettableAttributesAsync == 0 {	1164		if x.xQuerySettableAttributesAsync == 0 {

@@ -1171,7 +1171,7 @@ func (x *FileIface) GetQuerySettableAttributesAsync() func() {
1171		}	1171		}
1172		}	1172		}
1173			1173
1174	-	// OverrideQuerySettableAttributesFinish sets the callback function.	1174	+	// OverrideQuerySettableAttributesFinish sets the "_query_settable_attributes_finish" callback function.
1175		// Finishes asynchronously querying settable attributes.	1175		// Finishes asynchronously querying settable attributes.
1176		func (x *FileIface) OverrideQuerySettableAttributesFinish(cb func()) {	1176		func (x *FileIface) OverrideQuerySettableAttributesFinish(cb func()) {
1177		if cb == nil {	1177		if cb == nil {

@@ -1183,7 +1183,7 @@ func (x *FileIface) OverrideQuerySettableAttributesFinish(cb func()) {
1183		}	1183		}
1184		}	1184		}
1185			1185
1186	-	// GetQuerySettableAttributesFinish gets the callback function.	1186	+	// GetQuerySettableAttributesFinish gets the "_query_settable_attributes_finish" callback function.
1187		// Finishes asynchronously querying settable attributes.	1187		// Finishes asynchronously querying settable attributes.
1188		func (x *FileIface) GetQuerySettableAttributesFinish() func() {	1188		func (x *FileIface) GetQuerySettableAttributesFinish() func() {
1189		if x.xQuerySettableAttributesFinish == 0 {	1189		if x.xQuerySettableAttributesFinish == 0 {

@@ -1196,7 +1196,7 @@ func (x *FileIface) GetQuerySettableAttributesFinish() func() {
1196		}	1196		}
1197		}	1197		}
1198			1198
1199	-	// OverrideQueryWritableNamespaces sets the callback function.	1199	+	// OverrideQueryWritableNamespaces sets the "query_writable_namespaces" callback function.
1200		// Returns a list of #GFileAttributeInfo namespaces that are writable.	1200		// Returns a list of #GFileAttributeInfo namespaces that are writable.
1201		func (x FileIface) OverrideQueryWritableNamespaces(cb func(File, Cancellable) *FileAttributeInfoList) {	1201		func (x FileIface) OverrideQueryWritableNamespaces(cb func(File, Cancellable) *FileAttributeInfoList) {
1202		if cb == nil {	1202		if cb == nil {

@@ -1208,7 +1208,7 @@ func (x FileIface) OverrideQueryWritableNamespaces(cb func(File, Cancellable)
1208		}	1208		}
1209		}	1209		}
1210			1210
1211	-	// GetQueryWritableNamespaces gets the callback function.	1211	+	// GetQueryWritableNamespaces gets the "query_writable_namespaces" callback function.
1212		// Returns a list of #GFileAttributeInfo namespaces that are writable.	1212		// Returns a list of #GFileAttributeInfo namespaces that are writable.
1213		func (x FileIface) GetQueryWritableNamespaces() func(File, Cancellable) *FileAttributeInfoList {	1213		func (x FileIface) GetQueryWritableNamespaces() func(File, Cancellable) *FileAttributeInfoList {
1214		if x.xQueryWritableNamespaces == 0 {	1214		if x.xQueryWritableNamespaces == 0 {

@@ -1221,7 +1221,7 @@ func (x FileIface) GetQueryWritableNamespaces() func(File, Cancellable) *FileA
1221		}	1221		}
1222		}	1222		}
1223			1223
1224	-	// OverrideQueryWritableNamespacesAsync sets the callback function.	1224	+	// OverrideQueryWritableNamespacesAsync sets the "_query_writable_namespaces_async" callback function.
1225		// Asynchronously gets a list of #GFileAttributeInfo namespaces that are writable.	1225		// Asynchronously gets a list of #GFileAttributeInfo namespaces that are writable.
1226		func (x *FileIface) OverrideQueryWritableNamespacesAsync(cb func()) {	1226		func (x *FileIface) OverrideQueryWritableNamespacesAsync(cb func()) {
1227		if cb == nil {	1227		if cb == nil {

@@ -1233,7 +1233,7 @@ func (x *FileIface) OverrideQueryWritableNamespacesAsync(cb func()) {
1233		}	1233		}
1234		}	1234		}
1235			1235
1236	-	// GetQueryWritableNamespacesAsync gets the callback function.	1236	+	// GetQueryWritableNamespacesAsync gets the "_query_writable_namespaces_async" callback function.
1237		// Asynchronously gets a list of #GFileAttributeInfo namespaces that are writable.	1237		// Asynchronously gets a list of #GFileAttributeInfo namespaces that are writable.
1238		func (x *FileIface) GetQueryWritableNamespacesAsync() func() {	1238		func (x *FileIface) GetQueryWritableNamespacesAsync() func() {
1239		if x.xQueryWritableNamespacesAsync == 0 {	1239		if x.xQueryWritableNamespacesAsync == 0 {

@@ -1246,7 +1246,7 @@ func (x *FileIface) GetQueryWritableNamespacesAsync() func() {
1246		}	1246		}
1247		}	1247		}
1248			1248
1249	-	// OverrideQueryWritableNamespacesFinish sets the callback function.	1249	+	// OverrideQueryWritableNamespacesFinish sets the "_query_writable_namespaces_finish" callback function.
1250		// Finishes asynchronously querying the writable namespaces.	1250		// Finishes asynchronously querying the writable namespaces.
1251		func (x *FileIface) OverrideQueryWritableNamespacesFinish(cb func()) {	1251		func (x *FileIface) OverrideQueryWritableNamespacesFinish(cb func()) {
1252		if cb == nil {	1252		if cb == nil {

@@ -1258,7 +1258,7 @@ func (x *FileIface) OverrideQueryWritableNamespacesFinish(cb func()) {
1258		}	1258		}
1259		}	1259		}
1260			1260
1261	-	// GetQueryWritableNamespacesFinish gets the callback function.	1261	+	// GetQueryWritableNamespacesFinish gets the "_query_writable_namespaces_finish" callback function.
1262		// Finishes asynchronously querying the writable namespaces.	1262		// Finishes asynchronously querying the writable namespaces.
1263		func (x *FileIface) GetQueryWritableNamespacesFinish() func() {	1263		func (x *FileIface) GetQueryWritableNamespacesFinish() func() {
1264		if x.xQueryWritableNamespacesFinish == 0 {	1264		if x.xQueryWritableNamespacesFinish == 0 {

@@ -1271,7 +1271,7 @@ func (x *FileIface) GetQueryWritableNamespacesFinish() func() {
1271		}	1271		}
1272		}	1272		}
1273			1273
1274	-	// OverrideSetAttribute sets the callback function.	1274	+	// OverrideSetAttribute sets the "set_attribute" callback function.
1275		// Sets a #GFileAttributeInfo.	1275		// Sets a #GFileAttributeInfo.
1276		func (x FileIface) OverrideSetAttribute(cb func(File, string, FileAttributeType, uintptr, FileQueryInfoFlags, Cancellable) bool) {	1276		func (x FileIface) OverrideSetAttribute(cb func(File, string, FileAttributeType, uintptr, FileQueryInfoFlags, Cancellable) bool) {
1277		if cb == nil {	1277		if cb == nil {

@@ -1283,7 +1283,7 @@ func (x *FileIface) OverrideSetAttribute(cb func(File, string, FileAttributeType
1283		}	1283		}
1284		}	1284		}
1285			1285
1286	-	// GetSetAttribute gets the callback function.	1286	+	// GetSetAttribute gets the "set_attribute" callback function.
1287		// Sets a #GFileAttributeInfo.	1287		// Sets a #GFileAttributeInfo.
1288		func (x FileIface) GetSetAttribute() func(File, string, FileAttributeType, uintptr, FileQueryInfoFlags, Cancellable) bool {	1288		func (x FileIface) GetSetAttribute() func(File, string, FileAttributeType, uintptr, FileQueryInfoFlags, Cancellable) bool {
1289		if x.xSetAttribute == 0 {	1289		if x.xSetAttribute == 0 {

@@ -1296,7 +1296,7 @@ func (x *FileIface) GetSetAttribute() func(File, string, FileAttributeType, uint
1296		}	1296		}
1297		}	1297		}
1298			1298
1299	-	// OverrideSetAttributesFromInfo sets the callback function.	1299	+	// OverrideSetAttributesFromInfo sets the "set_attributes_from_info" callback function.
1300		// Sets a #GFileAttributeInfo with information from a #GFileInfo.	1300		// Sets a #GFileAttributeInfo with information from a #GFileInfo.
1301		func (x FileIface) OverrideSetAttributesFromInfo(cb func(File, FileInfo, FileQueryInfoFlags, *Cancellable) bool) {	1301		func (x FileIface) OverrideSetAttributesFromInfo(cb func(File, FileInfo, FileQueryInfoFlags, *Cancellable) bool) {
1302		if cb == nil {	1302		if cb == nil {

@@ -1308,7 +1308,7 @@ func (x FileIface) OverrideSetAttributesFromInfo(cb func(File, FileInfo, FileQ
1308		}	1308		}
1309		}	1309		}
1310			1310
1311	-	// GetSetAttributesFromInfo gets the callback function.	1311	+	// GetSetAttributesFromInfo gets the "set_attributes_from_info" callback function.
1312		// Sets a #GFileAttributeInfo with information from a #GFileInfo.	1312		// Sets a #GFileAttributeInfo with information from a #GFileInfo.
1313		func (x FileIface) GetSetAttributesFromInfo() func(File, FileInfo, FileQueryInfoFlags, *Cancellable) bool {	1313		func (x FileIface) GetSetAttributesFromInfo() func(File, FileInfo, FileQueryInfoFlags, *Cancellable) bool {
1314		if x.xSetAttributesFromInfo == 0 {	1314		if x.xSetAttributesFromInfo == 0 {

@@ -1321,7 +1321,7 @@ func (x FileIface) GetSetAttributesFromInfo() func(File, FileInfo, FileQueryIn
1321		}	1321		}
1322		}	1322		}
1323			1323
1324	-	// OverrideSetAttributesAsync sets the callback function.	1324	+	// OverrideSetAttributesAsync sets the "set_attributes_async" callback function.
1325		// Asynchronously sets a file's attributes.	1325		// Asynchronously sets a file's attributes.
1326		func (x FileIface) OverrideSetAttributesAsync(cb func(File, FileInfo, FileQueryInfoFlags, int, Cancellable, AsyncReadyCallback, uintptr)) {	1326		func (x FileIface) OverrideSetAttributesAsync(cb func(File, FileInfo, FileQueryInfoFlags, int, Cancellable, AsyncReadyCallback, uintptr)) {
1327		if cb == nil {	1327		if cb == nil {

@@ -1333,7 +1333,7 @@ func (x FileIface) OverrideSetAttributesAsync(cb func(File, FileInfo, FileQuer
1333		}	1333		}
1334		}	1334		}
1335			1335
1336	-	// GetSetAttributesAsync gets the callback function.	1336	+	// GetSetAttributesAsync gets the "set_attributes_async" callback function.
1337		// Asynchronously sets a file's attributes.	1337		// Asynchronously sets a file's attributes.
1338		func (x FileIface) GetSetAttributesAsync() func(File, FileInfo, FileQueryInfoFlags, int, Cancellable, AsyncReadyCallback, uintptr) {	1338		func (x FileIface) GetSetAttributesAsync() func(File, FileInfo, FileQueryInfoFlags, int, Cancellable, AsyncReadyCallback, uintptr) {
1339		if x.xSetAttributesAsync == 0 {	1339		if x.xSetAttributesAsync == 0 {

@@ -1346,32 +1346,32 @@ func (x FileIface) GetSetAttributesAsync() func(File, FileInfo, FileQueryInfoF
1346		}	1346		}
1347		}	1347		}
1348			1348
1349	-	// OverrideSetAttributesFinish sets the callback function.	1349	+	// OverrideSetAttributesFinish sets the "set_attributes_finish" callback function.
1350		// Finishes setting a file's attributes asynchronously.	1350		// Finishes setting a file's attributes asynchronously.
1351		func (x FileIface) OverrideSetAttributesFinish(cb func(File, AsyncResult, *FileInfo) bool) {	1351		func (x FileIface) OverrideSetAttributesFinish(cb func(File, AsyncResult, *FileInfo) bool) {
1352		if cb == nil {	1352		if cb == nil {
1353		x.xSetAttributesFinish = 0	1353		x.xSetAttributesFinish = 0
1354		} else {	1354		} else {
1355	-	x.xSetAttributesFinish = purego.NewCallback(func(FileVarp uintptr, ResultVarp uintptr, InfoVarp uintptr) bool {	1355	+	x.xSetAttributesFinish = purego.NewCallback(func(FileVarp uintptr, ResultVarp uintptr, InfoVarp **FileInfo) bool {
1356	-	return cb(&FileBase{Ptr: FileVarp}, &AsyncResultBase{Ptr: ResultVarp}, (**FileInfo)(unsafe.Pointer(InfoVarp)))	1356	+	return cb(&FileBase{Ptr: FileVarp}, &AsyncResultBase{Ptr: ResultVarp}, InfoVarp)
1357		})	1357		})
1358		}	1358		}
1359		}	1359		}
1360			1360
1361	-	// GetSetAttributesFinish gets the callback function.	1361	+	// GetSetAttributesFinish gets the "set_attributes_finish" callback function.
1362		// Finishes setting a file's attributes asynchronously.	1362		// Finishes setting a file's attributes asynchronously.
1363		func (x FileIface) GetSetAttributesFinish() func(File, AsyncResult, *FileInfo) bool {	1363		func (x FileIface) GetSetAttributesFinish() func(File, AsyncResult, *FileInfo) bool {
1364		if x.xSetAttributesFinish == 0 {	1364		if x.xSetAttributesFinish == 0 {
1365		return nil	1365		return nil
1366		}	1366		}
1367	-	var rawCallback func(FileVarp uintptr, ResultVarp uintptr, InfoVarp uintptr) bool	1367	+	var rawCallback func(FileVarp uintptr, ResultVarp uintptr, InfoVarp **FileInfo) bool
1368		purego.RegisterFunc(&rawCallback, x.xSetAttributesFinish)	1368		purego.RegisterFunc(&rawCallback, x.xSetAttributesFinish)
1369		return func(FileVar File, ResultVar AsyncResult, InfoVar **FileInfo) bool {	1369		return func(FileVar File, ResultVar AsyncResult, InfoVar **FileInfo) bool {
1370	-	return rawCallback(FileVar.GoPointer(), ResultVar.GoPointer(), *gobject.ConvertPtr(InfoVar))	1370	+	return rawCallback(FileVar.GoPointer(), ResultVar.GoPointer(), InfoVar)
1371		}	1371		}
1372		}	1372		}
1373			1373
1374	-	// OverrideReadFn sets the callback function.	1374	+	// OverrideReadFn sets the "read_fn" callback function.
1375		// Reads a file asynchronously.	1375		// Reads a file asynchronously.
1376		func (x FileIface) OverrideReadFn(cb func(File, Cancellable) *FileInputStream) {	1376		func (x FileIface) OverrideReadFn(cb func(File, Cancellable) *FileInputStream) {
1377		if cb == nil {	1377		if cb == nil {

@@ -1387,7 +1387,7 @@ func (x FileIface) OverrideReadFn(cb func(File, Cancellable) *FileInputStream)
1387		}	1387		}
1388		}	1388		}
1389			1389
1390	-	// GetReadFn gets the callback function.	1390	+	// GetReadFn gets the "read_fn" callback function.
1391		// Reads a file asynchronously.	1391		// Reads a file asynchronously.
1392		func (x FileIface) GetReadFn() func(File, Cancellable) *FileInputStream {	1392		func (x FileIface) GetReadFn() func(File, Cancellable) *FileInputStream {
1393		if x.xReadFn == 0 {	1393		if x.xReadFn == 0 {

@@ -1406,7 +1406,7 @@ func (x FileIface) GetReadFn() func(File, Cancellable) *FileInputStream {
1406		}	1406		}
1407		}	1407		}
1408			1408
1409	-	// OverrideReadAsync sets the callback function.	1409	+	// OverrideReadAsync sets the "read_async" callback function.
1410		// Asynchronously reads a file.	1410		// Asynchronously reads a file.
1411		func (x FileIface) OverrideReadAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {	1411		func (x FileIface) OverrideReadAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {
1412		if cb == nil {	1412		if cb == nil {

@@ -1418,7 +1418,7 @@ func (x FileIface) OverrideReadAsync(cb func(File, int, Cancellable, *AsyncRea
1418		}	1418		}
1419		}	1419		}
1420			1420
1421	-	// GetReadAsync gets the callback function.	1421	+	// GetReadAsync gets the "read_async" callback function.
1422		// Asynchronously reads a file.	1422		// Asynchronously reads a file.
1423		func (x FileIface) GetReadAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {	1423		func (x FileIface) GetReadAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {
1424		if x.xReadAsync == 0 {	1424		if x.xReadAsync == 0 {

@@ -1431,7 +1431,7 @@ func (x FileIface) GetReadAsync() func(File, int, Cancellable, *AsyncReadyCall
1431		}	1431		}
1432		}	1432		}
1433			1433
1434	-	// OverrideReadFinish sets the callback function.	1434	+	// OverrideReadFinish sets the "read_finish" callback function.
1435		// Finishes asynchronously reading a file.	1435		// Finishes asynchronously reading a file.
1436		func (x FileIface) OverrideReadFinish(cb func(File, AsyncResult) FileInputStream) {	1436		func (x FileIface) OverrideReadFinish(cb func(File, AsyncResult) FileInputStream) {
1437		if cb == nil {	1437		if cb == nil {

@@ -1447,7 +1447,7 @@ func (x FileIface) OverrideReadFinish(cb func(File, AsyncResult) FileInputStre
1447		}	1447		}
1448		}	1448		}
1449			1449
1450	-	// GetReadFinish gets the callback function.	1450	+	// GetReadFinish gets the "read_finish" callback function.
1451		// Finishes asynchronously reading a file.	1451		// Finishes asynchronously reading a file.
1452		func (x FileIface) GetReadFinish() func(File, AsyncResult) FileInputStream {	1452		func (x FileIface) GetReadFinish() func(File, AsyncResult) FileInputStream {
1453		if x.xReadFinish == 0 {	1453		if x.xReadFinish == 0 {

@@ -1466,7 +1466,7 @@ func (x FileIface) GetReadFinish() func(File, AsyncResult) FileInputStream {
1466		}	1466		}
1467		}	1467		}
1468			1468
1469	-	// OverrideAppendTo sets the callback function.	1469	+	// OverrideAppendTo sets the "append_to" callback function.
1470		// Writes to the end of a file.	1470		// Writes to the end of a file.
1471		func (x FileIface) OverrideAppendTo(cb func(File, FileCreateFlags, Cancellable) *FileOutputStream) {	1471		func (x FileIface) OverrideAppendTo(cb func(File, FileCreateFlags, Cancellable) *FileOutputStream) {
1472		if cb == nil {	1472		if cb == nil {

@@ -1482,7 +1482,7 @@ func (x FileIface) OverrideAppendTo(cb func(File, FileCreateFlags, Cancellable
1482		}	1482		}
1483		}	1483		}
1484			1484
1485	-	// GetAppendTo gets the callback function.	1485	+	// GetAppendTo gets the "append_to" callback function.
1486		// Writes to the end of a file.	1486		// Writes to the end of a file.
1487		func (x FileIface) GetAppendTo() func(File, FileCreateFlags, Cancellable) *FileOutputStream {	1487		func (x FileIface) GetAppendTo() func(File, FileCreateFlags, Cancellable) *FileOutputStream {
1488		if x.xAppendTo == 0 {	1488		if x.xAppendTo == 0 {

@@ -1501,7 +1501,7 @@ func (x FileIface) GetAppendTo() func(File, FileCreateFlags, Cancellable) *Fil
1501		}	1501		}
1502		}	1502		}
1503			1503
1504	-	// OverrideAppendToAsync sets the callback function.	1504	+	// OverrideAppendToAsync sets the "append_to_async" callback function.
1505		// Asynchronously writes to the end of a file.	1505		// Asynchronously writes to the end of a file.
1506		func (x FileIface) OverrideAppendToAsync(cb func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {	1506		func (x FileIface) OverrideAppendToAsync(cb func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {
1507		if cb == nil {	1507		if cb == nil {

@@ -1513,7 +1513,7 @@ func (x FileIface) OverrideAppendToAsync(cb func(File, FileCreateFlags, int, C
1513		}	1513		}
1514		}	1514		}
1515			1515
1516	-	// GetAppendToAsync gets the callback function.	1516	+	// GetAppendToAsync gets the "append_to_async" callback function.
1517		// Asynchronously writes to the end of a file.	1517		// Asynchronously writes to the end of a file.
1518		func (x FileIface) GetAppendToAsync() func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {	1518		func (x FileIface) GetAppendToAsync() func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {
1519		if x.xAppendToAsync == 0 {	1519		if x.xAppendToAsync == 0 {

@@ -1526,7 +1526,7 @@ func (x FileIface) GetAppendToAsync() func(File, FileCreateFlags, int, Cancell
1526		}	1526		}
1527		}	1527		}
1528			1528
1529	-	// OverrideAppendToFinish sets the callback function.	1529	+	// OverrideAppendToFinish sets the "append_to_finish" callback function.
1530		// Finishes an asynchronous file append operation.	1530		// Finishes an asynchronous file append operation.
1531		func (x FileIface) OverrideAppendToFinish(cb func(File, AsyncResult) FileOutputStream) {	1531		func (x FileIface) OverrideAppendToFinish(cb func(File, AsyncResult) FileOutputStream) {
1532		if cb == nil {	1532		if cb == nil {

@@ -1542,7 +1542,7 @@ func (x FileIface) OverrideAppendToFinish(cb func(File, AsyncResult) FileOutpu
1542		}	1542		}
1543		}	1543		}
1544			1544
1545	-	// GetAppendToFinish gets the callback function.	1545	+	// GetAppendToFinish gets the "append_to_finish" callback function.
1546		// Finishes an asynchronous file append operation.	1546		// Finishes an asynchronous file append operation.
1547		func (x FileIface) GetAppendToFinish() func(File, AsyncResult) FileOutputStream {	1547		func (x FileIface) GetAppendToFinish() func(File, AsyncResult) FileOutputStream {
1548		if x.xAppendToFinish == 0 {	1548		if x.xAppendToFinish == 0 {

@@ -1561,7 +1561,7 @@ func (x FileIface) GetAppendToFinish() func(File, AsyncResult) FileOutputStrea
1561		}	1561		}
1562		}	1562		}
1563			1563
1564	-	// OverrideCreate sets the callback function.	1564	+	// OverrideCreate sets the "create" callback function.
1565		// Creates a new file.	1565		// Creates a new file.
1566		func (x FileIface) OverrideCreate(cb func(File, FileCreateFlags, Cancellable) *FileOutputStream) {	1566		func (x FileIface) OverrideCreate(cb func(File, FileCreateFlags, Cancellable) *FileOutputStream) {
1567		if cb == nil {	1567		if cb == nil {

@@ -1577,7 +1577,7 @@ func (x FileIface) OverrideCreate(cb func(File, FileCreateFlags, Cancellable)
1577		}	1577		}
1578		}	1578		}
1579			1579
1580	-	// GetCreate gets the callback function.	1580	+	// GetCreate gets the "create" callback function.
1581		// Creates a new file.	1581		// Creates a new file.
1582		func (x FileIface) GetCreate() func(File, FileCreateFlags, Cancellable) *FileOutputStream {	1582		func (x FileIface) GetCreate() func(File, FileCreateFlags, Cancellable) *FileOutputStream {
1583		if x.xCreate == 0 {	1583		if x.xCreate == 0 {

@@ -1596,7 +1596,7 @@ func (x FileIface) GetCreate() func(File, FileCreateFlags, Cancellable) *FileO
1596		}	1596		}
1597		}	1597		}
1598			1598
1599	-	// OverrideCreateAsync sets the callback function.	1599	+	// OverrideCreateAsync sets the "create_async" callback function.
1600		// Asynchronously creates a file.	1600		// Asynchronously creates a file.
1601		func (x FileIface) OverrideCreateAsync(cb func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {	1601		func (x FileIface) OverrideCreateAsync(cb func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {
1602		if cb == nil {	1602		if cb == nil {

@@ -1608,7 +1608,7 @@ func (x FileIface) OverrideCreateAsync(cb func(File, FileCreateFlags, int, Can
1608		}	1608		}
1609		}	1609		}
1610			1610
1611	-	// GetCreateAsync gets the callback function.	1611	+	// GetCreateAsync gets the "create_async" callback function.
1612		// Asynchronously creates a file.	1612		// Asynchronously creates a file.
1613		func (x FileIface) GetCreateAsync() func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {	1613		func (x FileIface) GetCreateAsync() func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {
1614		if x.xCreateAsync == 0 {	1614		if x.xCreateAsync == 0 {

@@ -1621,7 +1621,7 @@ func (x FileIface) GetCreateAsync() func(File, FileCreateFlags, int, Cancellab
1621		}	1621		}
1622		}	1622		}
1623			1623
1624	-	// OverrideCreateFinish sets the callback function.	1624	+	// OverrideCreateFinish sets the "create_finish" callback function.
1625		// Finishes asynchronously creating a file.	1625		// Finishes asynchronously creating a file.
1626		func (x FileIface) OverrideCreateFinish(cb func(File, AsyncResult) FileOutputStream) {	1626		func (x FileIface) OverrideCreateFinish(cb func(File, AsyncResult) FileOutputStream) {
1627		if cb == nil {	1627		if cb == nil {

@@ -1637,7 +1637,7 @@ func (x FileIface) OverrideCreateFinish(cb func(File, AsyncResult) FileOutputS
1637		}	1637		}
1638		}	1638		}
1639			1639
1640	-	// GetCreateFinish gets the callback function.	1640	+	// GetCreateFinish gets the "create_finish" callback function.
1641		// Finishes asynchronously creating a file.	1641		// Finishes asynchronously creating a file.
1642		func (x FileIface) GetCreateFinish() func(File, AsyncResult) FileOutputStream {	1642		func (x FileIface) GetCreateFinish() func(File, AsyncResult) FileOutputStream {
1643		if x.xCreateFinish == 0 {	1643		if x.xCreateFinish == 0 {

@@ -1656,7 +1656,7 @@ func (x FileIface) GetCreateFinish() func(File, AsyncResult) FileOutputStream
1656		}	1656		}
1657		}	1657		}
1658			1658
1659	-	// OverrideReplace sets the callback function.	1659	+	// OverrideReplace sets the "replace" callback function.
1660		// Replaces the contents of a file.	1660		// Replaces the contents of a file.
1661		func (x FileIface) OverrideReplace(cb func(File, string, bool, FileCreateFlags, Cancellable) *FileOutputStream) {	1661		func (x FileIface) OverrideReplace(cb func(File, string, bool, FileCreateFlags, Cancellable) *FileOutputStream) {
1662		if cb == nil {	1662		if cb == nil {

@@ -1672,7 +1672,7 @@ func (x *FileIface) OverrideReplace(cb func(File, string, bool, FileCreateFlags,
1672		}	1672		}
1673		}	1673		}
1674			1674
1675	-	// GetReplace gets the callback function.	1675	+	// GetReplace gets the "replace" callback function.
1676		// Replaces the contents of a file.	1676		// Replaces the contents of a file.
1677		func (x FileIface) GetReplace() func(File, string, bool, FileCreateFlags, Cancellable) *FileOutputStream {	1677		func (x FileIface) GetReplace() func(File, string, bool, FileCreateFlags, Cancellable) *FileOutputStream {
1678		if x.xReplace == 0 {	1678		if x.xReplace == 0 {

@@ -1691,7 +1691,7 @@ func (x FileIface) GetReplace() func(File, string, bool, FileCreateFlags, Canc
1691		}	1691		}
1692		}	1692		}
1693			1693
1694	-	// OverrideReplaceAsync sets the callback function.	1694	+	// OverrideReplaceAsync sets the "replace_async" callback function.
1695		// Asynchronously replaces the contents of a file.	1695		// Asynchronously replaces the contents of a file.
1696		func (x FileIface) OverrideReplaceAsync(cb func(File, string, bool, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {	1696		func (x FileIface) OverrideReplaceAsync(cb func(File, string, bool, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {
1697		if cb == nil {	1697		if cb == nil {

@@ -1703,7 +1703,7 @@ func (x *FileIface) OverrideReplaceAsync(cb func(File, string, bool, FileCreateF
1703		}	1703		}
1704		}	1704		}
1705			1705
1706	-	// GetReplaceAsync gets the callback function.	1706	+	// GetReplaceAsync gets the "replace_async" callback function.
1707		// Asynchronously replaces the contents of a file.	1707		// Asynchronously replaces the contents of a file.
1708		func (x FileIface) GetReplaceAsync() func(File, string, bool, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {	1708		func (x FileIface) GetReplaceAsync() func(File, string, bool, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {
1709		if x.xReplaceAsync == 0 {	1709		if x.xReplaceAsync == 0 {

@@ -1716,7 +1716,7 @@ func (x *FileIface) GetReplaceAsync() func(File, string, bool, FileCreateFlags,
1716		}	1716		}
1717		}	1717		}
1718			1718
1719	-	// OverrideReplaceFinish sets the callback function.	1719	+	// OverrideReplaceFinish sets the "replace_finish" callback function.
1720		// Finishes asynchronously replacing a file.	1720		// Finishes asynchronously replacing a file.
1721		func (x FileIface) OverrideReplaceFinish(cb func(File, AsyncResult) FileOutputStream) {	1721		func (x FileIface) OverrideReplaceFinish(cb func(File, AsyncResult) FileOutputStream) {
1722		if cb == nil {	1722		if cb == nil {

@@ -1732,7 +1732,7 @@ func (x FileIface) OverrideReplaceFinish(cb func(File, AsyncResult) FileOutput
1732		}	1732		}
1733		}	1733		}
1734			1734
1735	-	// GetReplaceFinish gets the callback function.	1735	+	// GetReplaceFinish gets the "replace_finish" callback function.
1736		// Finishes asynchronously replacing a file.	1736		// Finishes asynchronously replacing a file.
1737		func (x FileIface) GetReplaceFinish() func(File, AsyncResult) FileOutputStream {	1737		func (x FileIface) GetReplaceFinish() func(File, AsyncResult) FileOutputStream {
1738		if x.xReplaceFinish == 0 {	1738		if x.xReplaceFinish == 0 {

@@ -1751,7 +1751,7 @@ func (x FileIface) GetReplaceFinish() func(File, AsyncResult) FileOutputStream
1751		}	1751		}
1752		}	1752		}
1753			1753
1754	-	// OverrideDeleteFile sets the callback function.	1754	+	// OverrideDeleteFile sets the "delete_file" callback function.
1755		// Deletes a file.	1755		// Deletes a file.
1756		func (x FileIface) OverrideDeleteFile(cb func(File, Cancellable) bool) {	1756		func (x FileIface) OverrideDeleteFile(cb func(File, Cancellable) bool) {
1757		if cb == nil {	1757		if cb == nil {

@@ -1763,7 +1763,7 @@ func (x FileIface) OverrideDeleteFile(cb func(File, Cancellable) bool) {
1763		}	1763		}
1764		}	1764		}
1765			1765
1766	-	// GetDeleteFile gets the callback function.	1766	+	// GetDeleteFile gets the "delete_file" callback function.
1767		// Deletes a file.	1767		// Deletes a file.
1768		func (x FileIface) GetDeleteFile() func(File, Cancellable) bool {	1768		func (x FileIface) GetDeleteFile() func(File, Cancellable) bool {
1769		if x.xDeleteFile == 0 {	1769		if x.xDeleteFile == 0 {

@@ -1776,7 +1776,7 @@ func (x FileIface) GetDeleteFile() func(File, Cancellable) bool {
1776		}	1776		}
1777		}	1777		}
1778			1778
1779	-	// OverrideDeleteFileAsync sets the callback function.	1779	+	// OverrideDeleteFileAsync sets the "delete_file_async" callback function.
1780		// Asynchronously deletes a file.	1780		// Asynchronously deletes a file.
1781		func (x FileIface) OverrideDeleteFileAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {	1781		func (x FileIface) OverrideDeleteFileAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {
1782		if cb == nil {	1782		if cb == nil {

@@ -1788,7 +1788,7 @@ func (x FileIface) OverrideDeleteFileAsync(cb func(File, int, Cancellable, *As
1788		}	1788		}
1789		}	1789		}
1790			1790
1791	-	// GetDeleteFileAsync gets the callback function.	1791	+	// GetDeleteFileAsync gets the "delete_file_async" callback function.
1792		// Asynchronously deletes a file.	1792		// Asynchronously deletes a file.
1793		func (x FileIface) GetDeleteFileAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {	1793		func (x FileIface) GetDeleteFileAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {
1794		if x.xDeleteFileAsync == 0 {	1794		if x.xDeleteFileAsync == 0 {

@@ -1801,7 +1801,7 @@ func (x FileIface) GetDeleteFileAsync() func(File, int, Cancellable, *AsyncRea
1801		}	1801		}
1802		}	1802		}
1803			1803
1804	-	// OverrideDeleteFileFinish sets the callback function.	1804	+	// OverrideDeleteFileFinish sets the "delete_file_finish" callback function.
1805		// Finishes an asynchronous delete.	1805		// Finishes an asynchronous delete.
1806		func (x *FileIface) OverrideDeleteFileFinish(cb func(File, AsyncResult) bool) {	1806		func (x *FileIface) OverrideDeleteFileFinish(cb func(File, AsyncResult) bool) {
1807		if cb == nil {	1807		if cb == nil {

@@ -1813,7 +1813,7 @@ func (x *FileIface) OverrideDeleteFileFinish(cb func(File, AsyncResult) bool) {
1813		}	1813		}
1814		}	1814		}
1815			1815
1816	-	// GetDeleteFileFinish gets the callback function.	1816	+	// GetDeleteFileFinish gets the "delete_file_finish" callback function.
1817		// Finishes an asynchronous delete.	1817		// Finishes an asynchronous delete.
1818		func (x *FileIface) GetDeleteFileFinish() func(File, AsyncResult) bool {	1818		func (x *FileIface) GetDeleteFileFinish() func(File, AsyncResult) bool {
1819		if x.xDeleteFileFinish == 0 {	1819		if x.xDeleteFileFinish == 0 {

@@ -1826,7 +1826,7 @@ func (x *FileIface) GetDeleteFileFinish() func(File, AsyncResult) bool {
1826		}	1826		}
1827		}	1827		}
1828			1828
1829	-	// OverrideTrash sets the callback function.	1829	+	// OverrideTrash sets the "trash" callback function.
1830		// Sends a #GFile to the Trash location.	1830		// Sends a #GFile to the Trash location.
1831		func (x FileIface) OverrideTrash(cb func(File, Cancellable) bool) {	1831		func (x FileIface) OverrideTrash(cb func(File, Cancellable) bool) {
1832		if cb == nil {	1832		if cb == nil {

@@ -1838,7 +1838,7 @@ func (x FileIface) OverrideTrash(cb func(File, Cancellable) bool) {
1838		}	1838		}
1839		}	1839		}
1840			1840
1841	-	// GetTrash gets the callback function.	1841	+	// GetTrash gets the "trash" callback function.
1842		// Sends a #GFile to the Trash location.	1842		// Sends a #GFile to the Trash location.
1843		func (x FileIface) GetTrash() func(File, Cancellable) bool {	1843		func (x FileIface) GetTrash() func(File, Cancellable) bool {
1844		if x.xTrash == 0 {	1844		if x.xTrash == 0 {

@@ -1851,7 +1851,7 @@ func (x FileIface) GetTrash() func(File, Cancellable) bool {
1851		}	1851		}
1852		}	1852		}
1853			1853
1854	-	// OverrideTrashAsync sets the callback function.	1854	+	// OverrideTrashAsync sets the "trash_async" callback function.
1855		// Asynchronously sends a #GFile to the Trash location.	1855		// Asynchronously sends a #GFile to the Trash location.
1856		func (x FileIface) OverrideTrashAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {	1856		func (x FileIface) OverrideTrashAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {
1857		if cb == nil {	1857		if cb == nil {

@@ -1863,7 +1863,7 @@ func (x FileIface) OverrideTrashAsync(cb func(File, int, Cancellable, *AsyncRe
1863		}	1863		}
1864		}	1864		}
1865			1865
1866	-	// GetTrashAsync gets the callback function.	1866	+	// GetTrashAsync gets the "trash_async" callback function.
1867		// Asynchronously sends a #GFile to the Trash location.	1867		// Asynchronously sends a #GFile to the Trash location.
1868		func (x FileIface) GetTrashAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {	1868		func (x FileIface) GetTrashAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {
1869		if x.xTrashAsync == 0 {	1869		if x.xTrashAsync == 0 {

@@ -1876,7 +1876,7 @@ func (x FileIface) GetTrashAsync() func(File, int, Cancellable, *AsyncReadyCal
1876		}	1876		}
1877		}	1877		}
1878			1878
1879	-	// OverrideTrashFinish sets the callback function.	1879	+	// OverrideTrashFinish sets the "trash_finish" callback function.
1880		// Finishes an asynchronous file trashing operation.	1880		// Finishes an asynchronous file trashing operation.
1881		func (x *FileIface) OverrideTrashFinish(cb func(File, AsyncResult) bool) {	1881		func (x *FileIface) OverrideTrashFinish(cb func(File, AsyncResult) bool) {
1882		if cb == nil {	1882		if cb == nil {

@@ -1888,7 +1888,7 @@ func (x *FileIface) OverrideTrashFinish(cb func(File, AsyncResult) bool) {
1888		}	1888		}
1889		}	1889		}
1890			1890
1891	-	// GetTrashFinish gets the callback function.	1891	+	// GetTrashFinish gets the "trash_finish" callback function.
1892		// Finishes an asynchronous file trashing operation.	1892		// Finishes an asynchronous file trashing operation.
1893		func (x *FileIface) GetTrashFinish() func(File, AsyncResult) bool {	1893		func (x *FileIface) GetTrashFinish() func(File, AsyncResult) bool {
1894		if x.xTrashFinish == 0 {	1894		if x.xTrashFinish == 0 {

@@ -1901,7 +1901,7 @@ func (x *FileIface) GetTrashFinish() func(File, AsyncResult) bool {
1901		}	1901		}
1902		}	1902		}
1903			1903
1904	-	// OverrideMakeDirectory sets the callback function.	1904	+	// OverrideMakeDirectory sets the "make_directory" callback function.
1905		// Makes a directory.	1905		// Makes a directory.
1906		func (x FileIface) OverrideMakeDirectory(cb func(File, Cancellable) bool) {	1906		func (x FileIface) OverrideMakeDirectory(cb func(File, Cancellable) bool) {
1907		if cb == nil {	1907		if cb == nil {

@@ -1913,7 +1913,7 @@ func (x FileIface) OverrideMakeDirectory(cb func(File, Cancellable) bool) {
1913		}	1913		}
1914		}	1914		}
1915			1915
1916	-	// GetMakeDirectory gets the callback function.	1916	+	// GetMakeDirectory gets the "make_directory" callback function.
1917		// Makes a directory.	1917		// Makes a directory.
1918		func (x FileIface) GetMakeDirectory() func(File, Cancellable) bool {	1918		func (x FileIface) GetMakeDirectory() func(File, Cancellable) bool {
1919		if x.xMakeDirectory == 0 {	1919		if x.xMakeDirectory == 0 {

@@ -1926,7 +1926,7 @@ func (x FileIface) GetMakeDirectory() func(File, Cancellable) bool {
1926		}	1926		}
1927		}	1927		}
1928			1928
1929	-	// OverrideMakeDirectoryAsync sets the callback function.	1929	+	// OverrideMakeDirectoryAsync sets the "make_directory_async" callback function.
1930		// Asynchronously makes a directory.	1930		// Asynchronously makes a directory.
1931		func (x FileIface) OverrideMakeDirectoryAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {	1931		func (x FileIface) OverrideMakeDirectoryAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {
1932		if cb == nil {	1932		if cb == nil {

@@ -1938,7 +1938,7 @@ func (x FileIface) OverrideMakeDirectoryAsync(cb func(File, int, Cancellable,
1938		}	1938		}
1939		}	1939		}
1940			1940
1941	-	// GetMakeDirectoryAsync gets the callback function.	1941	+	// GetMakeDirectoryAsync gets the "make_directory_async" callback function.
1942		// Asynchronously makes a directory.	1942		// Asynchronously makes a directory.
1943		func (x FileIface) GetMakeDirectoryAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {	1943		func (x FileIface) GetMakeDirectoryAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {
1944		if x.xMakeDirectoryAsync == 0 {	1944		if x.xMakeDirectoryAsync == 0 {

@@ -1951,7 +1951,7 @@ func (x FileIface) GetMakeDirectoryAsync() func(File, int, Cancellable, *Async
1951		}	1951		}
1952		}	1952		}
1953			1953
1954	-	// OverrideMakeDirectoryFinish sets the callback function.	1954	+	// OverrideMakeDirectoryFinish sets the "make_directory_finish" callback function.
1955		// Finishes making a directory asynchronously.	1955		// Finishes making a directory asynchronously.
1956		func (x *FileIface) OverrideMakeDirectoryFinish(cb func(File, AsyncResult) bool) {	1956		func (x *FileIface) OverrideMakeDirectoryFinish(cb func(File, AsyncResult) bool) {
1957		if cb == nil {	1957		if cb == nil {

@@ -1963,7 +1963,7 @@ func (x *FileIface) OverrideMakeDirectoryFinish(cb func(File, AsyncResult) bool)
1963		}	1963		}
1964		}	1964		}
1965			1965
1966	-	// GetMakeDirectoryFinish gets the callback function.	1966	+	// GetMakeDirectoryFinish gets the "make_directory_finish" callback function.
1967		// Finishes making a directory asynchronously.	1967		// Finishes making a directory asynchronously.
1968		func (x *FileIface) GetMakeDirectoryFinish() func(File, AsyncResult) bool {	1968		func (x *FileIface) GetMakeDirectoryFinish() func(File, AsyncResult) bool {
1969		if x.xMakeDirectoryFinish == 0 {	1969		if x.xMakeDirectoryFinish == 0 {

@@ -1976,7 +1976,7 @@ func (x *FileIface) GetMakeDirectoryFinish() func(File, AsyncResult) bool {
1976		}	1976		}
1977		}	1977		}
1978			1978
1979	-	// OverrideMakeSymbolicLink sets the callback function.	1979	+	// OverrideMakeSymbolicLink sets the "make_symbolic_link" callback function.
1980		// Makes a symbolic link. %NULL if symbolic	1980		// Makes a symbolic link. %NULL if symbolic
1981		//	1981		//
1982		// links are unsupported.	1982		// links are unsupported.

@@ -1990,7 +1990,7 @@ func (x FileIface) OverrideMakeSymbolicLink(cb func(File, string, Cancellable)
1990		}	1990		}
1991		}	1991		}
1992			1992
1993	-	// GetMakeSymbolicLink gets the callback function.	1993	+	// GetMakeSymbolicLink gets the "make_symbolic_link" callback function.
1994		// Makes a symbolic link. %NULL if symbolic	1994		// Makes a symbolic link. %NULL if symbolic
1995		//	1995		//
1996		// links are unsupported.	1996		// links are unsupported.

@@ -2005,7 +2005,7 @@ func (x FileIface) GetMakeSymbolicLink() func(File, string, Cancellable) bool
2005		}	2005		}
2006		}	2006		}
2007			2007
2008	-	// OverrideMakeSymbolicLinkAsync sets the callback function.	2008	+	// OverrideMakeSymbolicLinkAsync sets the "make_symbolic_link_async" callback function.
2009		// Asynchronously makes a symbolic link	2009		// Asynchronously makes a symbolic link
2010		func (x FileIface) OverrideMakeSymbolicLinkAsync(cb func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr)) {	2010		func (x FileIface) OverrideMakeSymbolicLinkAsync(cb func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr)) {
2011		if cb == nil {	2011		if cb == nil {

@@ -2017,7 +2017,7 @@ func (x FileIface) OverrideMakeSymbolicLinkAsync(cb func(File, string, int, Ca
2017		}	2017		}
2018		}	2018		}
2019			2019
2020	-	// GetMakeSymbolicLinkAsync gets the callback function.	2020	+	// GetMakeSymbolicLinkAsync gets the "make_symbolic_link_async" callback function.
2021		// Asynchronously makes a symbolic link	2021		// Asynchronously makes a symbolic link
2022		func (x FileIface) GetMakeSymbolicLinkAsync() func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr) {	2022		func (x FileIface) GetMakeSymbolicLinkAsync() func(File, string, int, Cancellable, *AsyncReadyCallback, uintptr) {
2023		if x.xMakeSymbolicLinkAsync == 0 {	2023		if x.xMakeSymbolicLinkAsync == 0 {

@@ -2030,7 +2030,7 @@ func (x FileIface) GetMakeSymbolicLinkAsync() func(File, string, int, Cancella
2030		}	2030		}
2031		}	2031		}
2032			2032
2033	-	// OverrideMakeSymbolicLinkFinish sets the callback function.	2033	+	// OverrideMakeSymbolicLinkFinish sets the "make_symbolic_link_finish" callback function.
2034		// Finishes making a symbolic link asynchronously.	2034		// Finishes making a symbolic link asynchronously.
2035		func (x *FileIface) OverrideMakeSymbolicLinkFinish(cb func(File, AsyncResult) bool) {	2035		func (x *FileIface) OverrideMakeSymbolicLinkFinish(cb func(File, AsyncResult) bool) {
2036		if cb == nil {	2036		if cb == nil {

@@ -2042,7 +2042,7 @@ func (x *FileIface) OverrideMakeSymbolicLinkFinish(cb func(File, AsyncResult) bo
2042		}	2042		}
2043		}	2043		}
2044			2044
2045	-	// GetMakeSymbolicLinkFinish gets the callback function.	2045	+	// GetMakeSymbolicLinkFinish gets the "make_symbolic_link_finish" callback function.
2046		// Finishes making a symbolic link asynchronously.	2046		// Finishes making a symbolic link asynchronously.
2047		func (x *FileIface) GetMakeSymbolicLinkFinish() func(File, AsyncResult) bool {	2047		func (x *FileIface) GetMakeSymbolicLinkFinish() func(File, AsyncResult) bool {
2048		if x.xMakeSymbolicLinkFinish == 0 {	2048		if x.xMakeSymbolicLinkFinish == 0 {

@@ -2055,7 +2055,7 @@ func (x *FileIface) GetMakeSymbolicLinkFinish() func(File, AsyncResult) bool {
2055		}	2055		}
2056		}	2056		}
2057			2057
2058	-	// OverrideCopy sets the callback function.	2058	+	// OverrideCopy sets the "copy" callback function.
2059		// Copies a file. %NULL if copying is unsupported, which will	2059		// Copies a file. %NULL if copying is unsupported, which will
2060		//	2060		//
2061		// cause `GFile` to use a fallback copy method where it reads from the	2061		// cause `GFile` to use a fallback copy method where it reads from the

@@ -2070,7 +2070,7 @@ func (x FileIface) OverrideCopy(cb func(File, File, FileCopyFlags, Cancellable
2070		}	2070		}
2071		}	2071		}
2072			2072
2073	-	// GetCopy gets the callback function.	2073	+	// GetCopy gets the "copy" callback function.
2074		// Copies a file. %NULL if copying is unsupported, which will	2074		// Copies a file. %NULL if copying is unsupported, which will
2075		//	2075		//
2076		// cause `GFile` to use a fallback copy method where it reads from the	2076		// cause `GFile` to use a fallback copy method where it reads from the

@@ -2086,7 +2086,7 @@ func (x FileIface) GetCopy() func(File, File, FileCopyFlags, Cancellable, *Fil
2086		}	2086		}
2087		}	2087		}
2088			2088
2089	-	// OverrideCopyAsync sets the callback function.	2089	+	// OverrideCopyAsync sets the "copy_async" callback function.
2090		// Asynchronously copies a file.	2090		// Asynchronously copies a file.
2091		func (x FileIface) OverrideCopyAsync(cb func(File, File, FileCopyFlags, int, Cancellable, FileProgressCallback, uintptr, AsyncReadyCallback, uintptr)) {	2091		func (x FileIface) OverrideCopyAsync(cb func(File, File, FileCopyFlags, int, Cancellable, FileProgressCallback, uintptr, AsyncReadyCallback, uintptr)) {
2092		if cb == nil {	2092		if cb == nil {

@@ -2098,7 +2098,7 @@ func (x FileIface) OverrideCopyAsync(cb func(File, File, FileCopyFlags, int, C
2098		}	2098		}
2099		}	2099		}
2100			2100
2101	-	// GetCopyAsync gets the callback function.	2101	+	// GetCopyAsync gets the "copy_async" callback function.
2102		// Asynchronously copies a file.	2102		// Asynchronously copies a file.
2103		func (x FileIface) GetCopyAsync() func(File, File, FileCopyFlags, int, Cancellable, FileProgressCallback, uintptr, AsyncReadyCallback, uintptr) {	2103		func (x FileIface) GetCopyAsync() func(File, File, FileCopyFlags, int, Cancellable, FileProgressCallback, uintptr, AsyncReadyCallback, uintptr) {
2104		if x.xCopyAsync == 0 {	2104		if x.xCopyAsync == 0 {

@@ -2111,7 +2111,7 @@ func (x FileIface) GetCopyAsync() func(File, File, FileCopyFlags, int, Cancell
2111		}	2111		}
2112		}	2112		}
2113			2113
2114	-	// OverrideCopyFinish sets the callback function.	2114	+	// OverrideCopyFinish sets the "copy_finish" callback function.
2115		// Finishes an asynchronous copy operation.	2115		// Finishes an asynchronous copy operation.
2116		func (x *FileIface) OverrideCopyFinish(cb func(File, AsyncResult) bool) {	2116		func (x *FileIface) OverrideCopyFinish(cb func(File, AsyncResult) bool) {
2117		if cb == nil {	2117		if cb == nil {

@@ -2123,7 +2123,7 @@ func (x *FileIface) OverrideCopyFinish(cb func(File, AsyncResult) bool) {
2123		}	2123		}
2124		}	2124		}
2125			2125
2126	-	// GetCopyFinish gets the callback function.	2126	+	// GetCopyFinish gets the "copy_finish" callback function.
2127		// Finishes an asynchronous copy operation.	2127		// Finishes an asynchronous copy operation.
2128		func (x *FileIface) GetCopyFinish() func(File, AsyncResult) bool {	2128		func (x *FileIface) GetCopyFinish() func(File, AsyncResult) bool {
2129		if x.xCopyFinish == 0 {	2129		if x.xCopyFinish == 0 {

@@ -2136,7 +2136,7 @@ func (x *FileIface) GetCopyFinish() func(File, AsyncResult) bool {
2136		}	2136		}
2137		}	2137		}
2138			2138
2139	-	// OverrideMove sets the callback function.	2139	+	// OverrideMove sets the "move" callback function.
2140		// Moves a file.	2140		// Moves a file.
2141		func (x FileIface) OverrideMove(cb func(File, File, FileCopyFlags, Cancellable, *FileProgressCallback, uintptr) bool) {	2141		func (x FileIface) OverrideMove(cb func(File, File, FileCopyFlags, Cancellable, *FileProgressCallback, uintptr) bool) {
2142		if cb == nil {	2142		if cb == nil {

@@ -2148,7 +2148,7 @@ func (x FileIface) OverrideMove(cb func(File, File, FileCopyFlags, Cancellable
2148		}	2148		}
2149		}	2149		}
2150			2150
2151	-	// GetMove gets the callback function.	2151	+	// GetMove gets the "move" callback function.
2152		// Moves a file.	2152		// Moves a file.
2153		func (x FileIface) GetMove() func(File, File, FileCopyFlags, Cancellable, *FileProgressCallback, uintptr) bool {	2153		func (x FileIface) GetMove() func(File, File, FileCopyFlags, Cancellable, *FileProgressCallback, uintptr) bool {
2154		if x.xMove == 0 {	2154		if x.xMove == 0 {

@@ -2161,7 +2161,7 @@ func (x FileIface) GetMove() func(File, File, FileCopyFlags, Cancellable, *Fil
2161		}	2161		}
2162		}	2162		}
2163			2163
2164	-	// OverrideMoveAsync sets the callback function.	2164	+	// OverrideMoveAsync sets the "move_async" callback function.
2165		// Asynchronously moves a file. Since: 2.72	2165		// Asynchronously moves a file. Since: 2.72
2166		func (x FileIface) OverrideMoveAsync(cb func(File, File, FileCopyFlags, int, Cancellable, FileProgressCallback, uintptr, AsyncReadyCallback, uintptr)) {	2166		func (x FileIface) OverrideMoveAsync(cb func(File, File, FileCopyFlags, int, Cancellable, FileProgressCallback, uintptr, AsyncReadyCallback, uintptr)) {
2167		if cb == nil {	2167		if cb == nil {

@@ -2173,7 +2173,7 @@ func (x FileIface) OverrideMoveAsync(cb func(File, File, FileCopyFlags, int, C
2173		}	2173		}
2174		}	2174		}
2175			2175
2176	-	// GetMoveAsync gets the callback function.	2176	+	// GetMoveAsync gets the "move_async" callback function.
2177		// Asynchronously moves a file. Since: 2.72	2177		// Asynchronously moves a file. Since: 2.72
2178		func (x FileIface) GetMoveAsync() func(File, File, FileCopyFlags, int, Cancellable, FileProgressCallback, uintptr, AsyncReadyCallback, uintptr) {	2178		func (x FileIface) GetMoveAsync() func(File, File, FileCopyFlags, int, Cancellable, FileProgressCallback, uintptr, AsyncReadyCallback, uintptr) {
2179		if x.xMoveAsync == 0 {	2179		if x.xMoveAsync == 0 {

@@ -2186,7 +2186,7 @@ func (x FileIface) GetMoveAsync() func(File, File, FileCopyFlags, int, Cancell
2186		}	2186		}
2187		}	2187		}
2188			2188
2189	-	// OverrideMoveFinish sets the callback function.	2189	+	// OverrideMoveFinish sets the "move_finish" callback function.
2190		// Finishes an asynchronous move operation. Since: 2.72	2190		// Finishes an asynchronous move operation. Since: 2.72
2191		func (x *FileIface) OverrideMoveFinish(cb func(File, AsyncResult) bool) {	2191		func (x *FileIface) OverrideMoveFinish(cb func(File, AsyncResult) bool) {
2192		if cb == nil {	2192		if cb == nil {

@@ -2198,7 +2198,7 @@ func (x *FileIface) OverrideMoveFinish(cb func(File, AsyncResult) bool) {
2198		}	2198		}
2199		}	2199		}
2200			2200
2201	-	// GetMoveFinish gets the callback function.	2201	+	// GetMoveFinish gets the "move_finish" callback function.
2202		// Finishes an asynchronous move operation. Since: 2.72	2202		// Finishes an asynchronous move operation. Since: 2.72
2203		func (x *FileIface) GetMoveFinish() func(File, AsyncResult) bool {	2203		func (x *FileIface) GetMoveFinish() func(File, AsyncResult) bool {
2204		if x.xMoveFinish == 0 {	2204		if x.xMoveFinish == 0 {

@@ -2211,7 +2211,7 @@ func (x *FileIface) GetMoveFinish() func(File, AsyncResult) bool {
2211		}	2211		}
2212		}	2212		}
2213			2213
2214	-	// OverrideMountMountable sets the callback function.	2214	+	// OverrideMountMountable sets the "mount_mountable" callback function.
2215		// Mounts a mountable object.	2215		// Mounts a mountable object.
2216		func (x FileIface) OverrideMountMountable(cb func(File, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	2216		func (x FileIface) OverrideMountMountable(cb func(File, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
2217		if cb == nil {	2217		if cb == nil {

@@ -2223,7 +2223,7 @@ func (x FileIface) OverrideMountMountable(cb func(File, MountMountFlags, Mount
2223		}	2223		}
2224		}	2224		}
2225			2225
2226	-	// GetMountMountable gets the callback function.	2226	+	// GetMountMountable gets the "mount_mountable" callback function.
2227		// Mounts a mountable object.	2227		// Mounts a mountable object.
2228		func (x FileIface) GetMountMountable() func(File, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	2228		func (x FileIface) GetMountMountable() func(File, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
2229		if x.xMountMountable == 0 {	2229		if x.xMountMountable == 0 {

@@ -2236,7 +2236,7 @@ func (x FileIface) GetMountMountable() func(File, MountMountFlags, MountOperat
2236		}	2236		}
2237		}	2237		}
2238			2238
2239	-	// OverrideMountMountableFinish sets the callback function.	2239	+	// OverrideMountMountableFinish sets the "mount_mountable_finish" callback function.
2240		// Finishes a mounting operation.	2240		// Finishes a mounting operation.
2241		func (x FileIface) OverrideMountMountableFinish(cb func(File, AsyncResult) FileBase) {	2241		func (x FileIface) OverrideMountMountableFinish(cb func(File, AsyncResult) FileBase) {
2242		if cb == nil {	2242		if cb == nil {

@@ -2252,7 +2252,7 @@ func (x FileIface) OverrideMountMountableFinish(cb func(File, AsyncResult) Fil
2252		}	2252		}
2253		}	2253		}
2254			2254
2255	-	// GetMountMountableFinish gets the callback function.	2255	+	// GetMountMountableFinish gets the "mount_mountable_finish" callback function.
2256		// Finishes a mounting operation.	2256		// Finishes a mounting operation.
2257		func (x FileIface) GetMountMountableFinish() func(File, AsyncResult) FileBase {	2257		func (x FileIface) GetMountMountableFinish() func(File, AsyncResult) FileBase {
2258		if x.xMountMountableFinish == 0 {	2258		if x.xMountMountableFinish == 0 {

@@ -2271,7 +2271,7 @@ func (x FileIface) GetMountMountableFinish() func(File, AsyncResult) FileBase
2271		}	2271		}
2272		}	2272		}
2273			2273
2274	-	// OverrideUnmountMountable sets the callback function.	2274	+	// OverrideUnmountMountable sets the "unmount_mountable" callback function.
2275		// Unmounts a mountable object.	2275		// Unmounts a mountable object.
2276		func (x FileIface) OverrideUnmountMountable(cb func(File, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {	2276		func (x FileIface) OverrideUnmountMountable(cb func(File, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {
2277		if cb == nil {	2277		if cb == nil {

@@ -2283,7 +2283,7 @@ func (x FileIface) OverrideUnmountMountable(cb func(File, MountUnmountFlags, C
2283		}	2283		}
2284		}	2284		}
2285			2285
2286	-	// GetUnmountMountable gets the callback function.	2286	+	// GetUnmountMountable gets the "unmount_mountable" callback function.
2287		// Unmounts a mountable object.	2287		// Unmounts a mountable object.
2288		func (x FileIface) GetUnmountMountable() func(File, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {	2288		func (x FileIface) GetUnmountMountable() func(File, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {
2289		if x.xUnmountMountable == 0 {	2289		if x.xUnmountMountable == 0 {

@@ -2296,7 +2296,7 @@ func (x FileIface) GetUnmountMountable() func(File, MountUnmountFlags, Cancell
2296		}	2296		}
2297		}	2297		}
2298			2298
2299	-	// OverrideUnmountMountableFinish sets the callback function.	2299	+	// OverrideUnmountMountableFinish sets the "unmount_mountable_finish" callback function.
2300		// Finishes an unmount operation.	2300		// Finishes an unmount operation.
2301		func (x *FileIface) OverrideUnmountMountableFinish(cb func(File, AsyncResult) bool) {	2301		func (x *FileIface) OverrideUnmountMountableFinish(cb func(File, AsyncResult) bool) {
2302		if cb == nil {	2302		if cb == nil {

@@ -2308,7 +2308,7 @@ func (x *FileIface) OverrideUnmountMountableFinish(cb func(File, AsyncResult) bo
2308		}	2308		}
2309		}	2309		}
2310			2310
2311	-	// GetUnmountMountableFinish gets the callback function.	2311	+	// GetUnmountMountableFinish gets the "unmount_mountable_finish" callback function.
2312		// Finishes an unmount operation.	2312		// Finishes an unmount operation.
2313		func (x *FileIface) GetUnmountMountableFinish() func(File, AsyncResult) bool {	2313		func (x *FileIface) GetUnmountMountableFinish() func(File, AsyncResult) bool {
2314		if x.xUnmountMountableFinish == 0 {	2314		if x.xUnmountMountableFinish == 0 {

@@ -2321,7 +2321,7 @@ func (x *FileIface) GetUnmountMountableFinish() func(File, AsyncResult) bool {
2321		}	2321		}
2322		}	2322		}
2323			2323
2324	-	// OverrideEjectMountable sets the callback function.	2324	+	// OverrideEjectMountable sets the "eject_mountable" callback function.
2325		// Ejects a mountable.	2325		// Ejects a mountable.
2326		func (x FileIface) OverrideEjectMountable(cb func(File, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {	2326		func (x FileIface) OverrideEjectMountable(cb func(File, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {
2327		if cb == nil {	2327		if cb == nil {

@@ -2333,7 +2333,7 @@ func (x FileIface) OverrideEjectMountable(cb func(File, MountUnmountFlags, Can
2333		}	2333		}
2334		}	2334		}
2335			2335
2336	-	// GetEjectMountable gets the callback function.	2336	+	// GetEjectMountable gets the "eject_mountable" callback function.
2337		// Ejects a mountable.	2337		// Ejects a mountable.
2338		func (x FileIface) GetEjectMountable() func(File, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {	2338		func (x FileIface) GetEjectMountable() func(File, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {
2339		if x.xEjectMountable == 0 {	2339		if x.xEjectMountable == 0 {

@@ -2346,7 +2346,7 @@ func (x FileIface) GetEjectMountable() func(File, MountUnmountFlags, Cancellab
2346		}	2346		}
2347		}	2347		}
2348			2348
2349	-	// OverrideEjectMountableFinish sets the callback function.	2349	+	// OverrideEjectMountableFinish sets the "eject_mountable_finish" callback function.
2350		// Finishes an eject operation.	2350		// Finishes an eject operation.
2351		func (x *FileIface) OverrideEjectMountableFinish(cb func(File, AsyncResult) bool) {	2351		func (x *FileIface) OverrideEjectMountableFinish(cb func(File, AsyncResult) bool) {
2352		if cb == nil {	2352		if cb == nil {

@@ -2358,7 +2358,7 @@ func (x *FileIface) OverrideEjectMountableFinish(cb func(File, AsyncResult) bool
2358		}	2358		}
2359		}	2359		}
2360			2360
2361	-	// GetEjectMountableFinish gets the callback function.	2361	+	// GetEjectMountableFinish gets the "eject_mountable_finish" callback function.
2362		// Finishes an eject operation.	2362		// Finishes an eject operation.
2363		func (x *FileIface) GetEjectMountableFinish() func(File, AsyncResult) bool {	2363		func (x *FileIface) GetEjectMountableFinish() func(File, AsyncResult) bool {
2364		if x.xEjectMountableFinish == 0 {	2364		if x.xEjectMountableFinish == 0 {

@@ -2371,7 +2371,7 @@ func (x *FileIface) GetEjectMountableFinish() func(File, AsyncResult) bool {
2371		}	2371		}
2372		}	2372		}
2373			2373
2374	-	// OverrideMountEnclosingVolume sets the callback function.	2374	+	// OverrideMountEnclosingVolume sets the "mount_enclosing_volume" callback function.
2375		// Mounts a specified location.	2375		// Mounts a specified location.
2376		func (x FileIface) OverrideMountEnclosingVolume(cb func(File, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	2376		func (x FileIface) OverrideMountEnclosingVolume(cb func(File, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
2377		if cb == nil {	2377		if cb == nil {

@@ -2383,7 +2383,7 @@ func (x *FileIface) OverrideMountEnclosingVolume(cb func(File, MountMountFlags,
2383		}	2383		}
2384		}	2384		}
2385			2385
2386	-	// GetMountEnclosingVolume gets the callback function.	2386	+	// GetMountEnclosingVolume gets the "mount_enclosing_volume" callback function.
2387		// Mounts a specified location.	2387		// Mounts a specified location.
2388		func (x FileIface) GetMountEnclosingVolume() func(File, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	2388		func (x FileIface) GetMountEnclosingVolume() func(File, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
2389		if x.xMountEnclosingVolume == 0 {	2389		if x.xMountEnclosingVolume == 0 {

@@ -2396,7 +2396,7 @@ func (x FileIface) GetMountEnclosingVolume() func(File, MountMountFlags, Mount
2396		}	2396		}
2397		}	2397		}
2398			2398
2399	-	// OverrideMountEnclosingVolumeFinish sets the callback function.	2399	+	// OverrideMountEnclosingVolumeFinish sets the "mount_enclosing_volume_finish" callback function.
2400		// Finishes mounting a specified location.	2400		// Finishes mounting a specified location.
2401		func (x *FileIface) OverrideMountEnclosingVolumeFinish(cb func(File, AsyncResult) bool) {	2401		func (x *FileIface) OverrideMountEnclosingVolumeFinish(cb func(File, AsyncResult) bool) {
2402		if cb == nil {	2402		if cb == nil {

@@ -2408,7 +2408,7 @@ func (x *FileIface) OverrideMountEnclosingVolumeFinish(cb func(File, AsyncResult
2408		}	2408		}
2409		}	2409		}
2410			2410
2411	-	// GetMountEnclosingVolumeFinish gets the callback function.	2411	+	// GetMountEnclosingVolumeFinish gets the "mount_enclosing_volume_finish" callback function.
2412		// Finishes mounting a specified location.	2412		// Finishes mounting a specified location.
2413		func (x *FileIface) GetMountEnclosingVolumeFinish() func(File, AsyncResult) bool {	2413		func (x *FileIface) GetMountEnclosingVolumeFinish() func(File, AsyncResult) bool {
2414		if x.xMountEnclosingVolumeFinish == 0 {	2414		if x.xMountEnclosingVolumeFinish == 0 {

@@ -2421,7 +2421,7 @@ func (x *FileIface) GetMountEnclosingVolumeFinish() func(File, AsyncResult) bool
2421		}	2421		}
2422		}	2422		}
2423			2423
2424	-	// OverrideMonitorDir sets the callback function.	2424	+	// OverrideMonitorDir sets the "monitor_dir" callback function.
2425		// Creates a #GFileMonitor for the location.	2425		// Creates a #GFileMonitor for the location.
2426		func (x FileIface) OverrideMonitorDir(cb func(File, FileMonitorFlags, Cancellable) *FileMonitor) {	2426		func (x FileIface) OverrideMonitorDir(cb func(File, FileMonitorFlags, Cancellable) *FileMonitor) {
2427		if cb == nil {	2427		if cb == nil {

@@ -2437,7 +2437,7 @@ func (x FileIface) OverrideMonitorDir(cb func(File, FileMonitorFlags, Cancella
2437		}	2437		}
2438		}	2438		}
2439			2439
2440	-	// GetMonitorDir gets the callback function.	2440	+	// GetMonitorDir gets the "monitor_dir" callback function.
2441		// Creates a #GFileMonitor for the location.	2441		// Creates a #GFileMonitor for the location.
2442		func (x FileIface) GetMonitorDir() func(File, FileMonitorFlags, Cancellable) *FileMonitor {	2442		func (x FileIface) GetMonitorDir() func(File, FileMonitorFlags, Cancellable) *FileMonitor {
2443		if x.xMonitorDir == 0 {	2443		if x.xMonitorDir == 0 {

@@ -2456,7 +2456,7 @@ func (x FileIface) GetMonitorDir() func(File, FileMonitorFlags, Cancellable) *
2456		}	2456		}
2457		}	2457		}
2458			2458
2459	-	// OverrideMonitorFile sets the callback function.	2459	+	// OverrideMonitorFile sets the "monitor_file" callback function.
2460		// Creates a #GFileMonitor for the location.	2460		// Creates a #GFileMonitor for the location.
2461		func (x FileIface) OverrideMonitorFile(cb func(File, FileMonitorFlags, Cancellable) *FileMonitor) {	2461		func (x FileIface) OverrideMonitorFile(cb func(File, FileMonitorFlags, Cancellable) *FileMonitor) {
2462		if cb == nil {	2462		if cb == nil {

@@ -2472,7 +2472,7 @@ func (x FileIface) OverrideMonitorFile(cb func(File, FileMonitorFlags, Cancell
2472		}	2472		}
2473		}	2473		}
2474			2474
2475	-	// GetMonitorFile gets the callback function.	2475	+	// GetMonitorFile gets the "monitor_file" callback function.
2476		// Creates a #GFileMonitor for the location.	2476		// Creates a #GFileMonitor for the location.
2477		func (x FileIface) GetMonitorFile() func(File, FileMonitorFlags, Cancellable) *FileMonitor {	2477		func (x FileIface) GetMonitorFile() func(File, FileMonitorFlags, Cancellable) *FileMonitor {
2478		if x.xMonitorFile == 0 {	2478		if x.xMonitorFile == 0 {

@@ -2491,7 +2491,7 @@ func (x FileIface) GetMonitorFile() func(File, FileMonitorFlags, Cancellable)
2491		}	2491		}
2492		}	2492		}
2493			2493
2494	-	// OverrideOpenReadwrite sets the callback function.	2494	+	// OverrideOpenReadwrite sets the "open_readwrite" callback function.
2495		// Open file read/write. Since 2.22.	2495		// Open file read/write. Since 2.22.
2496		func (x FileIface) OverrideOpenReadwrite(cb func(File, Cancellable) *FileIOStream) {	2496		func (x FileIface) OverrideOpenReadwrite(cb func(File, Cancellable) *FileIOStream) {
2497		if cb == nil {	2497		if cb == nil {

@@ -2507,7 +2507,7 @@ func (x FileIface) OverrideOpenReadwrite(cb func(File, Cancellable) *FileIOStr
2507		}	2507		}
2508		}	2508		}
2509			2509
2510	-	// GetOpenReadwrite gets the callback function.	2510	+	// GetOpenReadwrite gets the "open_readwrite" callback function.
2511		// Open file read/write. Since 2.22.	2511		// Open file read/write. Since 2.22.
2512		func (x FileIface) GetOpenReadwrite() func(File, Cancellable) *FileIOStream {	2512		func (x FileIface) GetOpenReadwrite() func(File, Cancellable) *FileIOStream {
2513		if x.xOpenReadwrite == 0 {	2513		if x.xOpenReadwrite == 0 {

@@ -2526,7 +2526,7 @@ func (x FileIface) GetOpenReadwrite() func(File, Cancellable) *FileIOStream {
2526		}	2526		}
2527		}	2527		}
2528			2528
2529	-	// OverrideOpenReadwriteAsync sets the callback function.	2529	+	// OverrideOpenReadwriteAsync sets the "open_readwrite_async" callback function.
2530		// Asynchronously opens file read/write. Since 2.22.	2530		// Asynchronously opens file read/write. Since 2.22.
2531		func (x FileIface) OverrideOpenReadwriteAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {	2531		func (x FileIface) OverrideOpenReadwriteAsync(cb func(File, int, Cancellable, *AsyncReadyCallback, uintptr)) {
2532		if cb == nil {	2532		if cb == nil {

@@ -2538,7 +2538,7 @@ func (x FileIface) OverrideOpenReadwriteAsync(cb func(File, int, Cancellable,
2538		}	2538		}
2539		}	2539		}
2540			2540
2541	-	// GetOpenReadwriteAsync gets the callback function.	2541	+	// GetOpenReadwriteAsync gets the "open_readwrite_async" callback function.
2542		// Asynchronously opens file read/write. Since 2.22.	2542		// Asynchronously opens file read/write. Since 2.22.
2543		func (x FileIface) GetOpenReadwriteAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {	2543		func (x FileIface) GetOpenReadwriteAsync() func(File, int, Cancellable, *AsyncReadyCallback, uintptr) {
2544		if x.xOpenReadwriteAsync == 0 {	2544		if x.xOpenReadwriteAsync == 0 {

@@ -2551,7 +2551,7 @@ func (x FileIface) GetOpenReadwriteAsync() func(File, int, Cancellable, *Async
2551		}	2551		}
2552		}	2552		}
2553			2553
2554	-	// OverrideOpenReadwriteFinish sets the callback function.	2554	+	// OverrideOpenReadwriteFinish sets the "open_readwrite_finish" callback function.
2555		// Finishes an asynchronous open read/write. Since 2.22.	2555		// Finishes an asynchronous open read/write. Since 2.22.
2556		func (x FileIface) OverrideOpenReadwriteFinish(cb func(File, AsyncResult) FileIOStream) {	2556		func (x FileIface) OverrideOpenReadwriteFinish(cb func(File, AsyncResult) FileIOStream) {
2557		if cb == nil {	2557		if cb == nil {

@@ -2567,7 +2567,7 @@ func (x FileIface) OverrideOpenReadwriteFinish(cb func(File, AsyncResult) File
2567		}	2567		}
2568		}	2568		}
2569			2569
2570	-	// GetOpenReadwriteFinish gets the callback function.	2570	+	// GetOpenReadwriteFinish gets the "open_readwrite_finish" callback function.
2571		// Finishes an asynchronous open read/write. Since 2.22.	2571		// Finishes an asynchronous open read/write. Since 2.22.
2572		func (x FileIface) GetOpenReadwriteFinish() func(File, AsyncResult) FileIOStream {	2572		func (x FileIface) GetOpenReadwriteFinish() func(File, AsyncResult) FileIOStream {
2573		if x.xOpenReadwriteFinish == 0 {	2573		if x.xOpenReadwriteFinish == 0 {

@@ -2586,7 +2586,7 @@ func (x FileIface) GetOpenReadwriteFinish() func(File, AsyncResult) FileIOStre
2586		}	2586		}
2587		}	2587		}
2588			2588
2589	-	// OverrideCreateReadwrite sets the callback function.	2589	+	// OverrideCreateReadwrite sets the "create_readwrite" callback function.
2590		// Creates file read/write. Since 2.22.	2590		// Creates file read/write. Since 2.22.
2591		func (x FileIface) OverrideCreateReadwrite(cb func(File, FileCreateFlags, Cancellable) *FileIOStream) {	2591		func (x FileIface) OverrideCreateReadwrite(cb func(File, FileCreateFlags, Cancellable) *FileIOStream) {
2592		if cb == nil {	2592		if cb == nil {

@@ -2602,7 +2602,7 @@ func (x FileIface) OverrideCreateReadwrite(cb func(File, FileCreateFlags, Canc
2602		}	2602		}
2603		}	2603		}
2604			2604
2605	-	// GetCreateReadwrite gets the callback function.	2605	+	// GetCreateReadwrite gets the "create_readwrite" callback function.
2606		// Creates file read/write. Since 2.22.	2606		// Creates file read/write. Since 2.22.
2607		func (x FileIface) GetCreateReadwrite() func(File, FileCreateFlags, Cancellable) *FileIOStream {	2607		func (x FileIface) GetCreateReadwrite() func(File, FileCreateFlags, Cancellable) *FileIOStream {
2608		if x.xCreateReadwrite == 0 {	2608		if x.xCreateReadwrite == 0 {

@@ -2621,7 +2621,7 @@ func (x FileIface) GetCreateReadwrite() func(File, FileCreateFlags, Cancellabl
2621		}	2621		}
2622		}	2622		}
2623			2623
2624	-	// OverrideCreateReadwriteAsync sets the callback function.	2624	+	// OverrideCreateReadwriteAsync sets the "create_readwrite_async" callback function.
2625		// Asynchronously creates file read/write. Since 2.22.	2625		// Asynchronously creates file read/write. Since 2.22.
2626		func (x FileIface) OverrideCreateReadwriteAsync(cb func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {	2626		func (x FileIface) OverrideCreateReadwriteAsync(cb func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {
2627		if cb == nil {	2627		if cb == nil {

@@ -2633,7 +2633,7 @@ func (x *FileIface) OverrideCreateReadwriteAsync(cb func(File, FileCreateFlags,
2633		}	2633		}
2634		}	2634		}
2635			2635
2636	-	// GetCreateReadwriteAsync gets the callback function.	2636	+	// GetCreateReadwriteAsync gets the "create_readwrite_async" callback function.
2637		// Asynchronously creates file read/write. Since 2.22.	2637		// Asynchronously creates file read/write. Since 2.22.
2638		func (x FileIface) GetCreateReadwriteAsync() func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {	2638		func (x FileIface) GetCreateReadwriteAsync() func(File, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {
2639		if x.xCreateReadwriteAsync == 0 {	2639		if x.xCreateReadwriteAsync == 0 {

@@ -2646,7 +2646,7 @@ func (x FileIface) GetCreateReadwriteAsync() func(File, FileCreateFlags, int,
2646		}	2646		}
2647		}	2647		}
2648			2648
2649	-	// OverrideCreateReadwriteFinish sets the callback function.	2649	+	// OverrideCreateReadwriteFinish sets the "create_readwrite_finish" callback function.
2650		// Finishes an asynchronous creates read/write. Since 2.22.	2650		// Finishes an asynchronous creates read/write. Since 2.22.
2651		func (x FileIface) OverrideCreateReadwriteFinish(cb func(File, AsyncResult) FileIOStream) {	2651		func (x FileIface) OverrideCreateReadwriteFinish(cb func(File, AsyncResult) FileIOStream) {
2652		if cb == nil {	2652		if cb == nil {

@@ -2662,7 +2662,7 @@ func (x FileIface) OverrideCreateReadwriteFinish(cb func(File, AsyncResult) Fi
2662		}	2662		}
2663		}	2663		}
2664			2664
2665	-	// GetCreateReadwriteFinish gets the callback function.	2665	+	// GetCreateReadwriteFinish gets the "create_readwrite_finish" callback function.
2666		// Finishes an asynchronous creates read/write. Since 2.22.	2666		// Finishes an asynchronous creates read/write. Since 2.22.
2667		func (x FileIface) GetCreateReadwriteFinish() func(File, AsyncResult) FileIOStream {	2667		func (x FileIface) GetCreateReadwriteFinish() func(File, AsyncResult) FileIOStream {
2668		if x.xCreateReadwriteFinish == 0 {	2668		if x.xCreateReadwriteFinish == 0 {

@@ -2681,7 +2681,7 @@ func (x FileIface) GetCreateReadwriteFinish() func(File, AsyncResult) FileIOSt
2681		}	2681		}
2682		}	2682		}
2683			2683
2684	-	// OverrideReplaceReadwrite sets the callback function.	2684	+	// OverrideReplaceReadwrite sets the "replace_readwrite" callback function.
2685		// Replaces file read/write. Since 2.22.	2685		// Replaces file read/write. Since 2.22.
2686		func (x FileIface) OverrideReplaceReadwrite(cb func(File, string, bool, FileCreateFlags, Cancellable) *FileIOStream) {	2686		func (x FileIface) OverrideReplaceReadwrite(cb func(File, string, bool, FileCreateFlags, Cancellable) *FileIOStream) {
2687		if cb == nil {	2687		if cb == nil {

@@ -2697,7 +2697,7 @@ func (x *FileIface) OverrideReplaceReadwrite(cb func(File, string, bool, FileCre
2697		}	2697		}
2698		}	2698		}
2699			2699
2700	-	// GetReplaceReadwrite gets the callback function.	2700	+	// GetReplaceReadwrite gets the "replace_readwrite" callback function.
2701		// Replaces file read/write. Since 2.22.	2701		// Replaces file read/write. Since 2.22.
2702		func (x FileIface) GetReplaceReadwrite() func(File, string, bool, FileCreateFlags, Cancellable) *FileIOStream {	2702		func (x FileIface) GetReplaceReadwrite() func(File, string, bool, FileCreateFlags, Cancellable) *FileIOStream {
2703		if x.xReplaceReadwrite == 0 {	2703		if x.xReplaceReadwrite == 0 {

@@ -2716,7 +2716,7 @@ func (x *FileIface) GetReplaceReadwrite() func(File, string, bool, FileCreateFla
2716		}	2716		}
2717		}	2717		}
2718			2718
2719	-	// OverrideReplaceReadwriteAsync sets the callback function.	2719	+	// OverrideReplaceReadwriteAsync sets the "replace_readwrite_async" callback function.
2720		// Asynchronously replaces file read/write. Since 2.22.	2720		// Asynchronously replaces file read/write. Since 2.22.
2721		func (x FileIface) OverrideReplaceReadwriteAsync(cb func(File, string, bool, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {	2721		func (x FileIface) OverrideReplaceReadwriteAsync(cb func(File, string, bool, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {
2722		if cb == nil {	2722		if cb == nil {

@@ -2728,7 +2728,7 @@ func (x *FileIface) OverrideReplaceReadwriteAsync(cb func(File, string, bool, Fi
2728		}	2728		}
2729		}	2729		}
2730			2730
2731	-	// GetReplaceReadwriteAsync gets the callback function.	2731	+	// GetReplaceReadwriteAsync gets the "replace_readwrite_async" callback function.
2732		// Asynchronously replaces file read/write. Since 2.22.	2732		// Asynchronously replaces file read/write. Since 2.22.
2733		func (x FileIface) GetReplaceReadwriteAsync() func(File, string, bool, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {	2733		func (x FileIface) GetReplaceReadwriteAsync() func(File, string, bool, FileCreateFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {
2734		if x.xReplaceReadwriteAsync == 0 {	2734		if x.xReplaceReadwriteAsync == 0 {

@@ -2741,7 +2741,7 @@ func (x *FileIface) GetReplaceReadwriteAsync() func(File, string, bool, FileCrea
2741		}	2741		}
2742		}	2742		}
2743			2743
2744	-	// OverrideReplaceReadwriteFinish sets the callback function.	2744	+	// OverrideReplaceReadwriteFinish sets the "replace_readwrite_finish" callback function.
2745		// Finishes an asynchronous replace read/write. Since 2.22.	2745		// Finishes an asynchronous replace read/write. Since 2.22.
2746		func (x FileIface) OverrideReplaceReadwriteFinish(cb func(File, AsyncResult) FileIOStream) {	2746		func (x FileIface) OverrideReplaceReadwriteFinish(cb func(File, AsyncResult) FileIOStream) {
2747		if cb == nil {	2747		if cb == nil {

@@ -2757,7 +2757,7 @@ func (x FileIface) OverrideReplaceReadwriteFinish(cb func(File, AsyncResult) F
2757		}	2757		}
2758		}	2758		}
2759			2759
2760	-	// GetReplaceReadwriteFinish gets the callback function.	2760	+	// GetReplaceReadwriteFinish gets the "replace_readwrite_finish" callback function.
2761		// Finishes an asynchronous replace read/write. Since 2.22.	2761		// Finishes an asynchronous replace read/write. Since 2.22.
2762		func (x FileIface) GetReplaceReadwriteFinish() func(File, AsyncResult) FileIOStream {	2762		func (x FileIface) GetReplaceReadwriteFinish() func(File, AsyncResult) FileIOStream {
2763		if x.xReplaceReadwriteFinish == 0 {	2763		if x.xReplaceReadwriteFinish == 0 {

@@ -2776,7 +2776,7 @@ func (x FileIface) GetReplaceReadwriteFinish() func(File, AsyncResult) FileIOS
2776		}	2776		}
2777		}	2777		}
2778			2778
2779	-	// OverrideStartMountable sets the callback function.	2779	+	// OverrideStartMountable sets the "start_mountable" callback function.
2780		// Starts a mountable object. Since 2.22.	2780		// Starts a mountable object. Since 2.22.
2781		func (x FileIface) OverrideStartMountable(cb func(File, DriveStartFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	2781		func (x FileIface) OverrideStartMountable(cb func(File, DriveStartFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
2782		if cb == nil {	2782		if cb == nil {

@@ -2788,7 +2788,7 @@ func (x FileIface) OverrideStartMountable(cb func(File, DriveStartFlags, Mount
2788		}	2788		}
2789		}	2789		}
2790			2790
2791	-	// GetStartMountable gets the callback function.	2791	+	// GetStartMountable gets the "start_mountable" callback function.
2792		// Starts a mountable object. Since 2.22.	2792		// Starts a mountable object. Since 2.22.
2793		func (x FileIface) GetStartMountable() func(File, DriveStartFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	2793		func (x FileIface) GetStartMountable() func(File, DriveStartFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
2794		if x.xStartMountable == 0 {	2794		if x.xStartMountable == 0 {

@@ -2801,7 +2801,7 @@ func (x FileIface) GetStartMountable() func(File, DriveStartFlags, MountOperat
2801		}	2801		}
2802		}	2802		}
2803			2803
2804	-	// OverrideStartMountableFinish sets the callback function.	2804	+	// OverrideStartMountableFinish sets the "start_mountable_finish" callback function.
2805		// Finishes a start operation. Since 2.22.	2805		// Finishes a start operation. Since 2.22.
2806		func (x *FileIface) OverrideStartMountableFinish(cb func(File, AsyncResult) bool) {	2806		func (x *FileIface) OverrideStartMountableFinish(cb func(File, AsyncResult) bool) {
2807		if cb == nil {	2807		if cb == nil {

@@ -2813,7 +2813,7 @@ func (x *FileIface) OverrideStartMountableFinish(cb func(File, AsyncResult) bool
2813		}	2813		}
2814		}	2814		}
2815			2815
2816	-	// GetStartMountableFinish gets the callback function.	2816	+	// GetStartMountableFinish gets the "start_mountable_finish" callback function.
2817		// Finishes a start operation. Since 2.22.	2817		// Finishes a start operation. Since 2.22.
2818		func (x *FileIface) GetStartMountableFinish() func(File, AsyncResult) bool {	2818		func (x *FileIface) GetStartMountableFinish() func(File, AsyncResult) bool {
2819		if x.xStartMountableFinish == 0 {	2819		if x.xStartMountableFinish == 0 {

@@ -2826,7 +2826,7 @@ func (x *FileIface) GetStartMountableFinish() func(File, AsyncResult) bool {
2826		}	2826		}
2827		}	2827		}
2828			2828
2829	-	// OverrideStopMountable sets the callback function.	2829	+	// OverrideStopMountable sets the "stop_mountable" callback function.
2830		// Stops a mountable. Since 2.22.	2830		// Stops a mountable. Since 2.22.
2831		func (x FileIface) OverrideStopMountable(cb func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	2831		func (x FileIface) OverrideStopMountable(cb func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
2832		if cb == nil {	2832		if cb == nil {

@@ -2838,7 +2838,7 @@ func (x FileIface) OverrideStopMountable(cb func(File, MountUnmountFlags, Moun
2838		}	2838		}
2839		}	2839		}
2840			2840
2841	-	// GetStopMountable gets the callback function.	2841	+	// GetStopMountable gets the "stop_mountable" callback function.
2842		// Stops a mountable. Since 2.22.	2842		// Stops a mountable. Since 2.22.
2843		func (x FileIface) GetStopMountable() func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	2843		func (x FileIface) GetStopMountable() func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
2844		if x.xStopMountable == 0 {	2844		if x.xStopMountable == 0 {

@@ -2851,7 +2851,7 @@ func (x FileIface) GetStopMountable() func(File, MountUnmountFlags, MountOpera
2851		}	2851		}
2852		}	2852		}
2853			2853
2854	-	// OverrideStopMountableFinish sets the callback function.	2854	+	// OverrideStopMountableFinish sets the "stop_mountable_finish" callback function.
2855		// Finishes a stop operation. Since 2.22.	2855		// Finishes a stop operation. Since 2.22.
2856		func (x *FileIface) OverrideStopMountableFinish(cb func(File, AsyncResult) bool) {	2856		func (x *FileIface) OverrideStopMountableFinish(cb func(File, AsyncResult) bool) {
2857		if cb == nil {	2857		if cb == nil {

@@ -2863,7 +2863,7 @@ func (x *FileIface) OverrideStopMountableFinish(cb func(File, AsyncResult) bool)
2863		}	2863		}
2864		}	2864		}
2865			2865
2866	-	// GetStopMountableFinish gets the callback function.	2866	+	// GetStopMountableFinish gets the "stop_mountable_finish" callback function.
2867		// Finishes a stop operation. Since 2.22.	2867		// Finishes a stop operation. Since 2.22.
2868		func (x *FileIface) GetStopMountableFinish() func(File, AsyncResult) bool {	2868		func (x *FileIface) GetStopMountableFinish() func(File, AsyncResult) bool {
2869		if x.xStopMountableFinish == 0 {	2869		if x.xStopMountableFinish == 0 {

@@ -2876,7 +2876,7 @@ func (x *FileIface) GetStopMountableFinish() func(File, AsyncResult) bool {
2876		}	2876		}
2877		}	2877		}
2878			2878
2879	-	// OverrideUnmountMountableWithOperation sets the callback function.	2879	+	// OverrideUnmountMountableWithOperation sets the "unmount_mountable_with_operation" callback function.
2880		// Unmounts a mountable object using a #GMountOperation. Since 2.22.	2880		// Unmounts a mountable object using a #GMountOperation. Since 2.22.
2881		func (x FileIface) OverrideUnmountMountableWithOperation(cb func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	2881		func (x FileIface) OverrideUnmountMountableWithOperation(cb func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
2882		if cb == nil {	2882		if cb == nil {

@@ -2888,7 +2888,7 @@ func (x *FileIface) OverrideUnmountMountableWithOperation(cb func(File, MountUnm
2888		}	2888		}
2889		}	2889		}
2890			2890
2891	-	// GetUnmountMountableWithOperation gets the callback function.	2891	+	// GetUnmountMountableWithOperation gets the "unmount_mountable_with_operation" callback function.
2892		// Unmounts a mountable object using a #GMountOperation. Since 2.22.	2892		// Unmounts a mountable object using a #GMountOperation. Since 2.22.
2893		func (x FileIface) GetUnmountMountableWithOperation() func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	2893		func (x FileIface) GetUnmountMountableWithOperation() func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
2894		if x.xUnmountMountableWithOperation == 0 {	2894		if x.xUnmountMountableWithOperation == 0 {

@@ -2901,7 +2901,7 @@ func (x *FileIface) GetUnmountMountableWithOperation() func(File, MountUnmountFl
2901		}	2901		}
2902		}	2902		}
2903			2903
2904	-	// OverrideUnmountMountableWithOperationFinish sets the callback function.	2904	+	// OverrideUnmountMountableWithOperationFinish sets the "unmount_mountable_with_operation_finish" callback function.
2905		// Finishes an unmount operation using a #GMountOperation. Since 2.22.	2905		// Finishes an unmount operation using a #GMountOperation. Since 2.22.
2906		func (x *FileIface) OverrideUnmountMountableWithOperationFinish(cb func(File, AsyncResult) bool) {	2906		func (x *FileIface) OverrideUnmountMountableWithOperationFinish(cb func(File, AsyncResult) bool) {
2907		if cb == nil {	2907		if cb == nil {

@@ -2913,7 +2913,7 @@ func (x *FileIface) OverrideUnmountMountableWithOperationFinish(cb func(File, As
2913		}	2913		}
2914		}	2914		}
2915			2915
2916	-	// GetUnmountMountableWithOperationFinish gets the callback function.	2916	+	// GetUnmountMountableWithOperationFinish gets the "unmount_mountable_with_operation_finish" callback function.
2917		// Finishes an unmount operation using a #GMountOperation. Since 2.22.	2917		// Finishes an unmount operation using a #GMountOperation. Since 2.22.
2918		func (x *FileIface) GetUnmountMountableWithOperationFinish() func(File, AsyncResult) bool {	2918		func (x *FileIface) GetUnmountMountableWithOperationFinish() func(File, AsyncResult) bool {
2919		if x.xUnmountMountableWithOperationFinish == 0 {	2919		if x.xUnmountMountableWithOperationFinish == 0 {

@@ -2926,7 +2926,7 @@ func (x *FileIface) GetUnmountMountableWithOperationFinish() func(File, AsyncRes
2926		}	2926		}
2927		}	2927		}
2928			2928
2929	-	// OverrideEjectMountableWithOperation sets the callback function.	2929	+	// OverrideEjectMountableWithOperation sets the "eject_mountable_with_operation" callback function.
2930		// Ejects a mountable object using a #GMountOperation. Since 2.22.	2930		// Ejects a mountable object using a #GMountOperation. Since 2.22.
2931		func (x FileIface) OverrideEjectMountableWithOperation(cb func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	2931		func (x FileIface) OverrideEjectMountableWithOperation(cb func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
2932		if cb == nil {	2932		if cb == nil {

@@ -2938,7 +2938,7 @@ func (x *FileIface) OverrideEjectMountableWithOperation(cb func(File, MountUnmou
2938		}	2938		}
2939		}	2939		}
2940			2940
2941	-	// GetEjectMountableWithOperation gets the callback function.	2941	+	// GetEjectMountableWithOperation gets the "eject_mountable_with_operation" callback function.
2942		// Ejects a mountable object using a #GMountOperation. Since 2.22.	2942		// Ejects a mountable object using a #GMountOperation. Since 2.22.
2943		func (x FileIface) GetEjectMountableWithOperation() func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	2943		func (x FileIface) GetEjectMountableWithOperation() func(File, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
2944		if x.xEjectMountableWithOperation == 0 {	2944		if x.xEjectMountableWithOperation == 0 {

@@ -2951,7 +2951,7 @@ func (x *FileIface) GetEjectMountableWithOperation() func(File, MountUnmountFlag
2951		}	2951		}
2952		}	2952		}
2953			2953
2954	-	// OverrideEjectMountableWithOperationFinish sets the callback function.	2954	+	// OverrideEjectMountableWithOperationFinish sets the "eject_mountable_with_operation_finish" callback function.
2955		// Finishes an eject operation using a #GMountOperation. Since 2.22.	2955		// Finishes an eject operation using a #GMountOperation. Since 2.22.
2956		func (x *FileIface) OverrideEjectMountableWithOperationFinish(cb func(File, AsyncResult) bool) {	2956		func (x *FileIface) OverrideEjectMountableWithOperationFinish(cb func(File, AsyncResult) bool) {
2957		if cb == nil {	2957		if cb == nil {

@@ -2963,7 +2963,7 @@ func (x *FileIface) OverrideEjectMountableWithOperationFinish(cb func(File, Asyn
2963		}	2963		}
2964		}	2964		}
2965			2965
2966	-	// GetEjectMountableWithOperationFinish gets the callback function.	2966	+	// GetEjectMountableWithOperationFinish gets the "eject_mountable_with_operation_finish" callback function.
2967		// Finishes an eject operation using a #GMountOperation. Since 2.22.	2967		// Finishes an eject operation using a #GMountOperation. Since 2.22.
2968		func (x *FileIface) GetEjectMountableWithOperationFinish() func(File, AsyncResult) bool {	2968		func (x *FileIface) GetEjectMountableWithOperationFinish() func(File, AsyncResult) bool {
2969		if x.xEjectMountableWithOperationFinish == 0 {	2969		if x.xEjectMountableWithOperationFinish == 0 {

@@ -2976,7 +2976,7 @@ func (x *FileIface) GetEjectMountableWithOperationFinish() func(File, AsyncResul
2976		}	2976		}
2977		}	2977		}
2978			2978
2979	-	// OverridePollMountable sets the callback function.	2979	+	// OverridePollMountable sets the "poll_mountable" callback function.
2980		// Polls a mountable object for media changes. Since 2.22.	2980		// Polls a mountable object for media changes. Since 2.22.
2981		func (x FileIface) OverridePollMountable(cb func(File, Cancellable, *AsyncReadyCallback, uintptr)) {	2981		func (x FileIface) OverridePollMountable(cb func(File, Cancellable, *AsyncReadyCallback, uintptr)) {
2982		if cb == nil {	2982		if cb == nil {

@@ -2988,7 +2988,7 @@ func (x FileIface) OverridePollMountable(cb func(File, Cancellable, *AsyncRead
2988		}	2988		}
2989		}	2989		}
2990			2990
2991	-	// GetPollMountable gets the callback function.	2991	+	// GetPollMountable gets the "poll_mountable" callback function.
2992		// Polls a mountable object for media changes. Since 2.22.	2992		// Polls a mountable object for media changes. Since 2.22.
2993		func (x FileIface) GetPollMountable() func(File, Cancellable, *AsyncReadyCallback, uintptr) {	2993		func (x FileIface) GetPollMountable() func(File, Cancellable, *AsyncReadyCallback, uintptr) {
2994		if x.xPollMountable == 0 {	2994		if x.xPollMountable == 0 {

@@ -3001,7 +3001,7 @@ func (x FileIface) GetPollMountable() func(File, Cancellable, *AsyncReadyCallb
3001		}	3001		}
3002		}	3002		}
3003			3003
3004	-	// OverridePollMountableFinish sets the callback function.	3004	+	// OverridePollMountableFinish sets the "poll_mountable_finish" callback function.
3005		// Finishes a poll operation for media changes. Since 2.22.	3005		// Finishes a poll operation for media changes. Since 2.22.
3006		func (x *FileIface) OverridePollMountableFinish(cb func(File, AsyncResult) bool) {	3006		func (x *FileIface) OverridePollMountableFinish(cb func(File, AsyncResult) bool) {
3007		if cb == nil {	3007		if cb == nil {

@@ -3013,7 +3013,7 @@ func (x *FileIface) OverridePollMountableFinish(cb func(File, AsyncResult) bool)
3013		}	3013		}
3014		}	3014		}
3015			3015
3016	-	// GetPollMountableFinish gets the callback function.	3016	+	// GetPollMountableFinish gets the "poll_mountable_finish" callback function.
3017		// Finishes a poll operation for media changes. Since 2.22.	3017		// Finishes a poll operation for media changes. Since 2.22.
3018		func (x *FileIface) GetPollMountableFinish() func(File, AsyncResult) bool {	3018		func (x *FileIface) GetPollMountableFinish() func(File, AsyncResult) bool {
3019		if x.xPollMountableFinish == 0 {	3019		if x.xPollMountableFinish == 0 {

@@ -3026,32 +3026,32 @@ func (x *FileIface) GetPollMountableFinish() func(File, AsyncResult) bool {
3026		}	3026		}
3027		}	3027		}
3028			3028
3029	-	// OverrideMeasureDiskUsage sets the callback function.	3029	+	// OverrideMeasureDiskUsage sets the "measure_disk_usage" callback function.
3030		// Recursively measures the disk usage of @file. Since 2.38	3030		// Recursively measures the disk usage of @file. Since 2.38
3031	-	func (x FileIface) OverrideMeasureDiskUsage(cb func(File, FileMeasureFlags, Cancellable, *FileMeasureProgressCallback, uintptr, uint64, uint64, uint64) bool) {	3031	+	func (x FileIface) OverrideMeasureDiskUsage(cb func(File, FileMeasureFlags, Cancellable, FileMeasureProgressCallback, uintptr, uint64, uint64, uint64) bool) {
3032		if cb == nil {	3032		if cb == nil {
3033		x.xMeasureDiskUsage = 0	3033		x.xMeasureDiskUsage = 0
3034		} else {	3034		} else {
3035	-	x.xMeasureDiskUsage = purego.NewCallback(func(FileVarp uintptr, FlagsVarp FileMeasureFlags, CancellableVarp uintptr, ProgressCallbackVarp uintptr, ProgressDataVarp uintptr, DiskUsageVarp uint64, NumDirsVarp uint64, NumFilesVarp uint64) bool {	3035	+	x.xMeasureDiskUsage = purego.NewCallback(func(FileVarp uintptr, FlagsVarp FileMeasureFlags, CancellableVarp uintptr, ProgressCallbackVarp uintptr, ProgressDataVarp uintptr, DiskUsageVarp uint64, NumDirsVarp uint64, NumFilesVarp *uint64) bool {
3036		return cb(&FileBase{Ptr: FileVarp}, FlagsVarp, CancellableNewFromInternalPtr(CancellableVarp), (*FileMeasureProgressCallback)(unsafe.Pointer(ProgressCallbackVarp)), ProgressDataVarp, DiskUsageVarp, NumDirsVarp, NumFilesVarp)	3036		return cb(&FileBase{Ptr: FileVarp}, FlagsVarp, CancellableNewFromInternalPtr(CancellableVarp), (*FileMeasureProgressCallback)(unsafe.Pointer(ProgressCallbackVarp)), ProgressDataVarp, DiskUsageVarp, NumDirsVarp, NumFilesVarp)
3037		})	3037		})
3038		}	3038		}
3039		}	3039		}
3040			3040
3041	-	// GetMeasureDiskUsage gets the callback function.	3041	+	// GetMeasureDiskUsage gets the "measure_disk_usage" callback function.
3042		// Recursively measures the disk usage of @file. Since 2.38	3042		// Recursively measures the disk usage of @file. Since 2.38
3043	-	func (x FileIface) GetMeasureDiskUsage() func(File, FileMeasureFlags, Cancellable, *FileMeasureProgressCallback, uintptr, uint64, uint64, uint64) bool {	3043	+	func (x FileIface) GetMeasureDiskUsage() func(File, FileMeasureFlags, Cancellable, FileMeasureProgressCallback, uintptr, uint64, uint64, uint64) bool {
3044		if x.xMeasureDiskUsage == 0 {	3044		if x.xMeasureDiskUsage == 0 {
3045		return nil	3045		return nil
3046		}	3046		}
3047	-	var rawCallback func(FileVarp uintptr, FlagsVarp FileMeasureFlags, CancellableVarp uintptr, ProgressCallbackVarp uintptr, ProgressDataVarp uintptr, DiskUsageVarp uint64, NumDirsVarp uint64, NumFilesVarp uint64) bool	3047	+	var rawCallback func(FileVarp uintptr, FlagsVarp FileMeasureFlags, CancellableVarp uintptr, ProgressCallbackVarp uintptr, ProgressDataVarp uintptr, DiskUsageVarp uint64, NumDirsVarp uint64, NumFilesVarp *uint64) bool
3048		purego.RegisterFunc(&rawCallback, x.xMeasureDiskUsage)	3048		purego.RegisterFunc(&rawCallback, x.xMeasureDiskUsage)
3049	-	return func(FileVar File, FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) bool {	3049	+	return func(FileVar File, FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar *uint64) bool {
3050		return rawCallback(FileVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(ProgressCallbackVar), ProgressDataVar, DiskUsageVar, NumDirsVar, NumFilesVar)	3050		return rawCallback(FileVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(ProgressCallbackVar), ProgressDataVar, DiskUsageVar, NumDirsVar, NumFilesVar)
3051		}	3051		}
3052		}	3052		}
3053			3053
3054	-	// OverrideMeasureDiskUsageAsync sets the callback function.	3054	+	// OverrideMeasureDiskUsageAsync sets the "measure_disk_usage_async" callback function.
3055		// Asynchronously recursively measures the disk usage of @file. Since 2.38	3055		// Asynchronously recursively measures the disk usage of @file. Since 2.38
3056		func (x FileIface) OverrideMeasureDiskUsageAsync(cb func(File, FileMeasureFlags, int, Cancellable, FileMeasureProgressCallback, uintptr, AsyncReadyCallback, uintptr)) {	3056		func (x FileIface) OverrideMeasureDiskUsageAsync(cb func(File, FileMeasureFlags, int, Cancellable, FileMeasureProgressCallback, uintptr, AsyncReadyCallback, uintptr)) {
3057		if cb == nil {	3057		if cb == nil {

@@ -3063,7 +3063,7 @@ func (x *FileIface) OverrideMeasureDiskUsageAsync(cb func(File, FileMeasureFlags
3063		}	3063		}
3064		}	3064		}
3065			3065
3066	-	// GetMeasureDiskUsageAsync gets the callback function.	3066	+	// GetMeasureDiskUsageAsync gets the "measure_disk_usage_async" callback function.
3067		// Asynchronously recursively measures the disk usage of @file. Since 2.38	3067		// Asynchronously recursively measures the disk usage of @file. Since 2.38
3068		func (x FileIface) GetMeasureDiskUsageAsync() func(File, FileMeasureFlags, int, Cancellable, FileMeasureProgressCallback, uintptr, AsyncReadyCallback, uintptr) {	3068		func (x FileIface) GetMeasureDiskUsageAsync() func(File, FileMeasureFlags, int, Cancellable, FileMeasureProgressCallback, uintptr, AsyncReadyCallback, uintptr) {
3069		if x.xMeasureDiskUsageAsync == 0 {	3069		if x.xMeasureDiskUsageAsync == 0 {

@@ -3076,32 +3076,32 @@ func (x *FileIface) GetMeasureDiskUsageAsync() func(File, FileMeasureFlags, int,
3076		}	3076		}
3077		}	3077		}
3078			3078
3079	-	// OverrideMeasureDiskUsageFinish sets the callback function.	3079	+	// OverrideMeasureDiskUsageFinish sets the "measure_disk_usage_finish" callback function.
3080		// Finishes an asynchronous recursive measurement of the disk usage of @file. Since 2.38	3080		// Finishes an asynchronous recursive measurement of the disk usage of @file. Since 2.38
3081	-	func (x *FileIface) OverrideMeasureDiskUsageFinish(cb func(File, AsyncResult, uint64, uint64, uint64) bool) {	3081	+	func (x FileIface) OverrideMeasureDiskUsageFinish(cb func(File, AsyncResult, uint64, uint64, uint64) bool) {
3082		if cb == nil {	3082		if cb == nil {
3083		x.xMeasureDiskUsageFinish = 0	3083		x.xMeasureDiskUsageFinish = 0
3084		} else {	3084		} else {
3085	-	x.xMeasureDiskUsageFinish = purego.NewCallback(func(FileVarp uintptr, ResultVarp uintptr, DiskUsageVarp uint64, NumDirsVarp uint64, NumFilesVarp uint64) bool {	3085	+	x.xMeasureDiskUsageFinish = purego.NewCallback(func(FileVarp uintptr, ResultVarp uintptr, DiskUsageVarp uint64, NumDirsVarp uint64, NumFilesVarp *uint64) bool {
3086		return cb(&FileBase{Ptr: FileVarp}, &AsyncResultBase{Ptr: ResultVarp}, DiskUsageVarp, NumDirsVarp, NumFilesVarp)	3086		return cb(&FileBase{Ptr: FileVarp}, &AsyncResultBase{Ptr: ResultVarp}, DiskUsageVarp, NumDirsVarp, NumFilesVarp)
3087		})	3087		})
3088		}	3088		}
3089		}	3089		}
3090			3090
3091	-	// GetMeasureDiskUsageFinish gets the callback function.	3091	+	// GetMeasureDiskUsageFinish gets the "measure_disk_usage_finish" callback function.
3092		// Finishes an asynchronous recursive measurement of the disk usage of @file. Since 2.38	3092		// Finishes an asynchronous recursive measurement of the disk usage of @file. Since 2.38
3093	-	func (x *FileIface) GetMeasureDiskUsageFinish() func(File, AsyncResult, uint64, uint64, uint64) bool {	3093	+	func (x FileIface) GetMeasureDiskUsageFinish() func(File, AsyncResult, uint64, uint64, uint64) bool {
3094		if x.xMeasureDiskUsageFinish == 0 {	3094		if x.xMeasureDiskUsageFinish == 0 {
3095		return nil	3095		return nil
3096		}	3096		}
3097	-	var rawCallback func(FileVarp uintptr, ResultVarp uintptr, DiskUsageVarp uint64, NumDirsVarp uint64, NumFilesVarp uint64) bool	3097	+	var rawCallback func(FileVarp uintptr, ResultVarp uintptr, DiskUsageVarp uint64, NumDirsVarp uint64, NumFilesVarp *uint64) bool
3098		purego.RegisterFunc(&rawCallback, x.xMeasureDiskUsageFinish)	3098		purego.RegisterFunc(&rawCallback, x.xMeasureDiskUsageFinish)
3099	-	return func(FileVar File, ResultVar AsyncResult, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) bool {	3099	+	return func(FileVar File, ResultVar AsyncResult, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar *uint64) bool {
3100		return rawCallback(FileVar.GoPointer(), ResultVar.GoPointer(), DiskUsageVar, NumDirsVar, NumFilesVar)	3100		return rawCallback(FileVar.GoPointer(), ResultVar.GoPointer(), DiskUsageVar, NumDirsVar, NumFilesVar)
3101		}	3101		}
3102		}	3102		}
3103			3103
3104	-	// OverrideQueryExists sets the callback function.	3104	+	// OverrideQueryExists sets the "query_exists" callback function.
3105		// Queries whether a file exists. Since 2.84	3105		// Queries whether a file exists. Since 2.84
3106		func (x FileIface) OverrideQueryExists(cb func(File, Cancellable) bool) {	3106		func (x FileIface) OverrideQueryExists(cb func(File, Cancellable) bool) {
3107		if cb == nil {	3107		if cb == nil {

@@ -3113,7 +3113,7 @@ func (x FileIface) OverrideQueryExists(cb func(File, Cancellable) bool) {
3113		}	3113		}
3114		}	3114		}
3115			3115
3116	-	// GetQueryExists gets the callback function.	3116	+	// GetQueryExists gets the "query_exists" callback function.
3117		// Queries whether a file exists. Since 2.84	3117		// Queries whether a file exists. Since 2.84
3118		func (x FileIface) GetQueryExists() func(File, Cancellable) bool {	3118		func (x FileIface) GetQueryExists() func(File, Cancellable) bool {
3119		if x.xQueryExists == 0 {	3119		if x.xQueryExists == 0 {

@@ -3264,14 +3264,14 @@ type File interface {
3264		HasUriScheme(UriSchemeVar string) bool	3264		HasUriScheme(UriSchemeVar string) bool
3265		Hash() uint	3265		Hash() uint
3266		IsNative() bool	3266		IsNative() bool
3267	-	LoadBytes(CancellableVar Cancellable, EtagOutVar string) (glib.Bytes, error)	3267	+	LoadBytes(CancellableVar Cancellable, EtagOutVar string) (*glib.Bytes, error)
3268		LoadBytesAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	3268		LoadBytesAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
3269	-	LoadBytesFinish(ResultVar AsyncResult, EtagOutVar string) (*glib.Bytes, error)	3269	+	LoadBytesFinish(ResultVar AsyncResult, EtagOutVar string) (glib.Bytes, error)
3270	-	LoadContents(CancellableVar *Cancellable, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error)	3270	+	LoadContents(CancellableVar Cancellable, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error)
3271		LoadContentsAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	3271		LoadContentsAsync(CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
3272	-	LoadContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error)	3272	+	LoadContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar *string) (bool, error)
3273		LoadPartialContentsAsync(CancellableVar Cancellable, ReadMoreCallbackVar FileReadMoreCallback, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)	3273		LoadPartialContentsAsync(CancellableVar Cancellable, ReadMoreCallbackVar FileReadMoreCallback, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
3274	-	LoadPartialContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error)	3274	+	LoadPartialContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar *string) (bool, error)
3275		MakeDirectory(CancellableVar *Cancellable) (bool, error)	3275		MakeDirectory(CancellableVar *Cancellable) (bool, error)
3276		MakeDirectoryAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	3276		MakeDirectoryAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
3277		MakeDirectoryFinish(ResultVar AsyncResult) (bool, error)	3277		MakeDirectoryFinish(ResultVar AsyncResult) (bool, error)

@@ -3279,9 +3279,9 @@ type File interface {
3279		MakeSymbolicLink(SymlinkValueVar string, CancellableVar *Cancellable) (bool, error)	3279		MakeSymbolicLink(SymlinkValueVar string, CancellableVar *Cancellable) (bool, error)
3280		MakeSymbolicLinkAsync(SymlinkValueVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	3280		MakeSymbolicLinkAsync(SymlinkValueVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
3281		MakeSymbolicLinkFinish(ResultVar AsyncResult) (bool, error)	3281		MakeSymbolicLinkFinish(ResultVar AsyncResult) (bool, error)
3282	-	MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) (bool, error)	3282	+	MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar *uint64) (bool, error)
3283		MeasureDiskUsageAsync(FlagsVar FileMeasureFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)	3283		MeasureDiskUsageAsync(FlagsVar FileMeasureFlags, IoPriorityVar int, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
3284	-	MeasureDiskUsageFinish(ResultVar AsyncResult, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) (bool, error)	3284	+	MeasureDiskUsageFinish(ResultVar AsyncResult, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar *uint64) (bool, error)
3285		Monitor(FlagsVar FileMonitorFlags, CancellableVar Cancellable) (FileMonitor, error)	3285		Monitor(FlagsVar FileMonitorFlags, CancellableVar Cancellable) (FileMonitor, error)
3286		MonitorDirectory(FlagsVar FileMonitorFlags, CancellableVar Cancellable) (FileMonitor, error)	3286		MonitorDirectory(FlagsVar FileMonitorFlags, CancellableVar Cancellable) (FileMonitor, error)
3287		MonitorFile(FlagsVar FileMonitorFlags, CancellableVar Cancellable) (FileMonitor, error)	3287		MonitorFile(FlagsVar FileMonitorFlags, CancellableVar Cancellable) (FileMonitor, error)

@@ -3317,10 +3317,10 @@ type File interface {
3317		ReadFinish(ResVar AsyncResult) (*FileInputStream, error)	3317		ReadFinish(ResVar AsyncResult) (*FileInputStream, error)
3318		Replace(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable) (FileOutputStream, error)	3318		Replace(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable) (FileOutputStream, error)
3319		ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	3319		ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
3320	-	ReplaceContents(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar string, CancellableVar *Cancellable) (bool, error)	3320	+	ReplaceContents(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar string, CancellableVar Cancellable) (bool, error)
3321		ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	3321		ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
3322		ReplaceContentsBytesAsync(ContentsVar glib.Bytes, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)	3322		ReplaceContentsBytesAsync(ContentsVar glib.Bytes, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
3323	-	ReplaceContentsFinish(ResVar AsyncResult, NewEtagVar string) (bool, error)	3323	+	ReplaceContentsFinish(ResVar AsyncResult, NewEtagVar *string) (bool, error)
3324		ReplaceFinish(ResVar AsyncResult) (*FileOutputStream, error)	3324		ReplaceFinish(ResVar AsyncResult) (*FileOutputStream, error)
3325		ReplaceReadwrite(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable) (FileIOStream, error)	3325		ReplaceReadwrite(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar Cancellable) (FileIOStream, error)
3326		ReplaceReadwriteAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	3326		ReplaceReadwriteAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)

@@ -4227,7 +4227,7 @@ func (x *FileBase) IsNative() bool {
4227		// The data contained in the resulting #GBytes is always zero-terminated, but	4227		// The data contained in the resulting #GBytes is always zero-terminated, but
4228		// this is not included in the #GBytes length. The resulting #GBytes should be	4228		// this is not included in the #GBytes length. The resulting #GBytes should be
4229		// freed with g_bytes_unref() when no longer in use.	4229		// freed with g_bytes_unref() when no longer in use.
4230	-	func (x FileBase) LoadBytes(CancellableVar Cancellable, EtagOutVar string) (*glib.Bytes, error) {	4230	+	func (x FileBase) LoadBytes(CancellableVar Cancellable, EtagOutVar string) (glib.Bytes, error) {
4231		var cerr *glib.Error	4231		var cerr *glib.Error
4232			4232
4233		cret := XGFileLoadBytes(x.GoPointer(), CancellableVar.GoPointer(), EtagOutVar, &cerr)	4233		cret := XGFileLoadBytes(x.GoPointer(), CancellableVar.GoPointer(), EtagOutVar, &cerr)

@@ -4263,7 +4263,7 @@ func (x FileBase) LoadBytesAsync(CancellableVar Cancellable, CallbackVar *Asyn
4263		// freed with g_bytes_unref() when no longer in use.	4263		// freed with g_bytes_unref() when no longer in use.
4264		//	4264		//
4265		// See g_file_load_bytes() for more information.	4265		// See g_file_load_bytes() for more information.
4266	-	func (x FileBase) LoadBytesFinish(ResultVar AsyncResult, EtagOutVar string) (glib.Bytes, error) {	4266	+	func (x FileBase) LoadBytesFinish(ResultVar AsyncResult, EtagOutVar string) (*glib.Bytes, error) {
4267		var cerr *glib.Error	4267		var cerr *glib.Error
4268			4268
4269		cret := XGFileLoadBytesFinish(x.GoPointer(), ResultVar.GoPointer(), EtagOutVar, &cerr)	4269		cret := XGFileLoadBytesFinish(x.GoPointer(), ResultVar.GoPointer(), EtagOutVar, &cerr)

@@ -4282,7 +4282,7 @@ func (x FileBase) LoadBytesFinish(ResultVar AsyncResult, EtagOutVar string) (g
4282		// If @cancellable is not %NULL, then the operation can be cancelled by	4282		// If @cancellable is not %NULL, then the operation can be cancelled by
4283		// triggering the cancellable object from another thread. If the operation	4283		// triggering the cancellable object from another thread. If the operation
4284		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.	4284		// was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
4285	-	func (x FileBase) LoadContents(CancellableVar Cancellable, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error) {	4285	+	func (x FileBase) LoadContents(CancellableVar Cancellable, ContentsVar []string, LengthVar uint, EtagOutVar *string) (bool, error) {
4286		var cerr *glib.Error	4286		var cerr *glib.Error
4287			4287
4288		cret := XGFileLoadContents(x.GoPointer(), CancellableVar.GoPointer(), ContentsVar, LengthVar, EtagOutVar, &cerr)	4288		cret := XGFileLoadContents(x.GoPointer(), CancellableVar.GoPointer(), ContentsVar, LengthVar, EtagOutVar, &cerr)

@@ -4317,7 +4317,7 @@ func (x FileBase) LoadContentsAsync(CancellableVar Cancellable, CallbackVar *A
4317		// size of the @contents string. The @contents should be freed with	4317		// size of the @contents string. The @contents should be freed with
4318		// g_free() when no longer needed. If @etag_out is present, it will be	4318		// g_free() when no longer needed. If @etag_out is present, it will be
4319		// set to the new entity tag for the @file.	4319		// set to the new entity tag for the @file.
4320	-	func (x *FileBase) LoadContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error) {	4320	+	func (x FileBase) LoadContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error) {
4321		var cerr *glib.Error	4321		var cerr *glib.Error
4322			4322
4323		cret := XGFileLoadContentsFinish(x.GoPointer(), ResVar.GoPointer(), ContentsVar, LengthVar, EtagOutVar, &cerr)	4323		cret := XGFileLoadContentsFinish(x.GoPointer(), ResVar.GoPointer(), ContentsVar, LengthVar, EtagOutVar, &cerr)

@@ -4350,7 +4350,7 @@ func (x FileBase) LoadPartialContentsAsync(CancellableVar Cancellable, ReadMor
4350		// zero-terminated, but this is not included in the resultant @length.	4350		// zero-terminated, but this is not included in the resultant @length.
4351		// The returned @contents should be freed with g_free() when no longer	4351		// The returned @contents should be freed with g_free() when no longer
4352		// needed.	4352		// needed.
4353	-	func (x *FileBase) LoadPartialContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error) {	4353	+	func (x FileBase) LoadPartialContentsFinish(ResVar AsyncResult, ContentsVar []string, LengthVar uint, EtagOutVar string) (bool, error) {
4354		var cerr *glib.Error	4354		var cerr *glib.Error
4355			4355
4356		cret := XGFileLoadPartialContentsFinish(x.GoPointer(), ResVar.GoPointer(), ContentsVar, LengthVar, EtagOutVar, &cerr)	4356		cret := XGFileLoadPartialContentsFinish(x.GoPointer(), ResVar.GoPointer(), ContentsVar, LengthVar, EtagOutVar, &cerr)

@@ -4490,7 +4490,7 @@ func (x *FileBase) MakeSymbolicLinkFinish(ResultVar AsyncResult) (bool, error) {
4490		// periodic progress updates while scanning. See the documentation for	4490		// periodic progress updates while scanning. See the documentation for
4491		// #GFileMeasureProgressCallback for information about when and how the	4491		// #GFileMeasureProgressCallback for information about when and how the
4492		// callback will be invoked.	4492		// callback will be invoked.
4493	-	func (x FileBase) MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar *FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) (bool, error) {	4493	+	func (x FileBase) MeasureDiskUsage(FlagsVar FileMeasureFlags, CancellableVar Cancellable, ProgressCallbackVar FileMeasureProgressCallback, ProgressDataVar uintptr, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) (bool, error) {
4494		var cerr *glib.Error	4494		var cerr *glib.Error
4495			4495
4496		cret := XGFileMeasureDiskUsage(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(ProgressCallbackVar), ProgressDataVar, DiskUsageVar, NumDirsVar, NumFilesVar, &cerr)	4496		cret := XGFileMeasureDiskUsage(x.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(ProgressCallbackVar), ProgressDataVar, DiskUsageVar, NumDirsVar, NumFilesVar, &cerr)

@@ -4514,7 +4514,7 @@ func (x *FileBase) MeasureDiskUsageAsync(FlagsVar FileMeasureFlags, IoPriorityVa
4514		// Collects the results from an earlier call to	4514		// Collects the results from an earlier call to
4515		// g_file_measure_disk_usage_async(). See g_file_measure_disk_usage() for	4515		// g_file_measure_disk_usage_async(). See g_file_measure_disk_usage() for
4516		// more information.	4516		// more information.
4517	-	func (x *FileBase) MeasureDiskUsageFinish(ResultVar AsyncResult, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) (bool, error) {	4517	+	func (x FileBase) MeasureDiskUsageFinish(ResultVar AsyncResult, DiskUsageVar uint64, NumDirsVar uint64, NumFilesVar uint64) (bool, error) {
4518		var cerr *glib.Error	4518		var cerr *glib.Error
4519			4519
4520		cret := XGFileMeasureDiskUsageFinish(x.GoPointer(), ResultVar.GoPointer(), DiskUsageVar, NumDirsVar, NumFilesVar, &cerr)	4520		cret := XGFileMeasureDiskUsageFinish(x.GoPointer(), ResultVar.GoPointer(), DiskUsageVar, NumDirsVar, NumFilesVar, &cerr)

@@ -5329,7 +5329,7 @@ func (x *FileBase) ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar Fil
5329		//	5329		//
5330		// The returned @new_etag can be used to verify that the file hasn't	5330		// The returned @new_etag can be used to verify that the file hasn't
5331		// changed the next time it is saved over.	5331		// changed the next time it is saved over.
5332	-	func (x FileBase) ReplaceContents(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar string, CancellableVar Cancellable) (bool, error) {	5332	+	func (x FileBase) ReplaceContents(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar string, CancellableVar *Cancellable) (bool, error) {
5333		var cerr *glib.Error	5333		var cerr *glib.Error
5334			5334
5335		cret := XGFileReplaceContents(x.GoPointer(), ContentsVar, LengthVar, EtagVar, MakeBackupVar, FlagsVar, NewEtagVar, CancellableVar.GoPointer(), &cerr)	5335		cret := XGFileReplaceContents(x.GoPointer(), ContentsVar, LengthVar, EtagVar, MakeBackupVar, FlagsVar, NewEtagVar, CancellableVar.GoPointer(), &cerr)

@@ -5382,7 +5382,7 @@ func (x FileBase) ReplaceContentsBytesAsync(ContentsVar glib.Bytes, EtagVar st
5382		// Finishes an asynchronous replace of the given @file. See	5382		// Finishes an asynchronous replace of the given @file. See
5383		// g_file_replace_contents_async(). Sets @new_etag to the new entity	5383		// g_file_replace_contents_async(). Sets @new_etag to the new entity
5384		// tag for the document, if present.	5384		// tag for the document, if present.
5385	-	func (x *FileBase) ReplaceContentsFinish(ResVar AsyncResult, NewEtagVar string) (bool, error) {	5385	+	func (x FileBase) ReplaceContentsFinish(ResVar AsyncResult, NewEtagVar string) (bool, error) {
5386		var cerr *glib.Error	5386		var cerr *glib.Error
5387			5387
5388		cret := XGFileReplaceContentsFinish(x.GoPointer(), ResVar.GoPointer(), NewEtagVar, &cerr)	5388		cret := XGFileReplaceContentsFinish(x.GoPointer(), ResVar.GoPointer(), NewEtagVar, &cerr)

@@ -5636,7 +5636,7 @@ func (x FileBase) SetAttributesAsync(InfoVar FileInfo, FlagsVar FileQueryInfoF
5636		func (x FileBase) SetAttributesFinish(ResultVar AsyncResult, InfoVar *FileInfo) (bool, error) {	5636		func (x FileBase) SetAttributesFinish(ResultVar AsyncResult, InfoVar *FileInfo) (bool, error) {
5637		var cerr *glib.Error	5637		var cerr *glib.Error
5638			5638
5639	-	cret := XGFileSetAttributesFinish(x.GoPointer(), ResultVar.GoPointer(), *gobject.ConvertPtr(InfoVar), &cerr)	5639	+	cret := XGFileSetAttributesFinish(x.GoPointer(), ResultVar.GoPointer(), InfoVar, &cerr)
5640		if cerr == nil {	5640		if cerr == nil {
5641		return cret, nil	5641		return cret, nil
5642		}	5642		}

@@ -5955,14 +5955,14 @@ var XGFileHasPrefix func(uintptr, uintptr) bool
5955		var XGFileHasUriScheme func(uintptr, string) bool	5955		var XGFileHasUriScheme func(uintptr, string) bool
5956		var XGFileHash func(uintptr) uint	5956		var XGFileHash func(uintptr) uint
5957		var XGFileIsNative func(uintptr) bool	5957		var XGFileIsNative func(uintptr) bool
5958	-	var XGFileLoadBytes func(uintptr, uintptr, string, *glib.Error) glib.Bytes	5958	+	var XGFileLoadBytes func(uintptr, uintptr, string, glib.Error) glib.Bytes
5959		var XGFileLoadBytesAsync func(uintptr, uintptr, uintptr, uintptr)	5959		var XGFileLoadBytesAsync func(uintptr, uintptr, uintptr, uintptr)
5960	-	var XGFileLoadBytesFinish func(uintptr, uintptr, string, *glib.Error) glib.Bytes	5960	+	var XGFileLoadBytesFinish func(uintptr, uintptr, string, glib.Error) glib.Bytes
5961	-	var XGFileLoadContents func(uintptr, uintptr, []string, uint, string, **glib.Error) bool	5961	+	var XGFileLoadContents func(uintptr, uintptr, []string, uint, string, *glib.Error) bool
5962		var XGFileLoadContentsAsync func(uintptr, uintptr, uintptr, uintptr)	5962		var XGFileLoadContentsAsync func(uintptr, uintptr, uintptr, uintptr)
5963	-	var XGFileLoadContentsFinish func(uintptr, uintptr, []string, uint, string, **glib.Error) bool	5963	+	var XGFileLoadContentsFinish func(uintptr, uintptr, []string, uint, string, *glib.Error) bool
5964		var XGFileLoadPartialContentsAsync func(uintptr, uintptr, uintptr, uintptr, uintptr)	5964		var XGFileLoadPartialContentsAsync func(uintptr, uintptr, uintptr, uintptr, uintptr)
5965	-	var XGFileLoadPartialContentsFinish func(uintptr, uintptr, []string, uint, string, **glib.Error) bool	5965	+	var XGFileLoadPartialContentsFinish func(uintptr, uintptr, []string, uint, string, *glib.Error) bool
5966		var XGFileMakeDirectory func(uintptr, uintptr, **glib.Error) bool	5966		var XGFileMakeDirectory func(uintptr, uintptr, **glib.Error) bool
5967		var XGFileMakeDirectoryAsync func(uintptr, int, uintptr, uintptr, uintptr)	5967		var XGFileMakeDirectoryAsync func(uintptr, int, uintptr, uintptr, uintptr)
5968		var XGFileMakeDirectoryFinish func(uintptr, uintptr, **glib.Error) bool	5968		var XGFileMakeDirectoryFinish func(uintptr, uintptr, **glib.Error) bool

@@ -5970,9 +5970,9 @@ var XGFileMakeDirectoryWithParents func(uintptr, uintptr, **glib.Error) bool
5970		var XGFileMakeSymbolicLink func(uintptr, string, uintptr, **glib.Error) bool	5970		var XGFileMakeSymbolicLink func(uintptr, string, uintptr, **glib.Error) bool
5971		var XGFileMakeSymbolicLinkAsync func(uintptr, string, int, uintptr, uintptr, uintptr)	5971		var XGFileMakeSymbolicLinkAsync func(uintptr, string, int, uintptr, uintptr, uintptr)
5972		var XGFileMakeSymbolicLinkFinish func(uintptr, uintptr, **glib.Error) bool	5972		var XGFileMakeSymbolicLinkFinish func(uintptr, uintptr, **glib.Error) bool
5973	-	var XGFileMeasureDiskUsage func(uintptr, FileMeasureFlags, uintptr, uintptr, uintptr, uint64, uint64, uint64, **glib.Error) bool	5973	+	var XGFileMeasureDiskUsage func(uintptr, FileMeasureFlags, uintptr, uintptr, uintptr, uint64, uint64, uint64, *glib.Error) bool
5974		var XGFileMeasureDiskUsageAsync func(uintptr, FileMeasureFlags, int, uintptr, uintptr, uintptr, uintptr, uintptr)	5974		var XGFileMeasureDiskUsageAsync func(uintptr, FileMeasureFlags, int, uintptr, uintptr, uintptr, uintptr, uintptr)
5975	-	var XGFileMeasureDiskUsageFinish func(uintptr, uintptr, uint64, uint64, uint64, **glib.Error) bool	5975	+	var XGFileMeasureDiskUsageFinish func(uintptr, uintptr, uint64, uint64, uint64, *glib.Error) bool
5976		var XGFileMonitor func(uintptr, FileMonitorFlags, uintptr, **glib.Error) uintptr	5976		var XGFileMonitor func(uintptr, FileMonitorFlags, uintptr, **glib.Error) uintptr
5977		var XGFileMonitorDirectory func(uintptr, FileMonitorFlags, uintptr, **glib.Error) uintptr	5977		var XGFileMonitorDirectory func(uintptr, FileMonitorFlags, uintptr, **glib.Error) uintptr
5978		var XGFileMonitorFile func(uintptr, FileMonitorFlags, uintptr, **glib.Error) uintptr	5978		var XGFileMonitorFile func(uintptr, FileMonitorFlags, uintptr, **glib.Error) uintptr

@@ -6008,10 +6008,10 @@ var XGFileReadAsync func(uintptr, int, uintptr, uintptr, uintptr)
6008		var XGFileReadFinish func(uintptr, uintptr, **glib.Error) uintptr	6008		var XGFileReadFinish func(uintptr, uintptr, **glib.Error) uintptr
6009		var XGFileReplace func(uintptr, string, bool, FileCreateFlags, uintptr, **glib.Error) uintptr	6009		var XGFileReplace func(uintptr, string, bool, FileCreateFlags, uintptr, **glib.Error) uintptr
6010		var XGFileReplaceAsync func(uintptr, string, bool, FileCreateFlags, int, uintptr, uintptr, uintptr)	6010		var XGFileReplaceAsync func(uintptr, string, bool, FileCreateFlags, int, uintptr, uintptr, uintptr)
6011	-	var XGFileReplaceContents func(uintptr, string, uint, string, bool, FileCreateFlags, string, uintptr, **glib.Error) bool	6011	+	var XGFileReplaceContents func(uintptr, string, uint, string, bool, FileCreateFlags, string, uintptr, *glib.Error) bool
6012		var XGFileReplaceContentsAsync func(uintptr, string, uint, string, bool, FileCreateFlags, uintptr, uintptr, uintptr)	6012		var XGFileReplaceContentsAsync func(uintptr, string, uint, string, bool, FileCreateFlags, uintptr, uintptr, uintptr)
6013		var XGFileReplaceContentsBytesAsync func(uintptr, *glib.Bytes, string, bool, FileCreateFlags, uintptr, uintptr, uintptr)	6013		var XGFileReplaceContentsBytesAsync func(uintptr, *glib.Bytes, string, bool, FileCreateFlags, uintptr, uintptr, uintptr)
6014	-	var XGFileReplaceContentsFinish func(uintptr, uintptr, string, **glib.Error) bool	6014	+	var XGFileReplaceContentsFinish func(uintptr, uintptr, string, *glib.Error) bool
6015		var XGFileReplaceFinish func(uintptr, uintptr, **glib.Error) uintptr	6015		var XGFileReplaceFinish func(uintptr, uintptr, **glib.Error) uintptr
6016		var XGFileReplaceReadwrite func(uintptr, string, bool, FileCreateFlags, uintptr, **glib.Error) uintptr	6016		var XGFileReplaceReadwrite func(uintptr, string, bool, FileCreateFlags, uintptr, **glib.Error) uintptr
6017		var XGFileReplaceReadwriteAsync func(uintptr, string, bool, FileCreateFlags, int, uintptr, uintptr, uintptr)	6017		var XGFileReplaceReadwriteAsync func(uintptr, string, bool, FileCreateFlags, int, uintptr, uintptr, uintptr)

@@ -6025,7 +6025,7 @@ var XGFileSetAttributeString func(uintptr, string, string, FileQueryInfoFlags, u
6025		var XGFileSetAttributeUint32 func(uintptr, string, uint32, FileQueryInfoFlags, uintptr, **glib.Error) bool	6025		var XGFileSetAttributeUint32 func(uintptr, string, uint32, FileQueryInfoFlags, uintptr, **glib.Error) bool
6026		var XGFileSetAttributeUint64 func(uintptr, string, uint64, FileQueryInfoFlags, uintptr, **glib.Error) bool	6026		var XGFileSetAttributeUint64 func(uintptr, string, uint64, FileQueryInfoFlags, uintptr, **glib.Error) bool
6027		var XGFileSetAttributesAsync func(uintptr, uintptr, FileQueryInfoFlags, int, uintptr, uintptr, uintptr)	6027		var XGFileSetAttributesAsync func(uintptr, uintptr, FileQueryInfoFlags, int, uintptr, uintptr, uintptr)
6028	-	var XGFileSetAttributesFinish func(uintptr, uintptr, uintptr, **glib.Error) bool	6028	+	var XGFileSetAttributesFinish func(uintptr, uintptr, FileInfo, glib.Error) bool
6029		var XGFileSetAttributesFromInfo func(uintptr, uintptr, FileQueryInfoFlags, uintptr, **glib.Error) bool	6029		var XGFileSetAttributesFromInfo func(uintptr, uintptr, FileQueryInfoFlags, uintptr, **glib.Error) bool
6030		var XGFileSetDisplayName func(uintptr, string, uintptr, **glib.Error) uintptr	6030		var XGFileSetDisplayName func(uintptr, string, uintptr, **glib.Error) uintptr
6031		var XGFileSetDisplayNameAsync func(uintptr, string, int, uintptr, uintptr, uintptr)	6031		var XGFileSetDisplayNameAsync func(uintptr, string, int, uintptr, uintptr, uintptr)

@@ -6155,7 +6155,7 @@ func FileNewForUri(UriVar string) *FileBase {
6155		return cls	6155		return cls
6156		}	6156		}
6157			6157
6158	-	var xFileNewTmp func(string, uintptr, **glib.Error) uintptr	6158	+	var xFileNewTmp func(string, FileIOStream, glib.Error) uintptr
6159			6159
6160		// Opens a file in the preferred directory for temporary files (as	6160		// Opens a file in the preferred directory for temporary files (as
6161		// returned by g_get_tmp_dir()) and returns a #GFile and	6161		// returned by g_get_tmp_dir()) and returns a #GFile and

@@ -6171,7 +6171,7 @@ func FileNewTmp(TmplVar string, IostreamVar *FileIOStream) (FileBase, error) {
6171		var cls *FileBase	6171		var cls *FileBase
6172		var cerr *glib.Error	6172		var cerr *glib.Error
6173			6173
6174	-	cret := xFileNewTmp(TmplVar, *gobject.ConvertPtr(IostreamVar), &cerr)	6174	+	cret := xFileNewTmp(TmplVar, IostreamVar, &cerr)
6175			6175
6176		if cret == 0 {	6176		if cret == 0 {
6177		return nil, cerr	6177		return nil, cerr

@@ -6236,14 +6236,14 @@ func FileNewTmpDirFinish(ResultVar AsyncResult) (*FileBase, error) {
6236			6236
6237		}	6237		}
6238			6238
6239	-	var xFileNewTmpFinish func(uintptr, uintptr, **glib.Error) uintptr	6239	+	var xFileNewTmpFinish func(uintptr, FileIOStream, glib.Error) uintptr
6240			6240
6241		// Finishes a temporary file creation started by g_file_new_tmp_async().	6241		// Finishes a temporary file creation started by g_file_new_tmp_async().
6242		func FileNewTmpFinish(ResultVar AsyncResult, IostreamVar *FileIOStream) (FileBase, error) {	6242		func FileNewTmpFinish(ResultVar AsyncResult, IostreamVar *FileIOStream) (FileBase, error) {
6243		var cls *FileBase	6243		var cls *FileBase
6244		var cerr *glib.Error	6244		var cerr *glib.Error
6245			6245
6246	-	cret := xFileNewTmpFinish(ResultVar.GoPointer(), *gobject.ConvertPtr(IostreamVar), &cerr)	6246	+	cret := xFileNewTmpFinish(ResultVar.GoPointer(), IostreamVar, &cerr)
6247			6247
6248		if cret == 0 {	6248		if cret == 0 {
6249		return nil, cerr	6249		return nil, cerr

M v4/gio/gfileenumerator.go +29 -29


@@ -48,7 +48,7 @@ func (x *FileEnumeratorClass) GoPointer() uintptr {
48		return uintptr(unsafe.Pointer(x))	48		return uintptr(unsafe.Pointer(x))
49		}	49		}
50			50
51	-	// OverrideNextFile sets the callback function.	51	+	// OverrideNextFile sets the "next_file" callback function.
52		func (x FileEnumeratorClass) OverrideNextFile(cb func(FileEnumerator, Cancellable) FileInfo) {	52		func (x FileEnumeratorClass) OverrideNextFile(cb func(FileEnumerator, Cancellable) FileInfo) {
53		if cb == nil {	53		if cb == nil {
54		x.xNextFile = 0	54		x.xNextFile = 0

@@ -63,7 +63,7 @@ func (x FileEnumeratorClass) OverrideNextFile(cb func(FileEnumerator, *Cancell
63		}	63		}
64		}	64		}
65			65
66	-	// GetNextFile gets the callback function.	66	+	// GetNextFile gets the "next_file" callback function.
67		func (x FileEnumeratorClass) GetNextFile() func(FileEnumerator, Cancellable) FileInfo {	67		func (x FileEnumeratorClass) GetNextFile() func(FileEnumerator, Cancellable) FileInfo {
68		if x.xNextFile == 0 {	68		if x.xNextFile == 0 {
69		return nil	69		return nil

@@ -81,7 +81,7 @@ func (x FileEnumeratorClass) GetNextFile() func(FileEnumerator, *Cancellable)
81		}	81		}
82		}	82		}
83			83
84	-	// OverrideCloseFn sets the callback function.	84	+	// OverrideCloseFn sets the "close_fn" callback function.
85		func (x FileEnumeratorClass) OverrideCloseFn(cb func(FileEnumerator, *Cancellable) bool) {	85		func (x FileEnumeratorClass) OverrideCloseFn(cb func(FileEnumerator, *Cancellable) bool) {
86		if cb == nil {	86		if cb == nil {
87		x.xCloseFn = 0	87		x.xCloseFn = 0

@@ -92,7 +92,7 @@ func (x FileEnumeratorClass) OverrideCloseFn(cb func(FileEnumerator, *Cancella
92		}	92		}
93		}	93		}
94			94
95	-	// GetCloseFn gets the callback function.	95	+	// GetCloseFn gets the "close_fn" callback function.
96		func (x FileEnumeratorClass) GetCloseFn() func(FileEnumerator, *Cancellable) bool {	96		func (x FileEnumeratorClass) GetCloseFn() func(FileEnumerator, *Cancellable) bool {
97		if x.xCloseFn == 0 {	97		if x.xCloseFn == 0 {
98		return nil	98		return nil

@@ -104,7 +104,7 @@ func (x FileEnumeratorClass) GetCloseFn() func(FileEnumerator, *Cancellable) b
104		}	104		}
105		}	105		}
106			106
107	-	// OverrideNextFilesAsync sets the callback function.	107	+	// OverrideNextFilesAsync sets the "next_files_async" callback function.
108		func (x FileEnumeratorClass) OverrideNextFilesAsync(cb func(FileEnumerator, int, int, Cancellable, AsyncReadyCallback, uintptr)) {	108		func (x FileEnumeratorClass) OverrideNextFilesAsync(cb func(FileEnumerator, int, int, Cancellable, AsyncReadyCallback, uintptr)) {
109		if cb == nil {	109		if cb == nil {
110		x.xNextFilesAsync = 0	110		x.xNextFilesAsync = 0

@@ -115,7 +115,7 @@ func (x FileEnumeratorClass) OverrideNextFilesAsync(cb func(FileEnumerator, in
115		}	115		}
116		}	116		}
117			117
118	-	// GetNextFilesAsync gets the callback function.	118	+	// GetNextFilesAsync gets the "next_files_async" callback function.
119		func (x FileEnumeratorClass) GetNextFilesAsync() func(FileEnumerator, int, int, Cancellable, AsyncReadyCallback, uintptr) {	119		func (x FileEnumeratorClass) GetNextFilesAsync() func(FileEnumerator, int, int, Cancellable, AsyncReadyCallback, uintptr) {
120		if x.xNextFilesAsync == 0 {	120		if x.xNextFilesAsync == 0 {
121		return nil	121		return nil

@@ -127,7 +127,7 @@ func (x FileEnumeratorClass) GetNextFilesAsync() func(FileEnumerator, int, int
127		}	127		}
128		}	128		}
129			129
130	-	// OverrideNextFilesFinish sets the callback function.	130	+	// OverrideNextFilesFinish sets the "next_files_finish" callback function.
131		func (x FileEnumeratorClass) OverrideNextFilesFinish(cb func(FileEnumerator, AsyncResult) *glib.List) {	131		func (x FileEnumeratorClass) OverrideNextFilesFinish(cb func(FileEnumerator, AsyncResult) *glib.List) {
132		if cb == nil {	132		if cb == nil {
133		x.xNextFilesFinish = 0	133		x.xNextFilesFinish = 0

@@ -138,7 +138,7 @@ func (x FileEnumeratorClass) OverrideNextFilesFinish(cb func(FileEnumerator, A
138		}	138		}
139		}	139		}
140			140
141	-	// GetNextFilesFinish gets the callback function.	141	+	// GetNextFilesFinish gets the "next_files_finish" callback function.
142		func (x FileEnumeratorClass) GetNextFilesFinish() func(FileEnumerator, AsyncResult) *glib.List {	142		func (x FileEnumeratorClass) GetNextFilesFinish() func(FileEnumerator, AsyncResult) *glib.List {
143		if x.xNextFilesFinish == 0 {	143		if x.xNextFilesFinish == 0 {
144		return nil	144		return nil

@@ -150,7 +150,7 @@ func (x FileEnumeratorClass) GetNextFilesFinish() func(FileEnumerator, AsyncRe
150		}	150		}
151		}	151		}
152			152
153	-	// OverrideCloseAsync sets the callback function.	153	+	// OverrideCloseAsync sets the "close_async" callback function.
154		func (x FileEnumeratorClass) OverrideCloseAsync(cb func(FileEnumerator, int, Cancellable, AsyncReadyCallback, uintptr)) {	154		func (x FileEnumeratorClass) OverrideCloseAsync(cb func(FileEnumerator, int, Cancellable, AsyncReadyCallback, uintptr)) {
155		if cb == nil {	155		if cb == nil {
156		x.xCloseAsync = 0	156		x.xCloseAsync = 0

@@ -161,7 +161,7 @@ func (x FileEnumeratorClass) OverrideCloseAsync(cb func(FileEnumerator, int, *
161		}	161		}
162		}	162		}
163			163
164	-	// GetCloseAsync gets the callback function.	164	+	// GetCloseAsync gets the "close_async" callback function.
165		func (x FileEnumeratorClass) GetCloseAsync() func(FileEnumerator, int, Cancellable, AsyncReadyCallback, uintptr) {	165		func (x FileEnumeratorClass) GetCloseAsync() func(FileEnumerator, int, Cancellable, AsyncReadyCallback, uintptr) {
166		if x.xCloseAsync == 0 {	166		if x.xCloseAsync == 0 {
167		return nil	167		return nil

@@ -173,7 +173,7 @@ func (x FileEnumeratorClass) GetCloseAsync() func(FileEnumerator, int, *Cancel
173		}	173		}
174		}	174		}
175			175
176	-	// OverrideCloseFinish sets the callback function.	176	+	// OverrideCloseFinish sets the "close_finish" callback function.
177		func (x FileEnumeratorClass) OverrideCloseFinish(cb func(FileEnumerator, AsyncResult) bool) {	177		func (x FileEnumeratorClass) OverrideCloseFinish(cb func(FileEnumerator, AsyncResult) bool) {
178		if cb == nil {	178		if cb == nil {
179		x.xCloseFinish = 0	179		x.xCloseFinish = 0

@@ -184,7 +184,7 @@ func (x FileEnumeratorClass) OverrideCloseFinish(cb func(FileEnumerator, Async
184		}	184		}
185		}	185		}
186			186
187	-	// GetCloseFinish gets the callback function.	187	+	// GetCloseFinish gets the "close_finish" callback function.
188		func (x FileEnumeratorClass) GetCloseFinish() func(FileEnumerator, AsyncResult) bool {	188		func (x FileEnumeratorClass) GetCloseFinish() func(FileEnumerator, AsyncResult) bool {
189		if x.xCloseFinish == 0 {	189		if x.xCloseFinish == 0 {
190		return nil	190		return nil

@@ -196,7 +196,7 @@ func (x FileEnumeratorClass) GetCloseFinish() func(FileEnumerator, AsyncResult
196		}	196		}
197		}	197		}
198			198
199	-	// OverrideGReserved1 sets the callback function.	199	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
200		func (x *FileEnumeratorClass) OverrideGReserved1(cb func()) {	200		func (x *FileEnumeratorClass) OverrideGReserved1(cb func()) {
201		if cb == nil {	201		if cb == nil {
202		x.xGReserved1 = 0	202		x.xGReserved1 = 0

@@ -207,7 +207,7 @@ func (x *FileEnumeratorClass) OverrideGReserved1(cb func()) {
207		}	207		}
208		}	208		}
209			209
210	-	// GetGReserved1 gets the callback function.	210	+	// GetGReserved1 gets the "_g_reserved1" callback function.
211		func (x *FileEnumeratorClass) GetGReserved1() func() {	211		func (x *FileEnumeratorClass) GetGReserved1() func() {
212		if x.xGReserved1 == 0 {	212		if x.xGReserved1 == 0 {
213		return nil	213		return nil

@@ -219,7 +219,7 @@ func (x *FileEnumeratorClass) GetGReserved1() func() {
219		}	219		}
220		}	220		}
221			221
222	-	// OverrideGReserved2 sets the callback function.	222	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
223		func (x *FileEnumeratorClass) OverrideGReserved2(cb func()) {	223		func (x *FileEnumeratorClass) OverrideGReserved2(cb func()) {
224		if cb == nil {	224		if cb == nil {
225		x.xGReserved2 = 0	225		x.xGReserved2 = 0

@@ -230,7 +230,7 @@ func (x *FileEnumeratorClass) OverrideGReserved2(cb func()) {
230		}	230		}
231		}	231		}
232			232
233	-	// GetGReserved2 gets the callback function.	233	+	// GetGReserved2 gets the "_g_reserved2" callback function.
234		func (x *FileEnumeratorClass) GetGReserved2() func() {	234		func (x *FileEnumeratorClass) GetGReserved2() func() {
235		if x.xGReserved2 == 0 {	235		if x.xGReserved2 == 0 {
236		return nil	236		return nil

@@ -242,7 +242,7 @@ func (x *FileEnumeratorClass) GetGReserved2() func() {
242		}	242		}
243		}	243		}
244			244
245	-	// OverrideGReserved3 sets the callback function.	245	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
246		func (x *FileEnumeratorClass) OverrideGReserved3(cb func()) {	246		func (x *FileEnumeratorClass) OverrideGReserved3(cb func()) {
247		if cb == nil {	247		if cb == nil {
248		x.xGReserved3 = 0	248		x.xGReserved3 = 0

@@ -253,7 +253,7 @@ func (x *FileEnumeratorClass) OverrideGReserved3(cb func()) {
253		}	253		}
254		}	254		}
255			255
256	-	// GetGReserved3 gets the callback function.	256	+	// GetGReserved3 gets the "_g_reserved3" callback function.
257		func (x *FileEnumeratorClass) GetGReserved3() func() {	257		func (x *FileEnumeratorClass) GetGReserved3() func() {
258		if x.xGReserved3 == 0 {	258		if x.xGReserved3 == 0 {
259		return nil	259		return nil

@@ -265,7 +265,7 @@ func (x *FileEnumeratorClass) GetGReserved3() func() {
265		}	265		}
266		}	266		}
267			267
268	-	// OverrideGReserved4 sets the callback function.	268	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
269		func (x *FileEnumeratorClass) OverrideGReserved4(cb func()) {	269		func (x *FileEnumeratorClass) OverrideGReserved4(cb func()) {
270		if cb == nil {	270		if cb == nil {
271		x.xGReserved4 = 0	271		x.xGReserved4 = 0

@@ -276,7 +276,7 @@ func (x *FileEnumeratorClass) OverrideGReserved4(cb func()) {
276		}	276		}
277		}	277		}
278			278
279	-	// GetGReserved4 gets the callback function.	279	+	// GetGReserved4 gets the "_g_reserved4" callback function.
280		func (x *FileEnumeratorClass) GetGReserved4() func() {	280		func (x *FileEnumeratorClass) GetGReserved4() func() {
281		if x.xGReserved4 == 0 {	281		if x.xGReserved4 == 0 {
282		return nil	282		return nil

@@ -288,7 +288,7 @@ func (x *FileEnumeratorClass) GetGReserved4() func() {
288		}	288		}
289		}	289		}
290			290
291	-	// OverrideGReserved5 sets the callback function.	291	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
292		func (x *FileEnumeratorClass) OverrideGReserved5(cb func()) {	292		func (x *FileEnumeratorClass) OverrideGReserved5(cb func()) {
293		if cb == nil {	293		if cb == nil {
294		x.xGReserved5 = 0	294		x.xGReserved5 = 0

@@ -299,7 +299,7 @@ func (x *FileEnumeratorClass) OverrideGReserved5(cb func()) {
299		}	299		}
300		}	300		}
301			301
302	-	// GetGReserved5 gets the callback function.	302	+	// GetGReserved5 gets the "_g_reserved5" callback function.
303		func (x *FileEnumeratorClass) GetGReserved5() func() {	303		func (x *FileEnumeratorClass) GetGReserved5() func() {
304		if x.xGReserved5 == 0 {	304		if x.xGReserved5 == 0 {
305		return nil	305		return nil

@@ -311,7 +311,7 @@ func (x *FileEnumeratorClass) GetGReserved5() func() {
311		}	311		}
312		}	312		}
313			313
314	-	// OverrideGReserved6 sets the callback function.	314	+	// OverrideGReserved6 sets the "_g_reserved6" callback function.
315		func (x *FileEnumeratorClass) OverrideGReserved6(cb func()) {	315		func (x *FileEnumeratorClass) OverrideGReserved6(cb func()) {
316		if cb == nil {	316		if cb == nil {
317		x.xGReserved6 = 0	317		x.xGReserved6 = 0

@@ -322,7 +322,7 @@ func (x *FileEnumeratorClass) OverrideGReserved6(cb func()) {
322		}	322		}
323		}	323		}
324			324
325	-	// GetGReserved6 gets the callback function.	325	+	// GetGReserved6 gets the "_g_reserved6" callback function.
326		func (x *FileEnumeratorClass) GetGReserved6() func() {	326		func (x *FileEnumeratorClass) GetGReserved6() func() {
327		if x.xGReserved6 == 0 {	327		if x.xGReserved6 == 0 {
328		return nil	328		return nil

@@ -334,7 +334,7 @@ func (x *FileEnumeratorClass) GetGReserved6() func() {
334		}	334		}
335		}	335		}
336			336
337	-	// OverrideGReserved7 sets the callback function.	337	+	// OverrideGReserved7 sets the "_g_reserved7" callback function.
338		func (x *FileEnumeratorClass) OverrideGReserved7(cb func()) {	338		func (x *FileEnumeratorClass) OverrideGReserved7(cb func()) {
339		if cb == nil {	339		if cb == nil {
340		x.xGReserved7 = 0	340		x.xGReserved7 = 0

@@ -345,7 +345,7 @@ func (x *FileEnumeratorClass) OverrideGReserved7(cb func()) {
345		}	345		}
346		}	346		}
347			347
348	-	// GetGReserved7 gets the callback function.	348	+	// GetGReserved7 gets the "_g_reserved7" callback function.
349		func (x *FileEnumeratorClass) GetGReserved7() func() {	349		func (x *FileEnumeratorClass) GetGReserved7() func() {
350		if x.xGReserved7 == 0 {	350		if x.xGReserved7 == 0 {
351		return nil	351		return nil

@@ -528,7 +528,7 @@ func (x *FileEnumerator) IsClosed() bool {
528		return cret	528		return cret
529		}	529		}
530			530
531	-	var xFileEnumeratorIterate func(uintptr, uintptr, uintptr, uintptr, *glib.Error) bool	531	+	var xFileEnumeratorIterate func(uintptr, FileInfo, File, uintptr, **glib.Error) bool
532			532
533		// This is a version of g_file_enumerator_next_file() that's easier to	533		// This is a version of g_file_enumerator_next_file() that's easier to
534		// use correctly from C programs. With g_file_enumerator_next_file(),	534		// use correctly from C programs. With g_file_enumerator_next_file(),

@@ -571,10 +571,10 @@ var xFileEnumeratorIterate func(uintptr, uintptr, uintptr, uintptr, *glib.Erro
571		// g_object_unref (direnum); // Note: frees the last @info	571		// g_object_unref (direnum); // Note: frees the last @info
572		//	572		//
573		// ]\|	573		// ]\|
574	-	func (x FileEnumerator) Iterate(OutInfoVar FileInfo, OutChildVar File, CancellableVar *Cancellable) (bool, error) {	574	+	func (x FileEnumerator) Iterate(OutInfoVar FileInfo, OutChildVar File, CancellableVar Cancellable) (bool, error) {
575		var cerr *glib.Error	575		var cerr *glib.Error
576			576
577	-	cret := xFileEnumeratorIterate(x.GoPointer(), *gobject.ConvertPtr(OutInfoVar), gobject.ConvertPtr(OutChildVar), CancellableVar.GoPointer(), &cerr)	577	+	cret := xFileEnumeratorIterate(x.GoPointer(), OutInfoVar, OutChildVar, CancellableVar.GoPointer(), &cerr)
578		if cerr == nil {	578		if cerr == nil {
579		return cret, nil	579		return cret, nil
580		}	580		}

M v4/gio/gfileicon.go +2 -2


@@ -133,7 +133,7 @@ func (x *FileIcon) ToString() string {
133			133
134		// Loads a loadable icon. For the asynchronous version of this function,	134		// Loads a loadable icon. For the asynchronous version of this function,
135		// see g_loadable_icon_load_async().	135		// see g_loadable_icon_load_async().
136	-	func (x FileIcon) Load(SizeVar int, TypeVar string, CancellableVar Cancellable) (*InputStream, error) {	136	+	func (x FileIcon) Load(SizeVar int, TypeVar string, CancellableVar Cancellable) (InputStream, error) {
137		var cls *InputStream	137		var cls *InputStream
138		var cerr *glib.Error	138		var cerr *glib.Error
139			139

@@ -161,7 +161,7 @@ func (x FileIcon) LoadAsync(SizeVar int, CancellableVar Cancellable, CallbackV
161		}	161		}
162			162
163		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().	163		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().
164	-	func (x FileIcon) LoadFinish(ResVar AsyncResult, TypeVar string) (InputStream, error) {	164	+	func (x FileIcon) LoadFinish(ResVar AsyncResult, TypeVar string) (*InputStream, error) {
165		var cls *InputStream	165		var cls *InputStream
166		var cerr *glib.Error	166		var cerr *glib.Error
167			167

M v4/gio/gfileinfo.go +2 -2


@@ -857,10 +857,10 @@ func (x *FileInfo) GetAttributeByteString(AttributeVar string) string {
857		return cret	857		return cret
858		}	858		}
859			859
860	-	var xFileInfoGetAttributeData func(uintptr, string, FileAttributeType, uintptr, FileAttributeStatus) bool	860	+	var xFileInfoGetAttributeData func(uintptr, string, FileAttributeType, uintptr, *FileAttributeStatus) bool
861			861
862		// Gets the attribute type, value and status for an attribute key.	862		// Gets the attribute type, value and status for an attribute key.
863	-	func (x FileInfo) GetAttributeData(AttributeVar string, TypeVar FileAttributeType, ValuePpVar uintptr, StatusVar *FileAttributeStatus) bool {	863	+	func (x FileInfo) GetAttributeData(AttributeVar string, TypeVar FileAttributeType, ValuePpVar uintptr, StatusVar FileAttributeStatus) bool {
864			864
865		cret := xFileInfoGetAttributeData(x.GoPointer(), AttributeVar, TypeVar, ValuePpVar, StatusVar)	865		cret := xFileInfoGetAttributeData(x.GoPointer(), AttributeVar, TypeVar, ValuePpVar, StatusVar)
866		return cret	866		return cret

M v4/gio/gfileinputstream.go +22 -22


@@ -43,7 +43,7 @@ func (x *FileInputStreamClass) GoPointer() uintptr {
43		return uintptr(unsafe.Pointer(x))	43		return uintptr(unsafe.Pointer(x))
44		}	44		}
45			45
46	-	// OverrideTell sets the callback function.	46	+	// OverrideTell sets the "tell" callback function.
47		func (x FileInputStreamClass) OverrideTell(cb func(FileInputStream) int64) {	47		func (x FileInputStreamClass) OverrideTell(cb func(FileInputStream) int64) {
48		if cb == nil {	48		if cb == nil {
49		x.xTell = 0	49		x.xTell = 0

@@ -54,7 +54,7 @@ func (x FileInputStreamClass) OverrideTell(cb func(FileInputStream) int64) {
54		}	54		}
55		}	55		}
56			56
57	-	// GetTell gets the callback function.	57	+	// GetTell gets the "tell" callback function.
58		func (x FileInputStreamClass) GetTell() func(FileInputStream) int64 {	58		func (x FileInputStreamClass) GetTell() func(FileInputStream) int64 {
59		if x.xTell == 0 {	59		if x.xTell == 0 {
60		return nil	60		return nil

@@ -66,7 +66,7 @@ func (x FileInputStreamClass) GetTell() func(FileInputStream) int64 {
66		}	66		}
67		}	67		}
68			68
69	-	// OverrideCanSeek sets the callback function.	69	+	// OverrideCanSeek sets the "can_seek" callback function.
70		func (x FileInputStreamClass) OverrideCanSeek(cb func(FileInputStream) bool) {	70		func (x FileInputStreamClass) OverrideCanSeek(cb func(FileInputStream) bool) {
71		if cb == nil {	71		if cb == nil {
72		x.xCanSeek = 0	72		x.xCanSeek = 0

@@ -77,7 +77,7 @@ func (x FileInputStreamClass) OverrideCanSeek(cb func(FileInputStream) bool) {
77		}	77		}
78		}	78		}
79			79
80	-	// GetCanSeek gets the callback function.	80	+	// GetCanSeek gets the "can_seek" callback function.
81		func (x FileInputStreamClass) GetCanSeek() func(FileInputStream) bool {	81		func (x FileInputStreamClass) GetCanSeek() func(FileInputStream) bool {
82		if x.xCanSeek == 0 {	82		if x.xCanSeek == 0 {
83		return nil	83		return nil

@@ -89,7 +89,7 @@ func (x FileInputStreamClass) GetCanSeek() func(FileInputStream) bool {
89		}	89		}
90		}	90		}
91			91
92	-	// OverrideSeek sets the callback function.	92	+	// OverrideSeek sets the "seek" callback function.
93		func (x FileInputStreamClass) OverrideSeek(cb func(FileInputStream, int64, glib.SeekType, *Cancellable) bool) {	93		func (x FileInputStreamClass) OverrideSeek(cb func(FileInputStream, int64, glib.SeekType, *Cancellable) bool) {
94		if cb == nil {	94		if cb == nil {
95		x.xSeek = 0	95		x.xSeek = 0

@@ -100,7 +100,7 @@ func (x FileInputStreamClass) OverrideSeek(cb func(FileInputStream, int64, gli
100		}	100		}
101		}	101		}
102			102
103	-	// GetSeek gets the callback function.	103	+	// GetSeek gets the "seek" callback function.
104		func (x FileInputStreamClass) GetSeek() func(FileInputStream, int64, glib.SeekType, *Cancellable) bool {	104		func (x FileInputStreamClass) GetSeek() func(FileInputStream, int64, glib.SeekType, *Cancellable) bool {
105		if x.xSeek == 0 {	105		if x.xSeek == 0 {
106		return nil	106		return nil

@@ -112,7 +112,7 @@ func (x FileInputStreamClass) GetSeek() func(FileInputStream, int64, glib.Seek
112		}	112		}
113		}	113		}
114			114
115	-	// OverrideQueryInfo sets the callback function.	115	+	// OverrideQueryInfo sets the "query_info" callback function.
116		func (x FileInputStreamClass) OverrideQueryInfo(cb func(FileInputStream, string, Cancellable) FileInfo) {	116		func (x FileInputStreamClass) OverrideQueryInfo(cb func(FileInputStream, string, Cancellable) FileInfo) {
117		if cb == nil {	117		if cb == nil {
118		x.xQueryInfo = 0	118		x.xQueryInfo = 0

@@ -127,7 +127,7 @@ func (x FileInputStreamClass) OverrideQueryInfo(cb func(FileInputStream, strin
127		}	127		}
128		}	128		}
129			129
130	-	// GetQueryInfo gets the callback function.	130	+	// GetQueryInfo gets the "query_info" callback function.
131		func (x FileInputStreamClass) GetQueryInfo() func(FileInputStream, string, Cancellable) FileInfo {	131		func (x FileInputStreamClass) GetQueryInfo() func(FileInputStream, string, Cancellable) FileInfo {
132		if x.xQueryInfo == 0 {	132		if x.xQueryInfo == 0 {
133		return nil	133		return nil

@@ -145,7 +145,7 @@ func (x FileInputStreamClass) GetQueryInfo() func(FileInputStream, string, *Ca
145		}	145		}
146		}	146		}
147			147
148	-	// OverrideQueryInfoAsync sets the callback function.	148	+	// OverrideQueryInfoAsync sets the "query_info_async" callback function.
149		func (x FileInputStreamClass) OverrideQueryInfoAsync(cb func(FileInputStream, string, int, Cancellable, AsyncReadyCallback, uintptr)) {	149		func (x FileInputStreamClass) OverrideQueryInfoAsync(cb func(FileInputStream, string, int, Cancellable, AsyncReadyCallback, uintptr)) {
150		if cb == nil {	150		if cb == nil {
151		x.xQueryInfoAsync = 0	151		x.xQueryInfoAsync = 0

@@ -156,7 +156,7 @@ func (x FileInputStreamClass) OverrideQueryInfoAsync(cb func(FileInputStream,
156		}	156		}
157		}	157		}
158			158
159	-	// GetQueryInfoAsync gets the callback function.	159	+	// GetQueryInfoAsync gets the "query_info_async" callback function.
160		func (x FileInputStreamClass) GetQueryInfoAsync() func(FileInputStream, string, int, Cancellable, AsyncReadyCallback, uintptr) {	160		func (x FileInputStreamClass) GetQueryInfoAsync() func(FileInputStream, string, int, Cancellable, AsyncReadyCallback, uintptr) {
161		if x.xQueryInfoAsync == 0 {	161		if x.xQueryInfoAsync == 0 {
162		return nil	162		return nil

@@ -168,7 +168,7 @@ func (x FileInputStreamClass) GetQueryInfoAsync() func(FileInputStream, string
168		}	168		}
169		}	169		}
170			170
171	-	// OverrideQueryInfoFinish sets the callback function.	171	+	// OverrideQueryInfoFinish sets the "query_info_finish" callback function.
172		func (x FileInputStreamClass) OverrideQueryInfoFinish(cb func(FileInputStream, AsyncResult) *FileInfo) {	172		func (x FileInputStreamClass) OverrideQueryInfoFinish(cb func(FileInputStream, AsyncResult) *FileInfo) {
173		if cb == nil {	173		if cb == nil {
174		x.xQueryInfoFinish = 0	174		x.xQueryInfoFinish = 0

@@ -183,7 +183,7 @@ func (x FileInputStreamClass) OverrideQueryInfoFinish(cb func(FileInputStream,
183		}	183		}
184		}	184		}
185			185
186	-	// GetQueryInfoFinish gets the callback function.	186	+	// GetQueryInfoFinish gets the "query_info_finish" callback function.
187		func (x FileInputStreamClass) GetQueryInfoFinish() func(FileInputStream, AsyncResult) *FileInfo {	187		func (x FileInputStreamClass) GetQueryInfoFinish() func(FileInputStream, AsyncResult) *FileInfo {
188		if x.xQueryInfoFinish == 0 {	188		if x.xQueryInfoFinish == 0 {
189		return nil	189		return nil

@@ -201,7 +201,7 @@ func (x FileInputStreamClass) GetQueryInfoFinish() func(FileInputStream, Async
201		}	201		}
202		}	202		}
203			203
204	-	// OverrideGReserved1 sets the callback function.	204	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
205		func (x *FileInputStreamClass) OverrideGReserved1(cb func()) {	205		func (x *FileInputStreamClass) OverrideGReserved1(cb func()) {
206		if cb == nil {	206		if cb == nil {
207		x.xGReserved1 = 0	207		x.xGReserved1 = 0

@@ -212,7 +212,7 @@ func (x *FileInputStreamClass) OverrideGReserved1(cb func()) {
212		}	212		}
213		}	213		}
214			214
215	-	// GetGReserved1 gets the callback function.	215	+	// GetGReserved1 gets the "_g_reserved1" callback function.
216		func (x *FileInputStreamClass) GetGReserved1() func() {	216		func (x *FileInputStreamClass) GetGReserved1() func() {
217		if x.xGReserved1 == 0 {	217		if x.xGReserved1 == 0 {
218		return nil	218		return nil

@@ -224,7 +224,7 @@ func (x *FileInputStreamClass) GetGReserved1() func() {
224		}	224		}
225		}	225		}
226			226
227	-	// OverrideGReserved2 sets the callback function.	227	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
228		func (x *FileInputStreamClass) OverrideGReserved2(cb func()) {	228		func (x *FileInputStreamClass) OverrideGReserved2(cb func()) {
229		if cb == nil {	229		if cb == nil {
230		x.xGReserved2 = 0	230		x.xGReserved2 = 0

@@ -235,7 +235,7 @@ func (x *FileInputStreamClass) OverrideGReserved2(cb func()) {
235		}	235		}
236		}	236		}
237			237
238	-	// GetGReserved2 gets the callback function.	238	+	// GetGReserved2 gets the "_g_reserved2" callback function.
239		func (x *FileInputStreamClass) GetGReserved2() func() {	239		func (x *FileInputStreamClass) GetGReserved2() func() {
240		if x.xGReserved2 == 0 {	240		if x.xGReserved2 == 0 {
241		return nil	241		return nil

@@ -247,7 +247,7 @@ func (x *FileInputStreamClass) GetGReserved2() func() {
247		}	247		}
248		}	248		}
249			249
250	-	// OverrideGReserved3 sets the callback function.	250	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
251		func (x *FileInputStreamClass) OverrideGReserved3(cb func()) {	251		func (x *FileInputStreamClass) OverrideGReserved3(cb func()) {
252		if cb == nil {	252		if cb == nil {
253		x.xGReserved3 = 0	253		x.xGReserved3 = 0

@@ -258,7 +258,7 @@ func (x *FileInputStreamClass) OverrideGReserved3(cb func()) {
258		}	258		}
259		}	259		}
260			260
261	-	// GetGReserved3 gets the callback function.	261	+	// GetGReserved3 gets the "_g_reserved3" callback function.
262		func (x *FileInputStreamClass) GetGReserved3() func() {	262		func (x *FileInputStreamClass) GetGReserved3() func() {
263		if x.xGReserved3 == 0 {	263		if x.xGReserved3 == 0 {
264		return nil	264		return nil

@@ -270,7 +270,7 @@ func (x *FileInputStreamClass) GetGReserved3() func() {
270		}	270		}
271		}	271		}
272			272
273	-	// OverrideGReserved4 sets the callback function.	273	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
274		func (x *FileInputStreamClass) OverrideGReserved4(cb func()) {	274		func (x *FileInputStreamClass) OverrideGReserved4(cb func()) {
275		if cb == nil {	275		if cb == nil {
276		x.xGReserved4 = 0	276		x.xGReserved4 = 0

@@ -281,7 +281,7 @@ func (x *FileInputStreamClass) OverrideGReserved4(cb func()) {
281		}	281		}
282		}	282		}
283			283
284	-	// GetGReserved4 gets the callback function.	284	+	// GetGReserved4 gets the "_g_reserved4" callback function.
285		func (x *FileInputStreamClass) GetGReserved4() func() {	285		func (x *FileInputStreamClass) GetGReserved4() func() {
286		if x.xGReserved4 == 0 {	286		if x.xGReserved4 == 0 {
287		return nil	287		return nil

@@ -293,7 +293,7 @@ func (x *FileInputStreamClass) GetGReserved4() func() {
293		}	293		}
294		}	294		}
295			295
296	-	// OverrideGReserved5 sets the callback function.	296	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
297		func (x *FileInputStreamClass) OverrideGReserved5(cb func()) {	297		func (x *FileInputStreamClass) OverrideGReserved5(cb func()) {
298		if cb == nil {	298		if cb == nil {
299		x.xGReserved5 = 0	299		x.xGReserved5 = 0

@@ -304,7 +304,7 @@ func (x *FileInputStreamClass) OverrideGReserved5(cb func()) {
304		}	304		}
305		}	305		}
306			306
307	-	// GetGReserved5 gets the callback function.	307	+	// GetGReserved5 gets the "_g_reserved5" callback function.
308		func (x *FileInputStreamClass) GetGReserved5() func() {	308		func (x *FileInputStreamClass) GetGReserved5() func() {
309		if x.xGReserved5 == 0 {	309		if x.xGReserved5 == 0 {
310		return nil	310		return nil

M v4/gio/gfileiostream.go +28 -28


@@ -49,7 +49,7 @@ func (x *FileIOStreamClass) GoPointer() uintptr {
49		return uintptr(unsafe.Pointer(x))	49		return uintptr(unsafe.Pointer(x))
50		}	50		}
51			51
52	-	// OverrideTell sets the callback function.	52	+	// OverrideTell sets the "tell" callback function.
53		func (x FileIOStreamClass) OverrideTell(cb func(FileIOStream) int64) {	53		func (x FileIOStreamClass) OverrideTell(cb func(FileIOStream) int64) {
54		if cb == nil {	54		if cb == nil {
55		x.xTell = 0	55		x.xTell = 0

@@ -60,7 +60,7 @@ func (x FileIOStreamClass) OverrideTell(cb func(FileIOStream) int64) {
60		}	60		}
61		}	61		}
62			62
63	-	// GetTell gets the callback function.	63	+	// GetTell gets the "tell" callback function.
64		func (x FileIOStreamClass) GetTell() func(FileIOStream) int64 {	64		func (x FileIOStreamClass) GetTell() func(FileIOStream) int64 {
65		if x.xTell == 0 {	65		if x.xTell == 0 {
66		return nil	66		return nil

@@ -72,7 +72,7 @@ func (x FileIOStreamClass) GetTell() func(FileIOStream) int64 {
72		}	72		}
73		}	73		}
74			74
75	-	// OverrideCanSeek sets the callback function.	75	+	// OverrideCanSeek sets the "can_seek" callback function.
76		func (x FileIOStreamClass) OverrideCanSeek(cb func(FileIOStream) bool) {	76		func (x FileIOStreamClass) OverrideCanSeek(cb func(FileIOStream) bool) {
77		if cb == nil {	77		if cb == nil {
78		x.xCanSeek = 0	78		x.xCanSeek = 0

@@ -83,7 +83,7 @@ func (x FileIOStreamClass) OverrideCanSeek(cb func(FileIOStream) bool) {
83		}	83		}
84		}	84		}
85			85
86	-	// GetCanSeek gets the callback function.	86	+	// GetCanSeek gets the "can_seek" callback function.
87		func (x FileIOStreamClass) GetCanSeek() func(FileIOStream) bool {	87		func (x FileIOStreamClass) GetCanSeek() func(FileIOStream) bool {
88		if x.xCanSeek == 0 {	88		if x.xCanSeek == 0 {
89		return nil	89		return nil

@@ -95,7 +95,7 @@ func (x FileIOStreamClass) GetCanSeek() func(FileIOStream) bool {
95		}	95		}
96		}	96		}
97			97
98	-	// OverrideSeek sets the callback function.	98	+	// OverrideSeek sets the "seek" callback function.
99		func (x FileIOStreamClass) OverrideSeek(cb func(FileIOStream, int64, glib.SeekType, *Cancellable) bool) {	99		func (x FileIOStreamClass) OverrideSeek(cb func(FileIOStream, int64, glib.SeekType, *Cancellable) bool) {
100		if cb == nil {	100		if cb == nil {
101		x.xSeek = 0	101		x.xSeek = 0

@@ -106,7 +106,7 @@ func (x FileIOStreamClass) OverrideSeek(cb func(FileIOStream, int64, glib.Seek
106		}	106		}
107		}	107		}
108			108
109	-	// GetSeek gets the callback function.	109	+	// GetSeek gets the "seek" callback function.
110		func (x FileIOStreamClass) GetSeek() func(FileIOStream, int64, glib.SeekType, *Cancellable) bool {	110		func (x FileIOStreamClass) GetSeek() func(FileIOStream, int64, glib.SeekType, *Cancellable) bool {
111		if x.xSeek == 0 {	111		if x.xSeek == 0 {
112		return nil	112		return nil

@@ -118,7 +118,7 @@ func (x FileIOStreamClass) GetSeek() func(FileIOStream, int64, glib.SeekType,
118		}	118		}
119		}	119		}
120			120
121	-	// OverrideCanTruncate sets the callback function.	121	+	// OverrideCanTruncate sets the "can_truncate" callback function.
122		func (x FileIOStreamClass) OverrideCanTruncate(cb func(FileIOStream) bool) {	122		func (x FileIOStreamClass) OverrideCanTruncate(cb func(FileIOStream) bool) {
123		if cb == nil {	123		if cb == nil {
124		x.xCanTruncate = 0	124		x.xCanTruncate = 0

@@ -129,7 +129,7 @@ func (x FileIOStreamClass) OverrideCanTruncate(cb func(FileIOStream) bool) {
129		}	129		}
130		}	130		}
131			131
132	-	// GetCanTruncate gets the callback function.	132	+	// GetCanTruncate gets the "can_truncate" callback function.
133		func (x FileIOStreamClass) GetCanTruncate() func(FileIOStream) bool {	133		func (x FileIOStreamClass) GetCanTruncate() func(FileIOStream) bool {
134		if x.xCanTruncate == 0 {	134		if x.xCanTruncate == 0 {
135		return nil	135		return nil

@@ -141,7 +141,7 @@ func (x FileIOStreamClass) GetCanTruncate() func(FileIOStream) bool {
141		}	141		}
142		}	142		}
143			143
144	-	// OverrideTruncateFn sets the callback function.	144	+	// OverrideTruncateFn sets the "truncate_fn" callback function.
145		func (x FileIOStreamClass) OverrideTruncateFn(cb func(FileIOStream, int64, *Cancellable) bool) {	145		func (x FileIOStreamClass) OverrideTruncateFn(cb func(FileIOStream, int64, *Cancellable) bool) {
146		if cb == nil {	146		if cb == nil {
147		x.xTruncateFn = 0	147		x.xTruncateFn = 0

@@ -152,7 +152,7 @@ func (x FileIOStreamClass) OverrideTruncateFn(cb func(FileIOStream, int64, *Ca
152		}	152		}
153		}	153		}
154			154
155	-	// GetTruncateFn gets the callback function.	155	+	// GetTruncateFn gets the "truncate_fn" callback function.
156		func (x FileIOStreamClass) GetTruncateFn() func(FileIOStream, int64, *Cancellable) bool {	156		func (x FileIOStreamClass) GetTruncateFn() func(FileIOStream, int64, *Cancellable) bool {
157		if x.xTruncateFn == 0 {	157		if x.xTruncateFn == 0 {
158		return nil	158		return nil

@@ -164,7 +164,7 @@ func (x FileIOStreamClass) GetTruncateFn() func(FileIOStream, int64, *Cancella
164		}	164		}
165		}	165		}
166			166
167	-	// OverrideQueryInfo sets the callback function.	167	+	// OverrideQueryInfo sets the "query_info" callback function.
168		func (x FileIOStreamClass) OverrideQueryInfo(cb func(FileIOStream, string, Cancellable) FileInfo) {	168		func (x FileIOStreamClass) OverrideQueryInfo(cb func(FileIOStream, string, Cancellable) FileInfo) {
169		if cb == nil {	169		if cb == nil {
170		x.xQueryInfo = 0	170		x.xQueryInfo = 0

@@ -179,7 +179,7 @@ func (x FileIOStreamClass) OverrideQueryInfo(cb func(FileIOStream, string, *Ca
179		}	179		}
180		}	180		}
181			181
182	-	// GetQueryInfo gets the callback function.	182	+	// GetQueryInfo gets the "query_info" callback function.
183		func (x FileIOStreamClass) GetQueryInfo() func(FileIOStream, string, Cancellable) FileInfo {	183		func (x FileIOStreamClass) GetQueryInfo() func(FileIOStream, string, Cancellable) FileInfo {
184		if x.xQueryInfo == 0 {	184		if x.xQueryInfo == 0 {
185		return nil	185		return nil

@@ -197,7 +197,7 @@ func (x FileIOStreamClass) GetQueryInfo() func(FileIOStream, string, *Cancella
197		}	197		}
198		}	198		}
199			199
200	-	// OverrideQueryInfoAsync sets the callback function.	200	+	// OverrideQueryInfoAsync sets the "query_info_async" callback function.
201		func (x FileIOStreamClass) OverrideQueryInfoAsync(cb func(FileIOStream, string, int, Cancellable, AsyncReadyCallback, uintptr)) {	201		func (x FileIOStreamClass) OverrideQueryInfoAsync(cb func(FileIOStream, string, int, Cancellable, AsyncReadyCallback, uintptr)) {
202		if cb == nil {	202		if cb == nil {
203		x.xQueryInfoAsync = 0	203		x.xQueryInfoAsync = 0

@@ -208,7 +208,7 @@ func (x FileIOStreamClass) OverrideQueryInfoAsync(cb func(FileIOStream, string
208		}	208		}
209		}	209		}
210			210
211	-	// GetQueryInfoAsync gets the callback function.	211	+	// GetQueryInfoAsync gets the "query_info_async" callback function.
212		func (x FileIOStreamClass) GetQueryInfoAsync() func(FileIOStream, string, int, Cancellable, AsyncReadyCallback, uintptr) {	212		func (x FileIOStreamClass) GetQueryInfoAsync() func(FileIOStream, string, int, Cancellable, AsyncReadyCallback, uintptr) {
213		if x.xQueryInfoAsync == 0 {	213		if x.xQueryInfoAsync == 0 {
214		return nil	214		return nil

@@ -220,7 +220,7 @@ func (x FileIOStreamClass) GetQueryInfoAsync() func(FileIOStream, string, int,
220		}	220		}
221		}	221		}
222			222
223	-	// OverrideQueryInfoFinish sets the callback function.	223	+	// OverrideQueryInfoFinish sets the "query_info_finish" callback function.
224		func (x FileIOStreamClass) OverrideQueryInfoFinish(cb func(FileIOStream, AsyncResult) *FileInfo) {	224		func (x FileIOStreamClass) OverrideQueryInfoFinish(cb func(FileIOStream, AsyncResult) *FileInfo) {
225		if cb == nil {	225		if cb == nil {
226		x.xQueryInfoFinish = 0	226		x.xQueryInfoFinish = 0

@@ -235,7 +235,7 @@ func (x FileIOStreamClass) OverrideQueryInfoFinish(cb func(FileIOStream, Async
235		}	235		}
236		}	236		}
237			237
238	-	// GetQueryInfoFinish gets the callback function.	238	+	// GetQueryInfoFinish gets the "query_info_finish" callback function.
239		func (x FileIOStreamClass) GetQueryInfoFinish() func(FileIOStream, AsyncResult) *FileInfo {	239		func (x FileIOStreamClass) GetQueryInfoFinish() func(FileIOStream, AsyncResult) *FileInfo {
240		if x.xQueryInfoFinish == 0 {	240		if x.xQueryInfoFinish == 0 {
241		return nil	241		return nil

@@ -253,7 +253,7 @@ func (x FileIOStreamClass) GetQueryInfoFinish() func(FileIOStream, AsyncResult
253		}	253		}
254		}	254		}
255			255
256	-	// OverrideGetEtag sets the callback function.	256	+	// OverrideGetEtag sets the "get_etag" callback function.
257		func (x FileIOStreamClass) OverrideGetEtag(cb func(FileIOStream) string) {	257		func (x FileIOStreamClass) OverrideGetEtag(cb func(FileIOStream) string) {
258		if cb == nil {	258		if cb == nil {
259		x.xGetEtag = 0	259		x.xGetEtag = 0

@@ -264,7 +264,7 @@ func (x FileIOStreamClass) OverrideGetEtag(cb func(FileIOStream) string) {
264		}	264		}
265		}	265		}
266			266
267	-	// GetGetEtag gets the callback function.	267	+	// GetGetEtag gets the "get_etag" callback function.
268		func (x FileIOStreamClass) GetGetEtag() func(FileIOStream) string {	268		func (x FileIOStreamClass) GetGetEtag() func(FileIOStream) string {
269		if x.xGetEtag == 0 {	269		if x.xGetEtag == 0 {
270		return nil	270		return nil

@@ -276,7 +276,7 @@ func (x FileIOStreamClass) GetGetEtag() func(FileIOStream) string {
276		}	276		}
277		}	277		}
278			278
279	-	// OverrideGReserved1 sets the callback function.	279	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
280		func (x *FileIOStreamClass) OverrideGReserved1(cb func()) {	280		func (x *FileIOStreamClass) OverrideGReserved1(cb func()) {
281		if cb == nil {	281		if cb == nil {
282		x.xGReserved1 = 0	282		x.xGReserved1 = 0

@@ -287,7 +287,7 @@ func (x *FileIOStreamClass) OverrideGReserved1(cb func()) {
287		}	287		}
288		}	288		}
289			289
290	-	// GetGReserved1 gets the callback function.	290	+	// GetGReserved1 gets the "_g_reserved1" callback function.
291		func (x *FileIOStreamClass) GetGReserved1() func() {	291		func (x *FileIOStreamClass) GetGReserved1() func() {
292		if x.xGReserved1 == 0 {	292		if x.xGReserved1 == 0 {
293		return nil	293		return nil

@@ -299,7 +299,7 @@ func (x *FileIOStreamClass) GetGReserved1() func() {
299		}	299		}
300		}	300		}
301			301
302	-	// OverrideGReserved2 sets the callback function.	302	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
303		func (x *FileIOStreamClass) OverrideGReserved2(cb func()) {	303		func (x *FileIOStreamClass) OverrideGReserved2(cb func()) {
304		if cb == nil {	304		if cb == nil {
305		x.xGReserved2 = 0	305		x.xGReserved2 = 0

@@ -310,7 +310,7 @@ func (x *FileIOStreamClass) OverrideGReserved2(cb func()) {
310		}	310		}
311		}	311		}
312			312
313	-	// GetGReserved2 gets the callback function.	313	+	// GetGReserved2 gets the "_g_reserved2" callback function.
314		func (x *FileIOStreamClass) GetGReserved2() func() {	314		func (x *FileIOStreamClass) GetGReserved2() func() {
315		if x.xGReserved2 == 0 {	315		if x.xGReserved2 == 0 {
316		return nil	316		return nil

@@ -322,7 +322,7 @@ func (x *FileIOStreamClass) GetGReserved2() func() {
322		}	322		}
323		}	323		}
324			324
325	-	// OverrideGReserved3 sets the callback function.	325	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
326		func (x *FileIOStreamClass) OverrideGReserved3(cb func()) {	326		func (x *FileIOStreamClass) OverrideGReserved3(cb func()) {
327		if cb == nil {	327		if cb == nil {
328		x.xGReserved3 = 0	328		x.xGReserved3 = 0

@@ -333,7 +333,7 @@ func (x *FileIOStreamClass) OverrideGReserved3(cb func()) {
333		}	333		}
334		}	334		}
335			335
336	-	// GetGReserved3 gets the callback function.	336	+	// GetGReserved3 gets the "_g_reserved3" callback function.
337		func (x *FileIOStreamClass) GetGReserved3() func() {	337		func (x *FileIOStreamClass) GetGReserved3() func() {
338		if x.xGReserved3 == 0 {	338		if x.xGReserved3 == 0 {
339		return nil	339		return nil

@@ -345,7 +345,7 @@ func (x *FileIOStreamClass) GetGReserved3() func() {
345		}	345		}
346		}	346		}
347			347
348	-	// OverrideGReserved4 sets the callback function.	348	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
349		func (x *FileIOStreamClass) OverrideGReserved4(cb func()) {	349		func (x *FileIOStreamClass) OverrideGReserved4(cb func()) {
350		if cb == nil {	350		if cb == nil {
351		x.xGReserved4 = 0	351		x.xGReserved4 = 0

@@ -356,7 +356,7 @@ func (x *FileIOStreamClass) OverrideGReserved4(cb func()) {
356		}	356		}
357		}	357		}
358			358
359	-	// GetGReserved4 gets the callback function.	359	+	// GetGReserved4 gets the "_g_reserved4" callback function.
360		func (x *FileIOStreamClass) GetGReserved4() func() {	360		func (x *FileIOStreamClass) GetGReserved4() func() {
361		if x.xGReserved4 == 0 {	361		if x.xGReserved4 == 0 {
362		return nil	362		return nil

@@ -368,7 +368,7 @@ func (x *FileIOStreamClass) GetGReserved4() func() {
368		}	368		}
369		}	369		}
370			370
371	-	// OverrideGReserved5 sets the callback function.	371	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
372		func (x *FileIOStreamClass) OverrideGReserved5(cb func()) {	372		func (x *FileIOStreamClass) OverrideGReserved5(cb func()) {
373		if cb == nil {	373		if cb == nil {
374		x.xGReserved5 = 0	374		x.xGReserved5 = 0

@@ -379,7 +379,7 @@ func (x *FileIOStreamClass) OverrideGReserved5(cb func()) {
379		}	379		}
380		}	380		}
381			381
382	-	// GetGReserved5 gets the callback function.	382	+	// GetGReserved5 gets the "_g_reserved5" callback function.
383		func (x *FileIOStreamClass) GetGReserved5() func() {	383		func (x *FileIOStreamClass) GetGReserved5() func() {
384		if x.xGReserved5 == 0 {	384		if x.xGReserved5 == 0 {
385		return nil	385		return nil

M v4/gio/gfilemonitor.go +39 -14

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideChanged sets the callback function.
+// OverrideChanged sets the "changed" callback function.
 func (x *FileMonitorClass) OverrideChanged(cb func(*FileMonitor, File, File, FileMonitorEvent)) {
 	if cb == nil {
 		x.xChanged = 0
 	}
 }
-// GetChanged gets the callback function.
+// GetChanged gets the "changed" callback function.
 func (x *FileMonitorClass) GetChanged() func(*FileMonitor, File, File, FileMonitorEvent) {
 	if x.xChanged == 0 {
 		return nil
 	}
 }
-// OverrideCancel sets the callback function.
+// OverrideCancel sets the "cancel" callback function.
 func (x *FileMonitorClass) OverrideCancel(cb func(*FileMonitor) bool) {
 	if cb == nil {
 		x.xCancel = 0
 	}
 }
-// GetCancel gets the callback function.
+// GetCancel gets the "cancel" callback function.
 func (x *FileMonitorClass) GetCancel() func(*FileMonitor) bool {
 	if x.xCancel == 0 {
 		return nil
 	}
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *FileMonitorClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *FileMonitorClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *FileMonitorClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *FileMonitorClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *FileMonitorClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *FileMonitorClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *FileMonitorClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *FileMonitorClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *FileMonitorClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *FileMonitorClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// GetPropertyCancelled gets the "cancelled" property.
+// Whether the monitor has been cancelled.
+func (x *FileMonitor) GetPropertyCancelled() bool {
+	var v gobject.Value
+	x.GetProperty("cancelled", &v)
+	return v.GetBoolean()
+}
+// SetPropertyRateLimit sets the "rate-limit" property.
+// The limit of the monitor to watch for changes, in milliseconds.
+func (x *FileMonitor) SetPropertyRateLimit(value int) {
+	var v gobject.Value
+	v.Init(gobject.TypeIntVal)
+	v.SetInt(value)
+	x.SetProperty("rate-limit", &v)
+}
+// GetPropertyRateLimit gets the "rate-limit" property.
+// The limit of the monitor to watch for changes, in milliseconds.
+func (x *FileMonitor) GetPropertyRateLimit() int {
+	var v gobject.Value
+	x.GetProperty("rate-limit", &v)
+	return v.GetInt()
+}
 // Emitted when @file has been changed.
 //
 // If using %G_FILE_MONITOR_WATCH_MOVES on a directory monitor, and

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


@@ -30,7 +30,7 @@ func (x *FilenameCompleterClass) GoPointer() uintptr {
30		return uintptr(unsafe.Pointer(x))	30		return uintptr(unsafe.Pointer(x))
31		}	31		}
32			32
33	-	// OverrideGotCompletionData sets the callback function.	33	+	// OverrideGotCompletionData sets the "got_completion_data" callback function.
34		func (x FilenameCompleterClass) OverrideGotCompletionData(cb func(FilenameCompleter)) {	34		func (x FilenameCompleterClass) OverrideGotCompletionData(cb func(FilenameCompleter)) {
35		if cb == nil {	35		if cb == nil {
36		x.xGotCompletionData = 0	36		x.xGotCompletionData = 0

@@ -41,7 +41,7 @@ func (x FilenameCompleterClass) OverrideGotCompletionData(cb func(FilenameComp
41		}	41		}
42		}	42		}
43			43
44	-	// GetGotCompletionData gets the callback function.	44	+	// GetGotCompletionData gets the "got_completion_data" callback function.
45		func (x FilenameCompleterClass) GetGotCompletionData() func(FilenameCompleter) {	45		func (x FilenameCompleterClass) GetGotCompletionData() func(FilenameCompleter) {
46		if x.xGotCompletionData == 0 {	46		if x.xGotCompletionData == 0 {
47		return nil	47		return nil

@@ -53,7 +53,7 @@ func (x FilenameCompleterClass) GetGotCompletionData() func(FilenameCompleter)
53		}	53		}
54		}	54		}
55			55
56	-	// OverrideGReserved1 sets the callback function.	56	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
57		func (x *FilenameCompleterClass) OverrideGReserved1(cb func()) {	57		func (x *FilenameCompleterClass) OverrideGReserved1(cb func()) {
58		if cb == nil {	58		if cb == nil {
59		x.xGReserved1 = 0	59		x.xGReserved1 = 0

@@ -64,7 +64,7 @@ func (x *FilenameCompleterClass) OverrideGReserved1(cb func()) {
64		}	64		}
65		}	65		}
66			66
67	-	// GetGReserved1 gets the callback function.	67	+	// GetGReserved1 gets the "_g_reserved1" callback function.
68		func (x *FilenameCompleterClass) GetGReserved1() func() {	68		func (x *FilenameCompleterClass) GetGReserved1() func() {
69		if x.xGReserved1 == 0 {	69		if x.xGReserved1 == 0 {
70		return nil	70		return nil

@@ -76,7 +76,7 @@ func (x *FilenameCompleterClass) GetGReserved1() func() {
76		}	76		}
77		}	77		}
78			78
79	-	// OverrideGReserved2 sets the callback function.	79	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
80		func (x *FilenameCompleterClass) OverrideGReserved2(cb func()) {	80		func (x *FilenameCompleterClass) OverrideGReserved2(cb func()) {
81		if cb == nil {	81		if cb == nil {
82		x.xGReserved2 = 0	82		x.xGReserved2 = 0

@@ -87,7 +87,7 @@ func (x *FilenameCompleterClass) OverrideGReserved2(cb func()) {
87		}	87		}
88		}	88		}
89			89
90	-	// GetGReserved2 gets the callback function.	90	+	// GetGReserved2 gets the "_g_reserved2" callback function.
91		func (x *FilenameCompleterClass) GetGReserved2() func() {	91		func (x *FilenameCompleterClass) GetGReserved2() func() {
92		if x.xGReserved2 == 0 {	92		if x.xGReserved2 == 0 {
93		return nil	93		return nil

@@ -99,7 +99,7 @@ func (x *FilenameCompleterClass) GetGReserved2() func() {
99		}	99		}
100		}	100		}
101			101
102	-	// OverrideGReserved3 sets the callback function.	102	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
103		func (x *FilenameCompleterClass) OverrideGReserved3(cb func()) {	103		func (x *FilenameCompleterClass) OverrideGReserved3(cb func()) {
104		if cb == nil {	104		if cb == nil {
105		x.xGReserved3 = 0	105		x.xGReserved3 = 0

@@ -110,7 +110,7 @@ func (x *FilenameCompleterClass) OverrideGReserved3(cb func()) {
110		}	110		}
111		}	111		}
112			112
113	-	// GetGReserved3 gets the callback function.	113	+	// GetGReserved3 gets the "_g_reserved3" callback function.
114		func (x *FilenameCompleterClass) GetGReserved3() func() {	114		func (x *FilenameCompleterClass) GetGReserved3() func() {
115		if x.xGReserved3 == 0 {	115		if x.xGReserved3 == 0 {
116		return nil	116		return nil

M v4/gio/gfileoutputstream.go +28 -28


@@ -49,7 +49,7 @@ func (x *FileOutputStreamClass) GoPointer() uintptr {
49		return uintptr(unsafe.Pointer(x))	49		return uintptr(unsafe.Pointer(x))
50		}	50		}
51			51
52	-	// OverrideTell sets the callback function.	52	+	// OverrideTell sets the "tell" callback function.
53		func (x FileOutputStreamClass) OverrideTell(cb func(FileOutputStream) int64) {	53		func (x FileOutputStreamClass) OverrideTell(cb func(FileOutputStream) int64) {
54		if cb == nil {	54		if cb == nil {
55		x.xTell = 0	55		x.xTell = 0

@@ -60,7 +60,7 @@ func (x FileOutputStreamClass) OverrideTell(cb func(FileOutputStream) int64) {
60		}	60		}
61		}	61		}
62			62
63	-	// GetTell gets the callback function.	63	+	// GetTell gets the "tell" callback function.
64		func (x FileOutputStreamClass) GetTell() func(FileOutputStream) int64 {	64		func (x FileOutputStreamClass) GetTell() func(FileOutputStream) int64 {
65		if x.xTell == 0 {	65		if x.xTell == 0 {
66		return nil	66		return nil

@@ -72,7 +72,7 @@ func (x FileOutputStreamClass) GetTell() func(FileOutputStream) int64 {
72		}	72		}
73		}	73		}
74			74
75	-	// OverrideCanSeek sets the callback function.	75	+	// OverrideCanSeek sets the "can_seek" callback function.
76		func (x FileOutputStreamClass) OverrideCanSeek(cb func(FileOutputStream) bool) {	76		func (x FileOutputStreamClass) OverrideCanSeek(cb func(FileOutputStream) bool) {
77		if cb == nil {	77		if cb == nil {
78		x.xCanSeek = 0	78		x.xCanSeek = 0

@@ -83,7 +83,7 @@ func (x FileOutputStreamClass) OverrideCanSeek(cb func(FileOutputStream) bool)
83		}	83		}
84		}	84		}
85			85
86	-	// GetCanSeek gets the callback function.	86	+	// GetCanSeek gets the "can_seek" callback function.
87		func (x FileOutputStreamClass) GetCanSeek() func(FileOutputStream) bool {	87		func (x FileOutputStreamClass) GetCanSeek() func(FileOutputStream) bool {
88		if x.xCanSeek == 0 {	88		if x.xCanSeek == 0 {
89		return nil	89		return nil

@@ -95,7 +95,7 @@ func (x FileOutputStreamClass) GetCanSeek() func(FileOutputStream) bool {
95		}	95		}
96		}	96		}
97			97
98	-	// OverrideSeek sets the callback function.	98	+	// OverrideSeek sets the "seek" callback function.
99		func (x FileOutputStreamClass) OverrideSeek(cb func(FileOutputStream, int64, glib.SeekType, *Cancellable) bool) {	99		func (x FileOutputStreamClass) OverrideSeek(cb func(FileOutputStream, int64, glib.SeekType, *Cancellable) bool) {
100		if cb == nil {	100		if cb == nil {
101		x.xSeek = 0	101		x.xSeek = 0

@@ -106,7 +106,7 @@ func (x FileOutputStreamClass) OverrideSeek(cb func(FileOutputStream, int64, g
106		}	106		}
107		}	107		}
108			108
109	-	// GetSeek gets the callback function.	109	+	// GetSeek gets the "seek" callback function.
110		func (x FileOutputStreamClass) GetSeek() func(FileOutputStream, int64, glib.SeekType, *Cancellable) bool {	110		func (x FileOutputStreamClass) GetSeek() func(FileOutputStream, int64, glib.SeekType, *Cancellable) bool {
111		if x.xSeek == 0 {	111		if x.xSeek == 0 {
112		return nil	112		return nil

@@ -118,7 +118,7 @@ func (x FileOutputStreamClass) GetSeek() func(FileOutputStream, int64, glib.Se
118		}	118		}
119		}	119		}
120			120
121	-	// OverrideCanTruncate sets the callback function.	121	+	// OverrideCanTruncate sets the "can_truncate" callback function.
122		func (x FileOutputStreamClass) OverrideCanTruncate(cb func(FileOutputStream) bool) {	122		func (x FileOutputStreamClass) OverrideCanTruncate(cb func(FileOutputStream) bool) {
123		if cb == nil {	123		if cb == nil {
124		x.xCanTruncate = 0	124		x.xCanTruncate = 0

@@ -129,7 +129,7 @@ func (x FileOutputStreamClass) OverrideCanTruncate(cb func(FileOutputStream) b
129		}	129		}
130		}	130		}
131			131
132	-	// GetCanTruncate gets the callback function.	132	+	// GetCanTruncate gets the "can_truncate" callback function.
133		func (x FileOutputStreamClass) GetCanTruncate() func(FileOutputStream) bool {	133		func (x FileOutputStreamClass) GetCanTruncate() func(FileOutputStream) bool {
134		if x.xCanTruncate == 0 {	134		if x.xCanTruncate == 0 {
135		return nil	135		return nil

@@ -141,7 +141,7 @@ func (x FileOutputStreamClass) GetCanTruncate() func(FileOutputStream) bool {
141		}	141		}
142		}	142		}
143			143
144	-	// OverrideTruncateFn sets the callback function.	144	+	// OverrideTruncateFn sets the "truncate_fn" callback function.
145		func (x FileOutputStreamClass) OverrideTruncateFn(cb func(FileOutputStream, int64, *Cancellable) bool) {	145		func (x FileOutputStreamClass) OverrideTruncateFn(cb func(FileOutputStream, int64, *Cancellable) bool) {
146		if cb == nil {	146		if cb == nil {
147		x.xTruncateFn = 0	147		x.xTruncateFn = 0

@@ -152,7 +152,7 @@ func (x FileOutputStreamClass) OverrideTruncateFn(cb func(FileOutputStream, in
152		}	152		}
153		}	153		}
154			154
155	-	// GetTruncateFn gets the callback function.	155	+	// GetTruncateFn gets the "truncate_fn" callback function.
156		func (x FileOutputStreamClass) GetTruncateFn() func(FileOutputStream, int64, *Cancellable) bool {	156		func (x FileOutputStreamClass) GetTruncateFn() func(FileOutputStream, int64, *Cancellable) bool {
157		if x.xTruncateFn == 0 {	157		if x.xTruncateFn == 0 {
158		return nil	158		return nil

@@ -164,7 +164,7 @@ func (x FileOutputStreamClass) GetTruncateFn() func(FileOutputStream, int64, *
164		}	164		}
165		}	165		}
166			166
167	-	// OverrideQueryInfo sets the callback function.	167	+	// OverrideQueryInfo sets the "query_info" callback function.
168		func (x FileOutputStreamClass) OverrideQueryInfo(cb func(FileOutputStream, string, Cancellable) FileInfo) {	168		func (x FileOutputStreamClass) OverrideQueryInfo(cb func(FileOutputStream, string, Cancellable) FileInfo) {
169		if cb == nil {	169		if cb == nil {
170		x.xQueryInfo = 0	170		x.xQueryInfo = 0

@@ -179,7 +179,7 @@ func (x FileOutputStreamClass) OverrideQueryInfo(cb func(FileOutputStream, str
179		}	179		}
180		}	180		}
181			181
182	-	// GetQueryInfo gets the callback function.	182	+	// GetQueryInfo gets the "query_info" callback function.
183		func (x FileOutputStreamClass) GetQueryInfo() func(FileOutputStream, string, Cancellable) FileInfo {	183		func (x FileOutputStreamClass) GetQueryInfo() func(FileOutputStream, string, Cancellable) FileInfo {
184		if x.xQueryInfo == 0 {	184		if x.xQueryInfo == 0 {
185		return nil	185		return nil

@@ -197,7 +197,7 @@ func (x FileOutputStreamClass) GetQueryInfo() func(FileOutputStream, string, *
197		}	197		}
198		}	198		}
199			199
200	-	// OverrideQueryInfoAsync sets the callback function.	200	+	// OverrideQueryInfoAsync sets the "query_info_async" callback function.
201		func (x FileOutputStreamClass) OverrideQueryInfoAsync(cb func(FileOutputStream, string, int, Cancellable, AsyncReadyCallback, uintptr)) {	201		func (x FileOutputStreamClass) OverrideQueryInfoAsync(cb func(FileOutputStream, string, int, Cancellable, AsyncReadyCallback, uintptr)) {
202		if cb == nil {	202		if cb == nil {
203		x.xQueryInfoAsync = 0	203		x.xQueryInfoAsync = 0

@@ -208,7 +208,7 @@ func (x FileOutputStreamClass) OverrideQueryInfoAsync(cb func(FileOutputStream
208		}	208		}
209		}	209		}
210			210
211	-	// GetQueryInfoAsync gets the callback function.	211	+	// GetQueryInfoAsync gets the "query_info_async" callback function.
212		func (x FileOutputStreamClass) GetQueryInfoAsync() func(FileOutputStream, string, int, Cancellable, AsyncReadyCallback, uintptr) {	212		func (x FileOutputStreamClass) GetQueryInfoAsync() func(FileOutputStream, string, int, Cancellable, AsyncReadyCallback, uintptr) {
213		if x.xQueryInfoAsync == 0 {	213		if x.xQueryInfoAsync == 0 {
214		return nil	214		return nil

@@ -220,7 +220,7 @@ func (x FileOutputStreamClass) GetQueryInfoAsync() func(FileOutputStream, stri
220		}	220		}
221		}	221		}
222			222
223	-	// OverrideQueryInfoFinish sets the callback function.	223	+	// OverrideQueryInfoFinish sets the "query_info_finish" callback function.
224		func (x FileOutputStreamClass) OverrideQueryInfoFinish(cb func(FileOutputStream, AsyncResult) *FileInfo) {	224		func (x FileOutputStreamClass) OverrideQueryInfoFinish(cb func(FileOutputStream, AsyncResult) *FileInfo) {
225		if cb == nil {	225		if cb == nil {
226		x.xQueryInfoFinish = 0	226		x.xQueryInfoFinish = 0

@@ -235,7 +235,7 @@ func (x FileOutputStreamClass) OverrideQueryInfoFinish(cb func(FileOutputStrea
235		}	235		}
236		}	236		}
237			237
238	-	// GetQueryInfoFinish gets the callback function.	238	+	// GetQueryInfoFinish gets the "query_info_finish" callback function.
239		func (x FileOutputStreamClass) GetQueryInfoFinish() func(FileOutputStream, AsyncResult) *FileInfo {	239		func (x FileOutputStreamClass) GetQueryInfoFinish() func(FileOutputStream, AsyncResult) *FileInfo {
240		if x.xQueryInfoFinish == 0 {	240		if x.xQueryInfoFinish == 0 {
241		return nil	241		return nil

@@ -253,7 +253,7 @@ func (x FileOutputStreamClass) GetQueryInfoFinish() func(FileOutputStream, Asy
253		}	253		}
254		}	254		}
255			255
256	-	// OverrideGetEtag sets the callback function.	256	+	// OverrideGetEtag sets the "get_etag" callback function.
257		func (x FileOutputStreamClass) OverrideGetEtag(cb func(FileOutputStream) string) {	257		func (x FileOutputStreamClass) OverrideGetEtag(cb func(FileOutputStream) string) {
258		if cb == nil {	258		if cb == nil {
259		x.xGetEtag = 0	259		x.xGetEtag = 0

@@ -264,7 +264,7 @@ func (x FileOutputStreamClass) OverrideGetEtag(cb func(FileOutputStream) strin
264		}	264		}
265		}	265		}
266			266
267	-	// GetGetEtag gets the callback function.	267	+	// GetGetEtag gets the "get_etag" callback function.
268		func (x FileOutputStreamClass) GetGetEtag() func(FileOutputStream) string {	268		func (x FileOutputStreamClass) GetGetEtag() func(FileOutputStream) string {
269		if x.xGetEtag == 0 {	269		if x.xGetEtag == 0 {
270		return nil	270		return nil

@@ -276,7 +276,7 @@ func (x FileOutputStreamClass) GetGetEtag() func(FileOutputStream) string {
276		}	276		}
277		}	277		}
278			278
279	-	// OverrideGReserved1 sets the callback function.	279	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
280		func (x *FileOutputStreamClass) OverrideGReserved1(cb func()) {	280		func (x *FileOutputStreamClass) OverrideGReserved1(cb func()) {
281		if cb == nil {	281		if cb == nil {
282		x.xGReserved1 = 0	282		x.xGReserved1 = 0

@@ -287,7 +287,7 @@ func (x *FileOutputStreamClass) OverrideGReserved1(cb func()) {
287		}	287		}
288		}	288		}
289			289
290	-	// GetGReserved1 gets the callback function.	290	+	// GetGReserved1 gets the "_g_reserved1" callback function.
291		func (x *FileOutputStreamClass) GetGReserved1() func() {	291		func (x *FileOutputStreamClass) GetGReserved1() func() {
292		if x.xGReserved1 == 0 {	292		if x.xGReserved1 == 0 {
293		return nil	293		return nil

@@ -299,7 +299,7 @@ func (x *FileOutputStreamClass) GetGReserved1() func() {
299		}	299		}
300		}	300		}
301			301
302	-	// OverrideGReserved2 sets the callback function.	302	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
303		func (x *FileOutputStreamClass) OverrideGReserved2(cb func()) {	303		func (x *FileOutputStreamClass) OverrideGReserved2(cb func()) {
304		if cb == nil {	304		if cb == nil {
305		x.xGReserved2 = 0	305		x.xGReserved2 = 0

@@ -310,7 +310,7 @@ func (x *FileOutputStreamClass) OverrideGReserved2(cb func()) {
310		}	310		}
311		}	311		}
312			312
313	-	// GetGReserved2 gets the callback function.	313	+	// GetGReserved2 gets the "_g_reserved2" callback function.
314		func (x *FileOutputStreamClass) GetGReserved2() func() {	314		func (x *FileOutputStreamClass) GetGReserved2() func() {
315		if x.xGReserved2 == 0 {	315		if x.xGReserved2 == 0 {
316		return nil	316		return nil

@@ -322,7 +322,7 @@ func (x *FileOutputStreamClass) GetGReserved2() func() {
322		}	322		}
323		}	323		}
324			324
325	-	// OverrideGReserved3 sets the callback function.	325	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
326		func (x *FileOutputStreamClass) OverrideGReserved3(cb func()) {	326		func (x *FileOutputStreamClass) OverrideGReserved3(cb func()) {
327		if cb == nil {	327		if cb == nil {
328		x.xGReserved3 = 0	328		x.xGReserved3 = 0

@@ -333,7 +333,7 @@ func (x *FileOutputStreamClass) OverrideGReserved3(cb func()) {
333		}	333		}
334		}	334		}
335			335
336	-	// GetGReserved3 gets the callback function.	336	+	// GetGReserved3 gets the "_g_reserved3" callback function.
337		func (x *FileOutputStreamClass) GetGReserved3() func() {	337		func (x *FileOutputStreamClass) GetGReserved3() func() {
338		if x.xGReserved3 == 0 {	338		if x.xGReserved3 == 0 {
339		return nil	339		return nil

@@ -345,7 +345,7 @@ func (x *FileOutputStreamClass) GetGReserved3() func() {
345		}	345		}
346		}	346		}
347			347
348	-	// OverrideGReserved4 sets the callback function.	348	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
349		func (x *FileOutputStreamClass) OverrideGReserved4(cb func()) {	349		func (x *FileOutputStreamClass) OverrideGReserved4(cb func()) {
350		if cb == nil {	350		if cb == nil {
351		x.xGReserved4 = 0	351		x.xGReserved4 = 0

@@ -356,7 +356,7 @@ func (x *FileOutputStreamClass) OverrideGReserved4(cb func()) {
356		}	356		}
357		}	357		}
358			358
359	-	// GetGReserved4 gets the callback function.	359	+	// GetGReserved4 gets the "_g_reserved4" callback function.
360		func (x *FileOutputStreamClass) GetGReserved4() func() {	360		func (x *FileOutputStreamClass) GetGReserved4() func() {
361		if x.xGReserved4 == 0 {	361		if x.xGReserved4 == 0 {
362		return nil	362		return nil

@@ -368,7 +368,7 @@ func (x *FileOutputStreamClass) GetGReserved4() func() {
368		}	368		}
369		}	369		}
370			370
371	-	// OverrideGReserved5 sets the callback function.	371	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
372		func (x *FileOutputStreamClass) OverrideGReserved5(cb func()) {	372		func (x *FileOutputStreamClass) OverrideGReserved5(cb func()) {
373		if cb == nil {	373		if cb == nil {
374		x.xGReserved5 = 0	374		x.xGReserved5 = 0

@@ -379,7 +379,7 @@ func (x *FileOutputStreamClass) OverrideGReserved5(cb func()) {
379		}	379		}
380		}	380		}
381			381
382	-	// GetGReserved5 gets the callback function.	382	+	// GetGReserved5 gets the "_g_reserved5" callback function.
383		func (x *FileOutputStreamClass) GetGReserved5() func() {	383		func (x *FileOutputStreamClass) GetGReserved5() func() {
384		if x.xGReserved5 == 0 {	384		if x.xGReserved5 == 0 {
385		return nil	385		return nil

M v4/gio/gfilterinputstream.go +23 -6

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *FilterInputStreamClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *FilterInputStreamClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *FilterInputStreamClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *FilterInputStreamClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *FilterInputStreamClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *FilterInputStreamClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyCloseBaseStream sets the "close-base-stream" property.
+// Whether the base stream should be closed when the filter stream is closed.
+func (x *FilterInputStream) SetPropertyCloseBaseStream(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("close-base-stream", &v)
+}
+// GetPropertyCloseBaseStream gets the "close-base-stream" property.
+// Whether the base stream should be closed when the filter stream is closed.
+func (x *FilterInputStream) GetPropertyCloseBaseStream() bool {
+	var v gobject.Value
+	x.GetProperty("close-base-stream", &v)
+	return v.GetBoolean()
+}
 func init() {
 	core.SetPackageName("GIO", "gio-2.0")
 	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})

M v4/gio/gfilteroutputstream.go +23 -6

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *FilterOutputStreamClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *FilterOutputStreamClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *FilterOutputStreamClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *FilterOutputStreamClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *FilterOutputStreamClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *FilterOutputStreamClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyCloseBaseStream sets the "close-base-stream" property.
+// Whether the base stream should be closed when the filter stream is closed.
+func (x *FilterOutputStream) SetPropertyCloseBaseStream(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("close-base-stream", &v)
+}
+// GetPropertyCloseBaseStream gets the "close-base-stream" property.
+// Whether the base stream should be closed when the filter stream is closed.
+func (x *FilterOutputStream) GetPropertyCloseBaseStream() bool {
+	var v gobject.Value
+	x.GetProperty("close-base-stream", &v)
+	return v.GetBoolean()
+}
 func init() {
 	core.SetPackageName("GIO", "gio-2.0")
 	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})

M v4/gio/gicon.go +15 -15


@@ -34,7 +34,7 @@ func (x *IconIface) GoPointer() uintptr {
34		return uintptr(unsafe.Pointer(x))	34		return uintptr(unsafe.Pointer(x))
35		}	35		}
36			36
37	-	// OverrideHash sets the callback function.	37	+	// OverrideHash sets the "hash" callback function.
38		// A hash for a given #GIcon.	38		// A hash for a given #GIcon.
39		func (x *IconIface) OverrideHash(cb func(Icon) uint) {	39		func (x *IconIface) OverrideHash(cb func(Icon) uint) {
40		if cb == nil {	40		if cb == nil {

@@ -46,7 +46,7 @@ func (x *IconIface) OverrideHash(cb func(Icon) uint) {
46		}	46		}
47		}	47		}
48			48
49	-	// GetHash gets the callback function.	49	+	// GetHash gets the "hash" callback function.
50		// A hash for a given #GIcon.	50		// A hash for a given #GIcon.
51		func (x *IconIface) GetHash() func(Icon) uint {	51		func (x *IconIface) GetHash() func(Icon) uint {
52		if x.xHash == 0 {	52		if x.xHash == 0 {

@@ -59,7 +59,7 @@ func (x *IconIface) GetHash() func(Icon) uint {
59		}	59		}
60		}	60		}
61			61
62	-	// OverrideEqual sets the callback function.	62	+	// OverrideEqual sets the "equal" callback function.
63		// Checks if two #GIcons are equal.	63		// Checks if two #GIcons are equal.
64		func (x *IconIface) OverrideEqual(cb func(Icon, Icon) bool) {	64		func (x *IconIface) OverrideEqual(cb func(Icon, Icon) bool) {
65		if cb == nil {	65		if cb == nil {

@@ -71,7 +71,7 @@ func (x *IconIface) OverrideEqual(cb func(Icon, Icon) bool) {
71		}	71		}
72		}	72		}
73			73
74	-	// GetEqual gets the callback function.	74	+	// GetEqual gets the "equal" callback function.
75		// Checks if two #GIcons are equal.	75		// Checks if two #GIcons are equal.
76		func (x *IconIface) GetEqual() func(Icon, Icon) bool {	76		func (x *IconIface) GetEqual() func(Icon, Icon) bool {
77		if x.xEqual == 0 {	77		if x.xEqual == 0 {

@@ -84,36 +84,36 @@ func (x *IconIface) GetEqual() func(Icon, Icon) bool {
84		}	84		}
85		}	85		}
86			86
87	-	// OverrideToTokens sets the callback function.	87	+	// OverrideToTokens sets the "to_tokens" callback function.
88		// Serializes a #GIcon into tokens. The tokens must not	88		// Serializes a #GIcon into tokens. The tokens must not
89		// contain any whitespace. Don't implement if the #GIcon can't be	89		// contain any whitespace. Don't implement if the #GIcon can't be
90		// serialized (Since 2.20).	90		// serialized (Since 2.20).
91	-	func (x *IconIface) OverrideToTokens(cb func(Icon, []string, int) bool) {	91	+	func (x IconIface) OverrideToTokens(cb func(Icon, []string, *int) bool) {
92		if cb == nil {	92		if cb == nil {
93		x.xToTokens = 0	93		x.xToTokens = 0
94		} else {	94		} else {
95	-	x.xToTokens = purego.NewCallback(func(IconVarp uintptr, TokensVarp []string, OutVersionVarp int) bool {	95	+	x.xToTokens = purego.NewCallback(func(IconVarp uintptr, TokensVarp []string, OutVersionVarp int) bool {
96		return cb(&IconBase{Ptr: IconVarp}, TokensVarp, OutVersionVarp)	96		return cb(&IconBase{Ptr: IconVarp}, TokensVarp, OutVersionVarp)
97		})	97		})
98		}	98		}
99		}	99		}
100			100
101	-	// GetToTokens gets the callback function.	101	+	// GetToTokens gets the "to_tokens" callback function.
102		// Serializes a #GIcon into tokens. The tokens must not	102		// Serializes a #GIcon into tokens. The tokens must not
103		// contain any whitespace. Don't implement if the #GIcon can't be	103		// contain any whitespace. Don't implement if the #GIcon can't be
104		// serialized (Since 2.20).	104		// serialized (Since 2.20).
105	-	func (x *IconIface) GetToTokens() func(Icon, []string, int) bool {	105	+	func (x IconIface) GetToTokens() func(Icon, []string, *int) bool {
106		if x.xToTokens == 0 {	106		if x.xToTokens == 0 {
107		return nil	107		return nil
108		}	108		}
109	-	var rawCallback func(IconVarp uintptr, TokensVarp []string, OutVersionVarp int) bool	109	+	var rawCallback func(IconVarp uintptr, TokensVarp []string, OutVersionVarp int) bool
110		purego.RegisterFunc(&rawCallback, x.xToTokens)	110		purego.RegisterFunc(&rawCallback, x.xToTokens)
111	-	return func(IconVar Icon, TokensVar []string, OutVersionVar int) bool {	111	+	return func(IconVar Icon, TokensVar []string, OutVersionVar int) bool {
112		return rawCallback(IconVar.GoPointer(), TokensVar, OutVersionVar)	112		return rawCallback(IconVar.GoPointer(), TokensVar, OutVersionVar)
113		}	113		}
114		}	114		}
115			115
116	-	// OverrideFromTokens sets the callback function.	116	+	// OverrideFromTokens sets the "from_tokens" callback function.
117		// Constructs a #GIcon from tokens. Set the #GError if	117		// Constructs a #GIcon from tokens. Set the #GError if
118		// the tokens are malformed. Don't implement if the #GIcon can't be	118		// the tokens are malformed. Don't implement if the #GIcon can't be
119		// serialized (Since 2.20).	119		// serialized (Since 2.20).

@@ -131,7 +131,7 @@ func (x IconIface) OverrideFromTokens(cb func(string, int, int) IconBase) {
131		}	131		}
132		}	132		}
133			133
134	-	// GetFromTokens gets the callback function.	134	+	// GetFromTokens gets the "from_tokens" callback function.
135		// Constructs a #GIcon from tokens. Set the #GError if	135		// Constructs a #GIcon from tokens. Set the #GError if
136		// the tokens are malformed. Don't implement if the #GIcon can't be	136		// the tokens are malformed. Don't implement if the #GIcon can't be
137		// serialized (Since 2.20).	137		// serialized (Since 2.20).

@@ -152,7 +152,7 @@ func (x IconIface) GetFromTokens() func(string, int, int) IconBase {
152		}	152		}
153		}	153		}
154			154
155	-	// OverrideSerialize sets the callback function.	155	+	// OverrideSerialize sets the "serialize" callback function.
156		// Serializes a #GIcon into a #GVariant. Since: 2.38	156		// Serializes a #GIcon into a #GVariant. Since: 2.38
157		func (x IconIface) OverrideSerialize(cb func(Icon) glib.Variant) {	157		func (x IconIface) OverrideSerialize(cb func(Icon) glib.Variant) {
158		if cb == nil {	158		if cb == nil {

@@ -164,7 +164,7 @@ func (x IconIface) OverrideSerialize(cb func(Icon) glib.Variant) {
164		}	164		}
165		}	165		}
166			166
167	-	// GetSerialize gets the callback function.	167	+	// GetSerialize gets the "serialize" callback function.
168		// Serializes a #GIcon into a #GVariant. Since: 2.38	168		// Serializes a #GIcon into a #GVariant. Since: 2.38
169		func (x IconIface) GetSerialize() func(Icon) glib.Variant {	169		func (x IconIface) GetSerialize() func(Icon) glib.Variant {
170		if x.xSerialize == 0 {	170		if x.xSerialize == 0 {

M v4/gio/ginetaddress.go +149 -4


@@ -25,7 +25,7 @@ func (x *InetAddressClass) GoPointer() uintptr {
25		return uintptr(unsafe.Pointer(x))	25		return uintptr(unsafe.Pointer(x))
26		}	26		}
27			27
28	-	// OverrideToString sets the callback function.	28	+	// OverrideToString sets the "to_string" callback function.
29		func (x InetAddressClass) OverrideToString(cb func(InetAddress) string) {	29		func (x InetAddressClass) OverrideToString(cb func(InetAddress) string) {
30		if cb == nil {	30		if cb == nil {
31		x.xToString = 0	31		x.xToString = 0

@@ -36,7 +36,7 @@ func (x InetAddressClass) OverrideToString(cb func(InetAddress) string) {
36		}	36		}
37		}	37		}
38			38
39	-	// GetToString gets the callback function.	39	+	// GetToString gets the "to_string" callback function.
40		func (x InetAddressClass) GetToString() func(InetAddress) string {	40		func (x InetAddressClass) GetToString() func(InetAddress) string {
41		if x.xToString == 0 {	41		if x.xToString == 0 {
42		return nil	42		return nil

@@ -48,7 +48,7 @@ func (x InetAddressClass) GetToString() func(InetAddress) string {
48		}	48		}
49		}	49		}
50			50
51	-	// OverrideToBytes sets the callback function.	51	+	// OverrideToBytes sets the "to_bytes" callback function.
52		func (x InetAddressClass) OverrideToBytes(cb func(InetAddress) byte) {	52		func (x InetAddressClass) OverrideToBytes(cb func(InetAddress) byte) {
53		if cb == nil {	53		if cb == nil {
54		x.xToBytes = 0	54		x.xToBytes = 0

@@ -59,7 +59,7 @@ func (x InetAddressClass) OverrideToBytes(cb func(InetAddress) byte) {
59		}	59		}
60		}	60		}
61			61
62	-	// GetToBytes gets the callback function.	62	+	// GetToBytes gets the "to_bytes" callback function.
63		func (x InetAddressClass) GetToBytes() func(InetAddress) byte {	63		func (x InetAddressClass) GetToBytes() func(InetAddress) byte {
64		if x.xToBytes == 0 {	64		if x.xToBytes == 0 {
65		return nil	65		return nil

@@ -366,6 +366,151 @@ func (c *InetAddress) SetGoPointer(ptr uintptr) {
366		c.Ptr = ptr	366		c.Ptr = ptr
367		}	367		}
368			368
			369	+	// SetPropertyBytes sets the "bytes" property.
			370	+	// The raw address data.
			371	+	func (x *InetAddress) SetPropertyBytes(value uintptr) {
			372	+	var v gobject.Value
			373	+	v.Init(gobject.TypePointerVal)
			374	+	v.SetPointer(value)
			375	+	x.SetProperty("bytes", &v)
			376	+	}
			377	+
			378	+	// GetPropertyBytes gets the "bytes" property.
			379	+	// The raw address data.
			380	+	func (x *InetAddress) GetPropertyBytes() uintptr {
			381	+	var v gobject.Value
			382	+	x.GetProperty("bytes", &v)
			383	+	return v.GetPointer()
			384	+	}
			385	+
			386	+	// SetPropertyFlowinfo sets the "flowinfo" property.
			387	+	// The flowinfo for an IPv6 address.
			388	+	// See [method@Gio.InetAddress.get_flowinfo].
			389	+	func (x *InetAddress) SetPropertyFlowinfo(value uint) {
			390	+	var v gobject.Value
			391	+	v.Init(gobject.TypeUintVal)
			392	+	v.SetUint(value)
			393	+	x.SetProperty("flowinfo", &v)
			394	+	}
			395	+
			396	+	// GetPropertyFlowinfo gets the "flowinfo" property.
			397	+	// The flowinfo for an IPv6 address.
			398	+	// See [method@Gio.InetAddress.get_flowinfo].
			399	+	func (x *InetAddress) GetPropertyFlowinfo() uint {
			400	+	var v gobject.Value
			401	+	x.GetProperty("flowinfo", &v)
			402	+	return v.GetUint()
			403	+	}
			404	+
			405	+	// GetPropertyIsAny gets the "is-any" property.
			406	+	// Whether this is the "any" address for its family.
			407	+	// See g_inet_address_get_is_any().
			408	+	func (x *InetAddress) GetPropertyIsAny() bool {
			409	+	var v gobject.Value
			410	+	x.GetProperty("is-any", &v)
			411	+	return v.GetBoolean()
			412	+	}
			413	+
			414	+	// GetPropertyIsLinkLocal gets the "is-link-local" property.
			415	+	// Whether this is a link-local address.
			416	+	// See g_inet_address_get_is_link_local().
			417	+	func (x *InetAddress) GetPropertyIsLinkLocal() bool {
			418	+	var v gobject.Value
			419	+	x.GetProperty("is-link-local", &v)
			420	+	return v.GetBoolean()
			421	+	}
			422	+
			423	+	// GetPropertyIsLoopback gets the "is-loopback" property.
			424	+	// Whether this is the loopback address for its family.
			425	+	// See g_inet_address_get_is_loopback().
			426	+	func (x *InetAddress) GetPropertyIsLoopback() bool {
			427	+	var v gobject.Value
			428	+	x.GetProperty("is-loopback", &v)
			429	+	return v.GetBoolean()
			430	+	}
			431	+
			432	+	// GetPropertyIsMcGlobal gets the "is-mc-global" property.
			433	+	// Whether this is a global multicast address.
			434	+	// See g_inet_address_get_is_mc_global().
			435	+	func (x *InetAddress) GetPropertyIsMcGlobal() bool {
			436	+	var v gobject.Value
			437	+	x.GetProperty("is-mc-global", &v)
			438	+	return v.GetBoolean()
			439	+	}
			440	+
			441	+	// GetPropertyIsMcLinkLocal gets the "is-mc-link-local" property.
			442	+	// Whether this is a link-local multicast address.
			443	+	// See g_inet_address_get_is_mc_link_local().
			444	+	func (x *InetAddress) GetPropertyIsMcLinkLocal() bool {
			445	+	var v gobject.Value
			446	+	x.GetProperty("is-mc-link-local", &v)
			447	+	return v.GetBoolean()
			448	+	}
			449	+
			450	+	// GetPropertyIsMcNodeLocal gets the "is-mc-node-local" property.
			451	+	// Whether this is a node-local multicast address.
			452	+	// See g_inet_address_get_is_mc_node_local().
			453	+	func (x *InetAddress) GetPropertyIsMcNodeLocal() bool {
			454	+	var v gobject.Value
			455	+	x.GetProperty("is-mc-node-local", &v)
			456	+	return v.GetBoolean()
			457	+	}
			458	+
			459	+	// GetPropertyIsMcOrgLocal gets the "is-mc-org-local" property.
			460	+	// Whether this is an organization-local multicast address.
			461	+	// See g_inet_address_get_is_mc_org_local().
			462	+	func (x *InetAddress) GetPropertyIsMcOrgLocal() bool {
			463	+	var v gobject.Value
			464	+	x.GetProperty("is-mc-org-local", &v)
			465	+	return v.GetBoolean()
			466	+	}
			467	+
			468	+	// GetPropertyIsMcSiteLocal gets the "is-mc-site-local" property.
			469	+	// Whether this is a site-local multicast address.
			470	+	// See g_inet_address_get_is_mc_site_local().
			471	+	func (x *InetAddress) GetPropertyIsMcSiteLocal() bool {
			472	+	var v gobject.Value
			473	+	x.GetProperty("is-mc-site-local", &v)
			474	+	return v.GetBoolean()
			475	+	}
			476	+
			477	+	// GetPropertyIsMulticast gets the "is-multicast" property.
			478	+	// Whether this is a multicast address.
			479	+	// See g_inet_address_get_is_multicast().
			480	+	func (x *InetAddress) GetPropertyIsMulticast() bool {
			481	+	var v gobject.Value
			482	+	x.GetProperty("is-multicast", &v)
			483	+	return v.GetBoolean()
			484	+	}
			485	+
			486	+	// GetPropertyIsSiteLocal gets the "is-site-local" property.
			487	+	// Whether this is a site-local address.
			488	+	// See g_inet_address_get_is_loopback().
			489	+	func (x *InetAddress) GetPropertyIsSiteLocal() bool {
			490	+	var v gobject.Value
			491	+	x.GetProperty("is-site-local", &v)
			492	+	return v.GetBoolean()
			493	+	}
			494	+
			495	+	// SetPropertyScopeId sets the "scope-id" property.
			496	+	// The scope-id for an IPv6 address.
			497	+	// See [method@Gio.InetAddress.get_scope_id].
			498	+	func (x *InetAddress) SetPropertyScopeId(value uint) {
			499	+	var v gobject.Value
			500	+	v.Init(gobject.TypeUintVal)
			501	+	v.SetUint(value)
			502	+	x.SetProperty("scope-id", &v)
			503	+	}
			504	+
			505	+	// GetPropertyScopeId gets the "scope-id" property.
			506	+	// The scope-id for an IPv6 address.
			507	+	// See [method@Gio.InetAddress.get_scope_id].
			508	+	func (x *InetAddress) GetPropertyScopeId() uint {
			509	+	var v gobject.Value
			510	+	x.GetProperty("scope-id", &v)
			511	+	return v.GetUint()
			512	+	}
			513	+
369		func init() {	514		func init() {
370		core.SetPackageName("GIO", "gio-2.0")	515		core.SetPackageName("GIO", "gio-2.0")
371		core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})	516		core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})

M v4/gio/ginetaddressmask.go +17 -0


@@ -169,6 +169,23 @@ func (c *InetAddressMask) SetGoPointer(ptr uintptr) {
169	c.Ptr = ptr	169		c.Ptr = ptr
170	}	170		}
171		171
		172	+	// SetPropertyLength sets the "length" property.
		173	+	// The prefix length, in bytes.
		174	+	func (x *InetAddressMask) SetPropertyLength(value uint) {
		175	+	var v gobject.Value
		176	+	v.Init(gobject.TypeUintVal)
		177	+	v.SetUint(value)
		178	+	x.SetProperty("length", &v)
		179	+	}
		180	+
		181	+	// GetPropertyLength gets the "length" property.
		182	+	// The prefix length, in bytes.
		183	+	func (x *InetAddressMask) GetPropertyLength() uint {
		184	+	var v gobject.Value
		185	+	x.GetProperty("length", &v)
		186	+	return v.GetUint()
		187	+	}
		188	+
172	// Initializes the object implementing the interface.	189		// Initializes the object implementing the interface.
173	//	190		//
174	// This method is intended for language bindings. If writing in C,	191		// This method is intended for language bindings. If writing in C,

M v4/gio/ginetsocketaddress.go +59 -0


@@ -147,6 +147,65 @@ func (c *InetSocketAddress) SetGoPointer(ptr uintptr) {
147	c.Ptr = ptr	147		c.Ptr = ptr
148	}	148		}
149		149
		150	+	// SetPropertyFlowinfo sets the "flowinfo" property.
		151	+	// The `sin6_flowinfo` field, for IPv6 addresses.
		152	+	//
		153	+	// If unset this property is inherited from [property@Gio.InetSocketAddress:address].
		154	+	func (x *InetSocketAddress) SetPropertyFlowinfo(value uint) {
		155	+	var v gobject.Value
		156	+	v.Init(gobject.TypeUintVal)
		157	+	v.SetUint(value)
		158	+	x.SetProperty("flowinfo", &v)
		159	+	}
		160	+
		161	+	// GetPropertyFlowinfo gets the "flowinfo" property.
		162	+	// The `sin6_flowinfo` field, for IPv6 addresses.
		163	+	//
		164	+	// If unset this property is inherited from [property@Gio.InetSocketAddress:address].
		165	+	func (x *InetSocketAddress) GetPropertyFlowinfo() uint {
		166	+	var v gobject.Value
		167	+	x.GetProperty("flowinfo", &v)
		168	+	return v.GetUint()
		169	+	}
		170	+
		171	+	// SetPropertyPort sets the "port" property.
		172	+	// The port.
		173	+	func (x *InetSocketAddress) SetPropertyPort(value uint) {
		174	+	var v gobject.Value
		175	+	v.Init(gobject.TypeUintVal)
		176	+	v.SetUint(value)
		177	+	x.SetProperty("port", &v)
		178	+	}
		179	+
		180	+	// GetPropertyPort gets the "port" property.
		181	+	// The port.
		182	+	func (x *InetSocketAddress) GetPropertyPort() uint {
		183	+	var v gobject.Value
		184	+	x.GetProperty("port", &v)
		185	+	return v.GetUint()
		186	+	}
		187	+
		188	+	// SetPropertyScopeId sets the "scope-id" property.
		189	+	// The `sin6_scope_id` field, for IPv6 addresses.
		190	+	//
		191	+	// If unset this property is inherited from [property@Gio.InetSocketAddress:address].
		192	+	func (x *InetSocketAddress) SetPropertyScopeId(value uint) {
		193	+	var v gobject.Value
		194	+	v.Init(gobject.TypeUintVal)
		195	+	v.SetUint(value)
		196	+	x.SetProperty("scope-id", &v)
		197	+	}
		198	+
		199	+	// GetPropertyScopeId gets the "scope-id" property.
		200	+	// The `sin6_scope_id` field, for IPv6 addresses.
		201	+	//
		202	+	// If unset this property is inherited from [property@Gio.InetSocketAddress:address].
		203	+	func (x *InetSocketAddress) GetPropertyScopeId() uint {
		204	+	var v gobject.Value
		205	+	x.GetProperty("scope-id", &v)
		206	+	return v.GetUint()
		207	+	}
		208	+
150	// Creates a #GSocketAddressEnumerator for @connectable.	209		// Creates a #GSocketAddressEnumerator for @connectable.
151	func (x InetSocketAddress) Enumerate() SocketAddressEnumerator {	210		func (x InetSocketAddress) Enumerate() SocketAddressEnumerator {
152	var cls *SocketAddressEnumerator	211		var cls *SocketAddressEnumerator

M v4/gio/ginitable.go +2 -2


@@ -26,7 +26,7 @@ func (x *InitableIface) GoPointer() uintptr {
26		return uintptr(unsafe.Pointer(x))	26		return uintptr(unsafe.Pointer(x))
27		}	27		}
28			28
29	-	// OverrideInit sets the callback function.	29	+	// OverrideInit sets the "init" callback function.
30		// Initializes the object.	30		// Initializes the object.
31		func (x InitableIface) OverrideInit(cb func(Initable, Cancellable) bool) {	31		func (x InitableIface) OverrideInit(cb func(Initable, Cancellable) bool) {
32		if cb == nil {	32		if cb == nil {

@@ -38,7 +38,7 @@ func (x InitableIface) OverrideInit(cb func(Initable, Cancellable) bool) {
38		}	38		}
39		}	39		}
40			40
41	-	// GetInit gets the callback function.	41	+	// GetInit gets the "init" callback function.
42		// Initializes the object.	42		// Initializes the object.
43		func (x InitableIface) GetInit() func(Initable, Cancellable) bool {	43		func (x InitableIface) GetInit() func(Initable, Cancellable) bool {
44		if x.xInit == 0 {	44		if x.xInit == 0 {

M v4/gio/ginputstream.go +43 -43


@@ -50,7 +50,7 @@ func (x *InputStreamClass) GoPointer() uintptr {
50		return uintptr(unsafe.Pointer(x))	50		return uintptr(unsafe.Pointer(x))
51		}	51		}
52			52
53	-	// OverrideReadFn sets the callback function.	53	+	// OverrideReadFn sets the "read_fn" callback function.
54		func (x InputStreamClass) OverrideReadFn(cb func(InputStream, uintptr, uint, *Cancellable) int) {	54		func (x InputStreamClass) OverrideReadFn(cb func(InputStream, uintptr, uint, *Cancellable) int) {
55		if cb == nil {	55		if cb == nil {
56		x.xReadFn = 0	56		x.xReadFn = 0

@@ -61,7 +61,7 @@ func (x InputStreamClass) OverrideReadFn(cb func(InputStream, uintptr, uint, *
61		}	61		}
62		}	62		}
63			63
64	-	// GetReadFn gets the callback function.	64	+	// GetReadFn gets the "read_fn" callback function.
65		func (x InputStreamClass) GetReadFn() func(InputStream, uintptr, uint, *Cancellable) int {	65		func (x InputStreamClass) GetReadFn() func(InputStream, uintptr, uint, *Cancellable) int {
66		if x.xReadFn == 0 {	66		if x.xReadFn == 0 {
67		return nil	67		return nil

@@ -73,7 +73,7 @@ func (x InputStreamClass) GetReadFn() func(InputStream, uintptr, uint, *Cancel
73		}	73		}
74		}	74		}
75			75
76	-	// OverrideSkip sets the callback function.	76	+	// OverrideSkip sets the "skip" callback function.
77		func (x InputStreamClass) OverrideSkip(cb func(InputStream, uint, *Cancellable) int) {	77		func (x InputStreamClass) OverrideSkip(cb func(InputStream, uint, *Cancellable) int) {
78		if cb == nil {	78		if cb == nil {
79		x.xSkip = 0	79		x.xSkip = 0

@@ -84,7 +84,7 @@ func (x InputStreamClass) OverrideSkip(cb func(InputStream, uint, *Cancellable
84		}	84		}
85		}	85		}
86			86
87	-	// GetSkip gets the callback function.	87	+	// GetSkip gets the "skip" callback function.
88		func (x InputStreamClass) GetSkip() func(InputStream, uint, *Cancellable) int {	88		func (x InputStreamClass) GetSkip() func(InputStream, uint, *Cancellable) int {
89		if x.xSkip == 0 {	89		if x.xSkip == 0 {
90		return nil	90		return nil

@@ -96,7 +96,7 @@ func (x InputStreamClass) GetSkip() func(InputStream, uint, *Cancellable) int
96		}	96		}
97		}	97		}
98			98
99	-	// OverrideCloseFn sets the callback function.	99	+	// OverrideCloseFn sets the "close_fn" callback function.
100		func (x InputStreamClass) OverrideCloseFn(cb func(InputStream, *Cancellable) bool) {	100		func (x InputStreamClass) OverrideCloseFn(cb func(InputStream, *Cancellable) bool) {
101		if cb == nil {	101		if cb == nil {
102		x.xCloseFn = 0	102		x.xCloseFn = 0

@@ -107,7 +107,7 @@ func (x InputStreamClass) OverrideCloseFn(cb func(InputStream, *Cancellable) b
107		}	107		}
108		}	108		}
109			109
110	-	// GetCloseFn gets the callback function.	110	+	// GetCloseFn gets the "close_fn" callback function.
111		func (x InputStreamClass) GetCloseFn() func(InputStream, *Cancellable) bool {	111		func (x InputStreamClass) GetCloseFn() func(InputStream, *Cancellable) bool {
112		if x.xCloseFn == 0 {	112		if x.xCloseFn == 0 {
113		return nil	113		return nil

@@ -119,30 +119,30 @@ func (x InputStreamClass) GetCloseFn() func(InputStream, *Cancellable) bool {
119		}	119		}
120		}	120		}
121			121
122	-	// OverrideReadAsync sets the callback function.	122	+	// OverrideReadAsync sets the "read_async" callback function.
123	-	func (x InputStreamClass) OverrideReadAsync(cb func(InputStream, []byte, uint, int, Cancellable, AsyncReadyCallback, uintptr)) {	123	+	func (x InputStreamClass) OverrideReadAsync(cb func(InputStream, []byte, uint, int, Cancellable, *AsyncReadyCallback, uintptr)) {
124		if cb == nil {	124		if cb == nil {
125		x.xReadAsync = 0	125		x.xReadAsync = 0
126		} else {	126		} else {
127	-	x.xReadAsync = purego.NewCallback(func(StreamVarp uintptr, BufferVarp []byte, CountVarp uint, IoPriorityVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {	127	+	x.xReadAsync = purego.NewCallback(func(StreamVarp uintptr, BufferVarp *[]byte, CountVarp uint, IoPriorityVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
128		cb(InputStreamNewFromInternalPtr(StreamVarp), BufferVarp, CountVarp, IoPriorityVarp, CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)	128		cb(InputStreamNewFromInternalPtr(StreamVarp), BufferVarp, CountVarp, IoPriorityVarp, CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
129		})	129		})
130		}	130		}
131		}	131		}
132			132
133	-	// GetReadAsync gets the callback function.	133	+	// GetReadAsync gets the "read_async" callback function.
134	-	func (x InputStreamClass) GetReadAsync() func(InputStream, []byte, uint, int, Cancellable, AsyncReadyCallback, uintptr) {	134	+	func (x InputStreamClass) GetReadAsync() func(InputStream, []byte, uint, int, Cancellable, *AsyncReadyCallback, uintptr) {
135		if x.xReadAsync == 0 {	135		if x.xReadAsync == 0 {
136		return nil	136		return nil
137		}	137		}
138	-	var rawCallback func(StreamVarp uintptr, BufferVarp []byte, CountVarp uint, IoPriorityVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)	138	+	var rawCallback func(StreamVarp uintptr, BufferVarp *[]byte, CountVarp uint, IoPriorityVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
139		purego.RegisterFunc(&rawCallback, x.xReadAsync)	139		purego.RegisterFunc(&rawCallback, x.xReadAsync)
140	-	return func(StreamVar InputStream, BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	140	+	return func(StreamVar InputStream, BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
141		rawCallback(StreamVar.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	141		rawCallback(StreamVar.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
142		}	142		}
143		}	143		}
144			144
145	-	// OverrideReadFinish sets the callback function.	145	+	// OverrideReadFinish sets the "read_finish" callback function.
146		func (x InputStreamClass) OverrideReadFinish(cb func(InputStream, AsyncResult) int) {	146		func (x InputStreamClass) OverrideReadFinish(cb func(InputStream, AsyncResult) int) {
147		if cb == nil {	147		if cb == nil {
148		x.xReadFinish = 0	148		x.xReadFinish = 0

@@ -153,7 +153,7 @@ func (x InputStreamClass) OverrideReadFinish(cb func(InputStream, AsyncResult)
153		}	153		}
154		}	154		}
155			155
156	-	// GetReadFinish gets the callback function.	156	+	// GetReadFinish gets the "read_finish" callback function.
157		func (x InputStreamClass) GetReadFinish() func(InputStream, AsyncResult) int {	157		func (x InputStreamClass) GetReadFinish() func(InputStream, AsyncResult) int {
158		if x.xReadFinish == 0 {	158		if x.xReadFinish == 0 {
159		return nil	159		return nil

@@ -165,7 +165,7 @@ func (x InputStreamClass) GetReadFinish() func(InputStream, AsyncResult) int {
165		}	165		}
166		}	166		}
167			167
168	-	// OverrideSkipAsync sets the callback function.	168	+	// OverrideSkipAsync sets the "skip_async" callback function.
169		func (x InputStreamClass) OverrideSkipAsync(cb func(InputStream, uint, int, Cancellable, AsyncReadyCallback, uintptr)) {	169		func (x InputStreamClass) OverrideSkipAsync(cb func(InputStream, uint, int, Cancellable, AsyncReadyCallback, uintptr)) {
170		if cb == nil {	170		if cb == nil {
171		x.xSkipAsync = 0	171		x.xSkipAsync = 0

@@ -176,7 +176,7 @@ func (x InputStreamClass) OverrideSkipAsync(cb func(InputStream, uint, int, *C
176		}	176		}
177		}	177		}
178			178
179	-	// GetSkipAsync gets the callback function.	179	+	// GetSkipAsync gets the "skip_async" callback function.
180		func (x InputStreamClass) GetSkipAsync() func(InputStream, uint, int, Cancellable, AsyncReadyCallback, uintptr) {	180		func (x InputStreamClass) GetSkipAsync() func(InputStream, uint, int, Cancellable, AsyncReadyCallback, uintptr) {
181		if x.xSkipAsync == 0 {	181		if x.xSkipAsync == 0 {
182		return nil	182		return nil

@@ -188,7 +188,7 @@ func (x InputStreamClass) GetSkipAsync() func(InputStream, uint, int, *Cancell
188		}	188		}
189		}	189		}
190			190
191	-	// OverrideSkipFinish sets the callback function.	191	+	// OverrideSkipFinish sets the "skip_finish" callback function.
192		func (x InputStreamClass) OverrideSkipFinish(cb func(InputStream, AsyncResult) int) {	192		func (x InputStreamClass) OverrideSkipFinish(cb func(InputStream, AsyncResult) int) {
193		if cb == nil {	193		if cb == nil {
194		x.xSkipFinish = 0	194		x.xSkipFinish = 0

@@ -199,7 +199,7 @@ func (x InputStreamClass) OverrideSkipFinish(cb func(InputStream, AsyncResult)
199		}	199		}
200		}	200		}
201			201
202	-	// GetSkipFinish gets the callback function.	202	+	// GetSkipFinish gets the "skip_finish" callback function.
203		func (x InputStreamClass) GetSkipFinish() func(InputStream, AsyncResult) int {	203		func (x InputStreamClass) GetSkipFinish() func(InputStream, AsyncResult) int {
204		if x.xSkipFinish == 0 {	204		if x.xSkipFinish == 0 {
205		return nil	205		return nil

@@ -211,7 +211,7 @@ func (x InputStreamClass) GetSkipFinish() func(InputStream, AsyncResult) int {
211		}	211		}
212		}	212		}
213			213
214	-	// OverrideCloseAsync sets the callback function.	214	+	// OverrideCloseAsync sets the "close_async" callback function.
215		func (x InputStreamClass) OverrideCloseAsync(cb func(InputStream, int, Cancellable, AsyncReadyCallback, uintptr)) {	215		func (x InputStreamClass) OverrideCloseAsync(cb func(InputStream, int, Cancellable, AsyncReadyCallback, uintptr)) {
216		if cb == nil {	216		if cb == nil {
217		x.xCloseAsync = 0	217		x.xCloseAsync = 0

@@ -222,7 +222,7 @@ func (x InputStreamClass) OverrideCloseAsync(cb func(InputStream, int, *Cancel
222		}	222		}
223		}	223		}
224			224
225	-	// GetCloseAsync gets the callback function.	225	+	// GetCloseAsync gets the "close_async" callback function.
226		func (x InputStreamClass) GetCloseAsync() func(InputStream, int, Cancellable, AsyncReadyCallback, uintptr) {	226		func (x InputStreamClass) GetCloseAsync() func(InputStream, int, Cancellable, AsyncReadyCallback, uintptr) {
227		if x.xCloseAsync == 0 {	227		if x.xCloseAsync == 0 {
228		return nil	228		return nil

@@ -234,7 +234,7 @@ func (x InputStreamClass) GetCloseAsync() func(InputStream, int, *Cancellable,
234		}	234		}
235		}	235		}
236			236
237	-	// OverrideCloseFinish sets the callback function.	237	+	// OverrideCloseFinish sets the "close_finish" callback function.
238		func (x InputStreamClass) OverrideCloseFinish(cb func(InputStream, AsyncResult) bool) {	238		func (x InputStreamClass) OverrideCloseFinish(cb func(InputStream, AsyncResult) bool) {
239		if cb == nil {	239		if cb == nil {
240		x.xCloseFinish = 0	240		x.xCloseFinish = 0

@@ -245,7 +245,7 @@ func (x InputStreamClass) OverrideCloseFinish(cb func(InputStream, AsyncResult
245		}	245		}
246		}	246		}
247			247
248	-	// GetCloseFinish gets the callback function.	248	+	// GetCloseFinish gets the "close_finish" callback function.
249		func (x InputStreamClass) GetCloseFinish() func(InputStream, AsyncResult) bool {	249		func (x InputStreamClass) GetCloseFinish() func(InputStream, AsyncResult) bool {
250		if x.xCloseFinish == 0 {	250		if x.xCloseFinish == 0 {
251		return nil	251		return nil

@@ -257,7 +257,7 @@ func (x InputStreamClass) GetCloseFinish() func(InputStream, AsyncResult) bool
257		}	257		}
258		}	258		}
259			259
260	-	// OverrideGReserved1 sets the callback function.	260	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
261		func (x *InputStreamClass) OverrideGReserved1(cb func()) {	261		func (x *InputStreamClass) OverrideGReserved1(cb func()) {
262		if cb == nil {	262		if cb == nil {
263		x.xGReserved1 = 0	263		x.xGReserved1 = 0

@@ -268,7 +268,7 @@ func (x *InputStreamClass) OverrideGReserved1(cb func()) {
268		}	268		}
269		}	269		}
270			270
271	-	// GetGReserved1 gets the callback function.	271	+	// GetGReserved1 gets the "_g_reserved1" callback function.
272		func (x *InputStreamClass) GetGReserved1() func() {	272		func (x *InputStreamClass) GetGReserved1() func() {
273		if x.xGReserved1 == 0 {	273		if x.xGReserved1 == 0 {
274		return nil	274		return nil

@@ -280,7 +280,7 @@ func (x *InputStreamClass) GetGReserved1() func() {
280		}	280		}
281		}	281		}
282			282
283	-	// OverrideGReserved2 sets the callback function.	283	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
284		func (x *InputStreamClass) OverrideGReserved2(cb func()) {	284		func (x *InputStreamClass) OverrideGReserved2(cb func()) {
285		if cb == nil {	285		if cb == nil {
286		x.xGReserved2 = 0	286		x.xGReserved2 = 0

@@ -291,7 +291,7 @@ func (x *InputStreamClass) OverrideGReserved2(cb func()) {
291		}	291		}
292		}	292		}
293			293
294	-	// GetGReserved2 gets the callback function.	294	+	// GetGReserved2 gets the "_g_reserved2" callback function.
295		func (x *InputStreamClass) GetGReserved2() func() {	295		func (x *InputStreamClass) GetGReserved2() func() {
296		if x.xGReserved2 == 0 {	296		if x.xGReserved2 == 0 {
297		return nil	297		return nil

@@ -303,7 +303,7 @@ func (x *InputStreamClass) GetGReserved2() func() {
303		}	303		}
304		}	304		}
305			305
306	-	// OverrideGReserved3 sets the callback function.	306	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
307		func (x *InputStreamClass) OverrideGReserved3(cb func()) {	307		func (x *InputStreamClass) OverrideGReserved3(cb func()) {
308		if cb == nil {	308		if cb == nil {
309		x.xGReserved3 = 0	309		x.xGReserved3 = 0

@@ -314,7 +314,7 @@ func (x *InputStreamClass) OverrideGReserved3(cb func()) {
314		}	314		}
315		}	315		}
316			316
317	-	// GetGReserved3 gets the callback function.	317	+	// GetGReserved3 gets the "_g_reserved3" callback function.
318		func (x *InputStreamClass) GetGReserved3() func() {	318		func (x *InputStreamClass) GetGReserved3() func() {
319		if x.xGReserved3 == 0 {	319		if x.xGReserved3 == 0 {
320		return nil	320		return nil

@@ -326,7 +326,7 @@ func (x *InputStreamClass) GetGReserved3() func() {
326		}	326		}
327		}	327		}
328			328
329	-	// OverrideGReserved4 sets the callback function.	329	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
330		func (x *InputStreamClass) OverrideGReserved4(cb func()) {	330		func (x *InputStreamClass) OverrideGReserved4(cb func()) {
331		if cb == nil {	331		if cb == nil {
332		x.xGReserved4 = 0	332		x.xGReserved4 = 0

@@ -337,7 +337,7 @@ func (x *InputStreamClass) OverrideGReserved4(cb func()) {
337		}	337		}
338		}	338		}
339			339
340	-	// GetGReserved4 gets the callback function.	340	+	// GetGReserved4 gets the "_g_reserved4" callback function.
341		func (x *InputStreamClass) GetGReserved4() func() {	341		func (x *InputStreamClass) GetGReserved4() func() {
342		if x.xGReserved4 == 0 {	342		if x.xGReserved4 == 0 {
343		return nil	343		return nil

@@ -349,7 +349,7 @@ func (x *InputStreamClass) GetGReserved4() func() {
349		}	349		}
350		}	350		}
351			351
352	-	// OverrideGReserved5 sets the callback function.	352	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
353		func (x *InputStreamClass) OverrideGReserved5(cb func()) {	353		func (x *InputStreamClass) OverrideGReserved5(cb func()) {
354		if cb == nil {	354		if cb == nil {
355		x.xGReserved5 = 0	355		x.xGReserved5 = 0

@@ -360,7 +360,7 @@ func (x *InputStreamClass) OverrideGReserved5(cb func()) {
360		}	360		}
361		}	361		}
362			362
363	-	// GetGReserved5 gets the callback function.	363	+	// GetGReserved5 gets the "_g_reserved5" callback function.
364		func (x *InputStreamClass) GetGReserved5() func() {	364		func (x *InputStreamClass) GetGReserved5() func() {
365		if x.xGReserved5 == 0 {	365		if x.xGReserved5 == 0 {
366		return nil	366		return nil

@@ -504,7 +504,7 @@ func (x *InputStream) IsClosed() bool {
504		return cret	504		return cret
505		}	505		}
506			506
507	-	var xInputStreamRead func(uintptr, []byte, uint, uintptr, **glib.Error) int	507	+	var xInputStreamRead func(uintptr, []byte, uint, uintptr, *glib.Error) int
508			508
509		// Tries to read @count bytes from the stream into the buffer starting at	509		// Tries to read @count bytes from the stream into the buffer starting at
510		// @buffer. Will block during this read.	510		// @buffer. Will block during this read.

@@ -527,7 +527,7 @@ var xInputStreamRead func(uintptr, []byte, uint, uintptr, **glib.Error) int
527		// partial result will be returned, without an error.	527		// partial result will be returned, without an error.
528		//	528		//
529		// On error -1 is returned and @error is set accordingly.	529		// On error -1 is returned and @error is set accordingly.
530	-	func (x InputStream) Read(BufferVar []byte, CountVar uint, CancellableVar Cancellable) (int, error) {	530	+	func (x InputStream) Read(BufferVar []byte, CountVar uint, CancellableVar *Cancellable) (int, error) {
531		var cerr *glib.Error	531		var cerr *glib.Error
532			532
533		cret := xInputStreamRead(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)	533		cret := xInputStreamRead(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)

@@ -538,7 +538,7 @@ func (x InputStream) Read(BufferVar []byte, CountVar uint, CancellableVar Canc
538			538
539		}	539		}
540			540
541	-	var xInputStreamReadAll func(uintptr, []byte, uint, uint, uintptr, **glib.Error) bool	541	+	var xInputStreamReadAll func(uintptr, []byte, uint, uint, uintptr, **glib.Error) bool
542			542
543		// Tries to read @count bytes from the stream into the buffer starting at	543		// Tries to read @count bytes from the stream into the buffer starting at
544		// @buffer. Will block during this read.	544		// @buffer. Will block during this read.

@@ -559,7 +559,7 @@ var xInputStreamReadAll func(uintptr, []byte, uint, uint, uintptr, **glib.Error)
559		// read before the error was encountered. This functionality is only	559		// read before the error was encountered. This functionality is only
560		// available from C. If you need it from another language then you must	560		// available from C. If you need it from another language then you must
561		// write your own loop around g_input_stream_read().	561		// write your own loop around g_input_stream_read().
562	-	func (x InputStream) ReadAll(BufferVar []byte, CountVar uint, BytesReadVar uint, CancellableVar Cancellable) (bool, error) {	562	+	func (x InputStream) ReadAll(BufferVar []byte, CountVar uint, BytesReadVar uint, CancellableVar Cancellable) (bool, error) {
563		var cerr *glib.Error	563		var cerr *glib.Error
564			564
565		cret := xInputStreamReadAll(x.GoPointer(), BufferVar, CountVar, BytesReadVar, CancellableVar.GoPointer(), &cerr)	565		cret := xInputStreamReadAll(x.GoPointer(), BufferVar, CountVar, BytesReadVar, CancellableVar.GoPointer(), &cerr)

@@ -570,7 +570,7 @@ func (x *InputStream) ReadAll(BufferVar []byte, CountVar uint, BytesReadVar uint
570			570
571		}	571		}
572			572
573	-	var xInputStreamReadAllAsync func(uintptr, []byte, uint, int, uintptr, uintptr, uintptr)	573	+	var xInputStreamReadAllAsync func(uintptr, *[]byte, uint, int, uintptr, uintptr, uintptr)
574			574
575		// Request an asynchronous read of @count bytes from the stream into the	575		// Request an asynchronous read of @count bytes from the stream into the
576		// buffer starting at @buffer.	576		// buffer starting at @buffer.

@@ -582,13 +582,13 @@ var xInputStreamReadAllAsync func(uintptr, []byte, uint, int, uintptr, uintptr,
582		// Any outstanding I/O request with higher priority (lower numerical	582		// Any outstanding I/O request with higher priority (lower numerical
583		// value) will be executed before an outstanding request with lower	583		// value) will be executed before an outstanding request with lower
584		// priority. Default priority is %G_PRIORITY_DEFAULT.	584		// priority. Default priority is %G_PRIORITY_DEFAULT.
585	-	func (x InputStream) ReadAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	585	+	func (x InputStream) ReadAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
586			586
587		xInputStreamReadAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	587		xInputStreamReadAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
588			588
589		}	589		}
590			590
591	-	var xInputStreamReadAllFinish func(uintptr, uintptr, uint, **glib.Error) bool	591	+	var xInputStreamReadAllFinish func(uintptr, uintptr, uint, *glib.Error) bool
592			592
593		// Finishes an asynchronous stream read operation started with	593		// Finishes an asynchronous stream read operation started with
594		// [method@InputStream.read_all_async].	594		// [method@InputStream.read_all_async].

@@ -599,7 +599,7 @@ var xInputStreamReadAllFinish func(uintptr, uintptr, uint, **glib.Error) bool
599		// read before the error was encountered. This functionality is only	599		// read before the error was encountered. This functionality is only
600		// available from C. If you need it from another language then you must	600		// available from C. If you need it from another language then you must
601		// write your own loop around g_input_stream_read_async().	601		// write your own loop around g_input_stream_read_async().
602	-	func (x *InputStream) ReadAllFinish(ResultVar AsyncResult, BytesReadVar uint) (bool, error) {	602	+	func (x InputStream) ReadAllFinish(ResultVar AsyncResult, BytesReadVar uint) (bool, error) {
603		var cerr *glib.Error	603		var cerr *glib.Error
604			604
605		cret := xInputStreamReadAllFinish(x.GoPointer(), ResultVar.GoPointer(), BytesReadVar, &cerr)	605		cret := xInputStreamReadAllFinish(x.GoPointer(), ResultVar.GoPointer(), BytesReadVar, &cerr)

@@ -610,7 +610,7 @@ func (x *InputStream) ReadAllFinish(ResultVar AsyncResult, BytesReadVar uint) (b
610			610
611		}	611		}
612			612
613	-	var xInputStreamReadAsync func(uintptr, []byte, uint, int, uintptr, uintptr, uintptr)	613	+	var xInputStreamReadAsync func(uintptr, *[]byte, uint, int, uintptr, uintptr, uintptr)
614			614
615		// Request an asynchronous read of @count bytes from the stream into the buffer	615		// Request an asynchronous read of @count bytes from the stream into the buffer
616		// starting at @buffer. When the operation is finished @callback will be called.	616		// starting at @buffer. When the operation is finished @callback will be called.

@@ -635,7 +635,7 @@ var xInputStreamReadAsync func(uintptr, []byte, uint, int, uintptr, uintptr, uin
635		// The asynchronous methods have a default fallback that uses threads to implement	635		// The asynchronous methods have a default fallback that uses threads to implement
636		// asynchronicity, so they are optional for inheriting classes. However, if you	636		// asynchronicity, so they are optional for inheriting classes. However, if you
637		// override one you must override all.	637		// override one you must override all.
638	-	func (x InputStream) ReadAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	638	+	func (x InputStream) ReadAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
639			639
640		xInputStreamReadAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	640		xInputStreamReadAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
641			641

M v4/gio/giostream.go +38 -30

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGetInputStream sets the callback function.
+// OverrideGetInputStream sets the "get_input_stream" callback function.
 func (x *IOStreamClass) OverrideGetInputStream(cb func(*IOStream) *InputStream) {
 	if cb == nil {
 		x.xGetInputStream = 0
 	}
 }
-// GetGetInputStream gets the callback function.
+// GetGetInputStream gets the "get_input_stream" callback function.
 func (x *IOStreamClass) GetGetInputStream() func(*IOStream) *InputStream {
 	if x.xGetInputStream == 0 {
 		return nil
 	}
 }
-// OverrideGetOutputStream sets the callback function.
+// OverrideGetOutputStream sets the "get_output_stream" callback function.
 func (x *IOStreamClass) OverrideGetOutputStream(cb func(*IOStream) *OutputStream) {
 	if cb == nil {
 		x.xGetOutputStream = 0
 	}
 }
-// GetGetOutputStream gets the callback function.
+// GetGetOutputStream gets the "get_output_stream" callback function.
 func (x *IOStreamClass) GetGetOutputStream() func(*IOStream) *OutputStream {
 	if x.xGetOutputStream == 0 {
 		return nil
 	}
 }
-// OverrideCloseFn sets the callback function.
+// OverrideCloseFn sets the "close_fn" callback function.
 func (x *IOStreamClass) OverrideCloseFn(cb func(*IOStream, *Cancellable) bool) {
 	if cb == nil {
 		x.xCloseFn = 0
 	}
 }
-// GetCloseFn gets the callback function.
+// GetCloseFn gets the "close_fn" callback function.
 func (x *IOStreamClass) GetCloseFn() func(*IOStream, *Cancellable) bool {
 	if x.xCloseFn == 0 {
 		return nil
 	}
 }
-// OverrideCloseAsync sets the callback function.
+// OverrideCloseAsync sets the "close_async" callback function.
 func (x *IOStreamClass) OverrideCloseAsync(cb func(*IOStream, int, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xCloseAsync = 0
 	}
 }
-// GetCloseAsync gets the callback function.
+// GetCloseAsync gets the "close_async" callback function.
 func (x *IOStreamClass) GetCloseAsync() func(*IOStream, int, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xCloseAsync == 0 {
 		return nil
 	}
 }
-// OverrideCloseFinish sets the callback function.
+// OverrideCloseFinish sets the "close_finish" callback function.
 func (x *IOStreamClass) OverrideCloseFinish(cb func(*IOStream, AsyncResult) bool) {
 	if cb == nil {
 		x.xCloseFinish = 0
 	}
 }
-// GetCloseFinish gets the callback function.
+// GetCloseFinish gets the "close_finish" callback function.
 func (x *IOStreamClass) GetCloseFinish() func(*IOStream, AsyncResult) bool {
 	if x.xCloseFinish == 0 {
 		return nil
 	}
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *IOStreamClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *IOStreamClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *IOStreamClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *IOStreamClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *IOStreamClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *IOStreamClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *IOStreamClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *IOStreamClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *IOStreamClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *IOStreamClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved6 sets the callback function.
+// OverrideGReserved6 sets the "_g_reserved6" callback function.
 func (x *IOStreamClass) OverrideGReserved6(cb func()) {
 	if cb == nil {
 		x.xGReserved6 = 0
 	}
 }
-// GetGReserved6 gets the callback function.
+// GetGReserved6 gets the "_g_reserved6" callback function.
 func (x *IOStreamClass) GetGReserved6() func() {
 	if x.xGReserved6 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved7 sets the callback function.
+// OverrideGReserved7 sets the "_g_reserved7" callback function.
 func (x *IOStreamClass) OverrideGReserved7(cb func()) {
 	if cb == nil {
 		x.xGReserved7 = 0
 	}
 }
-// GetGReserved7 gets the callback function.
+// GetGReserved7 gets the "_g_reserved7" callback function.
 func (x *IOStreamClass) GetGReserved7() func() {
 	if x.xGReserved7 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved8 sets the callback function.
+// OverrideGReserved8 sets the "_g_reserved8" callback function.
 func (x *IOStreamClass) OverrideGReserved8(cb func()) {
 	if cb == nil {
 		x.xGReserved8 = 0
 	}
 }
-// GetGReserved8 gets the callback function.
+// GetGReserved8 gets the "_g_reserved8" callback function.
 func (x *IOStreamClass) GetGReserved8() func() {
 	if x.xGReserved8 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved9 sets the callback function.
+// OverrideGReserved9 sets the "_g_reserved9" callback function.
 func (x *IOStreamClass) OverrideGReserved9(cb func()) {
 	if cb == nil {
 		x.xGReserved9 = 0
 	}
 }
-// GetGReserved9 gets the callback function.
+// GetGReserved9 gets the "_g_reserved9" callback function.
 func (x *IOStreamClass) GetGReserved9() func() {
 	if x.xGReserved9 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved10 sets the callback function.
+// OverrideGReserved10 sets the "_g_reserved10" callback function.
 func (x *IOStreamClass) OverrideGReserved10(cb func()) {
 	if cb == nil {
 		x.xGReserved10 = 0
 	}
 }
-// GetGReserved10 gets the callback function.
+// GetGReserved10 gets the "_g_reserved10" callback function.
 func (x *IOStreamClass) GetGReserved10() func() {
 	if x.xGReserved10 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// GetPropertyClosed gets the "closed" property.
+// Whether the stream is closed.
+func (x *IOStream) GetPropertyClosed() bool {
+	var v gobject.Value
+	x.GetProperty("closed", &v)
+	return v.GetBoolean()
+}
 var xIOStreamSpliceFinish func(uintptr, **glib.Error) bool
 // Finishes an asynchronous io stream splice operation.

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


@@ -776,7 +776,7 @@ func (x *Resource) EnumerateChildren(PathVar string, LookupFlagsVar ResourceLook
776			776
777		}	777		}
778			778
779	-	var xResourceGetInfo func(uintptr, string, ResourceLookupFlags, uint, uint32, **glib.Error) bool	779	+	var xResourceGetInfo func(uintptr, string, ResourceLookupFlags, uint, uint32, **glib.Error) bool
780			780
781		// Looks for a file at the specified @path in the resource and	781		// Looks for a file at the specified @path in the resource and
782		// if found returns information about it.	782		// if found returns information about it.

@@ -785,7 +785,7 @@ var xResourceGetInfo func(uintptr, string, ResourceLookupFlags, uint, uint32, **
785		//	785		//
786		// The only error this can return is %G_RESOURCE_ERROR_NOT_FOUND, if @path was	786		// The only error this can return is %G_RESOURCE_ERROR_NOT_FOUND, if @path was
787		// not found in @resource.	787		// not found in @resource.
788	-	func (x *Resource) GetInfo(PathVar string, LookupFlagsVar ResourceLookupFlags, SizeVar uint, FlagsVar uint32) (bool, error) {	788	+	func (x Resource) GetInfo(PathVar string, LookupFlagsVar ResourceLookupFlags, SizeVar uint, FlagsVar *uint32) (bool, error) {
789		var cerr *glib.Error	789		var cerr *glib.Error
790			790
791		cret := xResourceGetInfo(x.GoPointer(), PathVar, LookupFlagsVar, SizeVar, FlagsVar, &cerr)	791		cret := xResourceGetInfo(x.GoPointer(), PathVar, LookupFlagsVar, SizeVar, FlagsVar, &cerr)

M v4/gio/glistmodel.go +6 -6


@@ -28,7 +28,7 @@ func (x *ListModelInterface) GoPointer() uintptr {
28		return uintptr(unsafe.Pointer(x))	28		return uintptr(unsafe.Pointer(x))
29		}	29		}
30			30
31	-	// OverrideGetItemType sets the callback function.	31	+	// OverrideGetItemType sets the "get_item_type" callback function.
32		// the virtual function pointer for g_list_model_get_item_type()	32		// the virtual function pointer for g_list_model_get_item_type()
33		func (x *ListModelInterface) OverrideGetItemType(cb func(ListModel) types.GType) {	33		func (x *ListModelInterface) OverrideGetItemType(cb func(ListModel) types.GType) {
34		if cb == nil {	34		if cb == nil {

@@ -40,7 +40,7 @@ func (x *ListModelInterface) OverrideGetItemType(cb func(ListModel) types.GType)
40		}	40		}
41		}	41		}
42			42
43	-	// GetGetItemType gets the callback function.	43	+	// GetGetItemType gets the "get_item_type" callback function.
44		// the virtual function pointer for g_list_model_get_item_type()	44		// the virtual function pointer for g_list_model_get_item_type()
45		func (x *ListModelInterface) GetGetItemType() func(ListModel) types.GType {	45		func (x *ListModelInterface) GetGetItemType() func(ListModel) types.GType {
46		if x.xGetItemType == 0 {	46		if x.xGetItemType == 0 {

@@ -53,7 +53,7 @@ func (x *ListModelInterface) GetGetItemType() func(ListModel) types.GType {
53		}	53		}
54		}	54		}
55			55
56	-	// OverrideGetNItems sets the callback function.	56	+	// OverrideGetNItems sets the "get_n_items" callback function.
57		// the virtual function pointer for g_list_model_get_n_items()	57		// the virtual function pointer for g_list_model_get_n_items()
58		func (x *ListModelInterface) OverrideGetNItems(cb func(ListModel) uint) {	58		func (x *ListModelInterface) OverrideGetNItems(cb func(ListModel) uint) {
59		if cb == nil {	59		if cb == nil {

@@ -65,7 +65,7 @@ func (x *ListModelInterface) OverrideGetNItems(cb func(ListModel) uint) {
65		}	65		}
66		}	66		}
67			67
68	-	// GetGetNItems gets the callback function.	68	+	// GetGetNItems gets the "get_n_items" callback function.
69		// the virtual function pointer for g_list_model_get_n_items()	69		// the virtual function pointer for g_list_model_get_n_items()
70		func (x *ListModelInterface) GetGetNItems() func(ListModel) uint {	70		func (x *ListModelInterface) GetGetNItems() func(ListModel) uint {
71		if x.xGetNItems == 0 {	71		if x.xGetNItems == 0 {

@@ -78,7 +78,7 @@ func (x *ListModelInterface) GetGetNItems() func(ListModel) uint {
78		}	78		}
79		}	79		}
80			80
81	-	// OverrideGetItem sets the callback function.	81	+	// OverrideGetItem sets the "get_item" callback function.
82		// the virtual function pointer for g_list_model_get_item()	82		// the virtual function pointer for g_list_model_get_item()
83		func (x ListModelInterface) OverrideGetItem(cb func(ListModel, uint) gobject.Object) {	83		func (x ListModelInterface) OverrideGetItem(cb func(ListModel, uint) gobject.Object) {
84		if cb == nil {	84		if cb == nil {

@@ -94,7 +94,7 @@ func (x ListModelInterface) OverrideGetItem(cb func(ListModel, uint) gobject.O
94		}	94		}
95		}	95		}
96			96
97	-	// GetGetItem gets the callback function.	97	+	// GetGetItem gets the "get_item" callback function.
98		// the virtual function pointer for g_list_model_get_item()	98		// the virtual function pointer for g_list_model_get_item()
99		func (x ListModelInterface) GetGetItem() func(ListModel, uint) gobject.Object {	99		func (x ListModelInterface) GetGetItem() func(ListModel, uint) gobject.Object {
100		if x.xGetItem == 0 {	100		if x.xGetItem == 0 {

M v4/gio/gliststore.go +14 -6

 }
-var xListStoreFind func(uintptr, uintptr, uint) bool
+var xListStoreFind func(uintptr, uintptr, *uint) bool
 // Looks up the given @item in the list store by looping over the items until
 // the first occurrence of @item. If @item was not found, then @position will
 //
 // If you need to compare the two items with a custom comparison function, use
 // g_list_store_find_with_equal_func() with a custom #GEqualFunc instead.
-func (x *ListStore) Find(ItemVar *gobject.Object, PositionVar uint) bool {
+func (x *ListStore) Find(ItemVar *gobject.Object, PositionVar *uint) bool {
 	cret := xListStoreFind(x.GoPointer(), ItemVar.GoPointer(), PositionVar)
 	return cret
 }
-var xListStoreFindWithEqualFunc func(uintptr, uintptr, uintptr, uint) bool
+var xListStoreFindWithEqualFunc func(uintptr, uintptr, uintptr, *uint) bool
 // Looks up the given @item in the list store by looping over the items and
 // comparing them with @equal_func until the first occurrence of @item which
 // @item is always passed as second parameter to @equal_func.
 //
 // Since GLib 2.76 it is possible to pass `NULL` for @item.
-func (x *ListStore) FindWithEqualFunc(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFunc, PositionVar uint) bool {
+func (x *ListStore) FindWithEqualFunc(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFunc, PositionVar *uint) bool {
 	cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(EqualFuncVar), PositionVar)
 	return cret
 }
-var xListStoreFindWithEqualFuncFull func(uintptr, uintptr, uintptr, uintptr, uint) bool
+var xListStoreFindWithEqualFuncFull func(uintptr, uintptr, uintptr, uintptr, *uint) bool
 // Like g_list_store_find_with_equal_func() but with an additional @user_data
 // that is passed to @equal_func.
 // @item is always passed as second parameter to @equal_func.
 //
 // Since GLib 2.76 it is possible to pass `NULL` for @item.
-func (x *ListStore) FindWithEqualFuncFull(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFuncFull, UserDataVar uintptr, PositionVar uint) bool {
+func (x *ListStore) FindWithEqualFuncFull(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFuncFull, UserDataVar uintptr, PositionVar *uint) bool {
 	cret := xListStoreFindWithEqualFuncFull(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(EqualFuncVar), UserDataVar, PositionVar)
 	return cret
 	c.Ptr = ptr
 }
+// GetPropertyNItems gets the "n-items" property.
+// The number of items contained in this list store.
+func (x *ListStore) GetPropertyNItems() uint {
+	var v gobject.Value
+	x.GetProperty("n-items", &v)
+	return v.GetUint()
+}
 // Get the item at @position.
 //
 // If @position is greater than the number of items in @list, %NULL is

M v4/gio/gloadableicon.go +22 -22


@@ -28,13 +28,13 @@ func (x *LoadableIconIface) GoPointer() uintptr {
28		return uintptr(unsafe.Pointer(x))	28		return uintptr(unsafe.Pointer(x))
29		}	29		}
30			30
31	-	// OverrideLoad sets the callback function.	31	+	// OverrideLoad sets the "load" callback function.
32		// Loads an icon.	32		// Loads an icon.
33	-	func (x LoadableIconIface) OverrideLoad(cb func(LoadableIcon, int, string, Cancellable) *InputStream) {	33	+	func (x LoadableIconIface) OverrideLoad(cb func(LoadableIcon, int, string, Cancellable) InputStream) {
34		if cb == nil {	34		if cb == nil {
35		x.xLoad = 0	35		x.xLoad = 0
36		} else {	36		} else {
37	-	x.xLoad = purego.NewCallback(func(IconVarp uintptr, SizeVarp int, TypeVarp string, CancellableVarp uintptr) uintptr {	37	+	x.xLoad = purego.NewCallback(func(IconVarp uintptr, SizeVarp int, TypeVarp *string, CancellableVarp uintptr) uintptr {
38		ret := cb(&LoadableIconBase{Ptr: IconVarp}, SizeVarp, TypeVarp, CancellableNewFromInternalPtr(CancellableVarp))	38		ret := cb(&LoadableIconBase{Ptr: IconVarp}, SizeVarp, TypeVarp, CancellableNewFromInternalPtr(CancellableVarp))
39		if ret == nil {	39		if ret == nil {
40		return 0	40		return 0

@@ -44,15 +44,15 @@ func (x LoadableIconIface) OverrideLoad(cb func(LoadableIcon, int, string, Can
44		}	44		}
45		}	45		}
46			46
47	-	// GetLoad gets the callback function.	47	+	// GetLoad gets the "load" callback function.
48		// Loads an icon.	48		// Loads an icon.
49	-	func (x LoadableIconIface) GetLoad() func(LoadableIcon, int, string, Cancellable) *InputStream {	49	+	func (x LoadableIconIface) GetLoad() func(LoadableIcon, int, string, Cancellable) InputStream {
50		if x.xLoad == 0 {	50		if x.xLoad == 0 {
51		return nil	51		return nil
52		}	52		}
53	-	var rawCallback func(IconVarp uintptr, SizeVarp int, TypeVarp string, CancellableVarp uintptr) uintptr	53	+	var rawCallback func(IconVarp uintptr, SizeVarp int, TypeVarp *string, CancellableVarp uintptr) uintptr
54		purego.RegisterFunc(&rawCallback, x.xLoad)	54		purego.RegisterFunc(&rawCallback, x.xLoad)
55	-	return func(IconVar LoadableIcon, SizeVar int, TypeVar string, CancellableVar Cancellable) InputStream {	55	+	return func(IconVar LoadableIcon, SizeVar int, TypeVar string, CancellableVar Cancellable) *InputStream {
56		rawRet := rawCallback(IconVar.GoPointer(), SizeVar, TypeVar, CancellableVar.GoPointer())	56		rawRet := rawCallback(IconVar.GoPointer(), SizeVar, TypeVar, CancellableVar.GoPointer())
57		if rawRet == 0 {	57		if rawRet == 0 {
58		return nil	58		return nil

@@ -63,7 +63,7 @@ func (x LoadableIconIface) GetLoad() func(LoadableIcon, int, string, Cancellab
63		}	63		}
64		}	64		}
65			65
66	-	// OverrideLoadAsync sets the callback function.	66	+	// OverrideLoadAsync sets the "load_async" callback function.
67		// Loads an icon asynchronously.	67		// Loads an icon asynchronously.
68		func (x LoadableIconIface) OverrideLoadAsync(cb func(LoadableIcon, int, Cancellable, *AsyncReadyCallback, uintptr)) {	68		func (x LoadableIconIface) OverrideLoadAsync(cb func(LoadableIcon, int, Cancellable, *AsyncReadyCallback, uintptr)) {
69		if cb == nil {	69		if cb == nil {

@@ -75,7 +75,7 @@ func (x LoadableIconIface) OverrideLoadAsync(cb func(LoadableIcon, int, Cancel
75		}	75		}
76		}	76		}
77			77
78	-	// GetLoadAsync gets the callback function.	78	+	// GetLoadAsync gets the "load_async" callback function.
79		// Loads an icon asynchronously.	79		// Loads an icon asynchronously.
80		func (x LoadableIconIface) GetLoadAsync() func(LoadableIcon, int, Cancellable, *AsyncReadyCallback, uintptr) {	80		func (x LoadableIconIface) GetLoadAsync() func(LoadableIcon, int, Cancellable, *AsyncReadyCallback, uintptr) {
81		if x.xLoadAsync == 0 {	81		if x.xLoadAsync == 0 {

@@ -88,13 +88,13 @@ func (x LoadableIconIface) GetLoadAsync() func(LoadableIcon, int, Cancellable,
88		}	88		}
89		}	89		}
90			90
91	-	// OverrideLoadFinish sets the callback function.	91	+	// OverrideLoadFinish sets the "load_finish" callback function.
92		// Finishes an asynchronous icon load.	92		// Finishes an asynchronous icon load.
93	-	func (x LoadableIconIface) OverrideLoadFinish(cb func(LoadableIcon, AsyncResult, string) InputStream) {	93	+	func (x LoadableIconIface) OverrideLoadFinish(cb func(LoadableIcon, AsyncResult, string) *InputStream) {
94		if cb == nil {	94		if cb == nil {
95		x.xLoadFinish = 0	95		x.xLoadFinish = 0
96		} else {	96		} else {
97	-	x.xLoadFinish = purego.NewCallback(func(IconVarp uintptr, ResVarp uintptr, TypeVarp string) uintptr {	97	+	x.xLoadFinish = purego.NewCallback(func(IconVarp uintptr, ResVarp uintptr, TypeVarp *string) uintptr {
98		ret := cb(&LoadableIconBase{Ptr: IconVarp}, &AsyncResultBase{Ptr: ResVarp}, TypeVarp)	98		ret := cb(&LoadableIconBase{Ptr: IconVarp}, &AsyncResultBase{Ptr: ResVarp}, TypeVarp)
99		if ret == nil {	99		if ret == nil {
100		return 0	100		return 0

@@ -104,15 +104,15 @@ func (x *LoadableIconIface) OverrideLoadFinish(cb func(LoadableIcon, AsyncResult
104		}	104		}
105		}	105		}
106			106
107	-	// GetLoadFinish gets the callback function.	107	+	// GetLoadFinish gets the "load_finish" callback function.
108		// Finishes an asynchronous icon load.	108		// Finishes an asynchronous icon load.
109	-	func (x LoadableIconIface) GetLoadFinish() func(LoadableIcon, AsyncResult, string) InputStream {	109	+	func (x LoadableIconIface) GetLoadFinish() func(LoadableIcon, AsyncResult, string) *InputStream {
110		if x.xLoadFinish == 0 {	110		if x.xLoadFinish == 0 {
111		return nil	111		return nil
112		}	112		}
113	-	var rawCallback func(IconVarp uintptr, ResVarp uintptr, TypeVarp string) uintptr	113	+	var rawCallback func(IconVarp uintptr, ResVarp uintptr, TypeVarp *string) uintptr
114		purego.RegisterFunc(&rawCallback, x.xLoadFinish)	114		purego.RegisterFunc(&rawCallback, x.xLoadFinish)
115	-	return func(IconVar LoadableIcon, ResVar AsyncResult, TypeVar string) *InputStream {	115	+	return func(IconVar LoadableIcon, ResVar AsyncResult, TypeVar string) InputStream {
116		rawRet := rawCallback(IconVar.GoPointer(), ResVar.GoPointer(), TypeVar)	116		rawRet := rawCallback(IconVar.GoPointer(), ResVar.GoPointer(), TypeVar)
117		if rawRet == 0 {	117		if rawRet == 0 {
118		return nil	118		return nil

@@ -128,9 +128,9 @@ func (x *LoadableIconIface) GetLoadFinish() func(LoadableIcon, AsyncResult, stri
128		type LoadableIcon interface {	128		type LoadableIcon interface {
129		GoPointer() uintptr	129		GoPointer() uintptr
130		SetGoPointer(uintptr)	130		SetGoPointer(uintptr)
131	-	Load(SizeVar int, TypeVar string, CancellableVar Cancellable) (InputStream, error)	131	+	Load(SizeVar int, TypeVar string, CancellableVar Cancellable) (*InputStream, error)
132		LoadAsync(SizeVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)	132		LoadAsync(SizeVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr)
133	-	LoadFinish(ResVar AsyncResult, TypeVar string) (*InputStream, error)	133	+	LoadFinish(ResVar AsyncResult, TypeVar string) (InputStream, error)
134		}	134		}
135			135
136		var xLoadableIconGLibType func() types.GType	136		var xLoadableIconGLibType func() types.GType

@@ -156,7 +156,7 @@ func (x *LoadableIconBase) SetGoPointer(ptr uintptr) {
156			156
157		// Loads a loadable icon. For the asynchronous version of this function,	157		// Loads a loadable icon. For the asynchronous version of this function,
158		// see g_loadable_icon_load_async().	158		// see g_loadable_icon_load_async().
159	-	func (x LoadableIconBase) Load(SizeVar int, TypeVar string, CancellableVar Cancellable) (*InputStream, error) {	159	+	func (x LoadableIconBase) Load(SizeVar int, TypeVar string, CancellableVar Cancellable) (InputStream, error) {
160		var cls *InputStream	160		var cls *InputStream
161		var cerr *glib.Error	161		var cerr *glib.Error
162			162

@@ -184,7 +184,7 @@ func (x LoadableIconBase) LoadAsync(SizeVar int, CancellableVar Cancellable, C
184		}	184		}
185			185
186		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().	186		// Finishes an asynchronous icon load started in g_loadable_icon_load_async().
187	-	func (x LoadableIconBase) LoadFinish(ResVar AsyncResult, TypeVar string) (InputStream, error) {	187	+	func (x LoadableIconBase) LoadFinish(ResVar AsyncResult, TypeVar string) (*InputStream, error) {
188		var cls *InputStream	188		var cls *InputStream
189		var cerr *glib.Error	189		var cerr *glib.Error
190			190

@@ -202,9 +202,9 @@ func (x LoadableIconBase) LoadFinish(ResVar AsyncResult, TypeVar string) (Inpu
202			202
203		}	203		}
204			204
205	-	var XGLoadableIconLoad func(uintptr, int, string, uintptr, **glib.Error) uintptr	205	+	var XGLoadableIconLoad func(uintptr, int, string, uintptr, *glib.Error) uintptr
206		var XGLoadableIconLoadAsync func(uintptr, int, uintptr, uintptr, uintptr)	206		var XGLoadableIconLoadAsync func(uintptr, int, uintptr, uintptr, uintptr)
207	-	var XGLoadableIconLoadFinish func(uintptr, uintptr, string, **glib.Error) uintptr	207	+	var XGLoadableIconLoadFinish func(uintptr, uintptr, string, *glib.Error) uintptr
208			208
209		func init() {	209		func init() {
210		core.SetPackageName("GIO", "gio-2.0")	210		core.SetPackageName("GIO", "gio-2.0")

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


@@ -31,7 +31,7 @@ func (x *MemoryInputStreamClass) GoPointer() uintptr {
31		return uintptr(unsafe.Pointer(x))	31		return uintptr(unsafe.Pointer(x))
32		}	32		}
33			33
34	-	// OverrideGReserved1 sets the callback function.	34	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
35		func (x *MemoryInputStreamClass) OverrideGReserved1(cb func()) {	35		func (x *MemoryInputStreamClass) OverrideGReserved1(cb func()) {
36		if cb == nil {	36		if cb == nil {
37		x.xGReserved1 = 0	37		x.xGReserved1 = 0

@@ -42,7 +42,7 @@ func (x *MemoryInputStreamClass) OverrideGReserved1(cb func()) {
42		}	42		}
43		}	43		}
44			44
45	-	// GetGReserved1 gets the callback function.	45	+	// GetGReserved1 gets the "_g_reserved1" callback function.
46		func (x *MemoryInputStreamClass) GetGReserved1() func() {	46		func (x *MemoryInputStreamClass) GetGReserved1() func() {
47		if x.xGReserved1 == 0 {	47		if x.xGReserved1 == 0 {
48		return nil	48		return nil

@@ -54,7 +54,7 @@ func (x *MemoryInputStreamClass) GetGReserved1() func() {
54		}	54		}
55		}	55		}
56			56
57	-	// OverrideGReserved2 sets the callback function.	57	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
58		func (x *MemoryInputStreamClass) OverrideGReserved2(cb func()) {	58		func (x *MemoryInputStreamClass) OverrideGReserved2(cb func()) {
59		if cb == nil {	59		if cb == nil {
60		x.xGReserved2 = 0	60		x.xGReserved2 = 0

@@ -65,7 +65,7 @@ func (x *MemoryInputStreamClass) OverrideGReserved2(cb func()) {
65		}	65		}
66		}	66		}
67			67
68	-	// GetGReserved2 gets the callback function.	68	+	// GetGReserved2 gets the "_g_reserved2" callback function.
69		func (x *MemoryInputStreamClass) GetGReserved2() func() {	69		func (x *MemoryInputStreamClass) GetGReserved2() func() {
70		if x.xGReserved2 == 0 {	70		if x.xGReserved2 == 0 {
71		return nil	71		return nil

@@ -77,7 +77,7 @@ func (x *MemoryInputStreamClass) GetGReserved2() func() {
77		}	77		}
78		}	78		}
79			79
80	-	// OverrideGReserved3 sets the callback function.	80	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
81		func (x *MemoryInputStreamClass) OverrideGReserved3(cb func()) {	81		func (x *MemoryInputStreamClass) OverrideGReserved3(cb func()) {
82		if cb == nil {	82		if cb == nil {
83		x.xGReserved3 = 0	83		x.xGReserved3 = 0

@@ -88,7 +88,7 @@ func (x *MemoryInputStreamClass) OverrideGReserved3(cb func()) {
88		}	88		}
89		}	89		}
90			90
91	-	// GetGReserved3 gets the callback function.	91	+	// GetGReserved3 gets the "_g_reserved3" callback function.
92		func (x *MemoryInputStreamClass) GetGReserved3() func() {	92		func (x *MemoryInputStreamClass) GetGReserved3() func() {
93		if x.xGReserved3 == 0 {	93		if x.xGReserved3 == 0 {
94		return nil	94		return nil

@@ -100,7 +100,7 @@ func (x *MemoryInputStreamClass) GetGReserved3() func() {
100		}	100		}
101		}	101		}
102			102
103	-	// OverrideGReserved4 sets the callback function.	103	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
104		func (x *MemoryInputStreamClass) OverrideGReserved4(cb func()) {	104		func (x *MemoryInputStreamClass) OverrideGReserved4(cb func()) {
105		if cb == nil {	105		if cb == nil {
106		x.xGReserved4 = 0	106		x.xGReserved4 = 0

@@ -111,7 +111,7 @@ func (x *MemoryInputStreamClass) OverrideGReserved4(cb func()) {
111		}	111		}
112		}	112		}
113			113
114	-	// GetGReserved4 gets the callback function.	114	+	// GetGReserved4 gets the "_g_reserved4" callback function.
115		func (x *MemoryInputStreamClass) GetGReserved4() func() {	115		func (x *MemoryInputStreamClass) GetGReserved4() func() {
116		if x.xGReserved4 == 0 {	116		if x.xGReserved4 == 0 {
117		return nil	117		return nil

@@ -123,7 +123,7 @@ func (x *MemoryInputStreamClass) GetGReserved4() func() {
123		}	123		}
124		}	124		}
125			125
126	-	// OverrideGReserved5 sets the callback function.	126	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
127		func (x *MemoryInputStreamClass) OverrideGReserved5(cb func()) {	127		func (x *MemoryInputStreamClass) OverrideGReserved5(cb func()) {
128		if cb == nil {	128		if cb == nil {
129		x.xGReserved5 = 0	129		x.xGReserved5 = 0

@@ -134,7 +134,7 @@ func (x *MemoryInputStreamClass) OverrideGReserved5(cb func()) {
134		}	134		}
135		}	135		}
136			136
137	-	// GetGReserved5 gets the callback function.	137	+	// GetGReserved5 gets the "_g_reserved5" callback function.
138		func (x *MemoryInputStreamClass) GetGReserved5() func() {	138		func (x *MemoryInputStreamClass) GetGReserved5() func() {
139		if x.xGReserved5 == 0 {	139		if x.xGReserved5 == 0 {
140		return nil	140		return nil

@@ -313,7 +313,7 @@ func (x *MemoryInputStream) IsReadable() bool {
313		//	313		//
314		// The behaviour of this method is undefined if	314		// The behaviour of this method is undefined if
315		// g_pollable_input_stream_can_poll() returns %FALSE for @stream.	315		// g_pollable_input_stream_can_poll() returns %FALSE for @stream.
316	-	func (x MemoryInputStream) ReadNonblocking(BufferVar []byte, CountVar uint, CancellableVar Cancellable) (int, error) {	316	+	func (x MemoryInputStream) ReadNonblocking(BufferVar []byte, CountVar uint, CancellableVar *Cancellable) (int, error) {
317		var cerr *glib.Error	317		var cerr *glib.Error
318			318
319		cret := XGPollableInputStreamReadNonblocking(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)	319		cret := XGPollableInputStreamReadNonblocking(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)

M v4/gio/gmemorymonitor.go +2 -2


@@ -23,7 +23,7 @@ func (x *MemoryMonitorInterface) GoPointer() uintptr {
23		return uintptr(unsafe.Pointer(x))	23		return uintptr(unsafe.Pointer(x))
24		}	24		}
25			25
26	-	// OverrideLowMemoryWarning sets the callback function.	26	+	// OverrideLowMemoryWarning sets the "low_memory_warning" callback function.
27		// the virtual function pointer for the	27		// the virtual function pointer for the
28		//	28		//
29		// #GMemoryMonitor::low-memory-warning signal.	29		// #GMemoryMonitor::low-memory-warning signal.

@@ -37,7 +37,7 @@ func (x *MemoryMonitorInterface) OverrideLowMemoryWarning(cb func(MemoryMonitor,
37		}	37		}
38		}	38		}
39			39
40	-	// GetLowMemoryWarning gets the callback function.	40	+	// GetLowMemoryWarning gets the "low_memory_warning" callback function.
41		// the virtual function pointer for the	41		// the virtual function pointer for the
42		//	42		//
43		// #GMemoryMonitor::low-memory-warning signal.	43		// #GMemoryMonitor::low-memory-warning signal.

M v4/gio/gmemoryoutputstream.go +88 -11

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/pkg/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
+	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gobject/types"
 )
 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *MemoryOutputStreamClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *MemoryOutputStreamClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *MemoryOutputStreamClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *MemoryOutputStreamClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *MemoryOutputStreamClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *MemoryOutputStreamClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *MemoryOutputStreamClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *MemoryOutputStreamClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *MemoryOutputStreamClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *MemoryOutputStreamClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyData sets the "data" property.
+// Pointer to buffer where data will be written.
+func (x *MemoryOutputStream) SetPropertyData(value uintptr) {
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	x.SetProperty("data", &v)
+}
+// GetPropertyData gets the "data" property.
+// Pointer to buffer where data will be written.
+func (x *MemoryOutputStream) GetPropertyData() uintptr {
+	var v gobject.Value
+	x.GetProperty("data", &v)
+	return v.GetPointer()
+}
+// GetPropertyDataSize gets the "data-size" property.
+// Size of data written to the buffer.
+func (x *MemoryOutputStream) GetPropertyDataSize() uint32 {
+	var v gobject.Value
+	x.GetProperty("data-size", &v)
+	return v.GetUlong()
+}
+// SetPropertyDestroyFunction sets the "destroy-function" property.
+// Function called with the buffer as argument when the stream is destroyed.
+func (x *MemoryOutputStream) SetPropertyDestroyFunction(value uintptr) {
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	x.SetProperty("destroy-function", &v)
+}
+// GetPropertyDestroyFunction gets the "destroy-function" property.
+// Function called with the buffer as argument when the stream is destroyed.
+func (x *MemoryOutputStream) GetPropertyDestroyFunction() uintptr {
+	var v gobject.Value
+	x.GetProperty("destroy-function", &v)
+	return v.GetPointer()
+}
+// SetPropertyReallocFunction sets the "realloc-function" property.
+// Function with realloc semantics called to enlarge the buffer.
+func (x *MemoryOutputStream) SetPropertyReallocFunction(value uintptr) {
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	x.SetProperty("realloc-function", &v)
+}
+// GetPropertyReallocFunction gets the "realloc-function" property.
+// Function with realloc semantics called to enlarge the buffer.
+func (x *MemoryOutputStream) GetPropertyReallocFunction() uintptr {
+	var v gobject.Value
+	x.GetProperty("realloc-function", &v)
+	return v.GetPointer()
+}
+// SetPropertySize sets the "size" property.
+// Current size of the data buffer.
+func (x *MemoryOutputStream) SetPropertySize(value uint32) {
+	var v gobject.Value
+	v.Init(gobject.TypeUlongVal)
+	v.SetUlong(value)
+	x.SetProperty("size", &v)
+}
+// GetPropertySize gets the "size" property.
+// Current size of the data buffer.
+func (x *MemoryOutputStream) GetPropertySize() uint32 {
+	var v gobject.Value
+	x.GetProperty("size", &v)
+	return v.GetUlong()
+}
 // Checks if @stream is actually pollable. Some classes may implement
 // #GPollableOutputStream but have only certain instances of that
 // class be pollable. If this method returns %FALSE, then the behavior
 //
 // The behaviour of this method is undefined if
 // g_pollable_output_stream_can_poll() returns %FALSE for @stream.
-func (x *MemoryOutputStream) WritevNonblocking(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar *Cancellable) (PollableReturn, error) {
+func (x *MemoryOutputStream) WritevNonblocking(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar *uint, CancellableVar *Cancellable) (PollableReturn, error) {
 	var cerr *glib.Error
 	cret := XGPollableOutputStreamWritevNonblocking(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)

M v4/gio/gmenumodel.go +37 -37


@@ -24,25 +24,25 @@ func (x *MenuAttributeIterClass) GoPointer() uintptr {
24		return uintptr(unsafe.Pointer(x))	24		return uintptr(unsafe.Pointer(x))
25		}	25		}
26			26
27	-	// OverrideGetNext sets the callback function.	27	+	// OverrideGetNext sets the "get_next" callback function.
28	-	func (x MenuAttributeIterClass) OverrideGetNext(cb func(MenuAttributeIter, string, **glib.Variant) bool) {	28	+	func (x MenuAttributeIterClass) OverrideGetNext(cb func(MenuAttributeIter, string, *glib.Variant) bool) {
29		if cb == nil {	29		if cb == nil {
30		x.xGetNext = 0	30		x.xGetNext = 0
31		} else {	31		} else {
32	-	x.xGetNext = purego.NewCallback(func(IterVarp uintptr, OutNameVarp string, ValueVarp **glib.Variant) bool {	32	+	x.xGetNext = purego.NewCallback(func(IterVarp uintptr, OutNameVarp string, ValueVarp *glib.Variant) bool {
33		return cb(MenuAttributeIterNewFromInternalPtr(IterVarp), OutNameVarp, ValueVarp)	33		return cb(MenuAttributeIterNewFromInternalPtr(IterVarp), OutNameVarp, ValueVarp)
34		})	34		})
35		}	35		}
36		}	36		}
37			37
38	-	// GetGetNext gets the callback function.	38	+	// GetGetNext gets the "get_next" callback function.
39	-	func (x MenuAttributeIterClass) GetGetNext() func(MenuAttributeIter, string, **glib.Variant) bool {	39	+	func (x MenuAttributeIterClass) GetGetNext() func(MenuAttributeIter, string, *glib.Variant) bool {
40		if x.xGetNext == 0 {	40		if x.xGetNext == 0 {
41		return nil	41		return nil
42		}	42		}
43	-	var rawCallback func(IterVarp uintptr, OutNameVarp string, ValueVarp **glib.Variant) bool	43	+	var rawCallback func(IterVarp uintptr, OutNameVarp string, ValueVarp *glib.Variant) bool
44		purego.RegisterFunc(&rawCallback, x.xGetNext)	44		purego.RegisterFunc(&rawCallback, x.xGetNext)
45	-	return func(IterVar MenuAttributeIter, OutNameVar string, ValueVar *glib.Variant) bool {	45	+	return func(IterVar MenuAttributeIter, OutNameVar string, ValueVar **glib.Variant) bool {
46		return rawCallback(IterVar.GoPointer(), OutNameVar, ValueVar)	46		return rawCallback(IterVar.GoPointer(), OutNameVar, ValueVar)
47		}	47		}
48		}	48		}

@@ -67,26 +67,26 @@ func (x *MenuLinkIterClass) GoPointer() uintptr {
67		return uintptr(unsafe.Pointer(x))	67		return uintptr(unsafe.Pointer(x))
68		}	68		}
69			69
70	-	// OverrideGetNext sets the callback function.	70	+	// OverrideGetNext sets the "get_next" callback function.
71	-	func (x MenuLinkIterClass) OverrideGetNext(cb func(MenuLinkIter, string, **MenuModel) bool) {	71	+	func (x MenuLinkIterClass) OverrideGetNext(cb func(MenuLinkIter, string, *MenuModel) bool) {
72		if cb == nil {	72		if cb == nil {
73		x.xGetNext = 0	73		x.xGetNext = 0
74		} else {	74		} else {
75	-	x.xGetNext = purego.NewCallback(func(IterVarp uintptr, OutLinkVarp string, ValueVarp uintptr) bool {	75	+	x.xGetNext = purego.NewCallback(func(IterVarp uintptr, OutLinkVarp string, ValueVarp *MenuModel) bool {
76	-	return cb(MenuLinkIterNewFromInternalPtr(IterVarp), OutLinkVarp, (**MenuModel)(unsafe.Pointer(ValueVarp)))	76	+	return cb(MenuLinkIterNewFromInternalPtr(IterVarp), OutLinkVarp, ValueVarp)
77		})	77		})
78		}	78		}
79		}	79		}
80			80
81	-	// GetGetNext gets the callback function.	81	+	// GetGetNext gets the "get_next" callback function.
82	-	func (x MenuLinkIterClass) GetGetNext() func(MenuLinkIter, string, **MenuModel) bool {	82	+	func (x MenuLinkIterClass) GetGetNext() func(MenuLinkIter, string, *MenuModel) bool {
83		if x.xGetNext == 0 {	83		if x.xGetNext == 0 {
84		return nil	84		return nil
85		}	85		}
86	-	var rawCallback func(IterVarp uintptr, OutLinkVarp string, ValueVarp uintptr) bool	86	+	var rawCallback func(IterVarp uintptr, OutLinkVarp string, ValueVarp *MenuModel) bool
87		purego.RegisterFunc(&rawCallback, x.xGetNext)	87		purego.RegisterFunc(&rawCallback, x.xGetNext)
88	-	return func(IterVar MenuLinkIter, OutLinkVar string, ValueVar *MenuModel) bool {	88	+	return func(IterVar MenuLinkIter, OutLinkVar string, ValueVar **MenuModel) bool {
89	-	return rawCallback(IterVar.GoPointer(), OutLinkVar, *gobject.ConvertPtr(ValueVar))	89	+	return rawCallback(IterVar.GoPointer(), OutLinkVar, ValueVar)
90		}	90		}
91		}	91		}
92			92

@@ -124,7 +124,7 @@ func (x *MenuModelClass) GoPointer() uintptr {
124		return uintptr(unsafe.Pointer(x))	124		return uintptr(unsafe.Pointer(x))
125		}	125		}
126			126
127	-	// OverrideIsMutable sets the callback function.	127	+	// OverrideIsMutable sets the "is_mutable" callback function.
128		func (x MenuModelClass) OverrideIsMutable(cb func(MenuModel) bool) {	128		func (x MenuModelClass) OverrideIsMutable(cb func(MenuModel) bool) {
129		if cb == nil {	129		if cb == nil {
130		x.xIsMutable = 0	130		x.xIsMutable = 0

@@ -135,7 +135,7 @@ func (x MenuModelClass) OverrideIsMutable(cb func(MenuModel) bool) {
135		}	135		}
136		}	136		}
137			137
138	-	// GetIsMutable gets the callback function.	138	+	// GetIsMutable gets the "is_mutable" callback function.
139		func (x MenuModelClass) GetIsMutable() func(MenuModel) bool {	139		func (x MenuModelClass) GetIsMutable() func(MenuModel) bool {
140		if x.xIsMutable == 0 {	140		if x.xIsMutable == 0 {
141		return nil	141		return nil

@@ -147,7 +147,7 @@ func (x MenuModelClass) GetIsMutable() func(MenuModel) bool {
147		}	147		}
148		}	148		}
149			149
150	-	// OverrideGetNItems sets the callback function.	150	+	// OverrideGetNItems sets the "get_n_items" callback function.
151		func (x MenuModelClass) OverrideGetNItems(cb func(MenuModel) int) {	151		func (x MenuModelClass) OverrideGetNItems(cb func(MenuModel) int) {
152		if cb == nil {	152		if cb == nil {
153		x.xGetNItems = 0	153		x.xGetNItems = 0

@@ -158,7 +158,7 @@ func (x MenuModelClass) OverrideGetNItems(cb func(MenuModel) int) {
158		}	158		}
159		}	159		}
160			160
161	-	// GetGetNItems gets the callback function.	161	+	// GetGetNItems gets the "get_n_items" callback function.
162		func (x MenuModelClass) GetGetNItems() func(MenuModel) int {	162		func (x MenuModelClass) GetGetNItems() func(MenuModel) int {
163		if x.xGetNItems == 0 {	163		if x.xGetNItems == 0 {
164		return nil	164		return nil

@@ -170,7 +170,7 @@ func (x MenuModelClass) GetGetNItems() func(MenuModel) int {
170		}	170		}
171		}	171		}
172			172
173	-	// OverrideGetItemAttributes sets the callback function.	173	+	// OverrideGetItemAttributes sets the "get_item_attributes" callback function.
174		func (x MenuModelClass) OverrideGetItemAttributes(cb func(MenuModel, int, **glib.HashTable)) {	174		func (x MenuModelClass) OverrideGetItemAttributes(cb func(MenuModel, int, **glib.HashTable)) {
175		if cb == nil {	175		if cb == nil {
176		x.xGetItemAttributes = 0	176		x.xGetItemAttributes = 0

@@ -181,7 +181,7 @@ func (x MenuModelClass) OverrideGetItemAttributes(cb func(MenuModel, int, **gl
181		}	181		}
182		}	182		}
183			183
184	-	// GetGetItemAttributes gets the callback function.	184	+	// GetGetItemAttributes gets the "get_item_attributes" callback function.
185		func (x MenuModelClass) GetGetItemAttributes() func(MenuModel, int, **glib.HashTable) {	185		func (x MenuModelClass) GetGetItemAttributes() func(MenuModel, int, **glib.HashTable) {
186		if x.xGetItemAttributes == 0 {	186		if x.xGetItemAttributes == 0 {
187		return nil	187		return nil

@@ -193,7 +193,7 @@ func (x MenuModelClass) GetGetItemAttributes() func(MenuModel, int, **glib.Has
193		}	193		}
194		}	194		}
195			195
196	-	// OverrideIterateItemAttributes sets the callback function.	196	+	// OverrideIterateItemAttributes sets the "iterate_item_attributes" callback function.
197		func (x MenuModelClass) OverrideIterateItemAttributes(cb func(MenuModel, int) *MenuAttributeIter) {	197		func (x MenuModelClass) OverrideIterateItemAttributes(cb func(MenuModel, int) *MenuAttributeIter) {
198		if cb == nil {	198		if cb == nil {
199		x.xIterateItemAttributes = 0	199		x.xIterateItemAttributes = 0

@@ -208,7 +208,7 @@ func (x MenuModelClass) OverrideIterateItemAttributes(cb func(MenuModel, int)
208		}	208		}
209		}	209		}
210			210
211	-	// GetIterateItemAttributes gets the callback function.	211	+	// GetIterateItemAttributes gets the "iterate_item_attributes" callback function.
212		func (x MenuModelClass) GetIterateItemAttributes() func(MenuModel, int) *MenuAttributeIter {	212		func (x MenuModelClass) GetIterateItemAttributes() func(MenuModel, int) *MenuAttributeIter {
213		if x.xIterateItemAttributes == 0 {	213		if x.xIterateItemAttributes == 0 {
214		return nil	214		return nil

@@ -226,7 +226,7 @@ func (x MenuModelClass) GetIterateItemAttributes() func(MenuModel, int) *MenuA
226		}	226		}
227		}	227		}
228			228
229	-	// OverrideGetItemAttributeValue sets the callback function.	229	+	// OverrideGetItemAttributeValue sets the "get_item_attribute_value" callback function.
230		func (x MenuModelClass) OverrideGetItemAttributeValue(cb func(MenuModel, int, string, glib.VariantType) glib.Variant) {	230		func (x MenuModelClass) OverrideGetItemAttributeValue(cb func(MenuModel, int, string, glib.VariantType) glib.Variant) {
231		if cb == nil {	231		if cb == nil {
232		x.xGetItemAttributeValue = 0	232		x.xGetItemAttributeValue = 0

@@ -237,7 +237,7 @@ func (x MenuModelClass) OverrideGetItemAttributeValue(cb func(MenuModel, int,
237		}	237		}
238		}	238		}
239			239
240	-	// GetGetItemAttributeValue gets the callback function.	240	+	// GetGetItemAttributeValue gets the "get_item_attribute_value" callback function.
241		func (x MenuModelClass) GetGetItemAttributeValue() func(MenuModel, int, string, glib.VariantType) glib.Variant {	241		func (x MenuModelClass) GetGetItemAttributeValue() func(MenuModel, int, string, glib.VariantType) glib.Variant {
242		if x.xGetItemAttributeValue == 0 {	242		if x.xGetItemAttributeValue == 0 {
243		return nil	243		return nil

@@ -249,7 +249,7 @@ func (x MenuModelClass) GetGetItemAttributeValue() func(MenuModel, int, string
249		}	249		}
250		}	250		}
251			251
252	-	// OverrideGetItemLinks sets the callback function.	252	+	// OverrideGetItemLinks sets the "get_item_links" callback function.
253		func (x MenuModelClass) OverrideGetItemLinks(cb func(MenuModel, int, **glib.HashTable)) {	253		func (x MenuModelClass) OverrideGetItemLinks(cb func(MenuModel, int, **glib.HashTable)) {
254		if cb == nil {	254		if cb == nil {
255		x.xGetItemLinks = 0	255		x.xGetItemLinks = 0

@@ -260,7 +260,7 @@ func (x MenuModelClass) OverrideGetItemLinks(cb func(MenuModel, int, **glib.Ha
260		}	260		}
261		}	261		}
262			262
263	-	// GetGetItemLinks gets the callback function.	263	+	// GetGetItemLinks gets the "get_item_links" callback function.
264		func (x MenuModelClass) GetGetItemLinks() func(MenuModel, int, **glib.HashTable) {	264		func (x MenuModelClass) GetGetItemLinks() func(MenuModel, int, **glib.HashTable) {
265		if x.xGetItemLinks == 0 {	265		if x.xGetItemLinks == 0 {
266		return nil	266		return nil

@@ -272,7 +272,7 @@ func (x MenuModelClass) GetGetItemLinks() func(MenuModel, int, **glib.HashTabl
272		}	272		}
273		}	273		}
274			274
275	-	// OverrideIterateItemLinks sets the callback function.	275	+	// OverrideIterateItemLinks sets the "iterate_item_links" callback function.
276		func (x MenuModelClass) OverrideIterateItemLinks(cb func(MenuModel, int) *MenuLinkIter) {	276		func (x MenuModelClass) OverrideIterateItemLinks(cb func(MenuModel, int) *MenuLinkIter) {
277		if cb == nil {	277		if cb == nil {
278		x.xIterateItemLinks = 0	278		x.xIterateItemLinks = 0

@@ -287,7 +287,7 @@ func (x MenuModelClass) OverrideIterateItemLinks(cb func(MenuModel, int) *Menu
287		}	287		}
288		}	288		}
289			289
290	-	// GetIterateItemLinks gets the callback function.	290	+	// GetIterateItemLinks gets the "iterate_item_links" callback function.
291		func (x MenuModelClass) GetIterateItemLinks() func(MenuModel, int) *MenuLinkIter {	291		func (x MenuModelClass) GetIterateItemLinks() func(MenuModel, int) *MenuLinkIter {
292		if x.xIterateItemLinks == 0 {	292		if x.xIterateItemLinks == 0 {
293		return nil	293		return nil

@@ -305,7 +305,7 @@ func (x MenuModelClass) GetIterateItemLinks() func(MenuModel, int) *MenuLinkIt
305		}	305		}
306		}	306		}
307			307
308	-	// OverrideGetItemLink sets the callback function.	308	+	// OverrideGetItemLink sets the "get_item_link" callback function.
309		func (x MenuModelClass) OverrideGetItemLink(cb func(MenuModel, int, string) *MenuModel) {	309		func (x MenuModelClass) OverrideGetItemLink(cb func(MenuModel, int, string) *MenuModel) {
310		if cb == nil {	310		if cb == nil {
311		x.xGetItemLink = 0	311		x.xGetItemLink = 0

@@ -320,7 +320,7 @@ func (x MenuModelClass) OverrideGetItemLink(cb func(MenuModel, int, string) *M
320		}	320		}
321		}	321		}
322			322
323	-	// GetGetItemLink gets the callback function.	323	+	// GetGetItemLink gets the "get_item_link" callback function.
324		func (x MenuModelClass) GetGetItemLink() func(MenuModel, int, string) *MenuModel {	324		func (x MenuModelClass) GetGetItemLink() func(MenuModel, int, string) *MenuModel {
325		if x.xGetItemLink == 0 {	325		if x.xGetItemLink == 0 {
326		return nil	326		return nil

@@ -414,7 +414,7 @@ func (x *MenuAttributeIter) GetName() string {
414		return cret	414		return cret
415		}	415		}
416			416
417	-	var xMenuAttributeIterGetNext func(uintptr, string, **glib.Variant) bool	417	+	var xMenuAttributeIterGetNext func(uintptr, string, *glib.Variant) bool
418			418
419		// This function combines g_menu_attribute_iter_next() with	419		// This function combines g_menu_attribute_iter_next() with
420		// g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value().	420		// g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value().

@@ -431,7 +431,7 @@ var xMenuAttributeIterGetNext func(uintptr, string, **glib.Variant) bool
431		// The value returned in @name remains valid for as long as the iterator	431		// The value returned in @name remains valid for as long as the iterator
432		// remains at the current position. The value returned in @value must	432		// remains at the current position. The value returned in @value must
433		// be unreffed using g_variant_unref() when it is no longer in use.	433		// be unreffed using g_variant_unref() when it is no longer in use.
434	-	func (x MenuAttributeIter) GetNext(OutNameVar string, ValueVar *glib.Variant) bool {	434	+	func (x MenuAttributeIter) GetNext(OutNameVar string, ValueVar **glib.Variant) bool {
435			435
436		cret := xMenuAttributeIterGetNext(x.GoPointer(), OutNameVar, ValueVar)	436		cret := xMenuAttributeIterGetNext(x.GoPointer(), OutNameVar, ValueVar)
437		return cret	437		return cret

@@ -505,7 +505,7 @@ func (x *MenuLinkIter) GetName() string {
505		return cret	505		return cret
506		}	506		}
507			507
508	-	var xMenuLinkIterGetNext func(uintptr, string, uintptr) bool	508	+	var xMenuLinkIterGetNext func(uintptr, string, *MenuModel) bool
509			509
510		// This function combines g_menu_link_iter_next() with	510		// This function combines g_menu_link_iter_next() with
511		// g_menu_link_iter_get_name() and g_menu_link_iter_get_value().	511		// g_menu_link_iter_get_name() and g_menu_link_iter_get_value().

@@ -521,9 +521,9 @@ var xMenuLinkIterGetNext func(uintptr, string, uintptr) bool
521		// The value returned in @out_link remains valid for as long as the iterator	521		// The value returned in @out_link remains valid for as long as the iterator
522		// remains at the current position. The value returned in @value must	522		// remains at the current position. The value returned in @value must
523		// be unreffed using g_object_unref() when it is no longer in use.	523		// be unreffed using g_object_unref() when it is no longer in use.
524	-	func (x MenuLinkIter) GetNext(OutLinkVar string, ValueVar *MenuModel) bool {	524	+	func (x MenuLinkIter) GetNext(OutLinkVar string, ValueVar **MenuModel) bool {
525			525
526	-	cret := xMenuLinkIterGetNext(x.GoPointer(), OutLinkVar, *gobject.ConvertPtr(ValueVar))	526	+	cret := xMenuLinkIterGetNext(x.GoPointer(), OutLinkVar, ValueVar)
527		return cret	527		return cret
528		}	528		}
529			529

M v4/gio/gmount.go +54 -54


@@ -76,7 +76,7 @@ func (x *MountIface) GoPointer() uintptr {
76		return uintptr(unsafe.Pointer(x))	76		return uintptr(unsafe.Pointer(x))
77		}	77		}
78			78
79	-	// OverrideChanged sets the callback function.	79	+	// OverrideChanged sets the "changed" callback function.
80		// Changed signal that is emitted when the mount's state has changed.	80		// Changed signal that is emitted when the mount's state has changed.
81		func (x *MountIface) OverrideChanged(cb func(Mount)) {	81		func (x *MountIface) OverrideChanged(cb func(Mount)) {
82		if cb == nil {	82		if cb == nil {

@@ -88,7 +88,7 @@ func (x *MountIface) OverrideChanged(cb func(Mount)) {
88		}	88		}
89		}	89		}
90			90
91	-	// GetChanged gets the callback function.	91	+	// GetChanged gets the "changed" callback function.
92		// Changed signal that is emitted when the mount's state has changed.	92		// Changed signal that is emitted when the mount's state has changed.
93		func (x *MountIface) GetChanged() func(Mount) {	93		func (x *MountIface) GetChanged() func(Mount) {
94		if x.xChanged == 0 {	94		if x.xChanged == 0 {

@@ -101,7 +101,7 @@ func (x *MountIface) GetChanged() func(Mount) {
101		}	101		}
102		}	102		}
103			103
104	-	// OverrideUnmounted sets the callback function.	104	+	// OverrideUnmounted sets the "unmounted" callback function.
105		// The unmounted signal that is emitted when the #GMount have been unmounted. If the recipient is holding references to the object they should release them so the object can be finalized.	105		// The unmounted signal that is emitted when the #GMount have been unmounted. If the recipient is holding references to the object they should release them so the object can be finalized.
106		func (x *MountIface) OverrideUnmounted(cb func(Mount)) {	106		func (x *MountIface) OverrideUnmounted(cb func(Mount)) {
107		if cb == nil {	107		if cb == nil {

@@ -113,7 +113,7 @@ func (x *MountIface) OverrideUnmounted(cb func(Mount)) {
113		}	113		}
114		}	114		}
115			115
116	-	// GetUnmounted gets the callback function.	116	+	// GetUnmounted gets the "unmounted" callback function.
117		// The unmounted signal that is emitted when the #GMount have been unmounted. If the recipient is holding references to the object they should release them so the object can be finalized.	117		// The unmounted signal that is emitted when the #GMount have been unmounted. If the recipient is holding references to the object they should release them so the object can be finalized.
118		func (x *MountIface) GetUnmounted() func(Mount) {	118		func (x *MountIface) GetUnmounted() func(Mount) {
119		if x.xUnmounted == 0 {	119		if x.xUnmounted == 0 {

@@ -126,7 +126,7 @@ func (x *MountIface) GetUnmounted() func(Mount) {
126		}	126		}
127		}	127		}
128			128
129	-	// OverrideGetRoot sets the callback function.	129	+	// OverrideGetRoot sets the "get_root" callback function.
130		// Gets a #GFile to the root directory of the #GMount.	130		// Gets a #GFile to the root directory of the #GMount.
131		func (x MountIface) OverrideGetRoot(cb func(Mount) FileBase) {	131		func (x MountIface) OverrideGetRoot(cb func(Mount) FileBase) {
132		if cb == nil {	132		if cb == nil {

@@ -142,7 +142,7 @@ func (x MountIface) OverrideGetRoot(cb func(Mount) FileBase) {
142		}	142		}
143		}	143		}
144			144
145	-	// GetGetRoot gets the callback function.	145	+	// GetGetRoot gets the "get_root" callback function.
146		// Gets a #GFile to the root directory of the #GMount.	146		// Gets a #GFile to the root directory of the #GMount.
147		func (x MountIface) GetGetRoot() func(Mount) FileBase {	147		func (x MountIface) GetGetRoot() func(Mount) FileBase {
148		if x.xGetRoot == 0 {	148		if x.xGetRoot == 0 {

@@ -161,7 +161,7 @@ func (x MountIface) GetGetRoot() func(Mount) FileBase {
161		}	161		}
162		}	162		}
163			163
164	-	// OverrideGetName sets the callback function.	164	+	// OverrideGetName sets the "get_name" callback function.
165		// Gets a string containing the name of the #GMount.	165		// Gets a string containing the name of the #GMount.
166		func (x *MountIface) OverrideGetName(cb func(Mount) string) {	166		func (x *MountIface) OverrideGetName(cb func(Mount) string) {
167		if cb == nil {	167		if cb == nil {

@@ -173,7 +173,7 @@ func (x *MountIface) OverrideGetName(cb func(Mount) string) {
173		}	173		}
174		}	174		}
175			175
176	-	// GetGetName gets the callback function.	176	+	// GetGetName gets the "get_name" callback function.
177		// Gets a string containing the name of the #GMount.	177		// Gets a string containing the name of the #GMount.
178		func (x *MountIface) GetGetName() func(Mount) string {	178		func (x *MountIface) GetGetName() func(Mount) string {
179		if x.xGetName == 0 {	179		if x.xGetName == 0 {

@@ -186,7 +186,7 @@ func (x *MountIface) GetGetName() func(Mount) string {
186		}	186		}
187		}	187		}
188			188
189	-	// OverrideGetIcon sets the callback function.	189	+	// OverrideGetIcon sets the "get_icon" callback function.
190		// Gets a #GIcon for the #GMount.	190		// Gets a #GIcon for the #GMount.
191		func (x MountIface) OverrideGetIcon(cb func(Mount) IconBase) {	191		func (x MountIface) OverrideGetIcon(cb func(Mount) IconBase) {
192		if cb == nil {	192		if cb == nil {

@@ -202,7 +202,7 @@ func (x MountIface) OverrideGetIcon(cb func(Mount) IconBase) {
202		}	202		}
203		}	203		}
204			204
205	-	// GetGetIcon gets the callback function.	205	+	// GetGetIcon gets the "get_icon" callback function.
206		// Gets a #GIcon for the #GMount.	206		// Gets a #GIcon for the #GMount.
207		func (x MountIface) GetGetIcon() func(Mount) IconBase {	207		func (x MountIface) GetGetIcon() func(Mount) IconBase {
208		if x.xGetIcon == 0 {	208		if x.xGetIcon == 0 {

@@ -221,7 +221,7 @@ func (x MountIface) GetGetIcon() func(Mount) IconBase {
221		}	221		}
222		}	222		}
223			223
224	-	// OverrideGetUuid sets the callback function.	224	+	// OverrideGetUuid sets the "get_uuid" callback function.
225		// Gets the UUID for the #GMount. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.	225		// Gets the UUID for the #GMount. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.
226		func (x *MountIface) OverrideGetUuid(cb func(Mount) string) {	226		func (x *MountIface) OverrideGetUuid(cb func(Mount) string) {
227		if cb == nil {	227		if cb == nil {

@@ -233,7 +233,7 @@ func (x *MountIface) OverrideGetUuid(cb func(Mount) string) {
233		}	233		}
234		}	234		}
235			235
236	-	// GetGetUuid gets the callback function.	236	+	// GetGetUuid gets the "get_uuid" callback function.
237		// Gets the UUID for the #GMount. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.	237		// Gets the UUID for the #GMount. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.
238		func (x *MountIface) GetGetUuid() func(Mount) string {	238		func (x *MountIface) GetGetUuid() func(Mount) string {
239		if x.xGetUuid == 0 {	239		if x.xGetUuid == 0 {

@@ -246,7 +246,7 @@ func (x *MountIface) GetGetUuid() func(Mount) string {
246		}	246		}
247		}	247		}
248			248
249	-	// OverrideGetVolume sets the callback function.	249	+	// OverrideGetVolume sets the "get_volume" callback function.
250		// Gets a #GVolume the mount is located on. Returns %NULL if the #GMount is not associated with a #GVolume.	250		// Gets a #GVolume the mount is located on. Returns %NULL if the #GMount is not associated with a #GVolume.
251		func (x MountIface) OverrideGetVolume(cb func(Mount) VolumeBase) {	251		func (x MountIface) OverrideGetVolume(cb func(Mount) VolumeBase) {
252		if cb == nil {	252		if cb == nil {

@@ -262,7 +262,7 @@ func (x MountIface) OverrideGetVolume(cb func(Mount) VolumeBase) {
262		}	262		}
263		}	263		}
264			264
265	-	// GetGetVolume gets the callback function.	265	+	// GetGetVolume gets the "get_volume" callback function.
266		// Gets a #GVolume the mount is located on. Returns %NULL if the #GMount is not associated with a #GVolume.	266		// Gets a #GVolume the mount is located on. Returns %NULL if the #GMount is not associated with a #GVolume.
267		func (x MountIface) GetGetVolume() func(Mount) VolumeBase {	267		func (x MountIface) GetGetVolume() func(Mount) VolumeBase {
268		if x.xGetVolume == 0 {	268		if x.xGetVolume == 0 {

@@ -281,7 +281,7 @@ func (x MountIface) GetGetVolume() func(Mount) VolumeBase {
281		}	281		}
282		}	282		}
283			283
284	-	// OverrideGetDrive sets the callback function.	284	+	// OverrideGetDrive sets the "get_drive" callback function.
285		// Gets a #GDrive the volume of the mount is located on. Returns %NULL if the #GMount is not associated with a #GDrive or a #GVolume. This is convenience method for getting the #GVolume and using that to get the #GDrive.	285		// Gets a #GDrive the volume of the mount is located on. Returns %NULL if the #GMount is not associated with a #GDrive or a #GVolume. This is convenience method for getting the #GVolume and using that to get the #GDrive.
286		func (x MountIface) OverrideGetDrive(cb func(Mount) DriveBase) {	286		func (x MountIface) OverrideGetDrive(cb func(Mount) DriveBase) {
287		if cb == nil {	287		if cb == nil {

@@ -297,7 +297,7 @@ func (x MountIface) OverrideGetDrive(cb func(Mount) DriveBase) {
297		}	297		}
298		}	298		}
299			299
300	-	// GetGetDrive gets the callback function.	300	+	// GetGetDrive gets the "get_drive" callback function.
301		// Gets a #GDrive the volume of the mount is located on. Returns %NULL if the #GMount is not associated with a #GDrive or a #GVolume. This is convenience method for getting the #GVolume and using that to get the #GDrive.	301		// Gets a #GDrive the volume of the mount is located on. Returns %NULL if the #GMount is not associated with a #GDrive or a #GVolume. This is convenience method for getting the #GVolume and using that to get the #GDrive.
302		func (x MountIface) GetGetDrive() func(Mount) DriveBase {	302		func (x MountIface) GetGetDrive() func(Mount) DriveBase {
303		if x.xGetDrive == 0 {	303		if x.xGetDrive == 0 {

@@ -316,7 +316,7 @@ func (x MountIface) GetGetDrive() func(Mount) DriveBase {
316		}	316		}
317		}	317		}
318			318
319	-	// OverrideCanUnmount sets the callback function.	319	+	// OverrideCanUnmount sets the "can_unmount" callback function.
320		// Checks if a #GMount can be unmounted.	320		// Checks if a #GMount can be unmounted.
321		func (x *MountIface) OverrideCanUnmount(cb func(Mount) bool) {	321		func (x *MountIface) OverrideCanUnmount(cb func(Mount) bool) {
322		if cb == nil {	322		if cb == nil {

@@ -328,7 +328,7 @@ func (x *MountIface) OverrideCanUnmount(cb func(Mount) bool) {
328		}	328		}
329		}	329		}
330			330
331	-	// GetCanUnmount gets the callback function.	331	+	// GetCanUnmount gets the "can_unmount" callback function.
332		// Checks if a #GMount can be unmounted.	332		// Checks if a #GMount can be unmounted.
333		func (x *MountIface) GetCanUnmount() func(Mount) bool {	333		func (x *MountIface) GetCanUnmount() func(Mount) bool {
334		if x.xCanUnmount == 0 {	334		if x.xCanUnmount == 0 {

@@ -341,7 +341,7 @@ func (x *MountIface) GetCanUnmount() func(Mount) bool {
341		}	341		}
342		}	342		}
343			343
344	-	// OverrideCanEject sets the callback function.	344	+	// OverrideCanEject sets the "can_eject" callback function.
345		// Checks if a #GMount can be ejected.	345		// Checks if a #GMount can be ejected.
346		func (x *MountIface) OverrideCanEject(cb func(Mount) bool) {	346		func (x *MountIface) OverrideCanEject(cb func(Mount) bool) {
347		if cb == nil {	347		if cb == nil {

@@ -353,7 +353,7 @@ func (x *MountIface) OverrideCanEject(cb func(Mount) bool) {
353		}	353		}
354		}	354		}
355			355
356	-	// GetCanEject gets the callback function.	356	+	// GetCanEject gets the "can_eject" callback function.
357		// Checks if a #GMount can be ejected.	357		// Checks if a #GMount can be ejected.
358		func (x *MountIface) GetCanEject() func(Mount) bool {	358		func (x *MountIface) GetCanEject() func(Mount) bool {
359		if x.xCanEject == 0 {	359		if x.xCanEject == 0 {

@@ -366,7 +366,7 @@ func (x *MountIface) GetCanEject() func(Mount) bool {
366		}	366		}
367		}	367		}
368			368
369	-	// OverrideUnmount sets the callback function.	369	+	// OverrideUnmount sets the "unmount" callback function.
370		// Starts unmounting a #GMount.	370		// Starts unmounting a #GMount.
371		func (x MountIface) OverrideUnmount(cb func(Mount, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {	371		func (x MountIface) OverrideUnmount(cb func(Mount, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {
372		if cb == nil {	372		if cb == nil {

@@ -378,7 +378,7 @@ func (x MountIface) OverrideUnmount(cb func(Mount, MountUnmountFlags, Cancella
378		}	378		}
379		}	379		}
380			380
381	-	// GetUnmount gets the callback function.	381	+	// GetUnmount gets the "unmount" callback function.
382		// Starts unmounting a #GMount.	382		// Starts unmounting a #GMount.
383		func (x MountIface) GetUnmount() func(Mount, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {	383		func (x MountIface) GetUnmount() func(Mount, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {
384		if x.xUnmount == 0 {	384		if x.xUnmount == 0 {

@@ -391,7 +391,7 @@ func (x MountIface) GetUnmount() func(Mount, MountUnmountFlags, Cancellable, *
391		}	391		}
392		}	392		}
393			393
394	-	// OverrideUnmountFinish sets the callback function.	394	+	// OverrideUnmountFinish sets the "unmount_finish" callback function.
395		// Finishes an unmounting operation.	395		// Finishes an unmounting operation.
396		func (x *MountIface) OverrideUnmountFinish(cb func(Mount, AsyncResult) bool) {	396		func (x *MountIface) OverrideUnmountFinish(cb func(Mount, AsyncResult) bool) {
397		if cb == nil {	397		if cb == nil {

@@ -403,7 +403,7 @@ func (x *MountIface) OverrideUnmountFinish(cb func(Mount, AsyncResult) bool) {
403		}	403		}
404		}	404		}
405			405
406	-	// GetUnmountFinish gets the callback function.	406	+	// GetUnmountFinish gets the "unmount_finish" callback function.
407		// Finishes an unmounting operation.	407		// Finishes an unmounting operation.
408		func (x *MountIface) GetUnmountFinish() func(Mount, AsyncResult) bool {	408		func (x *MountIface) GetUnmountFinish() func(Mount, AsyncResult) bool {
409		if x.xUnmountFinish == 0 {	409		if x.xUnmountFinish == 0 {

@@ -416,7 +416,7 @@ func (x *MountIface) GetUnmountFinish() func(Mount, AsyncResult) bool {
416		}	416		}
417		}	417		}
418			418
419	-	// OverrideEject sets the callback function.	419	+	// OverrideEject sets the "eject" callback function.
420		// Starts ejecting a #GMount.	420		// Starts ejecting a #GMount.
421		func (x MountIface) OverrideEject(cb func(Mount, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {	421		func (x MountIface) OverrideEject(cb func(Mount, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {
422		if cb == nil {	422		if cb == nil {

@@ -428,7 +428,7 @@ func (x MountIface) OverrideEject(cb func(Mount, MountUnmountFlags, Cancellabl
428		}	428		}
429		}	429		}
430			430
431	-	// GetEject gets the callback function.	431	+	// GetEject gets the "eject" callback function.
432		// Starts ejecting a #GMount.	432		// Starts ejecting a #GMount.
433		func (x MountIface) GetEject() func(Mount, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {	433		func (x MountIface) GetEject() func(Mount, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {
434		if x.xEject == 0 {	434		if x.xEject == 0 {

@@ -441,7 +441,7 @@ func (x MountIface) GetEject() func(Mount, MountUnmountFlags, Cancellable, *As
441		}	441		}
442		}	442		}
443			443
444	-	// OverrideEjectFinish sets the callback function.	444	+	// OverrideEjectFinish sets the "eject_finish" callback function.
445		// Finishes an eject operation.	445		// Finishes an eject operation.
446		func (x *MountIface) OverrideEjectFinish(cb func(Mount, AsyncResult) bool) {	446		func (x *MountIface) OverrideEjectFinish(cb func(Mount, AsyncResult) bool) {
447		if cb == nil {	447		if cb == nil {

@@ -453,7 +453,7 @@ func (x *MountIface) OverrideEjectFinish(cb func(Mount, AsyncResult) bool) {
453		}	453		}
454		}	454		}
455			455
456	-	// GetEjectFinish gets the callback function.	456	+	// GetEjectFinish gets the "eject_finish" callback function.
457		// Finishes an eject operation.	457		// Finishes an eject operation.
458		func (x *MountIface) GetEjectFinish() func(Mount, AsyncResult) bool {	458		func (x *MountIface) GetEjectFinish() func(Mount, AsyncResult) bool {
459		if x.xEjectFinish == 0 {	459		if x.xEjectFinish == 0 {

@@ -466,7 +466,7 @@ func (x *MountIface) GetEjectFinish() func(Mount, AsyncResult) bool {
466		}	466		}
467		}	467		}
468			468
469	-	// OverrideRemount sets the callback function.	469	+	// OverrideRemount sets the "remount" callback function.
470		// Starts remounting a #GMount.	470		// Starts remounting a #GMount.
471		func (x MountIface) OverrideRemount(cb func(Mount, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	471		func (x MountIface) OverrideRemount(cb func(Mount, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
472		if cb == nil {	472		if cb == nil {

@@ -478,7 +478,7 @@ func (x MountIface) OverrideRemount(cb func(Mount, MountMountFlags, MountOpera
478		}	478		}
479		}	479		}
480			480
481	-	// GetRemount gets the callback function.	481	+	// GetRemount gets the "remount" callback function.
482		// Starts remounting a #GMount.	482		// Starts remounting a #GMount.
483		func (x MountIface) GetRemount() func(Mount, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	483		func (x MountIface) GetRemount() func(Mount, MountMountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
484		if x.xRemount == 0 {	484		if x.xRemount == 0 {

@@ -491,7 +491,7 @@ func (x MountIface) GetRemount() func(Mount, MountMountFlags, MountOperation,
491		}	491		}
492		}	492		}
493			493
494	-	// OverrideRemountFinish sets the callback function.	494	+	// OverrideRemountFinish sets the "remount_finish" callback function.
495		// Finishes a remounting operation.	495		// Finishes a remounting operation.
496		func (x *MountIface) OverrideRemountFinish(cb func(Mount, AsyncResult) bool) {	496		func (x *MountIface) OverrideRemountFinish(cb func(Mount, AsyncResult) bool) {
497		if cb == nil {	497		if cb == nil {

@@ -503,7 +503,7 @@ func (x *MountIface) OverrideRemountFinish(cb func(Mount, AsyncResult) bool) {
503		}	503		}
504		}	504		}
505			505
506	-	// GetRemountFinish gets the callback function.	506	+	// GetRemountFinish gets the "remount_finish" callback function.
507		// Finishes a remounting operation.	507		// Finishes a remounting operation.
508		func (x *MountIface) GetRemountFinish() func(Mount, AsyncResult) bool {	508		func (x *MountIface) GetRemountFinish() func(Mount, AsyncResult) bool {
509		if x.xRemountFinish == 0 {	509		if x.xRemountFinish == 0 {

@@ -516,7 +516,7 @@ func (x *MountIface) GetRemountFinish() func(Mount, AsyncResult) bool {
516		}	516		}
517		}	517		}
518			518
519	-	// OverrideGuessContentType sets the callback function.	519	+	// OverrideGuessContentType sets the "guess_content_type" callback function.
520		// Starts guessing the type of the content of a #GMount.	520		// Starts guessing the type of the content of a #GMount.
521		//	521		//
522		// See g_mount_guess_content_type() for more information on content	522		// See g_mount_guess_content_type() for more information on content

@@ -531,7 +531,7 @@ func (x MountIface) OverrideGuessContentType(cb func(Mount, bool, Cancellable,
531		}	531		}
532		}	532		}
533			533
534	-	// GetGuessContentType gets the callback function.	534	+	// GetGuessContentType gets the "guess_content_type" callback function.
535		// Starts guessing the type of the content of a #GMount.	535		// Starts guessing the type of the content of a #GMount.
536		//	536		//
537		// See g_mount_guess_content_type() for more information on content	537		// See g_mount_guess_content_type() for more information on content

@@ -547,7 +547,7 @@ func (x MountIface) GetGuessContentType() func(Mount, bool, Cancellable, *Asyn
547		}	547		}
548		}	548		}
549			549
550	-	// OverrideGuessContentTypeFinish sets the callback function.	550	+	// OverrideGuessContentTypeFinish sets the "guess_content_type_finish" callback function.
551		// Finishes a content type guessing operation. Added in 2.18.	551		// Finishes a content type guessing operation. Added in 2.18.
552		func (x *MountIface) OverrideGuessContentTypeFinish(cb func(Mount, AsyncResult) []string) {	552		func (x *MountIface) OverrideGuessContentTypeFinish(cb func(Mount, AsyncResult) []string) {
553		if cb == nil {	553		if cb == nil {

@@ -559,7 +559,7 @@ func (x *MountIface) OverrideGuessContentTypeFinish(cb func(Mount, AsyncResult)
559		}	559		}
560		}	560		}
561			561
562	-	// GetGuessContentTypeFinish gets the callback function.	562	+	// GetGuessContentTypeFinish gets the "guess_content_type_finish" callback function.
563		// Finishes a content type guessing operation. Added in 2.18.	563		// Finishes a content type guessing operation. Added in 2.18.
564		func (x *MountIface) GetGuessContentTypeFinish() func(Mount, AsyncResult) []string {	564		func (x *MountIface) GetGuessContentTypeFinish() func(Mount, AsyncResult) []string {
565		if x.xGuessContentTypeFinish == 0 {	565		if x.xGuessContentTypeFinish == 0 {

@@ -572,7 +572,7 @@ func (x *MountIface) GetGuessContentTypeFinish() func(Mount, AsyncResult) []stri
572		}	572		}
573		}	573		}
574			574
575	-	// OverrideGuessContentTypeSync sets the callback function.	575	+	// OverrideGuessContentTypeSync sets the "guess_content_type_sync" callback function.
576		// Synchronous variant of @guess_content_type. Added in 2.18	576		// Synchronous variant of @guess_content_type. Added in 2.18
577		func (x MountIface) OverrideGuessContentTypeSync(cb func(Mount, bool, Cancellable) []string) {	577		func (x MountIface) OverrideGuessContentTypeSync(cb func(Mount, bool, Cancellable) []string) {
578		if cb == nil {	578		if cb == nil {

@@ -584,7 +584,7 @@ func (x MountIface) OverrideGuessContentTypeSync(cb func(Mount, bool, Cancella
584		}	584		}
585		}	585		}
586			586
587	-	// GetGuessContentTypeSync gets the callback function.	587	+	// GetGuessContentTypeSync gets the "guess_content_type_sync" callback function.
588		// Synchronous variant of @guess_content_type. Added in 2.18	588		// Synchronous variant of @guess_content_type. Added in 2.18
589		func (x MountIface) GetGuessContentTypeSync() func(Mount, bool, Cancellable) []string {	589		func (x MountIface) GetGuessContentTypeSync() func(Mount, bool, Cancellable) []string {
590		if x.xGuessContentTypeSync == 0 {	590		if x.xGuessContentTypeSync == 0 {

@@ -597,7 +597,7 @@ func (x MountIface) GetGuessContentTypeSync() func(Mount, bool, Cancellable) [
597		}	597		}
598		}	598		}
599			599
600	-	// OverridePreUnmount sets the callback function.	600	+	// OverridePreUnmount sets the "pre_unmount" callback function.
601		// The ::pre-unmount signal that is emitted when the #GMount will soon be emitted. If the recipient is somehow holding the mount open by keeping an open file on it it should close the file.	601		// The ::pre-unmount signal that is emitted when the #GMount will soon be emitted. If the recipient is somehow holding the mount open by keeping an open file on it it should close the file.
602		func (x *MountIface) OverridePreUnmount(cb func(Mount)) {	602		func (x *MountIface) OverridePreUnmount(cb func(Mount)) {
603		if cb == nil {	603		if cb == nil {

@@ -609,7 +609,7 @@ func (x *MountIface) OverridePreUnmount(cb func(Mount)) {
609		}	609		}
610		}	610		}
611			611
612	-	// GetPreUnmount gets the callback function.	612	+	// GetPreUnmount gets the "pre_unmount" callback function.
613		// The ::pre-unmount signal that is emitted when the #GMount will soon be emitted. If the recipient is somehow holding the mount open by keeping an open file on it it should close the file.	613		// The ::pre-unmount signal that is emitted when the #GMount will soon be emitted. If the recipient is somehow holding the mount open by keeping an open file on it it should close the file.
614		func (x *MountIface) GetPreUnmount() func(Mount) {	614		func (x *MountIface) GetPreUnmount() func(Mount) {
615		if x.xPreUnmount == 0 {	615		if x.xPreUnmount == 0 {

@@ -622,7 +622,7 @@ func (x *MountIface) GetPreUnmount() func(Mount) {
622		}	622		}
623		}	623		}
624			624
625	-	// OverrideUnmountWithOperation sets the callback function.	625	+	// OverrideUnmountWithOperation sets the "unmount_with_operation" callback function.
626		// Starts unmounting a #GMount using a #GMountOperation. Since 2.22.	626		// Starts unmounting a #GMount using a #GMountOperation. Since 2.22.
627		func (x MountIface) OverrideUnmountWithOperation(cb func(Mount, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	627		func (x MountIface) OverrideUnmountWithOperation(cb func(Mount, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
628		if cb == nil {	628		if cb == nil {

@@ -634,7 +634,7 @@ func (x *MountIface) OverrideUnmountWithOperation(cb func(Mount, MountUnmountFla
634		}	634		}
635		}	635		}
636			636
637	-	// GetUnmountWithOperation gets the callback function.	637	+	// GetUnmountWithOperation gets the "unmount_with_operation" callback function.
638		// Starts unmounting a #GMount using a #GMountOperation. Since 2.22.	638		// Starts unmounting a #GMount using a #GMountOperation. Since 2.22.
639		func (x MountIface) GetUnmountWithOperation() func(Mount, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	639		func (x MountIface) GetUnmountWithOperation() func(Mount, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
640		if x.xUnmountWithOperation == 0 {	640		if x.xUnmountWithOperation == 0 {

@@ -647,7 +647,7 @@ func (x MountIface) GetUnmountWithOperation() func(Mount, MountUnmountFlags, M
647		}	647		}
648		}	648		}
649			649
650	-	// OverrideUnmountWithOperationFinish sets the callback function.	650	+	// OverrideUnmountWithOperationFinish sets the "unmount_with_operation_finish" callback function.
651		// Finishes an unmounting operation using a #GMountOperation. Since 2.22.	651		// Finishes an unmounting operation using a #GMountOperation. Since 2.22.
652		func (x *MountIface) OverrideUnmountWithOperationFinish(cb func(Mount, AsyncResult) bool) {	652		func (x *MountIface) OverrideUnmountWithOperationFinish(cb func(Mount, AsyncResult) bool) {
653		if cb == nil {	653		if cb == nil {

@@ -659,7 +659,7 @@ func (x *MountIface) OverrideUnmountWithOperationFinish(cb func(Mount, AsyncResu
659		}	659		}
660		}	660		}
661			661
662	-	// GetUnmountWithOperationFinish gets the callback function.	662	+	// GetUnmountWithOperationFinish gets the "unmount_with_operation_finish" callback function.
663		// Finishes an unmounting operation using a #GMountOperation. Since 2.22.	663		// Finishes an unmounting operation using a #GMountOperation. Since 2.22.
664		func (x *MountIface) GetUnmountWithOperationFinish() func(Mount, AsyncResult) bool {	664		func (x *MountIface) GetUnmountWithOperationFinish() func(Mount, AsyncResult) bool {
665		if x.xUnmountWithOperationFinish == 0 {	665		if x.xUnmountWithOperationFinish == 0 {

@@ -672,7 +672,7 @@ func (x *MountIface) GetUnmountWithOperationFinish() func(Mount, AsyncResult) bo
672		}	672		}
673		}	673		}
674			674
675	-	// OverrideEjectWithOperation sets the callback function.	675	+	// OverrideEjectWithOperation sets the "eject_with_operation" callback function.
676		// Starts ejecting a #GMount using a #GMountOperation. Since 2.22.	676		// Starts ejecting a #GMount using a #GMountOperation. Since 2.22.
677		func (x MountIface) OverrideEjectWithOperation(cb func(Mount, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	677		func (x MountIface) OverrideEjectWithOperation(cb func(Mount, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
678		if cb == nil {	678		if cb == nil {

@@ -684,7 +684,7 @@ func (x *MountIface) OverrideEjectWithOperation(cb func(Mount, MountUnmountFlags
684		}	684		}
685		}	685		}
686			686
687	-	// GetEjectWithOperation gets the callback function.	687	+	// GetEjectWithOperation gets the "eject_with_operation" callback function.
688		// Starts ejecting a #GMount using a #GMountOperation. Since 2.22.	688		// Starts ejecting a #GMount using a #GMountOperation. Since 2.22.
689		func (x MountIface) GetEjectWithOperation() func(Mount, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	689		func (x MountIface) GetEjectWithOperation() func(Mount, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
690		if x.xEjectWithOperation == 0 {	690		if x.xEjectWithOperation == 0 {

@@ -697,7 +697,7 @@ func (x MountIface) GetEjectWithOperation() func(Mount, MountUnmountFlags, Mou
697		}	697		}
698		}	698		}
699			699
700	-	// OverrideEjectWithOperationFinish sets the callback function.	700	+	// OverrideEjectWithOperationFinish sets the "eject_with_operation_finish" callback function.
701		// Finishes an eject operation using a #GMountOperation. Since 2.22.	701		// Finishes an eject operation using a #GMountOperation. Since 2.22.
702		func (x *MountIface) OverrideEjectWithOperationFinish(cb func(Mount, AsyncResult) bool) {	702		func (x *MountIface) OverrideEjectWithOperationFinish(cb func(Mount, AsyncResult) bool) {
703		if cb == nil {	703		if cb == nil {

@@ -709,7 +709,7 @@ func (x *MountIface) OverrideEjectWithOperationFinish(cb func(Mount, AsyncResult
709		}	709		}
710		}	710		}
711			711
712	-	// GetEjectWithOperationFinish gets the callback function.	712	+	// GetEjectWithOperationFinish gets the "eject_with_operation_finish" callback function.
713		// Finishes an eject operation using a #GMountOperation. Since 2.22.	713		// Finishes an eject operation using a #GMountOperation. Since 2.22.
714		func (x *MountIface) GetEjectWithOperationFinish() func(Mount, AsyncResult) bool {	714		func (x *MountIface) GetEjectWithOperationFinish() func(Mount, AsyncResult) bool {
715		if x.xEjectWithOperationFinish == 0 {	715		if x.xEjectWithOperationFinish == 0 {

@@ -722,7 +722,7 @@ func (x *MountIface) GetEjectWithOperationFinish() func(Mount, AsyncResult) bool
722		}	722		}
723		}	723		}
724			724
725	-	// OverrideGetDefaultLocation sets the callback function.	725	+	// OverrideGetDefaultLocation sets the "get_default_location" callback function.
726		// Gets a #GFile indication a start location that can be use as the entry point for this mount. Since 2.24.	726		// Gets a #GFile indication a start location that can be use as the entry point for this mount. Since 2.24.
727		func (x MountIface) OverrideGetDefaultLocation(cb func(Mount) FileBase) {	727		func (x MountIface) OverrideGetDefaultLocation(cb func(Mount) FileBase) {
728		if cb == nil {	728		if cb == nil {

@@ -738,7 +738,7 @@ func (x MountIface) OverrideGetDefaultLocation(cb func(Mount) FileBase) {
738		}	738		}
739		}	739		}
740			740
741	-	// GetGetDefaultLocation gets the callback function.	741	+	// GetGetDefaultLocation gets the "get_default_location" callback function.
742		// Gets a #GFile indication a start location that can be use as the entry point for this mount. Since 2.24.	742		// Gets a #GFile indication a start location that can be use as the entry point for this mount. Since 2.24.
743		func (x MountIface) GetGetDefaultLocation() func(Mount) FileBase {	743		func (x MountIface) GetGetDefaultLocation() func(Mount) FileBase {
744		if x.xGetDefaultLocation == 0 {	744		if x.xGetDefaultLocation == 0 {

@@ -757,7 +757,7 @@ func (x MountIface) GetGetDefaultLocation() func(Mount) FileBase {
757		}	757		}
758		}	758		}
759			759
760	-	// OverrideGetSortKey sets the callback function.	760	+	// OverrideGetSortKey sets the "get_sort_key" callback function.
761		// Gets a key used for sorting #GMount instance or %NULL if no such key exists. Since 2.32.	761		// Gets a key used for sorting #GMount instance or %NULL if no such key exists. Since 2.32.
762		func (x *MountIface) OverrideGetSortKey(cb func(Mount) string) {	762		func (x *MountIface) OverrideGetSortKey(cb func(Mount) string) {
763		if cb == nil {	763		if cb == nil {

@@ -769,7 +769,7 @@ func (x *MountIface) OverrideGetSortKey(cb func(Mount) string) {
769		}	769		}
770		}	770		}
771			771
772	-	// GetGetSortKey gets the callback function.	772	+	// GetGetSortKey gets the "get_sort_key" callback function.
773		// Gets a key used for sorting #GMount instance or %NULL if no such key exists. Since 2.32.	773		// Gets a key used for sorting #GMount instance or %NULL if no such key exists. Since 2.32.
774		func (x *MountIface) GetGetSortKey() func(Mount) string {	774		func (x *MountIface) GetGetSortKey() func(Mount) string {
775		if x.xGetSortKey == 0 {	775		if x.xGetSortKey == 0 {

@@ -782,7 +782,7 @@ func (x *MountIface) GetGetSortKey() func(Mount) string {
782		}	782		}
783		}	783		}
784			784
785	-	// OverrideGetSymbolicIcon sets the callback function.	785	+	// OverrideGetSymbolicIcon sets the "get_symbolic_icon" callback function.
786		// Gets a symbolic #GIcon for the #GMount. Since 2.34.	786		// Gets a symbolic #GIcon for the #GMount. Since 2.34.
787		func (x MountIface) OverrideGetSymbolicIcon(cb func(Mount) IconBase) {	787		func (x MountIface) OverrideGetSymbolicIcon(cb func(Mount) IconBase) {
788		if cb == nil {	788		if cb == nil {

@@ -798,7 +798,7 @@ func (x MountIface) OverrideGetSymbolicIcon(cb func(Mount) IconBase) {
798		}	798		}
799		}	799		}
800			800
801	-	// GetGetSymbolicIcon gets the callback function.	801	+	// GetGetSymbolicIcon gets the "get_symbolic_icon" callback function.
802		// Gets a symbolic #GIcon for the #GMount. Since 2.34.	802		// Gets a symbolic #GIcon for the #GMount. Since 2.34.
803		func (x MountIface) GetGetSymbolicIcon() func(Mount) IconBase {	803		func (x MountIface) GetGetSymbolicIcon() func(Mount) IconBase {
804		if x.xGetSymbolicIcon == 0 {	804		if x.xGetSymbolicIcon == 0 {

M v4/gio/gmountoperation.go +184 -30

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideAskPassword sets the callback function.
+// OverrideAskPassword sets the "ask_password" callback function.
 func (x *MountOperationClass) OverrideAskPassword(cb func(*MountOperation, string, string, string, AskPasswordFlags)) {
 	if cb == nil {
 		x.xAskPassword = 0
 	}
 }
-// GetAskPassword gets the callback function.
+// GetAskPassword gets the "ask_password" callback function.
 func (x *MountOperationClass) GetAskPassword() func(*MountOperation, string, string, string, AskPasswordFlags) {
 	if x.xAskPassword == 0 {
 		return nil
 	}
 }
-// OverrideAskQuestion sets the callback function.
+// OverrideAskQuestion sets the "ask_question" callback function.
 func (x *MountOperationClass) OverrideAskQuestion(cb func(*MountOperation, string, []string)) {
 	if cb == nil {
 		x.xAskQuestion = 0
 	}
 }
-// GetAskQuestion gets the callback function.
+// GetAskQuestion gets the "ask_question" callback function.
 func (x *MountOperationClass) GetAskQuestion() func(*MountOperation, string, []string) {
 	if x.xAskQuestion == 0 {
 		return nil
 	}
 }
-// OverrideReply sets the callback function.
+// OverrideReply sets the "reply" callback function.
 func (x *MountOperationClass) OverrideReply(cb func(*MountOperation, MountOperationResult)) {
 	if cb == nil {
 		x.xReply = 0
 	}
 }
-// GetReply gets the callback function.
+// GetReply gets the "reply" callback function.
 func (x *MountOperationClass) GetReply() func(*MountOperation, MountOperationResult) {
 	if x.xReply == 0 {
 		return nil
 	}
 }
-// OverrideAborted sets the callback function.
+// OverrideAborted sets the "aborted" callback function.
 func (x *MountOperationClass) OverrideAborted(cb func(*MountOperation)) {
 	if cb == nil {
 		x.xAborted = 0
 	}
 }
-// GetAborted gets the callback function.
+// GetAborted gets the "aborted" callback function.
 func (x *MountOperationClass) GetAborted() func(*MountOperation) {
 	if x.xAborted == 0 {
 		return nil
 	}
 }
-// OverrideShowProcesses sets the callback function.
+// OverrideShowProcesses sets the "show_processes" callback function.
 func (x *MountOperationClass) OverrideShowProcesses(cb func(*MountOperation, string, []glib.Pid, []string)) {
 	if cb == nil {
 		x.xShowProcesses = 0
 	}
 }
-// GetShowProcesses gets the callback function.
+// GetShowProcesses gets the "show_processes" callback function.
 func (x *MountOperationClass) GetShowProcesses() func(*MountOperation, string, []glib.Pid, []string) {
 	if x.xShowProcesses == 0 {
 		return nil
 	}
 }
-// OverrideShowUnmountProgress sets the callback function.
+// OverrideShowUnmountProgress sets the "show_unmount_progress" callback function.
 func (x *MountOperationClass) OverrideShowUnmountProgress(cb func(*MountOperation, string, int64, int64)) {
 	if cb == nil {
 		x.xShowUnmountProgress = 0
 	}
 }
-// GetShowUnmountProgress gets the callback function.
+// GetShowUnmountProgress gets the "show_unmount_progress" callback function.
 func (x *MountOperationClass) GetShowUnmountProgress() func(*MountOperation, string, int64, int64) {
 	if x.xShowUnmountProgress == 0 {
 		return nil
 	}
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *MountOperationClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *MountOperationClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *MountOperationClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *MountOperationClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *MountOperationClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *MountOperationClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *MountOperationClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *MountOperationClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *MountOperationClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *MountOperationClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved6 sets the callback function.
+// OverrideGReserved6 sets the "_g_reserved6" callback function.
 func (x *MountOperationClass) OverrideGReserved6(cb func()) {
 	if cb == nil {
 		x.xGReserved6 = 0
 	}
 }
-// GetGReserved6 gets the callback function.
+// GetGReserved6 gets the "_g_reserved6" callback function.
 func (x *MountOperationClass) GetGReserved6() func() {
 	if x.xGReserved6 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved7 sets the callback function.
+// OverrideGReserved7 sets the "_g_reserved7" callback function.
 func (x *MountOperationClass) OverrideGReserved7(cb func()) {
 	if cb == nil {
 		x.xGReserved7 = 0
 	}
 }
-// GetGReserved7 gets the callback function.
+// GetGReserved7 gets the "_g_reserved7" callback function.
 func (x *MountOperationClass) GetGReserved7() func() {
 	if x.xGReserved7 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved8 sets the callback function.
+// OverrideGReserved8 sets the "_g_reserved8" callback function.
 func (x *MountOperationClass) OverrideGReserved8(cb func()) {
 	if cb == nil {
 		x.xGReserved8 = 0
 	}
 }
-// GetGReserved8 gets the callback function.
+// GetGReserved8 gets the "_g_reserved8" callback function.
 func (x *MountOperationClass) GetGReserved8() func() {
 	if x.xGReserved8 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved9 sets the callback function.
+// OverrideGReserved9 sets the "_g_reserved9" callback function.
 func (x *MountOperationClass) OverrideGReserved9(cb func()) {
 	if cb == nil {
 		x.xGReserved9 = 0
 	}
 }
-// GetGReserved9 gets the callback function.
+// GetGReserved9 gets the "_g_reserved9" callback function.
 func (x *MountOperationClass) GetGReserved9() func() {
 	if x.xGReserved9 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyAnonymous sets the "anonymous" property.
+// Whether to use an anonymous user when authenticating.
+func (x *MountOperation) SetPropertyAnonymous(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("anonymous", &v)
+}
+// GetPropertyAnonymous gets the "anonymous" property.
+// Whether to use an anonymous user when authenticating.
+func (x *MountOperation) GetPropertyAnonymous() bool {
+	var v gobject.Value
+	x.GetProperty("anonymous", &v)
+	return v.GetBoolean()
+}
+// SetPropertyChoice sets the "choice" property.
+// The index of the user's choice when a question is asked during the
+// mount operation. See the #GMountOperation::ask-question signal.
+func (x *MountOperation) SetPropertyChoice(value int) {
+	var v gobject.Value
+	v.Init(gobject.TypeIntVal)
+	v.SetInt(value)
+	x.SetProperty("choice", &v)
+}
+// GetPropertyChoice gets the "choice" property.
+// The index of the user's choice when a question is asked during the
+// mount operation. See the #GMountOperation::ask-question signal.
+func (x *MountOperation) GetPropertyChoice() int {
+	var v gobject.Value
+	x.GetProperty("choice", &v)
+	return v.GetInt()
+}
+// SetPropertyDomain sets the "domain" property.
+// The domain to use for the mount operation.
+func (x *MountOperation) SetPropertyDomain(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("domain", &v)
+}
+// GetPropertyDomain gets the "domain" property.
+// The domain to use for the mount operation.
+func (x *MountOperation) GetPropertyDomain() string {
+	var v gobject.Value
+	x.GetProperty("domain", &v)
+	return v.GetString()
+}
+// SetPropertyIsTcryptHiddenVolume sets the "is-tcrypt-hidden-volume" property.
+// Whether the device to be unlocked is a TCRYPT hidden volume.
+// See [the VeraCrypt documentation](https://www.veracrypt.fr/en/Hidden%20Volume.html).
+func (x *MountOperation) SetPropertyIsTcryptHiddenVolume(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("is-tcrypt-hidden-volume", &v)
+}
+// GetPropertyIsTcryptHiddenVolume gets the "is-tcrypt-hidden-volume" property.
+// Whether the device to be unlocked is a TCRYPT hidden volume.
+// See [the VeraCrypt documentation](https://www.veracrypt.fr/en/Hidden%20Volume.html).
+func (x *MountOperation) GetPropertyIsTcryptHiddenVolume() bool {
+	var v gobject.Value
+	x.GetProperty("is-tcrypt-hidden-volume", &v)
+	return v.GetBoolean()
+}
+// SetPropertyIsTcryptSystemVolume sets the "is-tcrypt-system-volume" property.
+// Whether the device to be unlocked is a TCRYPT system volume.
+// In this context, a system volume is a volume with a bootloader
+// and operating system installed. This is only supported for Windows
+// operating systems. For further documentation, see
+// [the VeraCrypt documentation](https://www.veracrypt.fr/en/System%20Encryption.html).
+func (x *MountOperation) SetPropertyIsTcryptSystemVolume(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("is-tcrypt-system-volume", &v)
+}
+// GetPropertyIsTcryptSystemVolume gets the "is-tcrypt-system-volume" property.
+// Whether the device to be unlocked is a TCRYPT system volume.
+// In this context, a system volume is a volume with a bootloader
+// and operating system installed. This is only supported for Windows
+// operating systems. For further documentation, see
+// [the VeraCrypt documentation](https://www.veracrypt.fr/en/System%20Encryption.html).
+func (x *MountOperation) GetPropertyIsTcryptSystemVolume() bool {
+	var v gobject.Value
+	x.GetProperty("is-tcrypt-system-volume", &v)
+	return v.GetBoolean()
+}
+// SetPropertyPassword sets the "password" property.
+// The password that is used for authentication when carrying out
+// the mount operation.
+func (x *MountOperation) SetPropertyPassword(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("password", &v)
+}
+// GetPropertyPassword gets the "password" property.
+// The password that is used for authentication when carrying out
+// the mount operation.
+func (x *MountOperation) GetPropertyPassword() string {
+	var v gobject.Value
+	x.GetProperty("password", &v)
+	return v.GetString()
+}
+// SetPropertyPim sets the "pim" property.
+// The VeraCrypt PIM value, when unlocking a VeraCrypt volume. See
+// [the VeraCrypt documentation](https://www.veracrypt.fr/en/Personal%20Iterations%20Multiplier%20(PIM).html).
+func (x *MountOperation) SetPropertyPim(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("pim", &v)
+}
+// GetPropertyPim gets the "pim" property.
+// The VeraCrypt PIM value, when unlocking a VeraCrypt volume. See
+// [the VeraCrypt documentation](https://www.veracrypt.fr/en/Personal%20Iterations%20Multiplier%20(PIM).html).
+func (x *MountOperation) GetPropertyPim() uint {
+	var v gobject.Value
+	x.GetProperty("pim", &v)
+	return v.GetUint()
+}
+// SetPropertyUsername sets the "username" property.
+// The user name that is used for authentication when carrying out
+// the mount operation.
+func (x *MountOperation) SetPropertyUsername(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("username", &v)
+}
+// GetPropertyUsername gets the "username" property.
+// The user name that is used for authentication when carrying out
+// the mount operation.
+func (x *MountOperation) GetPropertyUsername() string {
+	var v gobject.Value
+	x.GetProperty("username", &v)
+	return v.GetString()
+}
 // Emitted by the backend when e.g. a device becomes unavailable
 // while a mount operation is in progress.
 //

M v4/gio/gnativevolumemonitor.go +2 -2


@@ -21,7 +21,7 @@ func (x *NativeVolumeMonitorClass) GoPointer() uintptr {
21		return uintptr(unsafe.Pointer(x))	21		return uintptr(unsafe.Pointer(x))
22		}	22		}
23			23
24	-	// OverrideGetMountForMountPath sets the callback function.	24	+	// OverrideGetMountForMountPath sets the "get_mount_for_mount_path" callback function.
25		func (x NativeVolumeMonitorClass) OverrideGetMountForMountPath(cb func(string, Cancellable) *MountBase) {	25		func (x NativeVolumeMonitorClass) OverrideGetMountForMountPath(cb func(string, Cancellable) *MountBase) {
26		if cb == nil {	26		if cb == nil {
27		x.xGetMountForMountPath = 0	27		x.xGetMountForMountPath = 0

@@ -36,7 +36,7 @@ func (x *NativeVolumeMonitorClass) OverrideGetMountForMountPath(cb func(string,
36		}	36		}
37		}	37		}
38			38
39	-	// GetGetMountForMountPath gets the callback function.	39	+	// GetGetMountForMountPath gets the "get_mount_for_mount_path" callback function.
40		func (x NativeVolumeMonitorClass) GetGetMountForMountPath() func(string, Cancellable) *MountBase {	40		func (x NativeVolumeMonitorClass) GetGetMountForMountPath() func(string, Cancellable) *MountBase {
41		if x.xGetMountForMountPath == 0 {	41		if x.xGetMountForMountPath == 0 {
42		return nil	42		return nil

M v4/gio/gnetworkaddress.go +51 -0


@@ -145,6 +145,57 @@ func (c *NetworkAddress) SetGoPointer(ptr uintptr) {
145	c.Ptr = ptr	145		c.Ptr = ptr
146	}	146		}
147		147
		148	+	// SetPropertyHostname sets the "hostname" property.
		149	+	// Hostname to resolve.
		150	+	func (x *NetworkAddress) SetPropertyHostname(value string) {
		151	+	var v gobject.Value
		152	+	v.Init(gobject.TypeStringVal)
		153	+	v.SetString(value)
		154	+	x.SetProperty("hostname", &v)
		155	+	}
		156	+
		157	+	// GetPropertyHostname gets the "hostname" property.
		158	+	// Hostname to resolve.
		159	+	func (x *NetworkAddress) GetPropertyHostname() string {
		160	+	var v gobject.Value
		161	+	x.GetProperty("hostname", &v)
		162	+	return v.GetString()
		163	+	}
		164	+
		165	+	// SetPropertyPort sets the "port" property.
		166	+	// Network port.
		167	+	func (x *NetworkAddress) SetPropertyPort(value uint) {
		168	+	var v gobject.Value
		169	+	v.Init(gobject.TypeUintVal)
		170	+	v.SetUint(value)
		171	+	x.SetProperty("port", &v)
		172	+	}
		173	+
		174	+	// GetPropertyPort gets the "port" property.
		175	+	// Network port.
		176	+	func (x *NetworkAddress) GetPropertyPort() uint {
		177	+	var v gobject.Value
		178	+	x.GetProperty("port", &v)
		179	+	return v.GetUint()
		180	+	}
		181	+
		182	+	// SetPropertyScheme sets the "scheme" property.
		183	+	// URI scheme.
		184	+	func (x *NetworkAddress) SetPropertyScheme(value string) {
		185	+	var v gobject.Value
		186	+	v.Init(gobject.TypeStringVal)
		187	+	v.SetString(value)
		188	+	x.SetProperty("scheme", &v)
		189	+	}
		190	+
		191	+	// GetPropertyScheme gets the "scheme" property.
		192	+	// URI scheme.
		193	+	func (x *NetworkAddress) GetPropertyScheme() string {
		194	+	var v gobject.Value
		195	+	x.GetProperty("scheme", &v)
		196	+	return v.GetString()
		197	+	}
		198	+
148	// Creates a #GSocketAddressEnumerator for @connectable.	199		// Creates a #GSocketAddressEnumerator for @connectable.
149	func (x NetworkAddress) Enumerate() SocketAddressEnumerator {	200		func (x NetworkAddress) Enumerate() SocketAddressEnumerator {
150	var cls *SocketAddressEnumerator	201		var cls *SocketAddressEnumerator

M v4/gio/gnetworkmonitor.go +64 -8

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideNetworkChanged sets the callback function.
+// OverrideNetworkChanged sets the "network_changed" callback function.
 // the virtual function pointer for the
 //
 //	GNetworkMonitor::network-changed signal.
 	}
 }
-// GetNetworkChanged gets the callback function.
+// GetNetworkChanged gets the "network_changed" callback function.
 // the virtual function pointer for the
 //
 //	GNetworkMonitor::network-changed signal.
 	}
 }
-// OverrideCanReach sets the callback function.
+// OverrideCanReach sets the "can_reach" callback function.
 // the virtual function pointer for g_network_monitor_can_reach()
 func (x *NetworkMonitorInterface) OverrideCanReach(cb func(NetworkMonitor, SocketConnectable, *Cancellable) bool) {
 	if cb == nil {
 	}
 }
-// GetCanReach gets the callback function.
+// GetCanReach gets the "can_reach" callback function.
 // the virtual function pointer for g_network_monitor_can_reach()
 func (x *NetworkMonitorInterface) GetCanReach() func(NetworkMonitor, SocketConnectable, *Cancellable) bool {
 	if x.xCanReach == 0 {
 	}
 }
-// OverrideCanReachAsync sets the callback function.
+// OverrideCanReachAsync sets the "can_reach_async" callback function.
 // the virtual function pointer for
 //
 //	g_network_monitor_can_reach_async()
 	}
 }
-// GetCanReachAsync gets the callback function.
+// GetCanReachAsync gets the "can_reach_async" callback function.
 // the virtual function pointer for
 //
 //	g_network_monitor_can_reach_async()
 	}
 }
-// OverrideCanReachFinish sets the callback function.
+// OverrideCanReachFinish sets the "can_reach_finish" callback function.
 // the virtual function pointer for
 //
 //	g_network_monitor_can_reach_finish()
 	}
 }
-// GetCanReachFinish gets the callback function.
+// GetCanReachFinish gets the "can_reach_finish" callback function.
 // the virtual function pointer for
 //
 //	g_network_monitor_can_reach_finish()
 	return cret
 }
+// GetPropertyNetworkAvailable gets the "network-available" property.
+// Whether the network is considered available. That is, whether the
+// system has a default route for at least one of IPv4 or IPv6.
+//
+// Real-world networks are of course much more complicated than
+// this; the machine may be connected to a wifi hotspot that
+// requires payment before allowing traffic through, or may be
+// connected to a functioning router that has lost its own upstream
+// connectivity. Some hosts might only be accessible when a VPN is
+// active. Other hosts might only be accessible when the VPN is
+// not active. Thus, it is best to use g_network_monitor_can_reach()
+// or g_network_monitor_can_reach_async() to test for reachability
+// on a host-by-host basis. (On the other hand, when the property is
+// %FALSE, the application can reasonably expect that no remote
+// hosts at all are reachable, and should indicate this to the user
+// in its UI.)
+//
+// See also #GNetworkMonitor::network-changed.
+func (x *NetworkMonitorBase) GetPropertyNetworkAvailable() bool {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("network-available", &v)
+	return v.GetBoolean()
+}
+// GetPropertyNetworkMetered gets the "network-metered" property.
+// Whether the network is considered metered.
+//
+// That is, whether the
+// system has traffic flowing through the default connection that is
+// subject to limitations set by service providers. For example, traffic
+// might be billed by the amount of data transmitted, or there might be a
+// quota on the amount of traffic per month. This is typical with tethered
+// connections (3G and 4G) and in such situations, bandwidth intensive
+// applications may wish to avoid network activity where possible if it will
+// cost the user money or use up their limited quota. Anything more than a
+// few hundreds of kilobytes of data usage per hour should be avoided without
+// asking permission from the user.
+//
+// If more information is required about specific devices then the
+// system network management API should be used instead (for example,
+// NetworkManager or ConnMan).
+//
+// If this information is not available then no networks will be
+// marked as metered.
+//
+// See also #GNetworkMonitor:network-available.
+func (x *NetworkMonitorBase) GetPropertyNetworkMetered() bool {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("network-metered", &v)
+	return v.GetBoolean()
+}
 var XGNetworkMonitorCanReach func(uintptr, uintptr, uintptr, **glib.Error) bool
 var XGNetworkMonitorCanReachAsync func(uintptr, uintptr, uintptr, uintptr, uintptr)
 var XGNetworkMonitorCanReachFinish func(uintptr, uintptr, **glib.Error) bool

M v4/gio/gnetworkservice.go +68 -0


@@ -131,6 +131,74 @@ func (c *NetworkService) SetGoPointer(ptr uintptr) {
131	c.Ptr = ptr	131		c.Ptr = ptr
132	}	132		}
133		133
		134	+	// SetPropertyDomain sets the "domain" property.
		135	+	// Network domain, for example `example.com`.
		136	+	func (x *NetworkService) SetPropertyDomain(value string) {
		137	+	var v gobject.Value
		138	+	v.Init(gobject.TypeStringVal)
		139	+	v.SetString(value)
		140	+	x.SetProperty("domain", &v)
		141	+	}
		142	+
		143	+	// GetPropertyDomain gets the "domain" property.
		144	+	// Network domain, for example `example.com`.
		145	+	func (x *NetworkService) GetPropertyDomain() string {
		146	+	var v gobject.Value
		147	+	x.GetProperty("domain", &v)
		148	+	return v.GetString()
		149	+	}
		150	+
		151	+	// SetPropertyProtocol sets the "protocol" property.
		152	+	// Network protocol, for example `tcp`.
		153	+	func (x *NetworkService) SetPropertyProtocol(value string) {
		154	+	var v gobject.Value
		155	+	v.Init(gobject.TypeStringVal)
		156	+	v.SetString(value)
		157	+	x.SetProperty("protocol", &v)
		158	+	}
		159	+
		160	+	// GetPropertyProtocol gets the "protocol" property.
		161	+	// Network protocol, for example `tcp`.
		162	+	func (x *NetworkService) GetPropertyProtocol() string {
		163	+	var v gobject.Value
		164	+	x.GetProperty("protocol", &v)
		165	+	return v.GetString()
		166	+	}
		167	+
		168	+	// SetPropertyScheme sets the "scheme" property.
		169	+	// Network scheme (default is to use service).
		170	+	func (x *NetworkService) SetPropertyScheme(value string) {
		171	+	var v gobject.Value
		172	+	v.Init(gobject.TypeStringVal)
		173	+	v.SetString(value)
		174	+	x.SetProperty("scheme", &v)
		175	+	}
		176	+
		177	+	// GetPropertyScheme gets the "scheme" property.
		178	+	// Network scheme (default is to use service).
		179	+	func (x *NetworkService) GetPropertyScheme() string {
		180	+	var v gobject.Value
		181	+	x.GetProperty("scheme", &v)
		182	+	return v.GetString()
		183	+	}
		184	+
		185	+	// SetPropertyService sets the "service" property.
		186	+	// Service name, for example `ldap`.
		187	+	func (x *NetworkService) SetPropertyService(value string) {
		188	+	var v gobject.Value
		189	+	v.Init(gobject.TypeStringVal)
		190	+	v.SetString(value)
		191	+	x.SetProperty("service", &v)
		192	+	}
		193	+
		194	+	// GetPropertyService gets the "service" property.
		195	+	// Service name, for example `ldap`.
		196	+	func (x *NetworkService) GetPropertyService() string {
		197	+	var v gobject.Value
		198	+	x.GetProperty("service", &v)
		199	+	return v.GetString()
		200	+	}
		201	+
134	// Creates a #GSocketAddressEnumerator for @connectable.	202		// Creates a #GSocketAddressEnumerator for @connectable.
135	func (x NetworkService) Enumerate() SocketAddressEnumerator {	203		func (x NetworkService) Enumerate() SocketAddressEnumerator {
136	var cls *SocketAddressEnumerator	204		var cls *SocketAddressEnumerator

M v4/gio/goutputstream.go +66 -66


@@ -62,7 +62,7 @@ func (x *OutputStreamClass) GoPointer() uintptr {
62		return uintptr(unsafe.Pointer(x))	62		return uintptr(unsafe.Pointer(x))
63		}	63		}
64			64
65	-	// OverrideWriteFn sets the callback function.	65	+	// OverrideWriteFn sets the "write_fn" callback function.
66		func (x OutputStreamClass) OverrideWriteFn(cb func(OutputStream, []byte, uint, *Cancellable) int) {	66		func (x OutputStreamClass) OverrideWriteFn(cb func(OutputStream, []byte, uint, *Cancellable) int) {
67		if cb == nil {	67		if cb == nil {
68		x.xWriteFn = 0	68		x.xWriteFn = 0

@@ -73,7 +73,7 @@ func (x OutputStreamClass) OverrideWriteFn(cb func(OutputStream, []byte, uint,
73		}	73		}
74		}	74		}
75			75
76	-	// GetWriteFn gets the callback function.	76	+	// GetWriteFn gets the "write_fn" callback function.
77		func (x OutputStreamClass) GetWriteFn() func(OutputStream, []byte, uint, *Cancellable) int {	77		func (x OutputStreamClass) GetWriteFn() func(OutputStream, []byte, uint, *Cancellable) int {
78		if x.xWriteFn == 0 {	78		if x.xWriteFn == 0 {
79		return nil	79		return nil

@@ -85,7 +85,7 @@ func (x OutputStreamClass) GetWriteFn() func(OutputStream, []byte, uint, *Canc
85		}	85		}
86		}	86		}
87			87
88	-	// OverrideSplice sets the callback function.	88	+	// OverrideSplice sets the "splice" callback function.
89		func (x OutputStreamClass) OverrideSplice(cb func(OutputStream, InputStream, OutputStreamSpliceFlags, Cancellable) int) {	89		func (x OutputStreamClass) OverrideSplice(cb func(OutputStream, InputStream, OutputStreamSpliceFlags, Cancellable) int) {
90		if cb == nil {	90		if cb == nil {
91		x.xSplice = 0	91		x.xSplice = 0

@@ -96,7 +96,7 @@ func (x OutputStreamClass) OverrideSplice(cb func(OutputStream, *InputStream,
96		}	96		}
97		}	97		}
98			98
99	-	// GetSplice gets the callback function.	99	+	// GetSplice gets the "splice" callback function.
100		func (x OutputStreamClass) GetSplice() func(OutputStream, InputStream, OutputStreamSpliceFlags, Cancellable) int {	100		func (x OutputStreamClass) GetSplice() func(OutputStream, InputStream, OutputStreamSpliceFlags, Cancellable) int {
101		if x.xSplice == 0 {	101		if x.xSplice == 0 {
102		return nil	102		return nil

@@ -108,7 +108,7 @@ func (x OutputStreamClass) GetSplice() func(OutputStream, *InputStream, Output
108		}	108		}
109		}	109		}
110			110
111	-	// OverrideFlush sets the callback function.	111	+	// OverrideFlush sets the "flush" callback function.
112		func (x OutputStreamClass) OverrideFlush(cb func(OutputStream, *Cancellable) bool) {	112		func (x OutputStreamClass) OverrideFlush(cb func(OutputStream, *Cancellable) bool) {
113		if cb == nil {	113		if cb == nil {
114		x.xFlush = 0	114		x.xFlush = 0

@@ -119,7 +119,7 @@ func (x OutputStreamClass) OverrideFlush(cb func(OutputStream, *Cancellable) b
119		}	119		}
120		}	120		}
121			121
122	-	// GetFlush gets the callback function.	122	+	// GetFlush gets the "flush" callback function.
123		func (x OutputStreamClass) GetFlush() func(OutputStream, *Cancellable) bool {	123		func (x OutputStreamClass) GetFlush() func(OutputStream, *Cancellable) bool {
124		if x.xFlush == 0 {	124		if x.xFlush == 0 {
125		return nil	125		return nil

@@ -131,7 +131,7 @@ func (x OutputStreamClass) GetFlush() func(OutputStream, *Cancellable) bool {
131		}	131		}
132		}	132		}
133			133
134	-	// OverrideCloseFn sets the callback function.	134	+	// OverrideCloseFn sets the "close_fn" callback function.
135		func (x OutputStreamClass) OverrideCloseFn(cb func(OutputStream, *Cancellable) bool) {	135		func (x OutputStreamClass) OverrideCloseFn(cb func(OutputStream, *Cancellable) bool) {
136		if cb == nil {	136		if cb == nil {
137		x.xCloseFn = 0	137		x.xCloseFn = 0

@@ -142,7 +142,7 @@ func (x OutputStreamClass) OverrideCloseFn(cb func(OutputStream, *Cancellable)
142		}	142		}
143		}	143		}
144			144
145	-	// GetCloseFn gets the callback function.	145	+	// GetCloseFn gets the "close_fn" callback function.
146		func (x OutputStreamClass) GetCloseFn() func(OutputStream, *Cancellable) bool {	146		func (x OutputStreamClass) GetCloseFn() func(OutputStream, *Cancellable) bool {
147		if x.xCloseFn == 0 {	147		if x.xCloseFn == 0 {
148		return nil	148		return nil

@@ -154,7 +154,7 @@ func (x OutputStreamClass) GetCloseFn() func(OutputStream, *Cancellable) bool
154		}	154		}
155		}	155		}
156			156
157	-	// OverrideWriteAsync sets the callback function.	157	+	// OverrideWriteAsync sets the "write_async" callback function.
158		func (x OutputStreamClass) OverrideWriteAsync(cb func(OutputStream, []byte, uint, int, Cancellable, AsyncReadyCallback, uintptr)) {	158		func (x OutputStreamClass) OverrideWriteAsync(cb func(OutputStream, []byte, uint, int, Cancellable, AsyncReadyCallback, uintptr)) {
159		if cb == nil {	159		if cb == nil {
160		x.xWriteAsync = 0	160		x.xWriteAsync = 0

@@ -165,7 +165,7 @@ func (x OutputStreamClass) OverrideWriteAsync(cb func(OutputStream, []byte, ui
165		}	165		}
166		}	166		}
167			167
168	-	// GetWriteAsync gets the callback function.	168	+	// GetWriteAsync gets the "write_async" callback function.
169		func (x OutputStreamClass) GetWriteAsync() func(OutputStream, []byte, uint, int, Cancellable, AsyncReadyCallback, uintptr) {	169		func (x OutputStreamClass) GetWriteAsync() func(OutputStream, []byte, uint, int, Cancellable, AsyncReadyCallback, uintptr) {
170		if x.xWriteAsync == 0 {	170		if x.xWriteAsync == 0 {
171		return nil	171		return nil

@@ -177,7 +177,7 @@ func (x OutputStreamClass) GetWriteAsync() func(OutputStream, []byte, uint, in
177		}	177		}
178		}	178		}
179			179
180	-	// OverrideWriteFinish sets the callback function.	180	+	// OverrideWriteFinish sets the "write_finish" callback function.
181		func (x OutputStreamClass) OverrideWriteFinish(cb func(OutputStream, AsyncResult) int) {	181		func (x OutputStreamClass) OverrideWriteFinish(cb func(OutputStream, AsyncResult) int) {
182		if cb == nil {	182		if cb == nil {
183		x.xWriteFinish = 0	183		x.xWriteFinish = 0

@@ -188,7 +188,7 @@ func (x OutputStreamClass) OverrideWriteFinish(cb func(OutputStream, AsyncResu
188		}	188		}
189		}	189		}
190			190
191	-	// GetWriteFinish gets the callback function.	191	+	// GetWriteFinish gets the "write_finish" callback function.
192		func (x OutputStreamClass) GetWriteFinish() func(OutputStream, AsyncResult) int {	192		func (x OutputStreamClass) GetWriteFinish() func(OutputStream, AsyncResult) int {
193		if x.xWriteFinish == 0 {	193		if x.xWriteFinish == 0 {
194		return nil	194		return nil

@@ -200,7 +200,7 @@ func (x OutputStreamClass) GetWriteFinish() func(OutputStream, AsyncResult) in
200		}	200		}
201		}	201		}
202			202
203	-	// OverrideSpliceAsync sets the callback function.	203	+	// OverrideSpliceAsync sets the "splice_async" callback function.
204		func (x OutputStreamClass) OverrideSpliceAsync(cb func(OutputStream, InputStream, OutputStreamSpliceFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {	204		func (x OutputStreamClass) OverrideSpliceAsync(cb func(OutputStream, InputStream, OutputStreamSpliceFlags, int, Cancellable, *AsyncReadyCallback, uintptr)) {
205		if cb == nil {	205		if cb == nil {
206		x.xSpliceAsync = 0	206		x.xSpliceAsync = 0

@@ -211,7 +211,7 @@ func (x OutputStreamClass) OverrideSpliceAsync(cb func(OutputStream, *InputStr
211		}	211		}
212		}	212		}
213			213
214	-	// GetSpliceAsync gets the callback function.	214	+	// GetSpliceAsync gets the "splice_async" callback function.
215		func (x OutputStreamClass) GetSpliceAsync() func(OutputStream, InputStream, OutputStreamSpliceFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {	215		func (x OutputStreamClass) GetSpliceAsync() func(OutputStream, InputStream, OutputStreamSpliceFlags, int, Cancellable, *AsyncReadyCallback, uintptr) {
216		if x.xSpliceAsync == 0 {	216		if x.xSpliceAsync == 0 {
217		return nil	217		return nil

@@ -223,7 +223,7 @@ func (x OutputStreamClass) GetSpliceAsync() func(OutputStream, *InputStream, O
223		}	223		}
224		}	224		}
225			225
226	-	// OverrideSpliceFinish sets the callback function.	226	+	// OverrideSpliceFinish sets the "splice_finish" callback function.
227		func (x OutputStreamClass) OverrideSpliceFinish(cb func(OutputStream, AsyncResult) int) {	227		func (x OutputStreamClass) OverrideSpliceFinish(cb func(OutputStream, AsyncResult) int) {
228		if cb == nil {	228		if cb == nil {
229		x.xSpliceFinish = 0	229		x.xSpliceFinish = 0

@@ -234,7 +234,7 @@ func (x OutputStreamClass) OverrideSpliceFinish(cb func(OutputStream, AsyncRes
234		}	234		}
235		}	235		}
236			236
237	-	// GetSpliceFinish gets the callback function.	237	+	// GetSpliceFinish gets the "splice_finish" callback function.
238		func (x OutputStreamClass) GetSpliceFinish() func(OutputStream, AsyncResult) int {	238		func (x OutputStreamClass) GetSpliceFinish() func(OutputStream, AsyncResult) int {
239		if x.xSpliceFinish == 0 {	239		if x.xSpliceFinish == 0 {
240		return nil	240		return nil

@@ -246,7 +246,7 @@ func (x OutputStreamClass) GetSpliceFinish() func(OutputStream, AsyncResult) i
246		}	246		}
247		}	247		}
248			248
249	-	// OverrideFlushAsync sets the callback function.	249	+	// OverrideFlushAsync sets the "flush_async" callback function.
250		func (x OutputStreamClass) OverrideFlushAsync(cb func(OutputStream, int, Cancellable, AsyncReadyCallback, uintptr)) {	250		func (x OutputStreamClass) OverrideFlushAsync(cb func(OutputStream, int, Cancellable, AsyncReadyCallback, uintptr)) {
251		if cb == nil {	251		if cb == nil {
252		x.xFlushAsync = 0	252		x.xFlushAsync = 0

@@ -257,7 +257,7 @@ func (x OutputStreamClass) OverrideFlushAsync(cb func(OutputStream, int, *Canc
257		}	257		}
258		}	258		}
259			259
260	-	// GetFlushAsync gets the callback function.	260	+	// GetFlushAsync gets the "flush_async" callback function.
261		func (x OutputStreamClass) GetFlushAsync() func(OutputStream, int, Cancellable, AsyncReadyCallback, uintptr) {	261		func (x OutputStreamClass) GetFlushAsync() func(OutputStream, int, Cancellable, AsyncReadyCallback, uintptr) {
262		if x.xFlushAsync == 0 {	262		if x.xFlushAsync == 0 {
263		return nil	263		return nil

@@ -269,7 +269,7 @@ func (x OutputStreamClass) GetFlushAsync() func(OutputStream, int, *Cancellabl
269		}	269		}
270		}	270		}
271			271
272	-	// OverrideFlushFinish sets the callback function.	272	+	// OverrideFlushFinish sets the "flush_finish" callback function.
273		func (x OutputStreamClass) OverrideFlushFinish(cb func(OutputStream, AsyncResult) bool) {	273		func (x OutputStreamClass) OverrideFlushFinish(cb func(OutputStream, AsyncResult) bool) {
274		if cb == nil {	274		if cb == nil {
275		x.xFlushFinish = 0	275		x.xFlushFinish = 0

@@ -280,7 +280,7 @@ func (x OutputStreamClass) OverrideFlushFinish(cb func(OutputStream, AsyncResu
280		}	280		}
281		}	281		}
282			282
283	-	// GetFlushFinish gets the callback function.	283	+	// GetFlushFinish gets the "flush_finish" callback function.
284		func (x OutputStreamClass) GetFlushFinish() func(OutputStream, AsyncResult) bool {	284		func (x OutputStreamClass) GetFlushFinish() func(OutputStream, AsyncResult) bool {
285		if x.xFlushFinish == 0 {	285		if x.xFlushFinish == 0 {
286		return nil	286		return nil

@@ -292,7 +292,7 @@ func (x OutputStreamClass) GetFlushFinish() func(OutputStream, AsyncResult) bo
292		}	292		}
293		}	293		}
294			294
295	-	// OverrideCloseAsync sets the callback function.	295	+	// OverrideCloseAsync sets the "close_async" callback function.
296		func (x OutputStreamClass) OverrideCloseAsync(cb func(OutputStream, int, Cancellable, AsyncReadyCallback, uintptr)) {	296		func (x OutputStreamClass) OverrideCloseAsync(cb func(OutputStream, int, Cancellable, AsyncReadyCallback, uintptr)) {
297		if cb == nil {	297		if cb == nil {
298		x.xCloseAsync = 0	298		x.xCloseAsync = 0

@@ -303,7 +303,7 @@ func (x OutputStreamClass) OverrideCloseAsync(cb func(OutputStream, int, *Canc
303		}	303		}
304		}	304		}
305			305
306	-	// GetCloseAsync gets the callback function.	306	+	// GetCloseAsync gets the "close_async" callback function.
307		func (x OutputStreamClass) GetCloseAsync() func(OutputStream, int, Cancellable, AsyncReadyCallback, uintptr) {	307		func (x OutputStreamClass) GetCloseAsync() func(OutputStream, int, Cancellable, AsyncReadyCallback, uintptr) {
308		if x.xCloseAsync == 0 {	308		if x.xCloseAsync == 0 {
309		return nil	309		return nil

@@ -315,7 +315,7 @@ func (x OutputStreamClass) GetCloseAsync() func(OutputStream, int, *Cancellabl
315		}	315		}
316		}	316		}
317			317
318	-	// OverrideCloseFinish sets the callback function.	318	+	// OverrideCloseFinish sets the "close_finish" callback function.
319		func (x OutputStreamClass) OverrideCloseFinish(cb func(OutputStream, AsyncResult) bool) {	319		func (x OutputStreamClass) OverrideCloseFinish(cb func(OutputStream, AsyncResult) bool) {
320		if cb == nil {	320		if cb == nil {
321		x.xCloseFinish = 0	321		x.xCloseFinish = 0

@@ -326,7 +326,7 @@ func (x OutputStreamClass) OverrideCloseFinish(cb func(OutputStream, AsyncResu
326		}	326		}
327		}	327		}
328			328
329	-	// GetCloseFinish gets the callback function.	329	+	// GetCloseFinish gets the "close_finish" callback function.
330		func (x OutputStreamClass) GetCloseFinish() func(OutputStream, AsyncResult) bool {	330		func (x OutputStreamClass) GetCloseFinish() func(OutputStream, AsyncResult) bool {
331		if x.xCloseFinish == 0 {	331		if x.xCloseFinish == 0 {
332		return nil	332		return nil

@@ -338,30 +338,30 @@ func (x OutputStreamClass) GetCloseFinish() func(OutputStream, AsyncResult) bo
338		}	338		}
339		}	339		}
340			340
341	-	// OverrideWritevFn sets the callback function.	341	+	// OverrideWritevFn sets the "writev_fn" callback function.
342	-	func (x OutputStreamClass) OverrideWritevFn(cb func(OutputStream, []OutputVector, uint, uint, *Cancellable) bool) {	342	+	func (x OutputStreamClass) OverrideWritevFn(cb func(OutputStream, []OutputVector, uint, uint, Cancellable) bool) {
343		if cb == nil {	343		if cb == nil {
344		x.xWritevFn = 0	344		x.xWritevFn = 0
345		} else {	345		} else {
346	-	x.xWritevFn = purego.NewCallback(func(StreamVarp uintptr, VectorsVarp []OutputVector, NVectorsVarp uint, BytesWrittenVarp uint, CancellableVarp uintptr) bool {	346	+	x.xWritevFn = purego.NewCallback(func(StreamVarp uintptr, VectorsVarp []OutputVector, NVectorsVarp uint, BytesWrittenVarp *uint, CancellableVarp uintptr) bool {
347		return cb(OutputStreamNewFromInternalPtr(StreamVarp), VectorsVarp, NVectorsVarp, BytesWrittenVarp, CancellableNewFromInternalPtr(CancellableVarp))	347		return cb(OutputStreamNewFromInternalPtr(StreamVarp), VectorsVarp, NVectorsVarp, BytesWrittenVarp, CancellableNewFromInternalPtr(CancellableVarp))
348		})	348		})
349		}	349		}
350		}	350		}
351			351
352	-	// GetWritevFn gets the callback function.	352	+	// GetWritevFn gets the "writev_fn" callback function.
353	-	func (x OutputStreamClass) GetWritevFn() func(OutputStream, []OutputVector, uint, uint, *Cancellable) bool {	353	+	func (x OutputStreamClass) GetWritevFn() func(OutputStream, []OutputVector, uint, uint, Cancellable) bool {
354		if x.xWritevFn == 0 {	354		if x.xWritevFn == 0 {
355		return nil	355		return nil
356		}	356		}
357	-	var rawCallback func(StreamVarp uintptr, VectorsVarp []OutputVector, NVectorsVarp uint, BytesWrittenVarp uint, CancellableVarp uintptr) bool	357	+	var rawCallback func(StreamVarp uintptr, VectorsVarp []OutputVector, NVectorsVarp uint, BytesWrittenVarp *uint, CancellableVarp uintptr) bool
358		purego.RegisterFunc(&rawCallback, x.xWritevFn)	358		purego.RegisterFunc(&rawCallback, x.xWritevFn)
359	-	return func(StreamVar OutputStream, VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar Cancellable) bool {	359	+	return func(StreamVar OutputStream, VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar *Cancellable) bool {
360		return rawCallback(StreamVar.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer())	360		return rawCallback(StreamVar.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer())
361		}	361		}
362		}	362		}
363			363
364	-	// OverrideWritevAsync sets the callback function.	364	+	// OverrideWritevAsync sets the "writev_async" callback function.
365		func (x OutputStreamClass) OverrideWritevAsync(cb func(OutputStream, []OutputVector, uint, int, Cancellable, AsyncReadyCallback, uintptr)) {	365		func (x OutputStreamClass) OverrideWritevAsync(cb func(OutputStream, []OutputVector, uint, int, Cancellable, AsyncReadyCallback, uintptr)) {
366		if cb == nil {	366		if cb == nil {
367		x.xWritevAsync = 0	367		x.xWritevAsync = 0

@@ -372,7 +372,7 @@ func (x OutputStreamClass) OverrideWritevAsync(cb func(OutputStream, []OutputV
372		}	372		}
373		}	373		}
374			374
375	-	// GetWritevAsync gets the callback function.	375	+	// GetWritevAsync gets the "writev_async" callback function.
376		func (x OutputStreamClass) GetWritevAsync() func(OutputStream, []OutputVector, uint, int, Cancellable, AsyncReadyCallback, uintptr) {	376		func (x OutputStreamClass) GetWritevAsync() func(OutputStream, []OutputVector, uint, int, Cancellable, AsyncReadyCallback, uintptr) {
377		if x.xWritevAsync == 0 {	377		if x.xWritevAsync == 0 {
378		return nil	378		return nil

@@ -384,30 +384,30 @@ func (x OutputStreamClass) GetWritevAsync() func(OutputStream, []OutputVector,
384		}	384		}
385		}	385		}
386			386
387	-	// OverrideWritevFinish sets the callback function.	387	+	// OverrideWritevFinish sets the "writev_finish" callback function.
388	-	func (x OutputStreamClass) OverrideWritevFinish(cb func(OutputStream, AsyncResult, uint) bool) {	388	+	func (x OutputStreamClass) OverrideWritevFinish(cb func(OutputStream, AsyncResult, *uint) bool) {
389		if cb == nil {	389		if cb == nil {
390		x.xWritevFinish = 0	390		x.xWritevFinish = 0
391		} else {	391		} else {
392	-	x.xWritevFinish = purego.NewCallback(func(StreamVarp uintptr, ResultVarp uintptr, BytesWrittenVarp uint) bool {	392	+	x.xWritevFinish = purego.NewCallback(func(StreamVarp uintptr, ResultVarp uintptr, BytesWrittenVarp *uint) bool {
393		return cb(OutputStreamNewFromInternalPtr(StreamVarp), &AsyncResultBase{Ptr: ResultVarp}, BytesWrittenVarp)	393		return cb(OutputStreamNewFromInternalPtr(StreamVarp), &AsyncResultBase{Ptr: ResultVarp}, BytesWrittenVarp)
394		})	394		})
395		}	395		}
396		}	396		}
397			397
398	-	// GetWritevFinish gets the callback function.	398	+	// GetWritevFinish gets the "writev_finish" callback function.
399	-	func (x OutputStreamClass) GetWritevFinish() func(OutputStream, AsyncResult, uint) bool {	399	+	func (x OutputStreamClass) GetWritevFinish() func(OutputStream, AsyncResult, *uint) bool {
400		if x.xWritevFinish == 0 {	400		if x.xWritevFinish == 0 {
401		return nil	401		return nil
402		}	402		}
403	-	var rawCallback func(StreamVarp uintptr, ResultVarp uintptr, BytesWrittenVarp uint) bool	403	+	var rawCallback func(StreamVarp uintptr, ResultVarp uintptr, BytesWrittenVarp *uint) bool
404		purego.RegisterFunc(&rawCallback, x.xWritevFinish)	404		purego.RegisterFunc(&rawCallback, x.xWritevFinish)
405	-	return func(StreamVar *OutputStream, ResultVar AsyncResult, BytesWrittenVar uint) bool {	405	+	return func(StreamVar OutputStream, ResultVar AsyncResult, BytesWrittenVar uint) bool {
406		return rawCallback(StreamVar.GoPointer(), ResultVar.GoPointer(), BytesWrittenVar)	406		return rawCallback(StreamVar.GoPointer(), ResultVar.GoPointer(), BytesWrittenVar)
407		}	407		}
408		}	408		}
409			409
410	-	// OverrideGReserved4 sets the callback function.	410	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
411		func (x *OutputStreamClass) OverrideGReserved4(cb func()) {	411		func (x *OutputStreamClass) OverrideGReserved4(cb func()) {
412		if cb == nil {	412		if cb == nil {
413		x.xGReserved4 = 0	413		x.xGReserved4 = 0

@@ -418,7 +418,7 @@ func (x *OutputStreamClass) OverrideGReserved4(cb func()) {
418		}	418		}
419		}	419		}
420			420
421	-	// GetGReserved4 gets the callback function.	421	+	// GetGReserved4 gets the "_g_reserved4" callback function.
422		func (x *OutputStreamClass) GetGReserved4() func() {	422		func (x *OutputStreamClass) GetGReserved4() func() {
423		if x.xGReserved4 == 0 {	423		if x.xGReserved4 == 0 {
424		return nil	424		return nil

@@ -430,7 +430,7 @@ func (x *OutputStreamClass) GetGReserved4() func() {
430		}	430		}
431		}	431		}
432			432
433	-	// OverrideGReserved5 sets the callback function.	433	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
434		func (x *OutputStreamClass) OverrideGReserved5(cb func()) {	434		func (x *OutputStreamClass) OverrideGReserved5(cb func()) {
435		if cb == nil {	435		if cb == nil {
436		x.xGReserved5 = 0	436		x.xGReserved5 = 0

@@ -441,7 +441,7 @@ func (x *OutputStreamClass) OverrideGReserved5(cb func()) {
441		}	441		}
442		}	442		}
443			443
444	-	// GetGReserved5 gets the callback function.	444	+	// GetGReserved5 gets the "_g_reserved5" callback function.
445		func (x *OutputStreamClass) GetGReserved5() func() {	445		func (x *OutputStreamClass) GetGReserved5() func() {
446		if x.xGReserved5 == 0 {	446		if x.xGReserved5 == 0 {
447		return nil	447		return nil

@@ -453,7 +453,7 @@ func (x *OutputStreamClass) GetGReserved5() func() {
453		}	453		}
454		}	454		}
455			455
456	-	// OverrideGReserved6 sets the callback function.	456	+	// OverrideGReserved6 sets the "_g_reserved6" callback function.
457		func (x *OutputStreamClass) OverrideGReserved6(cb func()) {	457		func (x *OutputStreamClass) OverrideGReserved6(cb func()) {
458		if cb == nil {	458		if cb == nil {
459		x.xGReserved6 = 0	459		x.xGReserved6 = 0

@@ -464,7 +464,7 @@ func (x *OutputStreamClass) OverrideGReserved6(cb func()) {
464		}	464		}
465		}	465		}
466			466
467	-	// GetGReserved6 gets the callback function.	467	+	// GetGReserved6 gets the "_g_reserved6" callback function.
468		func (x *OutputStreamClass) GetGReserved6() func() {	468		func (x *OutputStreamClass) GetGReserved6() func() {
469		if x.xGReserved6 == 0 {	469		if x.xGReserved6 == 0 {
470		return nil	470		return nil

@@ -476,7 +476,7 @@ func (x *OutputStreamClass) GetGReserved6() func() {
476		}	476		}
477		}	477		}
478			478
479	-	// OverrideGReserved7 sets the callback function.	479	+	// OverrideGReserved7 sets the "_g_reserved7" callback function.
480		func (x *OutputStreamClass) OverrideGReserved7(cb func()) {	480		func (x *OutputStreamClass) OverrideGReserved7(cb func()) {
481		if cb == nil {	481		if cb == nil {
482		x.xGReserved7 = 0	482		x.xGReserved7 = 0

@@ -487,7 +487,7 @@ func (x *OutputStreamClass) OverrideGReserved7(cb func()) {
487		}	487		}
488		}	488		}
489			489
490	-	// GetGReserved7 gets the callback function.	490	+	// GetGReserved7 gets the "_g_reserved7" callback function.
491		func (x *OutputStreamClass) GetGReserved7() func() {	491		func (x *OutputStreamClass) GetGReserved7() func() {
492		if x.xGReserved7 == 0 {	492		if x.xGReserved7 == 0 {
493		return nil	493		return nil

@@ -499,7 +499,7 @@ func (x *OutputStreamClass) GetGReserved7() func() {
499		}	499		}
500		}	500		}
501			501
502	-	// OverrideGReserved8 sets the callback function.	502	+	// OverrideGReserved8 sets the "_g_reserved8" callback function.
503		func (x *OutputStreamClass) OverrideGReserved8(cb func()) {	503		func (x *OutputStreamClass) OverrideGReserved8(cb func()) {
504		if cb == nil {	504		if cb == nil {
505		x.xGReserved8 = 0	505		x.xGReserved8 = 0

@@ -510,7 +510,7 @@ func (x *OutputStreamClass) OverrideGReserved8(cb func()) {
510		}	510		}
511		}	511		}
512			512
513	-	// GetGReserved8 gets the callback function.	513	+	// GetGReserved8 gets the "_g_reserved8" callback function.
514		func (x *OutputStreamClass) GetGReserved8() func() {	514		func (x *OutputStreamClass) GetGReserved8() func() {
515		if x.xGReserved8 == 0 {	515		if x.xGReserved8 == 0 {
516		return nil	516		return nil

@@ -727,7 +727,7 @@ func (x *OutputStream) IsClosing() bool {
727		return cret	727		return cret
728		}	728		}
729			729
730	-	var xOutputStreamPrintf func(uintptr, uint, uintptr, **glib.Error, string, ...interface{}) bool	730	+	var xOutputStreamPrintf func(uintptr, uint, uintptr, *glib.Error, string, ...interface{}) bool
731			731
732		// This is a utility function around g_output_stream_write_all(). It	732		// This is a utility function around g_output_stream_write_all(). It
733		// uses g_strdup_vprintf() to turn @format and @... into a string that	733		// uses g_strdup_vprintf() to turn @format and @... into a string that

@@ -741,7 +741,7 @@ var xOutputStreamPrintf func(uintptr, uint, uintptr, **glib.Error, string, ...in
741		// need precise control over partial write failures, you need to	741		// need precise control over partial write failures, you need to
742		// create you own printf()-like wrapper around g_output_stream_write()	742		// create you own printf()-like wrapper around g_output_stream_write()
743		// or g_output_stream_write_all().	743		// or g_output_stream_write_all().
744	-	func (x OutputStream) Printf(BytesWrittenVar uint, CancellableVar Cancellable, ErrorVar **glib.Error, FormatVar string, varArgs ...interface{}) bool {	744	+	func (x OutputStream) Printf(BytesWrittenVar uint, CancellableVar Cancellable, ErrorVar *glib.Error, FormatVar string, varArgs ...interface{}) bool {
745			745
746		cret := xOutputStreamPrintf(x.GoPointer(), BytesWrittenVar, CancellableVar.GoPointer(), ErrorVar, FormatVar, varArgs...)	746		cret := xOutputStreamPrintf(x.GoPointer(), BytesWrittenVar, CancellableVar.GoPointer(), ErrorVar, FormatVar, varArgs...)
747		return cret	747		return cret

@@ -806,7 +806,7 @@ func (x *OutputStream) SpliceFinish(ResultVar AsyncResult) (int, error) {
806			806
807		}	807		}
808			808
809	-	var xOutputStreamVprintf func(uintptr, uint, uintptr, **glib.Error, string, []interface{}) bool	809	+	var xOutputStreamVprintf func(uintptr, uint, uintptr, *glib.Error, string, []interface{}) bool
810			810
811		// This is a utility function around g_output_stream_write_all(). It	811		// This is a utility function around g_output_stream_write_all(). It
812		// uses g_strdup_vprintf() to turn @format and @args into a string that	812		// uses g_strdup_vprintf() to turn @format and @args into a string that

@@ -820,7 +820,7 @@ var xOutputStreamVprintf func(uintptr, uint, uintptr, **glib.Error, string, []in
820		// need precise control over partial write failures, you need to	820		// need precise control over partial write failures, you need to
821		// create you own printf()-like wrapper around g_output_stream_write()	821		// create you own printf()-like wrapper around g_output_stream_write()
822		// or g_output_stream_write_all().	822		// or g_output_stream_write_all().
823	-	func (x OutputStream) Vprintf(BytesWrittenVar uint, CancellableVar Cancellable, ErrorVar **glib.Error, FormatVar string, ArgsVar []interface{}) bool {	823	+	func (x OutputStream) Vprintf(BytesWrittenVar uint, CancellableVar Cancellable, ErrorVar *glib.Error, FormatVar string, ArgsVar []interface{}) bool {
824			824
825		cret := xOutputStreamVprintf(x.GoPointer(), BytesWrittenVar, CancellableVar.GoPointer(), ErrorVar, FormatVar, ArgsVar)	825		cret := xOutputStreamVprintf(x.GoPointer(), BytesWrittenVar, CancellableVar.GoPointer(), ErrorVar, FormatVar, ArgsVar)
826		return cret	826		return cret

@@ -859,7 +859,7 @@ func (x OutputStream) Write(BufferVar []byte, CountVar uint, CancellableVar Ca
859			859
860		}	860		}
861			861
862	-	var xOutputStreamWriteAll func(uintptr, []byte, uint, uint, uintptr, **glib.Error) bool	862	+	var xOutputStreamWriteAll func(uintptr, []byte, uint, uint, uintptr, *glib.Error) bool
863			863
864		// Tries to write @count bytes from @buffer into the stream. Will block	864		// Tries to write @count bytes from @buffer into the stream. Will block
865		// during the operation.	865		// during the operation.

@@ -880,7 +880,7 @@ var xOutputStreamWriteAll func(uintptr, []byte, uint, uint, uintptr, **glib.Erro
880		// functionality is only available from C. If you need it from another	880		// functionality is only available from C. If you need it from another
881		// language then you must write your own loop around	881		// language then you must write your own loop around
882		// g_output_stream_write().	882		// g_output_stream_write().
883	-	func (x OutputStream) WriteAll(BufferVar []byte, CountVar uint, BytesWrittenVar uint, CancellableVar Cancellable) (bool, error) {	883	+	func (x OutputStream) WriteAll(BufferVar []byte, CountVar uint, BytesWrittenVar uint, CancellableVar *Cancellable) (bool, error) {
884		var cerr *glib.Error	884		var cerr *glib.Error
885			885
886		cret := xOutputStreamWriteAll(x.GoPointer(), BufferVar, CountVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)	886		cret := xOutputStreamWriteAll(x.GoPointer(), BufferVar, CountVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)

@@ -914,7 +914,7 @@ func (x *OutputStream) WriteAllAsync(BufferVar []byte, CountVar uint, IoPriority
914			914
915		}	915		}
916			916
917	-	var xOutputStreamWriteAllFinish func(uintptr, uintptr, uint, **glib.Error) bool	917	+	var xOutputStreamWriteAllFinish func(uintptr, uintptr, uint, *glib.Error) bool
918			918
919		// Finishes an asynchronous stream write operation started with	919		// Finishes an asynchronous stream write operation started with
920		// g_output_stream_write_all_async().	920		// g_output_stream_write_all_async().

@@ -926,7 +926,7 @@ var xOutputStreamWriteAllFinish func(uintptr, uintptr, uint, **glib.Error) bool
926		// functionality is only available from C. If you need it from another	926		// functionality is only available from C. If you need it from another
927		// language then you must write your own loop around	927		// language then you must write your own loop around
928		// g_output_stream_write_async().	928		// g_output_stream_write_async().
929	-	func (x *OutputStream) WriteAllFinish(ResultVar AsyncResult, BytesWrittenVar uint) (bool, error) {	929	+	func (x OutputStream) WriteAllFinish(ResultVar AsyncResult, BytesWrittenVar uint) (bool, error) {
930		var cerr *glib.Error	930		var cerr *glib.Error
931			931
932		cret := xOutputStreamWriteAllFinish(x.GoPointer(), ResultVar.GoPointer(), BytesWrittenVar, &cerr)	932		cret := xOutputStreamWriteAllFinish(x.GoPointer(), ResultVar.GoPointer(), BytesWrittenVar, &cerr)

@@ -1053,7 +1053,7 @@ func (x *OutputStream) WriteFinish(ResultVar AsyncResult) (int, error) {
1053			1053
1054		}	1054		}
1055			1055
1056	-	var xOutputStreamWritev func(uintptr, []OutputVector, uint, uint, uintptr, **glib.Error) bool	1056	+	var xOutputStreamWritev func(uintptr, []OutputVector, uint, uint, uintptr, *glib.Error) bool
1057			1057
1058		// Tries to write the bytes contained in the @n_vectors @vectors into the	1058		// Tries to write the bytes contained in the @n_vectors @vectors into the
1059		// stream. Will block during the operation.	1059		// stream. Will block during the operation.

@@ -1078,7 +1078,7 @@ var xOutputStreamWritev func(uintptr, []OutputVector, uint, uint, uintptr, **gli
1078		// aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these	1078		// aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
1079		// are exceeded. For example, when writing to a local file on UNIX platforms,	1079		// are exceeded. For example, when writing to a local file on UNIX platforms,
1080		// the aggregate buffer size must not exceed %G_MAXSSIZE bytes.	1080		// the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
1081	-	func (x OutputStream) Writev(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar Cancellable) (bool, error) {	1081	+	func (x OutputStream) Writev(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar *Cancellable) (bool, error) {
1082		var cerr *glib.Error	1082		var cerr *glib.Error
1083			1083
1084		cret := xOutputStreamWritev(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)	1084		cret := xOutputStreamWritev(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)

@@ -1089,7 +1089,7 @@ func (x *OutputStream) Writev(VectorsVar []OutputVector, NVectorsVar uint, Bytes
1089			1089
1090		}	1090		}
1091			1091
1092	-	var xOutputStreamWritevAll func(uintptr, []OutputVector, uint, uint, uintptr, **glib.Error) bool	1092	+	var xOutputStreamWritevAll func(uintptr, []OutputVector, uint, uint, uintptr, *glib.Error) bool
1093			1093
1094		// Tries to write the bytes contained in the @n_vectors @vectors into the	1094		// Tries to write the bytes contained in the @n_vectors @vectors into the
1095		// stream. Will block during the operation.	1095		// stream. Will block during the operation.

@@ -1113,7 +1113,7 @@ var xOutputStreamWritevAll func(uintptr, []OutputVector, uint, uint, uintptr, **
1113		//	1113		//
1114		// The content of the individual elements of @vectors might be changed by this	1114		// The content of the individual elements of @vectors might be changed by this
1115		// function.	1115		// function.
1116	-	func (x OutputStream) WritevAll(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar Cancellable) (bool, error) {	1116	+	func (x OutputStream) WritevAll(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar *Cancellable) (bool, error) {
1117		var cerr *glib.Error	1117		var cerr *glib.Error
1118			1118
1119		cret := xOutputStreamWritevAll(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)	1119		cret := xOutputStreamWritevAll(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)

@@ -1148,7 +1148,7 @@ func (x *OutputStream) WritevAllAsync(VectorsVar []OutputVector, NVectorsVar uin
1148			1148
1149		}	1149		}
1150			1150
1151	-	var xOutputStreamWritevAllFinish func(uintptr, uintptr, uint, **glib.Error) bool	1151	+	var xOutputStreamWritevAllFinish func(uintptr, uintptr, uint, *glib.Error) bool
1152			1152
1153		// Finishes an asynchronous stream write operation started with	1153		// Finishes an asynchronous stream write operation started with
1154		// g_output_stream_writev_all_async().	1154		// g_output_stream_writev_all_async().

@@ -1160,7 +1160,7 @@ var xOutputStreamWritevAllFinish func(uintptr, uintptr, uint, **glib.Error) bool
1160		// functionality is only available from C. If you need it from another	1160		// functionality is only available from C. If you need it from another
1161		// language then you must write your own loop around	1161		// language then you must write your own loop around
1162		// g_output_stream_writev_async().	1162		// g_output_stream_writev_async().
1163	-	func (x *OutputStream) WritevAllFinish(ResultVar AsyncResult, BytesWrittenVar uint) (bool, error) {	1163	+	func (x OutputStream) WritevAllFinish(ResultVar AsyncResult, BytesWrittenVar uint) (bool, error) {
1164		var cerr *glib.Error	1164		var cerr *glib.Error
1165			1165
1166		cret := xOutputStreamWritevAllFinish(x.GoPointer(), ResultVar.GoPointer(), BytesWrittenVar, &cerr)	1166		cret := xOutputStreamWritevAllFinish(x.GoPointer(), ResultVar.GoPointer(), BytesWrittenVar, &cerr)

@@ -1209,10 +1209,10 @@ func (x *OutputStream) WritevAsync(VectorsVar []OutputVector, NVectorsVar uint,
1209			1209
1210		}	1210		}
1211			1211
1212	-	var xOutputStreamWritevFinish func(uintptr, uintptr, uint, **glib.Error) bool	1212	+	var xOutputStreamWritevFinish func(uintptr, uintptr, uint, *glib.Error) bool
1213			1213
1214		// Finishes a stream writev operation.	1214		// Finishes a stream writev operation.
1215	-	func (x *OutputStream) WritevFinish(ResultVar AsyncResult, BytesWrittenVar uint) (bool, error) {	1215	+	func (x OutputStream) WritevFinish(ResultVar AsyncResult, BytesWrittenVar uint) (bool, error) {
1216		var cerr *glib.Error	1216		var cerr *glib.Error
1217			1217
1218		cret := xOutputStreamWritevFinish(x.GoPointer(), ResultVar.GoPointer(), BytesWrittenVar, &cerr)	1218		cret := xOutputStreamWritevFinish(x.GoPointer(), ResultVar.GoPointer(), BytesWrittenVar, &cerr)

M v4/gio/gpermission.go +39 -12

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideAcquire sets the callback function.
+// OverrideAcquire sets the "acquire" callback function.
 func (x *PermissionClass) OverrideAcquire(cb func(*Permission, *Cancellable) bool) {
 	if cb == nil {
 		x.xAcquire = 0
 	}
 }
-// GetAcquire gets the callback function.
+// GetAcquire gets the "acquire" callback function.
 func (x *PermissionClass) GetAcquire() func(*Permission, *Cancellable) bool {
 	if x.xAcquire == 0 {
 		return nil
 	}
 }
-// OverrideAcquireAsync sets the callback function.
+// OverrideAcquireAsync sets the "acquire_async" callback function.
 func (x *PermissionClass) OverrideAcquireAsync(cb func(*Permission, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xAcquireAsync = 0
 	}
 }
-// GetAcquireAsync gets the callback function.
+// GetAcquireAsync gets the "acquire_async" callback function.
 func (x *PermissionClass) GetAcquireAsync() func(*Permission, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xAcquireAsync == 0 {
 		return nil
 	}
 }
-// OverrideAcquireFinish sets the callback function.
+// OverrideAcquireFinish sets the "acquire_finish" callback function.
 func (x *PermissionClass) OverrideAcquireFinish(cb func(*Permission, AsyncResult) bool) {
 	if cb == nil {
 		x.xAcquireFinish = 0
 	}
 }
-// GetAcquireFinish gets the callback function.
+// GetAcquireFinish gets the "acquire_finish" callback function.
 func (x *PermissionClass) GetAcquireFinish() func(*Permission, AsyncResult) bool {
 	if x.xAcquireFinish == 0 {
 		return nil
 	}
 }
-// OverrideRelease sets the callback function.
+// OverrideRelease sets the "release" callback function.
 func (x *PermissionClass) OverrideRelease(cb func(*Permission, *Cancellable) bool) {
 	if cb == nil {
 		x.xRelease = 0
 	}
 }
-// GetRelease gets the callback function.
+// GetRelease gets the "release" callback function.
 func (x *PermissionClass) GetRelease() func(*Permission, *Cancellable) bool {
 	if x.xRelease == 0 {
 		return nil
 	}
 }
-// OverrideReleaseAsync sets the callback function.
+// OverrideReleaseAsync sets the "release_async" callback function.
 func (x *PermissionClass) OverrideReleaseAsync(cb func(*Permission, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xReleaseAsync = 0
 	}
 }
-// GetReleaseAsync gets the callback function.
+// GetReleaseAsync gets the "release_async" callback function.
 func (x *PermissionClass) GetReleaseAsync() func(*Permission, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xReleaseAsync == 0 {
 		return nil
 	}
 }
-// OverrideReleaseFinish sets the callback function.
+// OverrideReleaseFinish sets the "release_finish" callback function.
 func (x *PermissionClass) OverrideReleaseFinish(cb func(*Permission, AsyncResult) bool) {
 	if cb == nil {
 		x.xReleaseFinish = 0
 	}
 }
-// GetReleaseFinish gets the callback function.
+// GetReleaseFinish gets the "release_finish" callback function.
 func (x *PermissionClass) GetReleaseFinish() func(*Permission, AsyncResult) bool {
 	if x.xReleaseFinish == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// GetPropertyAllowed gets the "allowed" property.
+// %TRUE if the caller currently has permission to perform the action that
+// @permission represents the permission to perform.
+func (x *Permission) GetPropertyAllowed() bool {
+	var v gobject.Value
+	x.GetProperty("allowed", &v)
+	return v.GetBoolean()
+}
+// GetPropertyCanAcquire gets the "can-acquire" property.
+// %TRUE if it is generally possible to acquire the permission by calling
+// g_permission_acquire().
+func (x *Permission) GetPropertyCanAcquire() bool {
+	var v gobject.Value
+	x.GetProperty("can-acquire", &v)
+	return v.GetBoolean()
+}
+// GetPropertyCanRelease gets the "can-release" property.
+// %TRUE if it is generally possible to release the permission by calling
+// g_permission_release().
+func (x *Permission) GetPropertyCanRelease() bool {
+	var v gobject.Value
+	x.GetProperty("can-release", &v)
+	return v.GetBoolean()
+}
 func init() {
 	core.SetPackageName("GIO", "gio-2.0")
 	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})

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


@@ -39,7 +39,7 @@ func (x *PollableInputStreamInterface) GoPointer() uintptr {
39		return uintptr(unsafe.Pointer(x))	39		return uintptr(unsafe.Pointer(x))
40		}	40		}
41			41
42	-	// OverrideCanPoll sets the callback function.	42	+	// OverrideCanPoll sets the "can_poll" callback function.
43		// Checks if the #GPollableInputStream instance is actually pollable	43		// Checks if the #GPollableInputStream instance is actually pollable
44		func (x *PollableInputStreamInterface) OverrideCanPoll(cb func(PollableInputStream) bool) {	44		func (x *PollableInputStreamInterface) OverrideCanPoll(cb func(PollableInputStream) bool) {
45		if cb == nil {	45		if cb == nil {

@@ -51,7 +51,7 @@ func (x *PollableInputStreamInterface) OverrideCanPoll(cb func(PollableInputStre
51		}	51		}
52		}	52		}
53			53
54	-	// GetCanPoll gets the callback function.	54	+	// GetCanPoll gets the "can_poll" callback function.
55		// Checks if the #GPollableInputStream instance is actually pollable	55		// Checks if the #GPollableInputStream instance is actually pollable
56		func (x *PollableInputStreamInterface) GetCanPoll() func(PollableInputStream) bool {	56		func (x *PollableInputStreamInterface) GetCanPoll() func(PollableInputStream) bool {
57		if x.xCanPoll == 0 {	57		if x.xCanPoll == 0 {

@@ -64,7 +64,7 @@ func (x *PollableInputStreamInterface) GetCanPoll() func(PollableInputStream) bo
64		}	64		}
65		}	65		}
66			66
67	-	// OverrideIsReadable sets the callback function.	67	+	// OverrideIsReadable sets the "is_readable" callback function.
68		// Checks if the stream is readable	68		// Checks if the stream is readable
69		func (x *PollableInputStreamInterface) OverrideIsReadable(cb func(PollableInputStream) bool) {	69		func (x *PollableInputStreamInterface) OverrideIsReadable(cb func(PollableInputStream) bool) {
70		if cb == nil {	70		if cb == nil {

@@ -76,7 +76,7 @@ func (x *PollableInputStreamInterface) OverrideIsReadable(cb func(PollableInputS
76		}	76		}
77		}	77		}
78			78
79	-	// GetIsReadable gets the callback function.	79	+	// GetIsReadable gets the "is_readable" callback function.
80		// Checks if the stream is readable	80		// Checks if the stream is readable
81		func (x *PollableInputStreamInterface) GetIsReadable() func(PollableInputStream) bool {	81		func (x *PollableInputStreamInterface) GetIsReadable() func(PollableInputStream) bool {
82		if x.xIsReadable == 0 {	82		if x.xIsReadable == 0 {

@@ -89,7 +89,7 @@ func (x *PollableInputStreamInterface) GetIsReadable() func(PollableInputStream)
89		}	89		}
90		}	90		}
91			91
92	-	// OverrideCreateSource sets the callback function.	92	+	// OverrideCreateSource sets the "create_source" callback function.
93		// Creates a #GSource to poll the stream	93		// Creates a #GSource to poll the stream
94		func (x PollableInputStreamInterface) OverrideCreateSource(cb func(PollableInputStream, Cancellable) *glib.Source) {	94		func (x PollableInputStreamInterface) OverrideCreateSource(cb func(PollableInputStream, Cancellable) *glib.Source) {
95		if cb == nil {	95		if cb == nil {

@@ -101,7 +101,7 @@ func (x *PollableInputStreamInterface) OverrideCreateSource(cb func(PollableInpu
101		}	101		}
102		}	102		}
103			103
104	-	// GetCreateSource gets the callback function.	104	+	// GetCreateSource gets the "create_source" callback function.
105		// Creates a #GSource to poll the stream	105		// Creates a #GSource to poll the stream
106		func (x PollableInputStreamInterface) GetCreateSource() func(PollableInputStream, Cancellable) *glib.Source {	106		func (x PollableInputStreamInterface) GetCreateSource() func(PollableInputStream, Cancellable) *glib.Source {
107		if x.xCreateSource == 0 {	107		if x.xCreateSource == 0 {

@@ -114,31 +114,31 @@ func (x *PollableInputStreamInterface) GetCreateSource() func(PollableInputStrea
114		}	114		}
115		}	115		}
116			116
117	-	// OverrideReadNonblocking sets the callback function.	117	+	// OverrideReadNonblocking sets the "read_nonblocking" callback function.
118		// Does a non-blocking read or returns	118		// Does a non-blocking read or returns
119		//	119		//
120		// %G_IO_ERROR_WOULD_BLOCK	120		// %G_IO_ERROR_WOULD_BLOCK
121	-	func (x *PollableInputStreamInterface) OverrideReadNonblocking(cb func(PollableInputStream, []byte, uint) int) {	121	+	func (x PollableInputStreamInterface) OverrideReadNonblocking(cb func(PollableInputStream, []byte, uint) int) {
122		if cb == nil {	122		if cb == nil {
123		x.xReadNonblocking = 0	123		x.xReadNonblocking = 0
124		} else {	124		} else {
125	-	x.xReadNonblocking = purego.NewCallback(func(StreamVarp uintptr, BufferVarp []byte, CountVarp uint) int {	125	+	x.xReadNonblocking = purego.NewCallback(func(StreamVarp uintptr, BufferVarp *[]byte, CountVarp uint) int {
126		return cb(&PollableInputStreamBase{Ptr: StreamVarp}, BufferVarp, CountVarp)	126		return cb(&PollableInputStreamBase{Ptr: StreamVarp}, BufferVarp, CountVarp)
127		})	127		})
128		}	128		}
129		}	129		}
130			130
131	-	// GetReadNonblocking gets the callback function.	131	+	// GetReadNonblocking gets the "read_nonblocking" callback function.
132		// Does a non-blocking read or returns	132		// Does a non-blocking read or returns
133		//	133		//
134		// %G_IO_ERROR_WOULD_BLOCK	134		// %G_IO_ERROR_WOULD_BLOCK
135	-	func (x *PollableInputStreamInterface) GetReadNonblocking() func(PollableInputStream, []byte, uint) int {	135	+	func (x PollableInputStreamInterface) GetReadNonblocking() func(PollableInputStream, []byte, uint) int {
136		if x.xReadNonblocking == 0 {	136		if x.xReadNonblocking == 0 {
137		return nil	137		return nil
138		}	138		}
139	-	var rawCallback func(StreamVarp uintptr, BufferVarp []byte, CountVarp uint) int	139	+	var rawCallback func(StreamVarp uintptr, BufferVarp *[]byte, CountVarp uint) int
140		purego.RegisterFunc(&rawCallback, x.xReadNonblocking)	140		purego.RegisterFunc(&rawCallback, x.xReadNonblocking)
141	-	return func(StreamVar PollableInputStream, BufferVar []byte, CountVar uint) int {	141	+	return func(StreamVar PollableInputStream, BufferVar *[]byte, CountVar uint) int {
142		return rawCallback(StreamVar.GoPointer(), BufferVar, CountVar)	142		return rawCallback(StreamVar.GoPointer(), BufferVar, CountVar)
143		}	143		}
144		}	144		}

@@ -158,7 +158,7 @@ type PollableInputStream interface {
158		CanPoll() bool	158		CanPoll() bool
159		CreateSource(CancellableVar Cancellable) glib.Source	159		CreateSource(CancellableVar Cancellable) glib.Source
160		IsReadable() bool	160		IsReadable() bool
161	-	ReadNonblocking(BufferVar []byte, CountVar uint, CancellableVar *Cancellable) (int, error)	161	+	ReadNonblocking(BufferVar []byte, CountVar uint, CancellableVar Cancellable) (int, error)
162		}	162		}
163			163
164		var xPollableInputStreamGLibType func() types.GType	164		var xPollableInputStreamGLibType func() types.GType

@@ -243,7 +243,7 @@ func (x *PollableInputStreamBase) IsReadable() bool {
243		//	243		//
244		// The behaviour of this method is undefined if	244		// The behaviour of this method is undefined if
245		// g_pollable_input_stream_can_poll() returns %FALSE for @stream.	245		// g_pollable_input_stream_can_poll() returns %FALSE for @stream.
246	-	func (x PollableInputStreamBase) ReadNonblocking(BufferVar []byte, CountVar uint, CancellableVar Cancellable) (int, error) {	246	+	func (x PollableInputStreamBase) ReadNonblocking(BufferVar []byte, CountVar uint, CancellableVar *Cancellable) (int, error) {
247		var cerr *glib.Error	247		var cerr *glib.Error
248			248
249		cret := XGPollableInputStreamReadNonblocking(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)	249		cret := XGPollableInputStreamReadNonblocking(x.GoPointer(), BufferVar, CountVar, CancellableVar.GoPointer(), &cerr)

@@ -257,7 +257,7 @@ func (x *PollableInputStreamBase) ReadNonblocking(BufferVar []byte, CountVar uin
257		var XGPollableInputStreamCanPoll func(uintptr) bool	257		var XGPollableInputStreamCanPoll func(uintptr) bool
258		var XGPollableInputStreamCreateSource func(uintptr, uintptr) *glib.Source	258		var XGPollableInputStreamCreateSource func(uintptr, uintptr) *glib.Source
259		var XGPollableInputStreamIsReadable func(uintptr) bool	259		var XGPollableInputStreamIsReadable func(uintptr) bool
260	-	var XGPollableInputStreamReadNonblocking func(uintptr, []byte, uint, uintptr, **glib.Error) int	260	+	var XGPollableInputStreamReadNonblocking func(uintptr, []byte, uint, uintptr, *glib.Error) int
261			261
262		func init() {	262		func init() {
263		core.SetPackageName("GIO", "gio-2.0")	263		core.SetPackageName("GIO", "gio-2.0")

M v4/gio/gpollableoutputstream.go +18 -18


@@ -47,7 +47,7 @@ func (x *PollableOutputStreamInterface) GoPointer() uintptr {
47		return uintptr(unsafe.Pointer(x))	47		return uintptr(unsafe.Pointer(x))
48		}	48		}
49			49
50	-	// OverrideCanPoll sets the callback function.	50	+	// OverrideCanPoll sets the "can_poll" callback function.
51		// Checks if the #GPollableOutputStream instance is actually pollable	51		// Checks if the #GPollableOutputStream instance is actually pollable
52		func (x *PollableOutputStreamInterface) OverrideCanPoll(cb func(PollableOutputStream) bool) {	52		func (x *PollableOutputStreamInterface) OverrideCanPoll(cb func(PollableOutputStream) bool) {
53		if cb == nil {	53		if cb == nil {

@@ -59,7 +59,7 @@ func (x *PollableOutputStreamInterface) OverrideCanPoll(cb func(PollableOutputSt
59		}	59		}
60		}	60		}
61			61
62	-	// GetCanPoll gets the callback function.	62	+	// GetCanPoll gets the "can_poll" callback function.
63		// Checks if the #GPollableOutputStream instance is actually pollable	63		// Checks if the #GPollableOutputStream instance is actually pollable
64		func (x *PollableOutputStreamInterface) GetCanPoll() func(PollableOutputStream) bool {	64		func (x *PollableOutputStreamInterface) GetCanPoll() func(PollableOutputStream) bool {
65		if x.xCanPoll == 0 {	65		if x.xCanPoll == 0 {

@@ -72,7 +72,7 @@ func (x *PollableOutputStreamInterface) GetCanPoll() func(PollableOutputStream)
72		}	72		}
73		}	73		}
74			74
75	-	// OverrideIsWritable sets the callback function.	75	+	// OverrideIsWritable sets the "is_writable" callback function.
76		// Checks if the stream is writable	76		// Checks if the stream is writable
77		func (x *PollableOutputStreamInterface) OverrideIsWritable(cb func(PollableOutputStream) bool) {	77		func (x *PollableOutputStreamInterface) OverrideIsWritable(cb func(PollableOutputStream) bool) {
78		if cb == nil {	78		if cb == nil {

@@ -84,7 +84,7 @@ func (x *PollableOutputStreamInterface) OverrideIsWritable(cb func(PollableOutpu
84		}	84		}
85		}	85		}
86			86
87	-	// GetIsWritable gets the callback function.	87	+	// GetIsWritable gets the "is_writable" callback function.
88		// Checks if the stream is writable	88		// Checks if the stream is writable
89		func (x *PollableOutputStreamInterface) GetIsWritable() func(PollableOutputStream) bool {	89		func (x *PollableOutputStreamInterface) GetIsWritable() func(PollableOutputStream) bool {
90		if x.xIsWritable == 0 {	90		if x.xIsWritable == 0 {

@@ -97,7 +97,7 @@ func (x *PollableOutputStreamInterface) GetIsWritable() func(PollableOutputStrea
97		}	97		}
98		}	98		}
99			99
100	-	// OverrideCreateSource sets the callback function.	100	+	// OverrideCreateSource sets the "create_source" callback function.
101		// Creates a #GSource to poll the stream	101		// Creates a #GSource to poll the stream
102		func (x PollableOutputStreamInterface) OverrideCreateSource(cb func(PollableOutputStream, Cancellable) *glib.Source) {	102		func (x PollableOutputStreamInterface) OverrideCreateSource(cb func(PollableOutputStream, Cancellable) *glib.Source) {
103		if cb == nil {	103		if cb == nil {

@@ -109,7 +109,7 @@ func (x *PollableOutputStreamInterface) OverrideCreateSource(cb func(PollableOut
109		}	109		}
110		}	110		}
111			111
112	-	// GetCreateSource gets the callback function.	112	+	// GetCreateSource gets the "create_source" callback function.
113		// Creates a #GSource to poll the stream	113		// Creates a #GSource to poll the stream
114		func (x PollableOutputStreamInterface) GetCreateSource() func(PollableOutputStream, Cancellable) *glib.Source {	114		func (x PollableOutputStreamInterface) GetCreateSource() func(PollableOutputStream, Cancellable) *glib.Source {
115		if x.xCreateSource == 0 {	115		if x.xCreateSource == 0 {

@@ -122,7 +122,7 @@ func (x *PollableOutputStreamInterface) GetCreateSource() func(PollableOutputStr
122		}	122		}
123		}	123		}
124			124
125	-	// OverrideWriteNonblocking sets the callback function.	125	+	// OverrideWriteNonblocking sets the "write_nonblocking" callback function.
126		// Does a non-blocking write or returns	126		// Does a non-blocking write or returns
127		//	127		//
128		// %G_IO_ERROR_WOULD_BLOCK	128		// %G_IO_ERROR_WOULD_BLOCK

@@ -136,7 +136,7 @@ func (x *PollableOutputStreamInterface) OverrideWriteNonblocking(cb func(Pollabl
136		}	136		}
137		}	137		}
138			138
139	-	// GetWriteNonblocking gets the callback function.	139	+	// GetWriteNonblocking gets the "write_nonblocking" callback function.
140		// Does a non-blocking write or returns	140		// Does a non-blocking write or returns
141		//	141		//
142		// %G_IO_ERROR_WOULD_BLOCK	142		// %G_IO_ERROR_WOULD_BLOCK

@@ -151,31 +151,31 @@ func (x *PollableOutputStreamInterface) GetWriteNonblocking() func(PollableOutpu
151		}	151		}
152		}	152		}
153			153
154	-	// OverrideWritevNonblocking sets the callback function.	154	+	// OverrideWritevNonblocking sets the "writev_nonblocking" callback function.
155		// Does a vectored non-blocking write, or returns	155		// Does a vectored non-blocking write, or returns
156		//	156		//
157		// %G_POLLABLE_RETURN_WOULD_BLOCK	157		// %G_POLLABLE_RETURN_WOULD_BLOCK
158	-	func (x *PollableOutputStreamInterface) OverrideWritevNonblocking(cb func(PollableOutputStream, []OutputVector, uint, uint) PollableReturn) {	158	+	func (x PollableOutputStreamInterface) OverrideWritevNonblocking(cb func(PollableOutputStream, []OutputVector, uint, uint) PollableReturn) {
159		if cb == nil {	159		if cb == nil {
160		x.xWritevNonblocking = 0	160		x.xWritevNonblocking = 0
161		} else {	161		} else {
162	-	x.xWritevNonblocking = purego.NewCallback(func(StreamVarp uintptr, VectorsVarp []OutputVector, NVectorsVarp uint, BytesWrittenVarp uint) PollableReturn {	162	+	x.xWritevNonblocking = purego.NewCallback(func(StreamVarp uintptr, VectorsVarp []OutputVector, NVectorsVarp uint, BytesWrittenVarp *uint) PollableReturn {
163		return cb(&PollableOutputStreamBase{Ptr: StreamVarp}, VectorsVarp, NVectorsVarp, BytesWrittenVarp)	163		return cb(&PollableOutputStreamBase{Ptr: StreamVarp}, VectorsVarp, NVectorsVarp, BytesWrittenVarp)
164		})	164		})
165		}	165		}
166		}	166		}
167			167
168	-	// GetWritevNonblocking gets the callback function.	168	+	// GetWritevNonblocking gets the "writev_nonblocking" callback function.
169		// Does a vectored non-blocking write, or returns	169		// Does a vectored non-blocking write, or returns
170		//	170		//
171		// %G_POLLABLE_RETURN_WOULD_BLOCK	171		// %G_POLLABLE_RETURN_WOULD_BLOCK
172	-	func (x *PollableOutputStreamInterface) GetWritevNonblocking() func(PollableOutputStream, []OutputVector, uint, uint) PollableReturn {	172	+	func (x PollableOutputStreamInterface) GetWritevNonblocking() func(PollableOutputStream, []OutputVector, uint, uint) PollableReturn {
173		if x.xWritevNonblocking == 0 {	173		if x.xWritevNonblocking == 0 {
174		return nil	174		return nil
175		}	175		}
176	-	var rawCallback func(StreamVarp uintptr, VectorsVarp []OutputVector, NVectorsVarp uint, BytesWrittenVarp uint) PollableReturn	176	+	var rawCallback func(StreamVarp uintptr, VectorsVarp []OutputVector, NVectorsVarp uint, BytesWrittenVarp *uint) PollableReturn
177		purego.RegisterFunc(&rawCallback, x.xWritevNonblocking)	177		purego.RegisterFunc(&rawCallback, x.xWritevNonblocking)
178	-	return func(StreamVar PollableOutputStream, VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint) PollableReturn {	178	+	return func(StreamVar PollableOutputStream, VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar *uint) PollableReturn {
179		return rawCallback(StreamVar.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar)	179		return rawCallback(StreamVar.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar)
180		}	180		}
181		}	181		}

@@ -196,7 +196,7 @@ type PollableOutputStream interface {
196		CreateSource(CancellableVar Cancellable) glib.Source	196		CreateSource(CancellableVar Cancellable) glib.Source
197		IsWritable() bool	197		IsWritable() bool
198		WriteNonblocking(BufferVar []byte, CountVar uint, CancellableVar *Cancellable) (int, error)	198		WriteNonblocking(BufferVar []byte, CountVar uint, CancellableVar *Cancellable) (int, error)
199	-	WritevNonblocking(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar *Cancellable) (PollableReturn, error)	199	+	WritevNonblocking(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar Cancellable) (PollableReturn, error)
200		}	200		}
201			201
202		var xPollableOutputStreamGLibType func() types.GType	202		var xPollableOutputStreamGLibType func() types.GType

@@ -315,7 +315,7 @@ func (x *PollableOutputStreamBase) WriteNonblocking(BufferVar []byte, CountVar u
315		//	315		//
316		// The behaviour of this method is undefined if	316		// The behaviour of this method is undefined if
317		// g_pollable_output_stream_can_poll() returns %FALSE for @stream.	317		// g_pollable_output_stream_can_poll() returns %FALSE for @stream.
318	-	func (x PollableOutputStreamBase) WritevNonblocking(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar Cancellable) (PollableReturn, error) {	318	+	func (x PollableOutputStreamBase) WritevNonblocking(VectorsVar []OutputVector, NVectorsVar uint, BytesWrittenVar uint, CancellableVar *Cancellable) (PollableReturn, error) {
319		var cerr *glib.Error	319		var cerr *glib.Error
320			320
321		cret := XGPollableOutputStreamWritevNonblocking(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)	321		cret := XGPollableOutputStreamWritevNonblocking(x.GoPointer(), VectorsVar, NVectorsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)

@@ -330,7 +330,7 @@ var XGPollableOutputStreamCanPoll func(uintptr) bool
330		var XGPollableOutputStreamCreateSource func(uintptr, uintptr) *glib.Source	330		var XGPollableOutputStreamCreateSource func(uintptr, uintptr) *glib.Source
331		var XGPollableOutputStreamIsWritable func(uintptr) bool	331		var XGPollableOutputStreamIsWritable func(uintptr) bool
332		var XGPollableOutputStreamWriteNonblocking func(uintptr, []byte, uint, uintptr, **glib.Error) int	332		var XGPollableOutputStreamWriteNonblocking func(uintptr, []byte, uint, uintptr, **glib.Error) int
333	-	var XGPollableOutputStreamWritevNonblocking func(uintptr, []OutputVector, uint, uint, uintptr, **glib.Error) PollableReturn	333	+	var XGPollableOutputStreamWritevNonblocking func(uintptr, []OutputVector, uint, uint, uintptr, *glib.Error) PollableReturn
334			334
335		func init() {	335		func init() {
336		core.SetPackageName("GIO", "gio-2.0")	336		core.SetPackageName("GIO", "gio-2.0")

M v4/gio/gpollableutils.go +2 -2


@@ -78,7 +78,7 @@ func PollableStreamWrite(StreamVar *OutputStream, BufferVar []byte, CountVar uin
78			78
79		}	79		}
80			80
81	-	var xPollableStreamWriteAll func(uintptr, []byte, uint, bool, uint, uintptr, **glib.Error) bool	81	+	var xPollableStreamWriteAll func(uintptr, []byte, uint, bool, uint, uintptr, *glib.Error) bool
82			82
83		// Tries to write @count bytes to @stream, as with	83		// Tries to write @count bytes to @stream, as with
84		// g_output_stream_write_all(), but using g_pollable_stream_write()	84		// g_output_stream_write_all(), but using g_pollable_stream_write()

@@ -98,7 +98,7 @@ var xPollableStreamWriteAll func(uintptr, []byte, uint, bool, uint, uintptr, **g
98		// g_pollable_output_stream_can_poll() returns %TRUE or else the	98		// g_pollable_output_stream_can_poll() returns %TRUE or else the
99		// behavior is undefined. If @blocking is %TRUE, then @stream does not	99		// behavior is undefined. If @blocking is %TRUE, then @stream does not
100		// need to be a #GPollableOutputStream.	100		// need to be a #GPollableOutputStream.
101	-	func PollableStreamWriteAll(StreamVar OutputStream, BufferVar []byte, CountVar uint, BlockingVar bool, BytesWrittenVar uint, CancellableVar Cancellable) (bool, error) {	101	+	func PollableStreamWriteAll(StreamVar OutputStream, BufferVar []byte, CountVar uint, BlockingVar bool, BytesWrittenVar uint, CancellableVar *Cancellable) (bool, error) {
102		var cerr *glib.Error	102		var cerr *glib.Error
103			103
104		cret := xPollableStreamWriteAll(StreamVar.GoPointer(), BufferVar, CountVar, BlockingVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)	104		cret := xPollableStreamWriteAll(StreamVar.GoPointer(), BufferVar, CountVar, BlockingVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)

M v4/gio/gpowerprofilemonitor.go +11 -0


@@ -7,6 +7,7 @@ import (
7		7
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
		10	+	"github.com/jwijenbergh/puregotk/v4/gobject"
10	"github.com/jwijenbergh/puregotk/v4/gobject/types"	11		"github.com/jwijenbergh/puregotk/v4/gobject/types"
11	)	12		)
12		13

@@ -83,6 +84,16 @@ func (x *PowerProfileMonitorBase) GetPowerSaverEnabled() bool {
83	return cret	84		return cret
84	}	85		}
85		86
		87	+	// GetPropertyPowerSaverEnabled gets the "power-saver-enabled" property.
		88	+	// Whether “Power Saver” mode is enabled on the system.
		89	+	func (x *PowerProfileMonitorBase) GetPropertyPowerSaverEnabled() bool {
		90	+	obj := gobject.Object{}
		91	+	obj.Ptr = x.GoPointer()
		92	+	var v gobject.Value
		93	+	obj.GetProperty("power-saver-enabled", &v)
		94	+	return v.GetBoolean()
		95	+	}
		96	+
86	var XGPowerProfileMonitorGetPowerSaverEnabled func(uintptr) bool	97		var XGPowerProfileMonitorGetPowerSaverEnabled func(uintptr) bool
87		98
88	const (	99		const (

M v4/gio/gpropertyaction.go +87 -0


@@ -111,6 +111,93 @@ func (c *PropertyAction) SetGoPointer(ptr uintptr) {
111	c.Ptr = ptr	111		c.Ptr = ptr
112	}	112		}
113		113
		114	+	// GetPropertyEnabled gets the "enabled" property.
		115	+	// If @action is currently enabled.
		116	+	//
		117	+	// If the action is disabled then calls to g_action_activate() and
		118	+	// g_action_change_state() have no effect.
		119	+	func (x *PropertyAction) GetPropertyEnabled() bool {
		120	+	var v gobject.Value
		121	+	x.GetProperty("enabled", &v)
		122	+	return v.GetBoolean()
		123	+	}
		124	+
		125	+	// SetPropertyInvertBoolean sets the "invert-boolean" property.
		126	+	// If %TRUE, the state of the action will be the negation of the
		127	+	// property value, provided the property is boolean.
		128	+	func (x *PropertyAction) SetPropertyInvertBoolean(value bool) {
		129	+	var v gobject.Value
		130	+	v.Init(gobject.TypeBooleanVal)
		131	+	v.SetBoolean(value)
		132	+	x.SetProperty("invert-boolean", &v)
		133	+	}
		134	+
		135	+	// GetPropertyInvertBoolean gets the "invert-boolean" property.
		136	+	// If %TRUE, the state of the action will be the negation of the
		137	+	// property value, provided the property is boolean.
		138	+	func (x *PropertyAction) GetPropertyInvertBoolean() bool {
		139	+	var v gobject.Value
		140	+	x.GetProperty("invert-boolean", &v)
		141	+	return v.GetBoolean()
		142	+	}
		143	+
		144	+	// SetPropertyName sets the "name" property.
		145	+	// The name of the action. This is mostly meaningful for identifying
		146	+	// the action once it has been added to a #GActionMap.
		147	+	func (x *PropertyAction) SetPropertyName(value string) {
		148	+	var v gobject.Value
		149	+	v.Init(gobject.TypeStringVal)
		150	+	v.SetString(value)
		151	+	x.SetProperty("name", &v)
		152	+	}
		153	+
		154	+	// GetPropertyName gets the "name" property.
		155	+	// The name of the action. This is mostly meaningful for identifying
		156	+	// the action once it has been added to a #GActionMap.
		157	+	func (x *PropertyAction) GetPropertyName() string {
		158	+	var v gobject.Value
		159	+	x.GetProperty("name", &v)
		160	+	return v.GetString()
		161	+	}
		162	+
		163	+	// GetPropertyParameterType gets the "parameter-type" property.
		164	+	// The type of the parameter that must be given when activating the
		165	+	// action.
		166	+	func (x *PropertyAction) GetPropertyParameterType() uintptr {
		167	+	var v gobject.Value
		168	+	x.GetProperty("parameter-type", &v)
		169	+	return v.GetPointer()
		170	+	}
		171	+
		172	+	// SetPropertyPropertyName sets the "property-name" property.
		173	+	// The name of the property to wrap on the object.
		174	+	//
		175	+	// The property must exist on the passed-in object and it must be
		176	+	// readable and writable (and not construct-only).
		177	+	func (x *PropertyAction) SetPropertyPropertyName(value string) {
		178	+	var v gobject.Value
		179	+	v.Init(gobject.TypeStringVal)
		180	+	v.SetString(value)
		181	+	x.SetProperty("property-name", &v)
		182	+	}
		183	+
		184	+	// GetPropertyState gets the "state" property.
		185	+	// The state of the action, or %NULL if the action is stateless.
		186	+	func (x *PropertyAction) GetPropertyState() uintptr {
		187	+	var v gobject.Value
		188	+	x.GetProperty("state", &v)
		189	+	return v.GetPointer()
		190	+	}
		191	+
		192	+	// GetPropertyStateType gets the "state-type" property.
		193	+	// The #GVariantType of the state that the action has, or %NULL if the
		194	+	// action is stateless.
		195	+	func (x *PropertyAction) GetPropertyStateType() uintptr {
		196	+	var v gobject.Value
		197	+	x.GetProperty("state-type", &v)
		198	+	return v.GetPointer()
		199	+	}
		200	+
114	// Activates the action.	201		// Activates the action.
115	//	202		//
116	// @parameter must be the correct type of parameter for the action (ie:	203		// @parameter must be the correct type of parameter for the action (ie:

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


@@ -30,7 +30,7 @@ func (x *ProxyInterface) GoPointer() uintptr {
30		return uintptr(unsafe.Pointer(x))	30		return uintptr(unsafe.Pointer(x))
31		}	31		}
32			32
33	-	// OverrideConnect sets the callback function.	33	+	// OverrideConnect sets the "connect" callback function.
34		// Connect to proxy server and wrap (if required) the #connection	34		// Connect to proxy server and wrap (if required) the #connection
35		//	35		//
36		// to handle payload.	36		// to handle payload.

@@ -48,7 +48,7 @@ func (x ProxyInterface) OverrideConnect(cb func(Proxy, IOStream, *ProxyAddress
48		}	48		}
49		}	49		}
50			50
51	-	// GetConnect gets the callback function.	51	+	// GetConnect gets the "connect" callback function.
52		// Connect to proxy server and wrap (if required) the #connection	52		// Connect to proxy server and wrap (if required) the #connection
53		//	53		//
54		// to handle payload.	54		// to handle payload.

@@ -69,7 +69,7 @@ func (x ProxyInterface) GetConnect() func(Proxy, IOStream, ProxyAddress, Can
69		}	69		}
70		}	70		}
71			71
72	-	// OverrideConnectAsync sets the callback function.	72	+	// OverrideConnectAsync sets the "connect_async" callback function.
73		// Same as connect() but asynchronous.	73		// Same as connect() but asynchronous.
74		func (x ProxyInterface) OverrideConnectAsync(cb func(Proxy, IOStream, ProxyAddress, Cancellable, *AsyncReadyCallback, uintptr)) {	74		func (x ProxyInterface) OverrideConnectAsync(cb func(Proxy, IOStream, ProxyAddress, Cancellable, *AsyncReadyCallback, uintptr)) {
75		if cb == nil {	75		if cb == nil {

@@ -81,7 +81,7 @@ func (x ProxyInterface) OverrideConnectAsync(cb func(Proxy, IOStream, *ProxyAd
81		}	81		}
82		}	82		}
83			83
84	-	// GetConnectAsync gets the callback function.	84	+	// GetConnectAsync gets the "connect_async" callback function.
85		// Same as connect() but asynchronous.	85		// Same as connect() but asynchronous.
86		func (x ProxyInterface) GetConnectAsync() func(Proxy, IOStream, ProxyAddress, Cancellable, *AsyncReadyCallback, uintptr) {	86		func (x ProxyInterface) GetConnectAsync() func(Proxy, IOStream, ProxyAddress, Cancellable, *AsyncReadyCallback, uintptr) {
87		if x.xConnectAsync == 0 {	87		if x.xConnectAsync == 0 {

@@ -94,7 +94,7 @@ func (x ProxyInterface) GetConnectAsync() func(Proxy, IOStream, *ProxyAddress,
94		}	94		}
95		}	95		}
96			96
97	-	// OverrideConnectFinish sets the callback function.	97	+	// OverrideConnectFinish sets the "connect_finish" callback function.
98		// Returns the result of connect_async()	98		// Returns the result of connect_async()
99		func (x ProxyInterface) OverrideConnectFinish(cb func(Proxy, AsyncResult) IOStream) {	99		func (x ProxyInterface) OverrideConnectFinish(cb func(Proxy, AsyncResult) IOStream) {
100		if cb == nil {	100		if cb == nil {

@@ -110,7 +110,7 @@ func (x ProxyInterface) OverrideConnectFinish(cb func(Proxy, AsyncResult) IOSt
110		}	110		}
111		}	111		}
112			112
113	-	// GetConnectFinish gets the callback function.	113	+	// GetConnectFinish gets the "connect_finish" callback function.
114		// Returns the result of connect_async()	114		// Returns the result of connect_async()
115		func (x ProxyInterface) GetConnectFinish() func(Proxy, AsyncResult) IOStream {	115		func (x ProxyInterface) GetConnectFinish() func(Proxy, AsyncResult) IOStream {
116		if x.xConnectFinish == 0 {	116		if x.xConnectFinish == 0 {

@@ -129,7 +129,7 @@ func (x ProxyInterface) GetConnectFinish() func(Proxy, AsyncResult) IOStream {
129		}	129		}
130		}	130		}
131			131
132	-	// OverrideSupportsHostname sets the callback function.	132	+	// OverrideSupportsHostname sets the "supports_hostname" callback function.
133		// Returns whether the proxy supports hostname lookups.	133		// Returns whether the proxy supports hostname lookups.
134		func (x *ProxyInterface) OverrideSupportsHostname(cb func(Proxy) bool) {	134		func (x *ProxyInterface) OverrideSupportsHostname(cb func(Proxy) bool) {
135		if cb == nil {	135		if cb == nil {

@@ -141,7 +141,7 @@ func (x *ProxyInterface) OverrideSupportsHostname(cb func(Proxy) bool) {
141		}	141		}
142		}	142		}
143			143
144	-	// GetSupportsHostname gets the callback function.	144	+	// GetSupportsHostname gets the "supports_hostname" callback function.
145		// Returns whether the proxy supports hostname lookups.	145		// Returns whether the proxy supports hostname lookups.
146		func (x *ProxyInterface) GetSupportsHostname() func(Proxy) bool {	146		func (x *ProxyInterface) GetSupportsHostname() func(Proxy) bool {
147		if x.xSupportsHostname == 0 {	147		if x.xSupportsHostname == 0 {

M v4/gio/gproxyaddress.go +124 -0


@@ -7,6 +7,7 @@ import (
7		7
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
		10	+	"github.com/jwijenbergh/puregotk/v4/gobject"
10	"github.com/jwijenbergh/puregotk/v4/gobject/types"	11		"github.com/jwijenbergh/puregotk/v4/gobject/types"
11	)	12		)
12		13

@@ -146,6 +147,129 @@ func (c *ProxyAddress) SetGoPointer(ptr uintptr) {
146	c.Ptr = ptr	147		c.Ptr = ptr
147	}	148		}
148		149
		150	+	// SetPropertyDestinationHostname sets the "destination-hostname" property.
		151	+	// The proxy destination hostname.
		152	+	func (x *ProxyAddress) SetPropertyDestinationHostname(value string) {
		153	+	var v gobject.Value
		154	+	v.Init(gobject.TypeStringVal)
		155	+	v.SetString(value)
		156	+	x.SetProperty("destination-hostname", &v)
		157	+	}
		158	+
		159	+	// GetPropertyDestinationHostname gets the "destination-hostname" property.
		160	+	// The proxy destination hostname.
		161	+	func (x *ProxyAddress) GetPropertyDestinationHostname() string {
		162	+	var v gobject.Value
		163	+	x.GetProperty("destination-hostname", &v)
		164	+	return v.GetString()
		165	+	}
		166	+
		167	+	// SetPropertyDestinationPort sets the "destination-port" property.
		168	+	// The proxy destination port.
		169	+	func (x *ProxyAddress) SetPropertyDestinationPort(value uint) {
		170	+	var v gobject.Value
		171	+	v.Init(gobject.TypeUintVal)
		172	+	v.SetUint(value)
		173	+	x.SetProperty("destination-port", &v)
		174	+	}
		175	+
		176	+	// GetPropertyDestinationPort gets the "destination-port" property.
		177	+	// The proxy destination port.
		178	+	func (x *ProxyAddress) GetPropertyDestinationPort() uint {
		179	+	var v gobject.Value
		180	+	x.GetProperty("destination-port", &v)
		181	+	return v.GetUint()
		182	+	}
		183	+
		184	+	// SetPropertyDestinationProtocol sets the "destination-protocol" property.
		185	+	// The protocol being spoke to the destination host, or %NULL if
		186	+	// the #GProxyAddress doesn't know.
		187	+	func (x *ProxyAddress) SetPropertyDestinationProtocol(value string) {
		188	+	var v gobject.Value
		189	+	v.Init(gobject.TypeStringVal)
		190	+	v.SetString(value)
		191	+	x.SetProperty("destination-protocol", &v)
		192	+	}
		193	+
		194	+	// GetPropertyDestinationProtocol gets the "destination-protocol" property.
		195	+	// The protocol being spoke to the destination host, or %NULL if
		196	+	// the #GProxyAddress doesn't know.
		197	+	func (x *ProxyAddress) GetPropertyDestinationProtocol() string {
		198	+	var v gobject.Value
		199	+	x.GetProperty("destination-protocol", &v)
		200	+	return v.GetString()
		201	+	}
		202	+
		203	+	// SetPropertyPassword sets the "password" property.
		204	+	// The proxy password.
		205	+	func (x *ProxyAddress) SetPropertyPassword(value string) {
		206	+	var v gobject.Value
		207	+	v.Init(gobject.TypeStringVal)
		208	+	v.SetString(value)
		209	+	x.SetProperty("password", &v)
		210	+	}
		211	+
		212	+	// GetPropertyPassword gets the "password" property.
		213	+	// The proxy password.
		214	+	func (x *ProxyAddress) GetPropertyPassword() string {
		215	+	var v gobject.Value
		216	+	x.GetProperty("password", &v)
		217	+	return v.GetString()
		218	+	}
		219	+
		220	+	// SetPropertyProtocol sets the "protocol" property.
		221	+	// The proxy protocol.
		222	+	func (x *ProxyAddress) SetPropertyProtocol(value string) {
		223	+	var v gobject.Value
		224	+	v.Init(gobject.TypeStringVal)
		225	+	v.SetString(value)
		226	+	x.SetProperty("protocol", &v)
		227	+	}
		228	+
		229	+	// GetPropertyProtocol gets the "protocol" property.
		230	+	// The proxy protocol.
		231	+	func (x *ProxyAddress) GetPropertyProtocol() string {
		232	+	var v gobject.Value
		233	+	x.GetProperty("protocol", &v)
		234	+	return v.GetString()
		235	+	}
		236	+
		237	+	// SetPropertyUri sets the "uri" property.
		238	+	// The URI string that the proxy was constructed from (or %NULL
		239	+	// if the creator didn't specify this).
		240	+	func (x *ProxyAddress) SetPropertyUri(value string) {
		241	+	var v gobject.Value
		242	+	v.Init(gobject.TypeStringVal)
		243	+	v.SetString(value)
		244	+	x.SetProperty("uri", &v)
		245	+	}
		246	+
		247	+	// GetPropertyUri gets the "uri" property.
		248	+	// The URI string that the proxy was constructed from (or %NULL
		249	+	// if the creator didn't specify this).
		250	+	func (x *ProxyAddress) GetPropertyUri() string {
		251	+	var v gobject.Value
		252	+	x.GetProperty("uri", &v)
		253	+	return v.GetString()
		254	+	}
		255	+
		256	+	// SetPropertyUsername sets the "username" property.
		257	+	// The proxy username.
		258	+	func (x *ProxyAddress) SetPropertyUsername(value string) {
		259	+	var v gobject.Value
		260	+	v.Init(gobject.TypeStringVal)
		261	+	v.SetString(value)
		262	+	x.SetProperty("username", &v)
		263	+	}
		264	+
		265	+	// GetPropertyUsername gets the "username" property.
		266	+	// The proxy username.
		267	+	func (x *ProxyAddress) GetPropertyUsername() string {
		268	+	var v gobject.Value
		269	+	x.GetProperty("username", &v)
		270	+	return v.GetString()
		271	+	}
		272	+
149	// Creates a #GSocketAddressEnumerator for @connectable.	273		// Creates a #GSocketAddressEnumerator for @connectable.
150	func (x ProxyAddress) Enumerate() SocketAddressEnumerator {	274		func (x ProxyAddress) Enumerate() SocketAddressEnumerator {
151	var cls *SocketAddressEnumerator	275		var cls *SocketAddressEnumerator

M v4/gio/gproxyaddressenumerator.go +51 -14

 	"unsafe"
 	"github.com/jwijenbergh/purego"
+	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gobject/types"
 )
 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *ProxyAddressEnumeratorClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *ProxyAddressEnumeratorClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *ProxyAddressEnumeratorClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *ProxyAddressEnumeratorClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *ProxyAddressEnumeratorClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *ProxyAddressEnumeratorClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *ProxyAddressEnumeratorClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *ProxyAddressEnumeratorClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *ProxyAddressEnumeratorClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *ProxyAddressEnumeratorClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved6 sets the callback function.
+// OverrideGReserved6 sets the "_g_reserved6" callback function.
 func (x *ProxyAddressEnumeratorClass) OverrideGReserved6(cb func()) {
 	if cb == nil {
 		x.xGReserved6 = 0
 	}
 }
-// GetGReserved6 gets the callback function.
+// GetGReserved6 gets the "_g_reserved6" callback function.
 func (x *ProxyAddressEnumeratorClass) GetGReserved6() func() {
 	if x.xGReserved6 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved7 sets the callback function.
+// OverrideGReserved7 sets the "_g_reserved7" callback function.
 func (x *ProxyAddressEnumeratorClass) OverrideGReserved7(cb func()) {
 	if cb == nil {
 		x.xGReserved7 = 0
 	}
 }
-// GetGReserved7 gets the callback function.
+// GetGReserved7 gets the "_g_reserved7" callback function.
 func (x *ProxyAddressEnumeratorClass) GetGReserved7() func() {
 	if x.xGReserved7 == 0 {
 		return nil
 func (c *ProxyAddressEnumerator) SetGoPointer(ptr uintptr) {
 	c.Ptr = ptr
 }
+// SetPropertyDefaultPort sets the "default-port" property.
+// The default port to use if #GProxyAddressEnumerator:uri does not
+// specify one.
+func (x *ProxyAddressEnumerator) SetPropertyDefaultPort(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("default-port", &v)
+}
+// GetPropertyDefaultPort gets the "default-port" property.
+// The default port to use if #GProxyAddressEnumerator:uri does not
+// specify one.
+func (x *ProxyAddressEnumerator) GetPropertyDefaultPort() uint {
+	var v gobject.Value
+	x.GetProperty("default-port", &v)
+	return v.GetUint()
+}
+// SetPropertyUri sets the "uri" property.
+// The destination URI. Use `none://` for a generic socket.
+func (x *ProxyAddressEnumerator) SetPropertyUri(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("uri", &v)
+}
+// GetPropertyUri gets the "uri" property.
+// The destination URI. Use `none://` for a generic socket.
+func (x *ProxyAddressEnumerator) GetPropertyUri() string {
+	var v gobject.Value
+	x.GetProperty("uri", &v)
+	return v.GetString()
+}

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


@@ -31,7 +31,7 @@ func (x *ProxyResolverInterface) GoPointer() uintptr {
31		return uintptr(unsafe.Pointer(x))	31		return uintptr(unsafe.Pointer(x))
32		}	32		}
33			33
34	-	// OverrideIsSupported sets the callback function.	34	+	// OverrideIsSupported sets the "is_supported" callback function.
35		// the virtual function pointer for g_proxy_resolver_is_supported()	35		// the virtual function pointer for g_proxy_resolver_is_supported()
36		func (x *ProxyResolverInterface) OverrideIsSupported(cb func(ProxyResolver) bool) {	36		func (x *ProxyResolverInterface) OverrideIsSupported(cb func(ProxyResolver) bool) {
37		if cb == nil {	37		if cb == nil {

@@ -43,7 +43,7 @@ func (x *ProxyResolverInterface) OverrideIsSupported(cb func(ProxyResolver) bool
43		}	43		}
44		}	44		}
45			45
46	-	// GetIsSupported gets the callback function.	46	+	// GetIsSupported gets the "is_supported" callback function.
47		// the virtual function pointer for g_proxy_resolver_is_supported()	47		// the virtual function pointer for g_proxy_resolver_is_supported()
48		func (x *ProxyResolverInterface) GetIsSupported() func(ProxyResolver) bool {	48		func (x *ProxyResolverInterface) GetIsSupported() func(ProxyResolver) bool {
49		if x.xIsSupported == 0 {	49		if x.xIsSupported == 0 {

@@ -56,7 +56,7 @@ func (x *ProxyResolverInterface) GetIsSupported() func(ProxyResolver) bool {
56		}	56		}
57		}	57		}
58			58
59	-	// OverrideLookup sets the callback function.	59	+	// OverrideLookup sets the "lookup" callback function.
60		// the virtual function pointer for g_proxy_resolver_lookup()	60		// the virtual function pointer for g_proxy_resolver_lookup()
61		func (x ProxyResolverInterface) OverrideLookup(cb func(ProxyResolver, string, Cancellable) []string) {	61		func (x ProxyResolverInterface) OverrideLookup(cb func(ProxyResolver, string, Cancellable) []string) {
62		if cb == nil {	62		if cb == nil {

@@ -68,7 +68,7 @@ func (x ProxyResolverInterface) OverrideLookup(cb func(ProxyResolver, string,
68		}	68		}
69		}	69		}
70			70
71	-	// GetLookup gets the callback function.	71	+	// GetLookup gets the "lookup" callback function.
72		// the virtual function pointer for g_proxy_resolver_lookup()	72		// the virtual function pointer for g_proxy_resolver_lookup()
73		func (x ProxyResolverInterface) GetLookup() func(ProxyResolver, string, Cancellable) []string {	73		func (x ProxyResolverInterface) GetLookup() func(ProxyResolver, string, Cancellable) []string {
74		if x.xLookup == 0 {	74		if x.xLookup == 0 {

@@ -81,7 +81,7 @@ func (x ProxyResolverInterface) GetLookup() func(ProxyResolver, string, Cancel
81		}	81		}
82		}	82		}
83			83
84	-	// OverrideLookupAsync sets the callback function.	84	+	// OverrideLookupAsync sets the "lookup_async" callback function.
85		// the virtual function pointer for	85		// the virtual function pointer for
86		//	86		//
87		// g_proxy_resolver_lookup_async()	87		// g_proxy_resolver_lookup_async()

@@ -95,7 +95,7 @@ func (x *ProxyResolverInterface) OverrideLookupAsync(cb func(ProxyResolver, stri
95		}	95		}
96		}	96		}
97			97
98	-	// GetLookupAsync gets the callback function.	98	+	// GetLookupAsync gets the "lookup_async" callback function.
99		// the virtual function pointer for	99		// the virtual function pointer for
100		//	100		//
101		// g_proxy_resolver_lookup_async()	101		// g_proxy_resolver_lookup_async()

@@ -110,7 +110,7 @@ func (x ProxyResolverInterface) GetLookupAsync() func(ProxyResolver, string, C
110		}	110		}
111		}	111		}
112			112
113	-	// OverrideLookupFinish sets the callback function.	113	+	// OverrideLookupFinish sets the "lookup_finish" callback function.
114		// the virtual function pointer for	114		// the virtual function pointer for
115		//	115		//
116		// g_proxy_resolver_lookup_finish()	116		// g_proxy_resolver_lookup_finish()

@@ -124,7 +124,7 @@ func (x *ProxyResolverInterface) OverrideLookupFinish(cb func(ProxyResolver, Asy
124		}	124		}
125		}	125		}
126			126
127	-	// GetLookupFinish gets the callback function.	127	+	// GetLookupFinish gets the "lookup_finish" callback function.
128		// the virtual function pointer for	128		// the virtual function pointer for
129		//	129		//
130		// g_proxy_resolver_lookup_finish()	130		// g_proxy_resolver_lookup_finish()

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


@@ -26,7 +26,7 @@ func (x *RemoteActionGroupInterface) GoPointer() uintptr {
26		return uintptr(unsafe.Pointer(x))	26		return uintptr(unsafe.Pointer(x))
27		}	27		}
28			28
29	-	// OverrideActivateActionFull sets the callback function.	29	+	// OverrideActivateActionFull sets the "activate_action_full" callback function.
30		// the virtual function pointer for g_remote_action_group_activate_action_full()	30		// the virtual function pointer for g_remote_action_group_activate_action_full()
31		func (x RemoteActionGroupInterface) OverrideActivateActionFull(cb func(RemoteActionGroup, string, glib.Variant, *glib.Variant)) {	31		func (x RemoteActionGroupInterface) OverrideActivateActionFull(cb func(RemoteActionGroup, string, glib.Variant, *glib.Variant)) {
32		if cb == nil {	32		if cb == nil {

@@ -38,7 +38,7 @@ func (x *RemoteActionGroupInterface) OverrideActivateActionFull(cb func(RemoteAc
38		}	38		}
39		}	39		}
40			40
41	-	// GetActivateActionFull gets the callback function.	41	+	// GetActivateActionFull gets the "activate_action_full" callback function.
42		// the virtual function pointer for g_remote_action_group_activate_action_full()	42		// the virtual function pointer for g_remote_action_group_activate_action_full()
43		func (x RemoteActionGroupInterface) GetActivateActionFull() func(RemoteActionGroup, string, glib.Variant, *glib.Variant) {	43		func (x RemoteActionGroupInterface) GetActivateActionFull() func(RemoteActionGroup, string, glib.Variant, *glib.Variant) {
44		if x.xActivateActionFull == 0 {	44		if x.xActivateActionFull == 0 {

@@ -51,7 +51,7 @@ func (x *RemoteActionGroupInterface) GetActivateActionFull() func(RemoteActionGr
51		}	51		}
52		}	52		}
53			53
54	-	// OverrideChangeActionStateFull sets the callback function.	54	+	// OverrideChangeActionStateFull sets the "change_action_state_full" callback function.
55		// the virtual function pointer for g_remote_action_group_change_action_state_full()	55		// the virtual function pointer for g_remote_action_group_change_action_state_full()
56		func (x RemoteActionGroupInterface) OverrideChangeActionStateFull(cb func(RemoteActionGroup, string, glib.Variant, *glib.Variant)) {	56		func (x RemoteActionGroupInterface) OverrideChangeActionStateFull(cb func(RemoteActionGroup, string, glib.Variant, *glib.Variant)) {
57		if cb == nil {	57		if cb == nil {

@@ -63,7 +63,7 @@ func (x *RemoteActionGroupInterface) OverrideChangeActionStateFull(cb func(Remot
63		}	63		}
64		}	64		}
65			65
66	-	// GetChangeActionStateFull gets the callback function.	66	+	// GetChangeActionStateFull gets the "change_action_state_full" callback function.
67		// the virtual function pointer for g_remote_action_group_change_action_state_full()	67		// the virtual function pointer for g_remote_action_group_change_action_state_full()
68		func (x RemoteActionGroupInterface) GetChangeActionStateFull() func(RemoteActionGroup, string, glib.Variant, *glib.Variant) {	68		func (x RemoteActionGroupInterface) GetChangeActionStateFull() func(RemoteActionGroup, string, glib.Variant, *glib.Variant) {
69		if x.xChangeActionStateFull == 0 {	69		if x.xChangeActionStateFull == 0 {

M v4/gio/gresolver.go +67 -32

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideReload sets the callback function.
+// OverrideReload sets the "reload" callback function.
 func (x *ResolverClass) OverrideReload(cb func(*Resolver)) {
 	if cb == nil {
 		x.xReload = 0
 	}
 }
-// GetReload gets the callback function.
+// GetReload gets the "reload" callback function.
 func (x *ResolverClass) GetReload() func(*Resolver) {
 	if x.xReload == 0 {
 		return nil
 	}
 }
-// OverrideLookupByName sets the callback function.
+// OverrideLookupByName sets the "lookup_by_name" callback function.
 func (x *ResolverClass) OverrideLookupByName(cb func(*Resolver, string, *Cancellable) *glib.List) {
 	if cb == nil {
 		x.xLookupByName = 0
 	}
 }
-// GetLookupByName gets the callback function.
+// GetLookupByName gets the "lookup_by_name" callback function.
 func (x *ResolverClass) GetLookupByName() func(*Resolver, string, *Cancellable) *glib.List {
 	if x.xLookupByName == 0 {
 		return nil
 	}
 }
-// OverrideLookupByNameAsync sets the callback function.
+// OverrideLookupByNameAsync sets the "lookup_by_name_async" callback function.
 func (x *ResolverClass) OverrideLookupByNameAsync(cb func(*Resolver, string, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xLookupByNameAsync = 0
 	}
 }
-// GetLookupByNameAsync gets the callback function.
+// GetLookupByNameAsync gets the "lookup_by_name_async" callback function.
 func (x *ResolverClass) GetLookupByNameAsync() func(*Resolver, string, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xLookupByNameAsync == 0 {
 		return nil
 	}
 }
-// OverrideLookupByNameFinish sets the callback function.
+// OverrideLookupByNameFinish sets the "lookup_by_name_finish" callback function.
 func (x *ResolverClass) OverrideLookupByNameFinish(cb func(*Resolver, AsyncResult) *glib.List) {
 	if cb == nil {
 		x.xLookupByNameFinish = 0
 	}
 }
-// GetLookupByNameFinish gets the callback function.
+// GetLookupByNameFinish gets the "lookup_by_name_finish" callback function.
 func (x *ResolverClass) GetLookupByNameFinish() func(*Resolver, AsyncResult) *glib.List {
 	if x.xLookupByNameFinish == 0 {
 		return nil
 	}
 }
-// OverrideLookupByAddress sets the callback function.
+// OverrideLookupByAddress sets the "lookup_by_address" callback function.
 func (x *ResolverClass) OverrideLookupByAddress(cb func(*Resolver, *InetAddress, *Cancellable) string) {
 	if cb == nil {
 		x.xLookupByAddress = 0
 	}
 }
-// GetLookupByAddress gets the callback function.
+// GetLookupByAddress gets the "lookup_by_address" callback function.
 func (x *ResolverClass) GetLookupByAddress() func(*Resolver, *InetAddress, *Cancellable) string {
 	if x.xLookupByAddress == 0 {
 		return nil
 	}
 }
-// OverrideLookupByAddressAsync sets the callback function.
+// OverrideLookupByAddressAsync sets the "lookup_by_address_async" callback function.
 func (x *ResolverClass) OverrideLookupByAddressAsync(cb func(*Resolver, *InetAddress, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xLookupByAddressAsync = 0
 	}
 }
-// GetLookupByAddressAsync gets the callback function.
+// GetLookupByAddressAsync gets the "lookup_by_address_async" callback function.
 func (x *ResolverClass) GetLookupByAddressAsync() func(*Resolver, *InetAddress, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xLookupByAddressAsync == 0 {
 		return nil
 	}
 }
-// OverrideLookupByAddressFinish sets the callback function.
+// OverrideLookupByAddressFinish sets the "lookup_by_address_finish" callback function.
 func (x *ResolverClass) OverrideLookupByAddressFinish(cb func(*Resolver, AsyncResult) string) {
 	if cb == nil {
 		x.xLookupByAddressFinish = 0
 	}
 }
-// GetLookupByAddressFinish gets the callback function.
+// GetLookupByAddressFinish gets the "lookup_by_address_finish" callback function.
 func (x *ResolverClass) GetLookupByAddressFinish() func(*Resolver, AsyncResult) string {
 	if x.xLookupByAddressFinish == 0 {
 		return nil
 	}
 }
-// OverrideLookupService sets the callback function.
+// OverrideLookupService sets the "lookup_service" callback function.
 func (x *ResolverClass) OverrideLookupService(cb func(*Resolver, string, *Cancellable) *glib.List) {
 	if cb == nil {
 		x.xLookupService = 0
 	}
 }
-// GetLookupService gets the callback function.
+// GetLookupService gets the "lookup_service" callback function.
 func (x *ResolverClass) GetLookupService() func(*Resolver, string, *Cancellable) *glib.List {
 	if x.xLookupService == 0 {
 		return nil
 	}
 }
-// OverrideLookupServiceAsync sets the callback function.
+// OverrideLookupServiceAsync sets the "lookup_service_async" callback function.
 func (x *ResolverClass) OverrideLookupServiceAsync(cb func(*Resolver, string, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xLookupServiceAsync = 0
 	}
 }
-// GetLookupServiceAsync gets the callback function.
+// GetLookupServiceAsync gets the "lookup_service_async" callback function.
 func (x *ResolverClass) GetLookupServiceAsync() func(*Resolver, string, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xLookupServiceAsync == 0 {
 		return nil
 	}
 }
-// OverrideLookupServiceFinish sets the callback function.
+// OverrideLookupServiceFinish sets the "lookup_service_finish" callback function.
 func (x *ResolverClass) OverrideLookupServiceFinish(cb func(*Resolver, AsyncResult) *glib.List) {
 	if cb == nil {
 		x.xLookupServiceFinish = 0
 	}
 }
-// GetLookupServiceFinish gets the callback function.
+// GetLookupServiceFinish gets the "lookup_service_finish" callback function.
 func (x *ResolverClass) GetLookupServiceFinish() func(*Resolver, AsyncResult) *glib.List {
 	if x.xLookupServiceFinish == 0 {
 		return nil
 	}
 }
-// OverrideLookupRecords sets the callback function.
+// OverrideLookupRecords sets the "lookup_records" callback function.
 func (x *ResolverClass) OverrideLookupRecords(cb func(*Resolver, string, ResolverRecordType, *Cancellable) *glib.List) {
 	if cb == nil {
 		x.xLookupRecords = 0
 	}
 }
-// GetLookupRecords gets the callback function.
+// GetLookupRecords gets the "lookup_records" callback function.
 func (x *ResolverClass) GetLookupRecords() func(*Resolver, string, ResolverRecordType, *Cancellable) *glib.List {
 	if x.xLookupRecords == 0 {
 		return nil
 	}
 }
-// OverrideLookupRecordsAsync sets the callback function.
+// OverrideLookupRecordsAsync sets the "lookup_records_async" callback function.
 func (x *ResolverClass) OverrideLookupRecordsAsync(cb func(*Resolver, string, ResolverRecordType, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xLookupRecordsAsync = 0
 	}
 }
-// GetLookupRecordsAsync gets the callback function.
+// GetLookupRecordsAsync gets the "lookup_records_async" callback function.
 func (x *ResolverClass) GetLookupRecordsAsync() func(*Resolver, string, ResolverRecordType, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xLookupRecordsAsync == 0 {
 		return nil
 	}
 }
-// OverrideLookupRecordsFinish sets the callback function.
+// OverrideLookupRecordsFinish sets the "lookup_records_finish" callback function.
 func (x *ResolverClass) OverrideLookupRecordsFinish(cb func(*Resolver, AsyncResult) *glib.List) {
 	if cb == nil {
 		x.xLookupRecordsFinish = 0
 	}
 }
-// GetLookupRecordsFinish gets the callback function.
+// GetLookupRecordsFinish gets the "lookup_records_finish" callback function.
 func (x *ResolverClass) GetLookupRecordsFinish() func(*Resolver, AsyncResult) *glib.List {
 	if x.xLookupRecordsFinish == 0 {
 		return nil
 	}
 }
-// OverrideLookupByNameWithFlagsAsync sets the callback function.
+// OverrideLookupByNameWithFlagsAsync sets the "lookup_by_name_with_flags_async" callback function.
 func (x *ResolverClass) OverrideLookupByNameWithFlagsAsync(cb func(*Resolver, string, ResolverNameLookupFlags, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 		x.xLookupByNameWithFlagsAsync = 0
 	}
 }
-// GetLookupByNameWithFlagsAsync gets the callback function.
+// GetLookupByNameWithFlagsAsync gets the "lookup_by_name_with_flags_async" callback function.
 func (x *ResolverClass) GetLookupByNameWithFlagsAsync() func(*Resolver, string, ResolverNameLookupFlags, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xLookupByNameWithFlagsAsync == 0 {
 		return nil
 	}
 }
-// OverrideLookupByNameWithFlagsFinish sets the callback function.
+// OverrideLookupByNameWithFlagsFinish sets the "lookup_by_name_with_flags_finish" callback function.
 func (x *ResolverClass) OverrideLookupByNameWithFlagsFinish(cb func(*Resolver, AsyncResult) *glib.List) {
 	if cb == nil {
 		x.xLookupByNameWithFlagsFinish = 0
 	}
 }
-// GetLookupByNameWithFlagsFinish gets the callback function.
+// GetLookupByNameWithFlagsFinish gets the "lookup_by_name_with_flags_finish" callback function.
 func (x *ResolverClass) GetLookupByNameWithFlagsFinish() func(*Resolver, AsyncResult) *glib.List {
 	if x.xLookupByNameWithFlagsFinish == 0 {
 		return nil
 	}
 }
-// OverrideLookupByNameWithFlags sets the callback function.
+// OverrideLookupByNameWithFlags sets the "lookup_by_name_with_flags" callback function.
 func (x *ResolverClass) OverrideLookupByNameWithFlags(cb func(*Resolver, string, ResolverNameLookupFlags, *Cancellable) *glib.List) {
 	if cb == nil {
 		x.xLookupByNameWithFlags = 0
 	}
 }
-// GetLookupByNameWithFlags gets the callback function.
+// GetLookupByNameWithFlags gets the "lookup_by_name_with_flags" callback function.
 func (x *ResolverClass) GetLookupByNameWithFlags() func(*Resolver, string, ResolverNameLookupFlags, *Cancellable) *glib.List {
 	if x.xLookupByNameWithFlags == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyTimeout sets the "timeout" property.
+// The timeout applied to all resolver lookups, in milliseconds.
+//
+// This may be changed through the lifetime of the #GResolver. The new value
+// will apply to any lookups started after the change, but not to any
+// already-ongoing lookups.
+//
+// If this is `0`, no timeout is applied to lookups.
+//
+// No timeout was applied to lookups before this property was added in
+// GLib 2.78.
+func (x *Resolver) SetPropertyTimeout(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("timeout", &v)
+}
+// GetPropertyTimeout gets the "timeout" property.
+// The timeout applied to all resolver lookups, in milliseconds.
+//
+// This may be changed through the lifetime of the #GResolver. The new value
+// will apply to any lookups started after the change, but not to any
+// already-ongoing lookups.
+//
+// If this is `0`, no timeout is applied to lookups.
+//
+// No timeout was applied to lookups before this property was added in
+// GLib 2.78.
+func (x *Resolver) GetPropertyTimeout() uint {
+	var v gobject.Value
+	x.GetProperty("timeout", &v)
+	return v.GetUint()
+}
 // Emitted when the resolver notices that the system resolver
 // configuration has changed.
 func (x *Resolver) ConnectReload(cb *func(Resolver)) uint32 {

M v4/gio/gresource.go +2 -2


@@ -124,13 +124,13 @@ func ResourcesEnumerateChildren(PathVar string, LookupFlagsVar ResourceLookupFla
124			124
125		}	125		}
126			126
127	-	var xResourcesGetInfo func(string, ResourceLookupFlags, uint, uint32, **glib.Error) bool	127	+	var xResourcesGetInfo func(string, ResourceLookupFlags, uint, uint32, **glib.Error) bool
128			128
129		// Looks for a file at the specified @path in the set of	129		// Looks for a file at the specified @path in the set of
130		// globally registered resources and if found returns information about it.	130		// globally registered resources and if found returns information about it.
131		//	131		//
132		// @lookup_flags controls the behaviour of the lookup.	132		// @lookup_flags controls the behaviour of the lookup.
133	-	func ResourcesGetInfo(PathVar string, LookupFlagsVar ResourceLookupFlags, SizeVar uint, FlagsVar uint32) (bool, error) {	133	+	func ResourcesGetInfo(PathVar string, LookupFlagsVar ResourceLookupFlags, SizeVar uint, FlagsVar uint32) (bool, error) {
134		var cerr *glib.Error	134		var cerr *glib.Error
135			135
136		cret := xResourcesGetInfo(PathVar, LookupFlagsVar, SizeVar, FlagsVar, &cerr)	136		cret := xResourcesGetInfo(PathVar, LookupFlagsVar, SizeVar, FlagsVar, &cerr)

M v4/gio/gseekable.go +10 -10


@@ -32,7 +32,7 @@ func (x *SeekableIface) GoPointer() uintptr {
32		return uintptr(unsafe.Pointer(x))	32		return uintptr(unsafe.Pointer(x))
33		}	33		}
34			34
35	-	// OverrideTell sets the callback function.	35	+	// OverrideTell sets the "tell" callback function.
36		// Tells the current location within a stream.	36		// Tells the current location within a stream.
37		func (x *SeekableIface) OverrideTell(cb func(Seekable) int64) {	37		func (x *SeekableIface) OverrideTell(cb func(Seekable) int64) {
38		if cb == nil {	38		if cb == nil {

@@ -44,7 +44,7 @@ func (x *SeekableIface) OverrideTell(cb func(Seekable) int64) {
44		}	44		}
45		}	45		}
46			46
47	-	// GetTell gets the callback function.	47	+	// GetTell gets the "tell" callback function.
48		// Tells the current location within a stream.	48		// Tells the current location within a stream.
49		func (x *SeekableIface) GetTell() func(Seekable) int64 {	49		func (x *SeekableIface) GetTell() func(Seekable) int64 {
50		if x.xTell == 0 {	50		if x.xTell == 0 {

@@ -57,7 +57,7 @@ func (x *SeekableIface) GetTell() func(Seekable) int64 {
57		}	57		}
58		}	58		}
59			59
60	-	// OverrideCanSeek sets the callback function.	60	+	// OverrideCanSeek sets the "can_seek" callback function.
61		// Checks if seeking is supported by the stream.	61		// Checks if seeking is supported by the stream.
62		func (x *SeekableIface) OverrideCanSeek(cb func(Seekable) bool) {	62		func (x *SeekableIface) OverrideCanSeek(cb func(Seekable) bool) {
63		if cb == nil {	63		if cb == nil {

@@ -69,7 +69,7 @@ func (x *SeekableIface) OverrideCanSeek(cb func(Seekable) bool) {
69		}	69		}
70		}	70		}
71			71
72	-	// GetCanSeek gets the callback function.	72	+	// GetCanSeek gets the "can_seek" callback function.
73		// Checks if seeking is supported by the stream.	73		// Checks if seeking is supported by the stream.
74		func (x *SeekableIface) GetCanSeek() func(Seekable) bool {	74		func (x *SeekableIface) GetCanSeek() func(Seekable) bool {
75		if x.xCanSeek == 0 {	75		if x.xCanSeek == 0 {

@@ -82,7 +82,7 @@ func (x *SeekableIface) GetCanSeek() func(Seekable) bool {
82		}	82		}
83		}	83		}
84			84
85	-	// OverrideSeek sets the callback function.	85	+	// OverrideSeek sets the "seek" callback function.
86		// Seeks to a location within a stream.	86		// Seeks to a location within a stream.
87		func (x SeekableIface) OverrideSeek(cb func(Seekable, int64, glib.SeekType, Cancellable) bool) {	87		func (x SeekableIface) OverrideSeek(cb func(Seekable, int64, glib.SeekType, Cancellable) bool) {
88		if cb == nil {	88		if cb == nil {

@@ -94,7 +94,7 @@ func (x SeekableIface) OverrideSeek(cb func(Seekable, int64, glib.SeekType, Ca
94		}	94		}
95		}	95		}
96			96
97	-	// GetSeek gets the callback function.	97	+	// GetSeek gets the "seek" callback function.
98		// Seeks to a location within a stream.	98		// Seeks to a location within a stream.
99		func (x SeekableIface) GetSeek() func(Seekable, int64, glib.SeekType, Cancellable) bool {	99		func (x SeekableIface) GetSeek() func(Seekable, int64, glib.SeekType, Cancellable) bool {
100		if x.xSeek == 0 {	100		if x.xSeek == 0 {

@@ -107,7 +107,7 @@ func (x SeekableIface) GetSeek() func(Seekable, int64, glib.SeekType, Cancella
107		}	107		}
108		}	108		}
109			109
110	-	// OverrideCanTruncate sets the callback function.	110	+	// OverrideCanTruncate sets the "can_truncate" callback function.
111		// Checks if truncation is supported by the stream.	111		// Checks if truncation is supported by the stream.
112		func (x *SeekableIface) OverrideCanTruncate(cb func(Seekable) bool) {	112		func (x *SeekableIface) OverrideCanTruncate(cb func(Seekable) bool) {
113		if cb == nil {	113		if cb == nil {

@@ -119,7 +119,7 @@ func (x *SeekableIface) OverrideCanTruncate(cb func(Seekable) bool) {
119		}	119		}
120		}	120		}
121			121
122	-	// GetCanTruncate gets the callback function.	122	+	// GetCanTruncate gets the "can_truncate" callback function.
123		// Checks if truncation is supported by the stream.	123		// Checks if truncation is supported by the stream.
124		func (x *SeekableIface) GetCanTruncate() func(Seekable) bool {	124		func (x *SeekableIface) GetCanTruncate() func(Seekable) bool {
125		if x.xCanTruncate == 0 {	125		if x.xCanTruncate == 0 {

@@ -132,7 +132,7 @@ func (x *SeekableIface) GetCanTruncate() func(Seekable) bool {
132		}	132		}
133		}	133		}
134			134
135	-	// OverrideTruncateFn sets the callback function.	135	+	// OverrideTruncateFn sets the "truncate_fn" callback function.
136		// Truncates a stream.	136		// Truncates a stream.
137		func (x SeekableIface) OverrideTruncateFn(cb func(Seekable, int64, Cancellable) bool) {	137		func (x SeekableIface) OverrideTruncateFn(cb func(Seekable, int64, Cancellable) bool) {
138		if cb == nil {	138		if cb == nil {

@@ -144,7 +144,7 @@ func (x SeekableIface) OverrideTruncateFn(cb func(Seekable, int64, Cancellable
144		}	144		}
145		}	145		}
146			146
147	-	// GetTruncateFn gets the callback function.	147	+	// GetTruncateFn gets the "truncate_fn" callback function.
148		// Truncates a stream.	148		// Truncates a stream.
149		func (x SeekableIface) GetTruncateFn() func(Seekable, int64, Cancellable) bool {	149		func (x SeekableIface) GetTruncateFn() func(Seekable, int64, Cancellable) bool {
150		if x.xTruncateFn == 0 {	150		if x.xTruncateFn == 0 {

M v4/gio/gsettings.go +128 -9


@@ -32,7 +32,7 @@ type SettingsBindSetMapping func(gobject.Value, glib.VariantType, uintptr) *gl
32		// If @value is `NULL` then it means that the mapping function is being	32		// If @value is `NULL` then it means that the mapping function is being
33		// given a ‘last chance’ to successfully return a valid value. True	33		// given a ‘last chance’ to successfully return a valid value. True
34		// must be returned in this case.	34		// must be returned in this case.
35	-	type SettingsGetMapping func(*glib.Variant, uintptr, uintptr) bool	35	+	type SettingsGetMapping func(glib.Variant, uintptr, uintptr) bool
36			36
37		type SettingsClass struct {	37		type SettingsClass struct {
38		_ structs.HostLayout	38		_ structs.HostLayout

@@ -54,7 +54,7 @@ func (x *SettingsClass) GoPointer() uintptr {
54		return uintptr(unsafe.Pointer(x))	54		return uintptr(unsafe.Pointer(x))
55		}	55		}
56			56
57	-	// OverrideWritableChanged sets the callback function.	57	+	// OverrideWritableChanged sets the "writable_changed" callback function.
58		func (x SettingsClass) OverrideWritableChanged(cb func(Settings, string)) {	58		func (x SettingsClass) OverrideWritableChanged(cb func(Settings, string)) {
59		if cb == nil {	59		if cb == nil {
60		x.xWritableChanged = 0	60		x.xWritableChanged = 0

@@ -65,7 +65,7 @@ func (x SettingsClass) OverrideWritableChanged(cb func(Settings, string)) {
65		}	65		}
66		}	66		}
67			67
68	-	// GetWritableChanged gets the callback function.	68	+	// GetWritableChanged gets the "writable_changed" callback function.
69		func (x SettingsClass) GetWritableChanged() func(Settings, string) {	69		func (x SettingsClass) GetWritableChanged() func(Settings, string) {
70		if x.xWritableChanged == 0 {	70		if x.xWritableChanged == 0 {
71		return nil	71		return nil

@@ -77,7 +77,7 @@ func (x SettingsClass) GetWritableChanged() func(Settings, string) {
77		}	77		}
78		}	78		}
79			79
80	-	// OverrideChanged sets the callback function.	80	+	// OverrideChanged sets the "changed" callback function.
81		func (x SettingsClass) OverrideChanged(cb func(Settings, string)) {	81		func (x SettingsClass) OverrideChanged(cb func(Settings, string)) {
82		if cb == nil {	82		if cb == nil {
83		x.xChanged = 0	83		x.xChanged = 0

@@ -88,7 +88,7 @@ func (x SettingsClass) OverrideChanged(cb func(Settings, string)) {
88		}	88		}
89		}	89		}
90			90
91	-	// GetChanged gets the callback function.	91	+	// GetChanged gets the "changed" callback function.
92		func (x SettingsClass) GetChanged() func(Settings, string) {	92		func (x SettingsClass) GetChanged() func(Settings, string) {
93		if x.xChanged == 0 {	93		if x.xChanged == 0 {
94		return nil	94		return nil

@@ -100,7 +100,7 @@ func (x SettingsClass) GetChanged() func(Settings, string) {
100		}	100		}
101		}	101		}
102			102
103	-	// OverrideWritableChangeEvent sets the callback function.	103	+	// OverrideWritableChangeEvent sets the "writable_change_event" callback function.
104		func (x SettingsClass) OverrideWritableChangeEvent(cb func(Settings, glib.Quark) bool) {	104		func (x SettingsClass) OverrideWritableChangeEvent(cb func(Settings, glib.Quark) bool) {
105		if cb == nil {	105		if cb == nil {
106		x.xWritableChangeEvent = 0	106		x.xWritableChangeEvent = 0

@@ -111,7 +111,7 @@ func (x SettingsClass) OverrideWritableChangeEvent(cb func(Settings, glib.Quar
111		}	111		}
112		}	112		}
113			113
114	-	// GetWritableChangeEvent gets the callback function.	114	+	// GetWritableChangeEvent gets the "writable_change_event" callback function.
115		func (x SettingsClass) GetWritableChangeEvent() func(Settings, glib.Quark) bool {	115		func (x SettingsClass) GetWritableChangeEvent() func(Settings, glib.Quark) bool {
116		if x.xWritableChangeEvent == 0 {	116		if x.xWritableChangeEvent == 0 {
117		return nil	117		return nil

@@ -123,7 +123,7 @@ func (x SettingsClass) GetWritableChangeEvent() func(Settings, glib.Quark) boo
123		}	123		}
124		}	124		}
125			125
126	-	// OverrideChangeEvent sets the callback function.	126	+	// OverrideChangeEvent sets the "change_event" callback function.
127		func (x SettingsClass) OverrideChangeEvent(cb func(Settings, *glib.Quark, int) bool) {	127		func (x SettingsClass) OverrideChangeEvent(cb func(Settings, *glib.Quark, int) bool) {
128		if cb == nil {	128		if cb == nil {
129		x.xChangeEvent = 0	129		x.xChangeEvent = 0

@@ -134,7 +134,7 @@ func (x SettingsClass) OverrideChangeEvent(cb func(Settings, *glib.Quark, int)
134		}	134		}
135		}	135		}
136			136
137	-	// GetChangeEvent gets the callback function.	137	+	// GetChangeEvent gets the "change_event" callback function.
138		func (x SettingsClass) GetChangeEvent() func(Settings, *glib.Quark, int) bool {	138		func (x SettingsClass) GetChangeEvent() func(Settings, *glib.Quark, int) bool {
139		if x.xChangeEvent == 0 {	139		if x.xChangeEvent == 0 {
140		return nil	140		return nil

@@ -1468,6 +1468,125 @@ func (c *Settings) SetGoPointer(ptr uintptr) {
1468		c.Ptr = ptr	1468		c.Ptr = ptr
1469		}	1469		}
1470			1470
			1471	+	// GetPropertyDelayApply gets the "delay-apply" property.
			1472	+	// Whether the [class@Gio.Settings] object is in
			1473	+	// [‘delay-apply’ mode](class.Settings.html#delay-apply-mode).
			1474	+	func (x *Settings) GetPropertyDelayApply() bool {
			1475	+	var v gobject.Value
			1476	+	x.GetProperty("delay-apply", &v)
			1477	+	return v.GetBoolean()
			1478	+	}
			1479	+
			1480	+	// GetPropertyHasUnapplied gets the "has-unapplied" property.
			1481	+	// Whether the [class@Gio.Settings] object has outstanding changes.
			1482	+	//
			1483	+	// These changes will be applied when [method@Gio.Settings.apply] is called.
			1484	+	func (x *Settings) GetPropertyHasUnapplied() bool {
			1485	+	var v gobject.Value
			1486	+	x.GetProperty("has-unapplied", &v)
			1487	+	return v.GetBoolean()
			1488	+	}
			1489	+
			1490	+	// SetPropertyPath sets the "path" property.
			1491	+	// The path within the backend where the settings are stored.
			1492	+	func (x *Settings) SetPropertyPath(value string) {
			1493	+	var v gobject.Value
			1494	+	v.Init(gobject.TypeStringVal)
			1495	+	v.SetString(value)
			1496	+	x.SetProperty("path", &v)
			1497	+	}
			1498	+
			1499	+	// GetPropertyPath gets the "path" property.
			1500	+	// The path within the backend where the settings are stored.
			1501	+	func (x *Settings) GetPropertyPath() string {
			1502	+	var v gobject.Value
			1503	+	x.GetProperty("path", &v)
			1504	+	return v.GetString()
			1505	+	}
			1506	+
			1507	+	// SetPropertySchema sets the "schema" property.
			1508	+	// The name of the schema that describes the types of keys
			1509	+	// for this [class@Gio.Settings] object.
			1510	+	//
			1511	+	// The type of this property is not [struct@Gio.SettingsSchema].
			1512	+	// [struct@Gio.SettingsSchema] has only existed since version 2.32 and
			1513	+	// unfortunately this name was used in previous versions to refer to
			1514	+	// the schema ID rather than the schema itself. Take care to use the
			1515	+	// [property@Gio.Settings:settings-schema] property if you wish to pass in a
			1516	+	// [struct@Gio.SettingsSchema].
			1517	+	func (x *Settings) SetPropertySchema(value string) {
			1518	+	var v gobject.Value
			1519	+	v.Init(gobject.TypeStringVal)
			1520	+	v.SetString(value)
			1521	+	x.SetProperty("schema", &v)
			1522	+	}
			1523	+
			1524	+	// GetPropertySchema gets the "schema" property.
			1525	+	// The name of the schema that describes the types of keys
			1526	+	// for this [class@Gio.Settings] object.
			1527	+	//
			1528	+	// The type of this property is not [struct@Gio.SettingsSchema].
			1529	+	// [struct@Gio.SettingsSchema] has only existed since version 2.32 and
			1530	+	// unfortunately this name was used in previous versions to refer to
			1531	+	// the schema ID rather than the schema itself. Take care to use the
			1532	+	// [property@Gio.Settings:settings-schema] property if you wish to pass in a
			1533	+	// [struct@Gio.SettingsSchema].
			1534	+	func (x *Settings) GetPropertySchema() string {
			1535	+	var v gobject.Value
			1536	+	x.GetProperty("schema", &v)
			1537	+	return v.GetString()
			1538	+	}
			1539	+
			1540	+	// SetPropertySchemaId sets the "schema-id" property.
			1541	+	// The name of the schema that describes the types of keys
			1542	+	// for this [class@Gio.Settings] object.
			1543	+	func (x *Settings) SetPropertySchemaId(value string) {
			1544	+	var v gobject.Value
			1545	+	v.Init(gobject.TypeStringVal)
			1546	+	v.SetString(value)
			1547	+	x.SetProperty("schema-id", &v)
			1548	+	}
			1549	+
			1550	+	// GetPropertySchemaId gets the "schema-id" property.
			1551	+	// The name of the schema that describes the types of keys
			1552	+	// for this [class@Gio.Settings] object.
			1553	+	func (x *Settings) GetPropertySchemaId() string {
			1554	+	var v gobject.Value
			1555	+	x.GetProperty("schema-id", &v)
			1556	+	return v.GetString()
			1557	+	}
			1558	+
			1559	+	// SetPropertySettingsSchema sets the "settings-schema" property.
			1560	+	// The [struct@Gio.SettingsSchema] describing the types of keys for this
			1561	+	// [class@Gio.Settings] object.
			1562	+	//
			1563	+	// Ideally, this property would be called [property@Gio.Settings:schema].
			1564	+	// [struct@Gio.SettingsSchema]
			1565	+	// has only existed since version 2.32, however, and before then the
			1566	+	// [property@Gio.Settings:schema] property was used to refer to the ID of the schema rather
			1567	+	// than the schema itself. Take care.
			1568	+	func (x *Settings) SetPropertySettingsSchema(value uintptr) {
			1569	+	var v gobject.Value
			1570	+	v.Init(gobject.TypePointerVal)
			1571	+	v.SetPointer(value)
			1572	+	x.SetProperty("settings-schema", &v)
			1573	+	}
			1574	+
			1575	+	// GetPropertySettingsSchema gets the "settings-schema" property.
			1576	+	// The [struct@Gio.SettingsSchema] describing the types of keys for this
			1577	+	// [class@Gio.Settings] object.
			1578	+	//
			1579	+	// Ideally, this property would be called [property@Gio.Settings:schema].
			1580	+	// [struct@Gio.SettingsSchema]
			1581	+	// has only existed since version 2.32, however, and before then the
			1582	+	// [property@Gio.Settings:schema] property was used to refer to the ID of the schema rather
			1583	+	// than the schema itself. Take care.
			1584	+	func (x *Settings) GetPropertySettingsSchema() uintptr {
			1585	+	var v gobject.Value
			1586	+	x.GetProperty("settings-schema", &v)
			1587	+	return v.GetPointer()
			1588	+	}
			1589	+
1471		// Emitted once per change event that affects this settings object.	1590		// Emitted once per change event that affects this settings object.
1472		//	1591		//
1473		// You should connect to this signal	1592		// You should connect to this signal

M v4/gio/gsettingsbackend.go +22 -22


@@ -45,7 +45,7 @@ func (x *SettingsBackendClass) GoPointer() uintptr {
45		return uintptr(unsafe.Pointer(x))	45		return uintptr(unsafe.Pointer(x))
46		}	46		}
47			47
48	-	// OverrideRead sets the callback function.	48	+	// OverrideRead sets the "read" callback function.
49		// virtual method to read a key's value	49		// virtual method to read a key's value
50		func (x SettingsBackendClass) OverrideRead(cb func(SettingsBackend, string, glib.VariantType, bool) glib.Variant) {	50		func (x SettingsBackendClass) OverrideRead(cb func(SettingsBackend, string, glib.VariantType, bool) glib.Variant) {
51		if cb == nil {	51		if cb == nil {

@@ -57,7 +57,7 @@ func (x SettingsBackendClass) OverrideRead(cb func(SettingsBackend, string, *g
57		}	57		}
58		}	58		}
59			59
60	-	// GetRead gets the callback function.	60	+	// GetRead gets the "read" callback function.
61		// virtual method to read a key's value	61		// virtual method to read a key's value
62		func (x SettingsBackendClass) GetRead() func(SettingsBackend, string, glib.VariantType, bool) glib.Variant {	62		func (x SettingsBackendClass) GetRead() func(SettingsBackend, string, glib.VariantType, bool) glib.Variant {
63		if x.xRead == 0 {	63		if x.xRead == 0 {

@@ -70,7 +70,7 @@ func (x SettingsBackendClass) GetRead() func(SettingsBackend, string, *glib.Va
70		}	70		}
71		}	71		}
72			72
73	-	// OverrideGetWritable sets the callback function.	73	+	// OverrideGetWritable sets the "get_writable" callback function.
74		// virtual method to get if a key is writable	74		// virtual method to get if a key is writable
75		func (x SettingsBackendClass) OverrideGetWritable(cb func(SettingsBackend, string) bool) {	75		func (x SettingsBackendClass) OverrideGetWritable(cb func(SettingsBackend, string) bool) {
76		if cb == nil {	76		if cb == nil {

@@ -82,7 +82,7 @@ func (x SettingsBackendClass) OverrideGetWritable(cb func(SettingsBackend, str
82		}	82		}
83		}	83		}
84			84
85	-	// GetGetWritable gets the callback function.	85	+	// GetGetWritable gets the "get_writable" callback function.
86		// virtual method to get if a key is writable	86		// virtual method to get if a key is writable
87		func (x SettingsBackendClass) GetGetWritable() func(SettingsBackend, string) bool {	87		func (x SettingsBackendClass) GetGetWritable() func(SettingsBackend, string) bool {
88		if x.xGetWritable == 0 {	88		if x.xGetWritable == 0 {

@@ -95,7 +95,7 @@ func (x SettingsBackendClass) GetGetWritable() func(SettingsBackend, string) b
95		}	95		}
96		}	96		}
97			97
98	-	// OverrideWrite sets the callback function.	98	+	// OverrideWrite sets the "write" callback function.
99		// virtual method to change key's value	99		// virtual method to change key's value
100		func (x SettingsBackendClass) OverrideWrite(cb func(SettingsBackend, string, *glib.Variant, uintptr) bool) {	100		func (x SettingsBackendClass) OverrideWrite(cb func(SettingsBackend, string, *glib.Variant, uintptr) bool) {
101		if cb == nil {	101		if cb == nil {

@@ -107,7 +107,7 @@ func (x SettingsBackendClass) OverrideWrite(cb func(SettingsBackend, string, *
107		}	107		}
108		}	108		}
109			109
110	-	// GetWrite gets the callback function.	110	+	// GetWrite gets the "write" callback function.
111		// virtual method to change key's value	111		// virtual method to change key's value
112		func (x SettingsBackendClass) GetWrite() func(SettingsBackend, string, *glib.Variant, uintptr) bool {	112		func (x SettingsBackendClass) GetWrite() func(SettingsBackend, string, *glib.Variant, uintptr) bool {
113		if x.xWrite == 0 {	113		if x.xWrite == 0 {

@@ -120,7 +120,7 @@ func (x SettingsBackendClass) GetWrite() func(SettingsBackend, string, *glib.V
120		}	120		}
121		}	121		}
122			122
123	-	// OverrideWriteTree sets the callback function.	123	+	// OverrideWriteTree sets the "write_tree" callback function.
124		// virtual method to change a tree of keys	124		// virtual method to change a tree of keys
125		func (x SettingsBackendClass) OverrideWriteTree(cb func(SettingsBackend, *glib.Tree, uintptr) bool) {	125		func (x SettingsBackendClass) OverrideWriteTree(cb func(SettingsBackend, *glib.Tree, uintptr) bool) {
126		if cb == nil {	126		if cb == nil {

@@ -132,7 +132,7 @@ func (x SettingsBackendClass) OverrideWriteTree(cb func(SettingsBackend, *glib
132		}	132		}
133		}	133		}
134			134
135	-	// GetWriteTree gets the callback function.	135	+	// GetWriteTree gets the "write_tree" callback function.
136		// virtual method to change a tree of keys	136		// virtual method to change a tree of keys
137		func (x SettingsBackendClass) GetWriteTree() func(SettingsBackend, *glib.Tree, uintptr) bool {	137		func (x SettingsBackendClass) GetWriteTree() func(SettingsBackend, *glib.Tree, uintptr) bool {
138		if x.xWriteTree == 0 {	138		if x.xWriteTree == 0 {

@@ -145,7 +145,7 @@ func (x SettingsBackendClass) GetWriteTree() func(SettingsBackend, *glib.Tree,
145		}	145		}
146		}	146		}
147			147
148	-	// OverrideReset sets the callback function.	148	+	// OverrideReset sets the "reset" callback function.
149		// virtual method to reset state	149		// virtual method to reset state
150		func (x SettingsBackendClass) OverrideReset(cb func(SettingsBackend, string, uintptr)) {	150		func (x SettingsBackendClass) OverrideReset(cb func(SettingsBackend, string, uintptr)) {
151		if cb == nil {	151		if cb == nil {

@@ -157,7 +157,7 @@ func (x SettingsBackendClass) OverrideReset(cb func(SettingsBackend, string, u
157		}	157		}
158		}	158		}
159			159
160	-	// GetReset gets the callback function.	160	+	// GetReset gets the "reset" callback function.
161		// virtual method to reset state	161		// virtual method to reset state
162		func (x SettingsBackendClass) GetReset() func(SettingsBackend, string, uintptr) {	162		func (x SettingsBackendClass) GetReset() func(SettingsBackend, string, uintptr) {
163		if x.xReset == 0 {	163		if x.xReset == 0 {

@@ -170,7 +170,7 @@ func (x SettingsBackendClass) GetReset() func(SettingsBackend, string, uintptr
170		}	170		}
171		}	171		}
172			172
173	-	// OverrideSubscribe sets the callback function.	173	+	// OverrideSubscribe sets the "subscribe" callback function.
174		// virtual method to subscribe to key changes	174		// virtual method to subscribe to key changes
175		func (x SettingsBackendClass) OverrideSubscribe(cb func(SettingsBackend, string)) {	175		func (x SettingsBackendClass) OverrideSubscribe(cb func(SettingsBackend, string)) {
176		if cb == nil {	176		if cb == nil {

@@ -182,7 +182,7 @@ func (x SettingsBackendClass) OverrideSubscribe(cb func(SettingsBackend, strin
182		}	182		}
183		}	183		}
184			184
185	-	// GetSubscribe gets the callback function.	185	+	// GetSubscribe gets the "subscribe" callback function.
186		// virtual method to subscribe to key changes	186		// virtual method to subscribe to key changes
187		func (x SettingsBackendClass) GetSubscribe() func(SettingsBackend, string) {	187		func (x SettingsBackendClass) GetSubscribe() func(SettingsBackend, string) {
188		if x.xSubscribe == 0 {	188		if x.xSubscribe == 0 {

@@ -195,7 +195,7 @@ func (x SettingsBackendClass) GetSubscribe() func(SettingsBackend, string) {
195		}	195		}
196		}	196		}
197			197
198	-	// OverrideUnsubscribe sets the callback function.	198	+	// OverrideUnsubscribe sets the "unsubscribe" callback function.
199		// virtual method to unsubscribe to key changes	199		// virtual method to unsubscribe to key changes
200		func (x SettingsBackendClass) OverrideUnsubscribe(cb func(SettingsBackend, string)) {	200		func (x SettingsBackendClass) OverrideUnsubscribe(cb func(SettingsBackend, string)) {
201		if cb == nil {	201		if cb == nil {

@@ -207,7 +207,7 @@ func (x SettingsBackendClass) OverrideUnsubscribe(cb func(SettingsBackend, str
207		}	207		}
208		}	208		}
209			209
210	-	// GetUnsubscribe gets the callback function.	210	+	// GetUnsubscribe gets the "unsubscribe" callback function.
211		// virtual method to unsubscribe to key changes	211		// virtual method to unsubscribe to key changes
212		func (x SettingsBackendClass) GetUnsubscribe() func(SettingsBackend, string) {	212		func (x SettingsBackendClass) GetUnsubscribe() func(SettingsBackend, string) {
213		if x.xUnsubscribe == 0 {	213		if x.xUnsubscribe == 0 {

@@ -220,7 +220,7 @@ func (x SettingsBackendClass) GetUnsubscribe() func(SettingsBackend, string) {
220		}	220		}
221		}	221		}
222			222
223	-	// OverrideSync sets the callback function.	223	+	// OverrideSync sets the "sync" callback function.
224		// virtual method to sync state	224		// virtual method to sync state
225		func (x SettingsBackendClass) OverrideSync(cb func(SettingsBackend)) {	225		func (x SettingsBackendClass) OverrideSync(cb func(SettingsBackend)) {
226		if cb == nil {	226		if cb == nil {

@@ -232,7 +232,7 @@ func (x SettingsBackendClass) OverrideSync(cb func(SettingsBackend)) {
232		}	232		}
233		}	233		}
234			234
235	-	// GetSync gets the callback function.	235	+	// GetSync gets the "sync" callback function.
236		// virtual method to sync state	236		// virtual method to sync state
237		func (x SettingsBackendClass) GetSync() func(SettingsBackend) {	237		func (x SettingsBackendClass) GetSync() func(SettingsBackend) {
238		if x.xSync == 0 {	238		if x.xSync == 0 {

@@ -245,7 +245,7 @@ func (x SettingsBackendClass) GetSync() func(SettingsBackend) {
245		}	245		}
246		}	246		}
247			247
248	-	// OverrideGetPermission sets the callback function.	248	+	// OverrideGetPermission sets the "get_permission" callback function.
249		// virtual method to get permission of a key	249		// virtual method to get permission of a key
250		func (x SettingsBackendClass) OverrideGetPermission(cb func(SettingsBackend, string) *Permission) {	250		func (x SettingsBackendClass) OverrideGetPermission(cb func(SettingsBackend, string) *Permission) {
251		if cb == nil {	251		if cb == nil {

@@ -261,7 +261,7 @@ func (x SettingsBackendClass) OverrideGetPermission(cb func(SettingsBackend, s
261		}	261		}
262		}	262		}
263			263
264	-	// GetGetPermission gets the callback function.	264	+	// GetGetPermission gets the "get_permission" callback function.
265		// virtual method to get permission of a key	265		// virtual method to get permission of a key
266		func (x SettingsBackendClass) GetGetPermission() func(SettingsBackend, string) *Permission {	266		func (x SettingsBackendClass) GetGetPermission() func(SettingsBackend, string) *Permission {
267		if x.xGetPermission == 0 {	267		if x.xGetPermission == 0 {

@@ -280,7 +280,7 @@ func (x SettingsBackendClass) GetGetPermission() func(SettingsBackend, string)
280		}	280		}
281		}	281		}
282			282
283	-	// OverrideReadUserValue sets the callback function.	283	+	// OverrideReadUserValue sets the "read_user_value" callback function.
284		// virtual method to read user's key value	284		// virtual method to read user's key value
285		func (x SettingsBackendClass) OverrideReadUserValue(cb func(SettingsBackend, string, glib.VariantType) glib.Variant) {	285		func (x SettingsBackendClass) OverrideReadUserValue(cb func(SettingsBackend, string, glib.VariantType) glib.Variant) {
286		if cb == nil {	286		if cb == nil {

@@ -292,7 +292,7 @@ func (x SettingsBackendClass) OverrideReadUserValue(cb func(SettingsBackend, s
292		}	292		}
293		}	293		}
294			294
295	-	// GetReadUserValue gets the callback function.	295	+	// GetReadUserValue gets the "read_user_value" callback function.
296		// virtual method to read user's key value	296		// virtual method to read user's key value
297		func (x SettingsBackendClass) GetReadUserValue() func(SettingsBackend, string, glib.VariantType) glib.Variant {	297		func (x SettingsBackendClass) GetReadUserValue() func(SettingsBackend, string, glib.VariantType) glib.Variant {
298		if x.xReadUserValue == 0 {	298		if x.xReadUserValue == 0 {

@@ -595,7 +595,7 @@ func (c *SettingsBackend) SetGoPointer(ptr uintptr) {
595		c.Ptr = ptr	595		c.Ptr = ptr
596		}	596		}
597			597
598	-	var xSettingsBackendFlattenTree func(*glib.Tree, string, []string, uintptr)	598	+	var xSettingsBackendFlattenTree func(glib.Tree, string, []string, uintptr)
599			599
600		// Calculate the longest common prefix of all keys in a tree and write	600		// Calculate the longest common prefix of all keys in a tree and write
601		// out an array of the key names relative to that prefix and,	601		// out an array of the key names relative to that prefix and,

@@ -604,7 +604,7 @@ var xSettingsBackendFlattenTree func(*glib.Tree, string, []string, uintptr)
604		// You must free the value returned in @path, @keys and @values using	604		// You must free the value returned in @path, @keys and @values using
605		// g_free(). You should not attempt to free or unref the contents of	605		// g_free(). You should not attempt to free or unref the contents of
606		// @keys or @values.	606		// @keys or @values.
607	-	func SettingsBackendFlattenTree(TreeVar *glib.Tree, PathVar string, KeysVar []string, ValuesVar uintptr) {	607	+	func SettingsBackendFlattenTree(TreeVar glib.Tree, PathVar string, KeysVar []string, ValuesVar uintptr) {
608			608
609		xSettingsBackendFlattenTree(TreeVar, PathVar, KeysVar, ValuesVar)	609		xSettingsBackendFlattenTree(TreeVar, PathVar, KeysVar, ValuesVar)
610			610

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


@@ -435,7 +435,7 @@ func NewSettingsSchemaSourceFromDirectory(DirectoryVar string, ParentVar *Settin
435			435
436		}	436		}
437			437
438	-	var xSettingsSchemaSourceListSchemas func(uintptr, bool, []string, []string)	438	+	var xSettingsSchemaSourceListSchemas func(uintptr, bool, []string, []string)
439			439
440		// Lists the schemas in a given source.	440		// Lists the schemas in a given source.
441		//	441		//

@@ -449,7 +449,7 @@ var xSettingsSchemaSourceListSchemas func(uintptr, bool, []string, []string)
449		//	449		//
450		// Do not call this function from normal programs. This is designed for	450		// Do not call this function from normal programs. This is designed for
451		// use by database editors, commandline tools, etc.	451		// use by database editors, commandline tools, etc.
452	-	func (x *SettingsSchemaSource) ListSchemas(RecursiveVar bool, NonRelocatableVar []string, RelocatableVar []string) {	452	+	func (x SettingsSchemaSource) ListSchemas(RecursiveVar bool, NonRelocatableVar []string, RelocatableVar *[]string) {
453			453
454		xSettingsSchemaSourceListSchemas(x.GoPointer(), RecursiveVar, NonRelocatableVar, RelocatableVar)	454		xSettingsSchemaSourceListSchemas(x.GoPointer(), RecursiveVar, NonRelocatableVar, RelocatableVar)
455			455

M v4/gio/gsimpleaction.go +87 -0


@@ -126,6 +126,93 @@ func (c *SimpleAction) SetGoPointer(ptr uintptr) {
126	c.Ptr = ptr	126		c.Ptr = ptr
127	}	127		}
128		128
		129	+	// SetPropertyEnabled sets the "enabled" property.
		130	+	// If @action is currently enabled.
		131	+	//
		132	+	// If the action is disabled then calls to g_action_activate() and
		133	+	// g_action_change_state() have no effect.
		134	+	func (x *SimpleAction) SetPropertyEnabled(value bool) {
		135	+	var v gobject.Value
		136	+	v.Init(gobject.TypeBooleanVal)
		137	+	v.SetBoolean(value)
		138	+	x.SetProperty("enabled", &v)
		139	+	}
		140	+
		141	+	// GetPropertyEnabled gets the "enabled" property.
		142	+	// If @action is currently enabled.
		143	+	//
		144	+	// If the action is disabled then calls to g_action_activate() and
		145	+	// g_action_change_state() have no effect.
		146	+	func (x *SimpleAction) GetPropertyEnabled() bool {
		147	+	var v gobject.Value
		148	+	x.GetProperty("enabled", &v)
		149	+	return v.GetBoolean()
		150	+	}
		151	+
		152	+	// SetPropertyName sets the "name" property.
		153	+	// The name of the action. This is mostly meaningful for identifying
		154	+	// the action once it has been added to a #GSimpleActionGroup.
		155	+	func (x *SimpleAction) SetPropertyName(value string) {
		156	+	var v gobject.Value
		157	+	v.Init(gobject.TypeStringVal)
		158	+	v.SetString(value)
		159	+	x.SetProperty("name", &v)
		160	+	}
		161	+
		162	+	// GetPropertyName gets the "name" property.
		163	+	// The name of the action. This is mostly meaningful for identifying
		164	+	// the action once it has been added to a #GSimpleActionGroup.
		165	+	func (x *SimpleAction) GetPropertyName() string {
		166	+	var v gobject.Value
		167	+	x.GetProperty("name", &v)
		168	+	return v.GetString()
		169	+	}
		170	+
		171	+	// SetPropertyParameterType sets the "parameter-type" property.
		172	+	// The type of the parameter that must be given when activating the
		173	+	// action.
		174	+	func (x *SimpleAction) SetPropertyParameterType(value uintptr) {
		175	+	var v gobject.Value
		176	+	v.Init(gobject.TypePointerVal)
		177	+	v.SetPointer(value)
		178	+	x.SetProperty("parameter-type", &v)
		179	+	}
		180	+
		181	+	// GetPropertyParameterType gets the "parameter-type" property.
		182	+	// The type of the parameter that must be given when activating the
		183	+	// action.
		184	+	func (x *SimpleAction) GetPropertyParameterType() uintptr {
		185	+	var v gobject.Value
		186	+	x.GetProperty("parameter-type", &v)
		187	+	return v.GetPointer()
		188	+	}
		189	+
		190	+	// SetPropertyState sets the "state" property.
		191	+	// The state of the action, or %NULL if the action is stateless.
		192	+	func (x *SimpleAction) SetPropertyState(value uintptr) {
		193	+	var v gobject.Value
		194	+	v.Init(gobject.TypePointerVal)
		195	+	v.SetPointer(value)
		196	+	x.SetProperty("state", &v)
		197	+	}
		198	+
		199	+	// GetPropertyState gets the "state" property.
		200	+	// The state of the action, or %NULL if the action is stateless.
		201	+	func (x *SimpleAction) GetPropertyState() uintptr {
		202	+	var v gobject.Value
		203	+	x.GetProperty("state", &v)
		204	+	return v.GetPointer()
		205	+	}
		206	+
		207	+	// GetPropertyStateType gets the "state-type" property.
		208	+	// The #GVariantType of the state that the action has, or %NULL if the
		209	+	// action is stateless.
		210	+	func (x *SimpleAction) GetPropertyStateType() uintptr {
		211	+	var v gobject.Value
		212	+	x.GetProperty("state-type", &v)
		213	+	return v.GetPointer()
		214	+	}
		215	+
129	// Indicates that the action was just activated.	216		// Indicates that the action was just activated.
130	//	217		//
131	// @parameter will always be of the expected type, i.e. the parameter type	218		// @parameter will always be of the expected type, i.e. the parameter type

M v4/gio/gsimpleactiongroup.go +1 -1


@@ -357,7 +357,7 @@ func (x *SimpleActionGroup) ListActions() []string {
357		// fields (as indicated by having a non-`NULL` reference passed in) are	357		// fields (as indicated by having a non-`NULL` reference passed in) are
358		// filled. If the action doesn’t exist, `FALSE` is returned and the	358		// filled. If the action doesn’t exist, `FALSE` is returned and the
359		// fields may or may not have been modified.	359		// fields may or may not have been modified.
360	-	func (x SimpleActionGroup) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar *glib.Variant) bool {	360	+	func (x SimpleActionGroup) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar glib.Variant) bool {
361			361
362		cret := XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)	362		cret := XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
363		return cret	363		return cret

M v4/gio/gsimpleproxyresolver.go +122 -10


@@ -32,7 +32,7 @@ func (x *SimpleProxyResolverClass) GoPointer() uintptr {
32		return uintptr(unsafe.Pointer(x))	32		return uintptr(unsafe.Pointer(x))
33		}	33		}
34			34
35	-	// OverrideGReserved1 sets the callback function.	35	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
36		func (x *SimpleProxyResolverClass) OverrideGReserved1(cb func()) {	36		func (x *SimpleProxyResolverClass) OverrideGReserved1(cb func()) {
37		if cb == nil {	37		if cb == nil {
38		x.xGReserved1 = 0	38		x.xGReserved1 = 0

@@ -43,7 +43,7 @@ func (x *SimpleProxyResolverClass) OverrideGReserved1(cb func()) {
43		}	43		}
44		}	44		}
45			45
46	-	// GetGReserved1 gets the callback function.	46	+	// GetGReserved1 gets the "_g_reserved1" callback function.
47		func (x *SimpleProxyResolverClass) GetGReserved1() func() {	47		func (x *SimpleProxyResolverClass) GetGReserved1() func() {
48		if x.xGReserved1 == 0 {	48		if x.xGReserved1 == 0 {
49		return nil	49		return nil

@@ -55,7 +55,7 @@ func (x *SimpleProxyResolverClass) GetGReserved1() func() {
55		}	55		}
56		}	56		}
57			57
58	-	// OverrideGReserved2 sets the callback function.	58	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
59		func (x *SimpleProxyResolverClass) OverrideGReserved2(cb func()) {	59		func (x *SimpleProxyResolverClass) OverrideGReserved2(cb func()) {
60		if cb == nil {	60		if cb == nil {
61		x.xGReserved2 = 0	61		x.xGReserved2 = 0

@@ -66,7 +66,7 @@ func (x *SimpleProxyResolverClass) OverrideGReserved2(cb func()) {
66		}	66		}
67		}	67		}
68			68
69	-	// GetGReserved2 gets the callback function.	69	+	// GetGReserved2 gets the "_g_reserved2" callback function.
70		func (x *SimpleProxyResolverClass) GetGReserved2() func() {	70		func (x *SimpleProxyResolverClass) GetGReserved2() func() {
71		if x.xGReserved2 == 0 {	71		if x.xGReserved2 == 0 {
72		return nil	72		return nil

@@ -78,7 +78,7 @@ func (x *SimpleProxyResolverClass) GetGReserved2() func() {
78		}	78		}
79		}	79		}
80			80
81	-	// OverrideGReserved3 sets the callback function.	81	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
82		func (x *SimpleProxyResolverClass) OverrideGReserved3(cb func()) {	82		func (x *SimpleProxyResolverClass) OverrideGReserved3(cb func()) {
83		if cb == nil {	83		if cb == nil {
84		x.xGReserved3 = 0	84		x.xGReserved3 = 0

@@ -89,7 +89,7 @@ func (x *SimpleProxyResolverClass) OverrideGReserved3(cb func()) {
89		}	89		}
90		}	90		}
91			91
92	-	// GetGReserved3 gets the callback function.	92	+	// GetGReserved3 gets the "_g_reserved3" callback function.
93		func (x *SimpleProxyResolverClass) GetGReserved3() func() {	93		func (x *SimpleProxyResolverClass) GetGReserved3() func() {
94		if x.xGReserved3 == 0 {	94		if x.xGReserved3 == 0 {
95		return nil	95		return nil

@@ -101,7 +101,7 @@ func (x *SimpleProxyResolverClass) GetGReserved3() func() {
101		}	101		}
102		}	102		}
103			103
104	-	// OverrideGReserved4 sets the callback function.	104	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
105		func (x *SimpleProxyResolverClass) OverrideGReserved4(cb func()) {	105		func (x *SimpleProxyResolverClass) OverrideGReserved4(cb func()) {
106		if cb == nil {	106		if cb == nil {
107		x.xGReserved4 = 0	107		x.xGReserved4 = 0

@@ -112,7 +112,7 @@ func (x *SimpleProxyResolverClass) OverrideGReserved4(cb func()) {
112		}	112		}
113		}	113		}
114			114
115	-	// GetGReserved4 gets the callback function.	115	+	// GetGReserved4 gets the "_g_reserved4" callback function.
116		func (x *SimpleProxyResolverClass) GetGReserved4() func() {	116		func (x *SimpleProxyResolverClass) GetGReserved4() func() {
117		if x.xGReserved4 == 0 {	117		if x.xGReserved4 == 0 {
118		return nil	118		return nil

@@ -124,7 +124,7 @@ func (x *SimpleProxyResolverClass) GetGReserved4() func() {
124		}	124		}
125		}	125		}
126			126
127	-	// OverrideGReserved5 sets the callback function.	127	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
128		func (x *SimpleProxyResolverClass) OverrideGReserved5(cb func()) {	128		func (x *SimpleProxyResolverClass) OverrideGReserved5(cb func()) {
129		if cb == nil {	129		if cb == nil {
130		x.xGReserved5 = 0	130		x.xGReserved5 = 0

@@ -135,7 +135,7 @@ func (x *SimpleProxyResolverClass) OverrideGReserved5(cb func()) {
135		}	135		}
136		}	136		}
137			137
138	-	// GetGReserved5 gets the callback function.	138	+	// GetGReserved5 gets the "_g_reserved5" callback function.
139		func (x *SimpleProxyResolverClass) GetGReserved5() func() {	139		func (x *SimpleProxyResolverClass) GetGReserved5() func() {
140		if x.xGReserved5 == 0 {	140		if x.xGReserved5 == 0 {
141		return nil	141		return nil

@@ -233,6 +233,118 @@ func (c *SimpleProxyResolver) SetGoPointer(ptr uintptr) {
233		c.Ptr = ptr	233		c.Ptr = ptr
234		}	234		}
235			235
			236	+	// SetPropertyDefaultProxy sets the "default-proxy" property.
			237	+	// The default proxy URI that will be used for any URI that doesn't
			238	+	// match #GSimpleProxyResolver:ignore-hosts, and doesn't match any
			239	+	// of the schemes set with g_simple_proxy_resolver_set_uri_proxy().
			240	+	//
			241	+	// Note that as a special case, if this URI starts with
			242	+	// "socks://", #GSimpleProxyResolver will treat it as referring
			243	+	// to all three of the socks5, socks4a, and socks4 proxy types.
			244	+	func (x *SimpleProxyResolver) SetPropertyDefaultProxy(value string) {
			245	+	var v gobject.Value
			246	+	v.Init(gobject.TypeStringVal)
			247	+	v.SetString(value)
			248	+	x.SetProperty("default-proxy", &v)
			249	+	}
			250	+
			251	+	// GetPropertyDefaultProxy gets the "default-proxy" property.
			252	+	// The default proxy URI that will be used for any URI that doesn't
			253	+	// match #GSimpleProxyResolver:ignore-hosts, and doesn't match any
			254	+	// of the schemes set with g_simple_proxy_resolver_set_uri_proxy().
			255	+	//
			256	+	// Note that as a special case, if this URI starts with
			257	+	// "socks://", #GSimpleProxyResolver will treat it as referring
			258	+	// to all three of the socks5, socks4a, and socks4 proxy types.
			259	+	func (x *SimpleProxyResolver) GetPropertyDefaultProxy() string {
			260	+	var v gobject.Value
			261	+	x.GetProperty("default-proxy", &v)
			262	+	return v.GetString()
			263	+	}
			264	+
			265	+	// SetPropertyIgnoreHosts sets the "ignore-hosts" property.
			266	+	// A list of hostnames and IP addresses that the resolver should
			267	+	// allow direct connections to.
			268	+	//
			269	+	// Entries can be in one of 4 formats:
			270	+	//
			271	+	// - A hostname, such as "example.com", ".example.com", or
			272	+	// "*.example.com", any of which match "example.com" or
			273	+	// any subdomain of it.
			274	+	//
			275	+	// - An IPv4 or IPv6 address, such as "192.168.1.1",
			276	+	// which matches only that address.
			277	+	//
			278	+	// - A hostname or IP address followed by a port, such as
			279	+	// "example.com:80", which matches whatever the hostname or IP
			280	+	// address would match, but only for URLs with the (explicitly)
			281	+	// indicated port. In the case of an IPv6 address, the address
			282	+	// part must appear in brackets: "[::1]:443"
			283	+	//
			284	+	// - An IP address range, given by a base address and prefix length,
			285	+	// such as "fe80::/10", which matches any address in that range.
			286	+	//
			287	+	// Note that when dealing with Unicode hostnames, the matching is
			288	+	// done against the ASCII form of the name.
			289	+	//
			290	+	// Also note that hostname exclusions apply only to connections made
			291	+	// to hosts identified by name, and IP address exclusions apply only
			292	+	// to connections made to hosts identified by address. That is, if
			293	+	// example.com has an address of 192.168.1.1, and the :ignore-hosts list
			294	+	// contains only "192.168.1.1", then a connection to "example.com"
			295	+	// (eg, via a #GNetworkAddress) will use the proxy, and a connection to
			296	+	// "192.168.1.1" (eg, via a #GInetSocketAddress) will not.
			297	+	//
			298	+	// These rules match the "ignore-hosts"/"noproxy" rules most
			299	+	// commonly used by other applications.
			300	+	func (x *SimpleProxyResolver) SetPropertyIgnoreHosts(value []string) {
			301	+	var v gobject.Value
			302	+	v.Init(glib.StrvGetType())
			303	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			304	+	x.SetProperty("ignore-hosts", &v)
			305	+	}
			306	+
			307	+	// GetPropertyIgnoreHosts gets the "ignore-hosts" property.
			308	+	// A list of hostnames and IP addresses that the resolver should
			309	+	// allow direct connections to.
			310	+	//
			311	+	// Entries can be in one of 4 formats:
			312	+	//
			313	+	// - A hostname, such as "example.com", ".example.com", or
			314	+	// "*.example.com", any of which match "example.com" or
			315	+	// any subdomain of it.
			316	+	//
			317	+	// - An IPv4 or IPv6 address, such as "192.168.1.1",
			318	+	// which matches only that address.
			319	+	//
			320	+	// - A hostname or IP address followed by a port, such as
			321	+	// "example.com:80", which matches whatever the hostname or IP
			322	+	// address would match, but only for URLs with the (explicitly)
			323	+	// indicated port. In the case of an IPv6 address, the address
			324	+	// part must appear in brackets: "[::1]:443"
			325	+	//
			326	+	// - An IP address range, given by a base address and prefix length,
			327	+	// such as "fe80::/10", which matches any address in that range.
			328	+	//
			329	+	// Note that when dealing with Unicode hostnames, the matching is
			330	+	// done against the ASCII form of the name.
			331	+	//
			332	+	// Also note that hostname exclusions apply only to connections made
			333	+	// to hosts identified by name, and IP address exclusions apply only
			334	+	// to connections made to hosts identified by address. That is, if
			335	+	// example.com has an address of 192.168.1.1, and the :ignore-hosts list
			336	+	// contains only "192.168.1.1", then a connection to "example.com"
			337	+	// (eg, via a #GNetworkAddress) will use the proxy, and a connection to
			338	+	// "192.168.1.1" (eg, via a #GInetSocketAddress) will not.
			339	+	//
			340	+	// These rules match the "ignore-hosts"/"noproxy" rules most
			341	+	// commonly used by other applications.
			342	+	func (x *SimpleProxyResolver) GetPropertyIgnoreHosts() []string {
			343	+	var v gobject.Value
			344	+	x.GetProperty("ignore-hosts", &v)
			345	+	return core.GoStringSlice(v.GetBoxed())
			346	+	}
			347	+
236		// Checks if @resolver can be used on this system. (This is used	348		// Checks if @resolver can be used on this system. (This is used
237		// internally; g_proxy_resolver_get_default() will only return a proxy	349		// internally; g_proxy_resolver_get_default() will only return a proxy
238		// resolver that returns %TRUE for this method.)	350		// resolver that returns %TRUE for this method.)

M v4/gio/gsocket.go +189 -36

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *SocketClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *SocketClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *SocketClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *SocketClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *SocketClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *SocketClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *SocketClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *SocketClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *SocketClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *SocketClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved6 sets the callback function.
+// OverrideGReserved6 sets the "_g_reserved6" callback function.
 func (x *SocketClass) OverrideGReserved6(cb func()) {
 	if cb == nil {
 		x.xGReserved6 = 0
 	}
 }
-// GetGReserved6 gets the callback function.
+// GetGReserved6 gets the "_g_reserved6" callback function.
 func (x *SocketClass) GetGReserved6() func() {
 	if x.xGReserved6 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved7 sets the callback function.
+// OverrideGReserved7 sets the "_g_reserved7" callback function.
 func (x *SocketClass) OverrideGReserved7(cb func()) {
 	if cb == nil {
 		x.xGReserved7 = 0
 	}
 }
-// GetGReserved7 gets the callback function.
+// GetGReserved7 gets the "_g_reserved7" callback function.
 func (x *SocketClass) GetGReserved7() func() {
 	if x.xGReserved7 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved8 sets the callback function.
+// OverrideGReserved8 sets the "_g_reserved8" callback function.
 func (x *SocketClass) OverrideGReserved8(cb func()) {
 	if cb == nil {
 		x.xGReserved8 = 0
 	}
 }
-// GetGReserved8 gets the callback function.
+// GetGReserved8 gets the "_g_reserved8" callback function.
 func (x *SocketClass) GetGReserved8() func() {
 	if x.xGReserved8 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved9 sets the callback function.
+// OverrideGReserved9 sets the "_g_reserved9" callback function.
 func (x *SocketClass) OverrideGReserved9(cb func()) {
 	if cb == nil {
 		x.xGReserved9 = 0
 	}
 }
-// GetGReserved9 gets the callback function.
+// GetGReserved9 gets the "_g_reserved9" callback function.
 func (x *SocketClass) GetGReserved9() func() {
 	if x.xGReserved9 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved10 sets the callback function.
+// OverrideGReserved10 sets the "_g_reserved10" callback function.
 func (x *SocketClass) OverrideGReserved10(cb func()) {
 	if cb == nil {
 		x.xGReserved10 = 0
 	}
 }
-// GetGReserved10 gets the callback function.
+// GetGReserved10 gets the "_g_reserved10" callback function.
 func (x *SocketClass) GetGReserved10() func() {
 	if x.xGReserved10 == 0 {
 		return nil
 	return cret
 }
-var xSocketGetOption func(uintptr, int, int, int, **glib.Error) bool
+var xSocketGetOption func(uintptr, int, int, *int, **glib.Error) bool
 // Gets the value of an integer-valued option on @socket, as with
 // getsockopt(). (If you need to fetch a  non-integer-valued option,
 // Note that even for socket options that are a single byte in size,
 // @value is still a pointer to a #gint variable, not a #guchar;
 // g_socket_get_option() will handle the conversion internally.
-func (x *Socket) GetOption(LevelVar int, OptnameVar int, ValueVar int) (bool, error) {
+func (x *Socket) GetOption(LevelVar int, OptnameVar int, ValueVar *int) (bool, error) {
 	var cerr *glib.Error
 	cret := xSocketGetOption(x.GoPointer(), LevelVar, OptnameVar, ValueVar, &cerr)
 }
-var xSocketReceive func(uintptr, []byte, uint, uintptr, **glib.Error) int
+var xSocketReceive func(uintptr, *[]byte, uint, uintptr, **glib.Error) int
 // Receive data (up to @size bytes) from a socket. This is mainly used by
 // connection-oriented sockets; it is identical to g_socket_receive_from()
 // %G_IO_IN condition.
 //
 // On error -1 is returned and @error is set accordingly.
-func (x *Socket) Receive(BufferVar []byte, SizeVar uint, CancellableVar *Cancellable) (int, error) {
+func (x *Socket) Receive(BufferVar *[]byte, SizeVar uint, CancellableVar *Cancellable) (int, error) {
 	var cerr *glib.Error
 	cret := xSocketReceive(x.GoPointer(), BufferVar, SizeVar, CancellableVar.GoPointer(), &cerr)
 }
-var xSocketReceiveBytesFrom func(uintptr, uintptr, uint, int64, uintptr, **glib.Error) *glib.Bytes
+var xSocketReceiveBytesFrom func(uintptr, **SocketAddress, uint, int64, uintptr, **glib.Error) *glib.Bytes
 // Receive data (up to @size bytes) from a socket.
 //
 func (x *Socket) ReceiveBytesFrom(AddressVar **SocketAddress, SizeVar uint, TimeoutUsVar int64, CancellableVar *Cancellable) (*glib.Bytes, error) {
 	var cerr *glib.Error
-	cret := xSocketReceiveBytesFrom(x.GoPointer(), *gobject.ConvertPtr(AddressVar), SizeVar, TimeoutUsVar, CancellableVar.GoPointer(), &cerr)
+	cret := xSocketReceiveBytesFrom(x.GoPointer(), AddressVar, SizeVar, TimeoutUsVar, CancellableVar.GoPointer(), &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 }
-var xSocketReceiveFrom func(uintptr, uintptr, []byte, uint, uintptr, **glib.Error) int
+var xSocketReceiveFrom func(uintptr, **SocketAddress, *[]byte, uint, uintptr, **glib.Error) int
 // Receive data (up to @size bytes) from a socket.
 //
 // @address is owned by the caller.
 //
 // See g_socket_receive() for additional information.
-func (x *Socket) ReceiveFrom(AddressVar **SocketAddress, BufferVar []byte, SizeVar uint, CancellableVar *Cancellable) (int, error) {
+func (x *Socket) ReceiveFrom(AddressVar **SocketAddress, BufferVar *[]byte, SizeVar uint, CancellableVar *Cancellable) (int, error) {
 	var cerr *glib.Error
-	cret := xSocketReceiveFrom(x.GoPointer(), *gobject.ConvertPtr(AddressVar), BufferVar, SizeVar, CancellableVar.GoPointer(), &cerr)
+	cret := xSocketReceiveFrom(x.GoPointer(), AddressVar, BufferVar, SizeVar, CancellableVar.GoPointer(), &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 }
-var xSocketReceiveMessage func(uintptr, uintptr, []InputVector, int, uintptr, int, int, uintptr, **glib.Error) int
+var xSocketReceiveMessage func(uintptr, **SocketAddress, []InputVector, int, *uintptr, *int, int, uintptr, **glib.Error) int
 // Receive data from a socket.  For receiving multiple messages, see
 // g_socket_receive_messages(); for easier use, see
 // %G_IO_IN condition.
 //
 // On error -1 is returned and @error is set accordingly.
-func (x *Socket) ReceiveMessage(AddressVar **SocketAddress, VectorsVar []InputVector, NumVectorsVar int, MessagesVar uintptr, NumMessagesVar int, FlagsVar int, CancellableVar *Cancellable) (int, error) {
+func (x *Socket) ReceiveMessage(AddressVar **SocketAddress, VectorsVar []InputVector, NumVectorsVar int, MessagesVar *uintptr, NumMessagesVar *int, FlagsVar int, CancellableVar *Cancellable) (int, error) {
 	var cerr *glib.Error
-	cret := xSocketReceiveMessage(x.GoPointer(), *gobject.ConvertPtr(AddressVar), VectorsVar, NumVectorsVar, MessagesVar, NumMessagesVar, FlagsVar, CancellableVar.GoPointer(), &cerr)
+	cret := xSocketReceiveMessage(x.GoPointer(), AddressVar, VectorsVar, NumVectorsVar, MessagesVar, NumMessagesVar, FlagsVar, CancellableVar.GoPointer(), &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 }
-var xSocketReceiveWithBlocking func(uintptr, []byte, uint, bool, uintptr, **glib.Error) int
+var xSocketReceiveWithBlocking func(uintptr, *[]byte, uint, bool, uintptr, **glib.Error) int
 // This behaves exactly the same as g_socket_receive(), except that
 // the choice of blocking or non-blocking behavior is determined by
 // the @blocking argument rather than by @socket's properties.
-func (x *Socket) ReceiveWithBlocking(BufferVar []byte, SizeVar uint, BlockingVar bool, CancellableVar *Cancellable) (int, error) {
+func (x *Socket) ReceiveWithBlocking(BufferVar *[]byte, SizeVar uint, BlockingVar bool, CancellableVar *Cancellable) (int, error) {
 	var cerr *glib.Error
 	cret := xSocketReceiveWithBlocking(x.GoPointer(), BufferVar, SizeVar, BlockingVar, CancellableVar.GoPointer(), &cerr)
 }
-var xSocketSendMessageWithTimeout func(uintptr, uintptr, []OutputVector, int, uintptr, int, int, int64, uint, uintptr, **glib.Error) PollableReturn
+var xSocketSendMessageWithTimeout func(uintptr, uintptr, []OutputVector, int, uintptr, int, int, int64, *uint, uintptr, **glib.Error) PollableReturn
 // This behaves exactly the same as g_socket_send_message(), except that
 // the choice of timeout behavior is determined by the @timeout_us argument
 // On error %G_POLLABLE_RETURN_FAILED is returned and @error is set accordingly, or
 // if the socket is currently not writable %G_POLLABLE_RETURN_WOULD_BLOCK is
 // returned. @bytes_written will contain 0 in both cases.
-func (x *Socket) SendMessageWithTimeout(AddressVar *SocketAddress, VectorsVar []OutputVector, NumVectorsVar int, MessagesVar uintptr, NumMessagesVar int, FlagsVar int, TimeoutUsVar int64, BytesWrittenVar uint, CancellableVar *Cancellable) (PollableReturn, error) {
+func (x *Socket) SendMessageWithTimeout(AddressVar *SocketAddress, VectorsVar []OutputVector, NumVectorsVar int, MessagesVar uintptr, NumMessagesVar int, FlagsVar int, TimeoutUsVar int64, BytesWrittenVar *uint, CancellableVar *Cancellable) (PollableReturn, error) {
 	var cerr *glib.Error
 	cret := xSocketSendMessageWithTimeout(x.GoPointer(), AddressVar.GoPointer(), VectorsVar, NumVectorsVar, MessagesVar, NumMessagesVar, FlagsVar, TimeoutUsVar, BytesWrittenVar, CancellableVar.GoPointer(), &cerr)
 	c.Ptr = ptr
 }
+// SetPropertyBlocking sets the "blocking" property.
+// Whether I/O on this socket is blocking.
+func (x *Socket) SetPropertyBlocking(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("blocking", &v)
+}
+// GetPropertyBlocking gets the "blocking" property.
+// Whether I/O on this socket is blocking.
+func (x *Socket) GetPropertyBlocking() bool {
+	var v gobject.Value
+	x.GetProperty("blocking", &v)
+	return v.GetBoolean()
+}
+// SetPropertyBroadcast sets the "broadcast" property.
+// Whether the socket should allow sending to broadcast addresses.
+func (x *Socket) SetPropertyBroadcast(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("broadcast", &v)
+}
+// GetPropertyBroadcast gets the "broadcast" property.
+// Whether the socket should allow sending to broadcast addresses.
+func (x *Socket) GetPropertyBroadcast() bool {
+	var v gobject.Value
+	x.GetProperty("broadcast", &v)
+	return v.GetBoolean()
+}
+// SetPropertyFd sets the "fd" property.
+// The socket’s file descriptor.
+func (x *Socket) SetPropertyFd(value int) {
+	var v gobject.Value
+	v.Init(gobject.TypeIntVal)
+	v.SetInt(value)
+	x.SetProperty("fd", &v)
+}
+// GetPropertyFd gets the "fd" property.
+// The socket’s file descriptor.
+func (x *Socket) GetPropertyFd() int {
+	var v gobject.Value
+	x.GetProperty("fd", &v)
+	return v.GetInt()
+}
+// SetPropertyKeepalive sets the "keepalive" property.
+// Whether to keep the connection alive by sending periodic pings.
+func (x *Socket) SetPropertyKeepalive(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("keepalive", &v)
+}
+// GetPropertyKeepalive gets the "keepalive" property.
+// Whether to keep the connection alive by sending periodic pings.
+func (x *Socket) GetPropertyKeepalive() bool {
+	var v gobject.Value
+	x.GetProperty("keepalive", &v)
+	return v.GetBoolean()
+}
+// SetPropertyListenBacklog sets the "listen-backlog" property.
+// The number of outstanding connections in the listen queue.
+func (x *Socket) SetPropertyListenBacklog(value int) {
+	var v gobject.Value
+	v.Init(gobject.TypeIntVal)
+	v.SetInt(value)
+	x.SetProperty("listen-backlog", &v)
+}
+// GetPropertyListenBacklog gets the "listen-backlog" property.
+// The number of outstanding connections in the listen queue.
+func (x *Socket) GetPropertyListenBacklog() int {
+	var v gobject.Value
+	x.GetProperty("listen-backlog", &v)
+	return v.GetInt()
+}
+// SetPropertyMulticastLoopback sets the "multicast-loopback" property.
+// Whether outgoing multicast packets loop back to the local host.
+func (x *Socket) SetPropertyMulticastLoopback(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("multicast-loopback", &v)
+}
+// GetPropertyMulticastLoopback gets the "multicast-loopback" property.
+// Whether outgoing multicast packets loop back to the local host.
+func (x *Socket) GetPropertyMulticastLoopback() bool {
+	var v gobject.Value
+	x.GetProperty("multicast-loopback", &v)
+	return v.GetBoolean()
+}
+// SetPropertyMulticastTtl sets the "multicast-ttl" property.
+// Time-to-live out outgoing multicast packets
+func (x *Socket) SetPropertyMulticastTtl(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("multicast-ttl", &v)
+}
+// GetPropertyMulticastTtl gets the "multicast-ttl" property.
+// Time-to-live out outgoing multicast packets
+func (x *Socket) GetPropertyMulticastTtl() uint {
+	var v gobject.Value
+	x.GetProperty("multicast-ttl", &v)
+	return v.GetUint()
+}
+// SetPropertyTimeout sets the "timeout" property.
+// The timeout in seconds on socket I/O
+func (x *Socket) SetPropertyTimeout(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("timeout", &v)
+}
+// GetPropertyTimeout gets the "timeout" property.
+// The timeout in seconds on socket I/O
+func (x *Socket) GetPropertyTimeout() uint {
+	var v gobject.Value
+	x.GetProperty("timeout", &v)
+	return v.GetUint()
+}
+// SetPropertyTtl sets the "ttl" property.
+// Time-to-live for outgoing unicast packets
+func (x *Socket) SetPropertyTtl(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("ttl", &v)
+}
+// GetPropertyTtl gets the "ttl" property.
+// Time-to-live for outgoing unicast packets
+func (x *Socket) GetPropertyTtl() uint {
+	var v gobject.Value
+	x.GetProperty("ttl", &v)
+	return v.GetUint()
+}
 // Initializes the object implementing the interface.
 //
 // This method is intended for language bindings. If writing in C,

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


@@ -28,7 +28,7 @@ func (x *SocketAddressClass) GoPointer() uintptr {
28		return uintptr(unsafe.Pointer(x))	28		return uintptr(unsafe.Pointer(x))
29		}	29		}
30			30
31	-	// OverrideGetFamily sets the callback function.	31	+	// OverrideGetFamily sets the "get_family" callback function.
32		func (x SocketAddressClass) OverrideGetFamily(cb func(SocketAddress) SocketFamily) {	32		func (x SocketAddressClass) OverrideGetFamily(cb func(SocketAddress) SocketFamily) {
33		if cb == nil {	33		if cb == nil {
34		x.xGetFamily = 0	34		x.xGetFamily = 0

@@ -39,7 +39,7 @@ func (x SocketAddressClass) OverrideGetFamily(cb func(SocketAddress) SocketFam
39		}	39		}
40		}	40		}
41			41
42	-	// GetGetFamily gets the callback function.	42	+	// GetGetFamily gets the "get_family" callback function.
43		func (x SocketAddressClass) GetGetFamily() func(SocketAddress) SocketFamily {	43		func (x SocketAddressClass) GetGetFamily() func(SocketAddress) SocketFamily {
44		if x.xGetFamily == 0 {	44		if x.xGetFamily == 0 {
45		return nil	45		return nil

@@ -51,7 +51,7 @@ func (x SocketAddressClass) GetGetFamily() func(SocketAddress) SocketFamily {
51		}	51		}
52		}	52		}
53			53
54	-	// OverrideGetNativeSize sets the callback function.	54	+	// OverrideGetNativeSize sets the "get_native_size" callback function.
55		func (x SocketAddressClass) OverrideGetNativeSize(cb func(SocketAddress) int) {	55		func (x SocketAddressClass) OverrideGetNativeSize(cb func(SocketAddress) int) {
56		if cb == nil {	56		if cb == nil {
57		x.xGetNativeSize = 0	57		x.xGetNativeSize = 0

@@ -62,7 +62,7 @@ func (x SocketAddressClass) OverrideGetNativeSize(cb func(SocketAddress) int)
62		}	62		}
63		}	63		}
64			64
65	-	// GetGetNativeSize gets the callback function.	65	+	// GetGetNativeSize gets the "get_native_size" callback function.
66		func (x SocketAddressClass) GetGetNativeSize() func(SocketAddress) int {	66		func (x SocketAddressClass) GetGetNativeSize() func(SocketAddress) int {
67		if x.xGetNativeSize == 0 {	67		if x.xGetNativeSize == 0 {
68		return nil	68		return nil

@@ -74,7 +74,7 @@ func (x SocketAddressClass) GetGetNativeSize() func(SocketAddress) int {
74		}	74		}
75		}	75		}
76			76
77	-	// OverrideToNative sets the callback function.	77	+	// OverrideToNative sets the "to_native" callback function.
78		func (x SocketAddressClass) OverrideToNative(cb func(SocketAddress, uintptr, uint) bool) {	78		func (x SocketAddressClass) OverrideToNative(cb func(SocketAddress, uintptr, uint) bool) {
79		if cb == nil {	79		if cb == nil {
80		x.xToNative = 0	80		x.xToNative = 0

@@ -85,7 +85,7 @@ func (x SocketAddressClass) OverrideToNative(cb func(SocketAddress, uintptr, u
85		}	85		}
86		}	86		}
87			87
88	-	// GetToNative gets the callback function.	88	+	// GetToNative gets the "to_native" callback function.
89		func (x SocketAddressClass) GetToNative() func(SocketAddress, uintptr, uint) bool {	89		func (x SocketAddressClass) GetToNative() func(SocketAddress, uintptr, uint) bool {
90		if x.xToNative == 0 {	90		if x.xToNative == 0 {
91		return nil	91		return nil

M v4/gio/gsocketaddressenumerator.go +6 -6


@@ -29,7 +29,7 @@ func (x *SocketAddressEnumeratorClass) GoPointer() uintptr {
29		return uintptr(unsafe.Pointer(x))	29		return uintptr(unsafe.Pointer(x))
30		}	30		}
31			31
32	-	// OverrideNext sets the callback function.	32	+	// OverrideNext sets the "next" callback function.
33		// Virtual method for g_socket_address_enumerator_next().	33		// Virtual method for g_socket_address_enumerator_next().
34		func (x SocketAddressEnumeratorClass) OverrideNext(cb func(SocketAddressEnumerator, Cancellable) SocketAddress) {	34		func (x SocketAddressEnumeratorClass) OverrideNext(cb func(SocketAddressEnumerator, Cancellable) SocketAddress) {
35		if cb == nil {	35		if cb == nil {

@@ -45,7 +45,7 @@ func (x SocketAddressEnumeratorClass) OverrideNext(cb func(SocketAddressEnumer
45		}	45		}
46		}	46		}
47			47
48	-	// GetNext gets the callback function.	48	+	// GetNext gets the "next" callback function.
49		// Virtual method for g_socket_address_enumerator_next().	49		// Virtual method for g_socket_address_enumerator_next().
50		func (x SocketAddressEnumeratorClass) GetNext() func(SocketAddressEnumerator, Cancellable) SocketAddress {	50		func (x SocketAddressEnumeratorClass) GetNext() func(SocketAddressEnumerator, Cancellable) SocketAddress {
51		if x.xNext == 0 {	51		if x.xNext == 0 {

@@ -64,7 +64,7 @@ func (x SocketAddressEnumeratorClass) GetNext() func(SocketAddressEnumerator,
64		}	64		}
65		}	65		}
66			66
67	-	// OverrideNextAsync sets the callback function.	67	+	// OverrideNextAsync sets the "next_async" callback function.
68		// Virtual method for g_socket_address_enumerator_next_async().	68		// Virtual method for g_socket_address_enumerator_next_async().
69		func (x SocketAddressEnumeratorClass) OverrideNextAsync(cb func(SocketAddressEnumerator, Cancellable, AsyncReadyCallback, uintptr)) {	69		func (x SocketAddressEnumeratorClass) OverrideNextAsync(cb func(SocketAddressEnumerator, Cancellable, AsyncReadyCallback, uintptr)) {
70		if cb == nil {	70		if cb == nil {

@@ -76,7 +76,7 @@ func (x SocketAddressEnumeratorClass) OverrideNextAsync(cb func(SocketAddressE
76		}	76		}
77		}	77		}
78			78
79	-	// GetNextAsync gets the callback function.	79	+	// GetNextAsync gets the "next_async" callback function.
80		// Virtual method for g_socket_address_enumerator_next_async().	80		// Virtual method for g_socket_address_enumerator_next_async().
81		func (x SocketAddressEnumeratorClass) GetNextAsync() func(SocketAddressEnumerator, Cancellable, AsyncReadyCallback, uintptr) {	81		func (x SocketAddressEnumeratorClass) GetNextAsync() func(SocketAddressEnumerator, Cancellable, AsyncReadyCallback, uintptr) {
82		if x.xNextAsync == 0 {	82		if x.xNextAsync == 0 {

@@ -89,7 +89,7 @@ func (x SocketAddressEnumeratorClass) GetNextAsync() func(SocketAddressEnumera
89		}	89		}
90		}	90		}
91			91
92	-	// OverrideNextFinish sets the callback function.	92	+	// OverrideNextFinish sets the "next_finish" callback function.
93		// Virtual method for g_socket_address_enumerator_next_finish().	93		// Virtual method for g_socket_address_enumerator_next_finish().
94		func (x SocketAddressEnumeratorClass) OverrideNextFinish(cb func(SocketAddressEnumerator, AsyncResult) *SocketAddress) {	94		func (x SocketAddressEnumeratorClass) OverrideNextFinish(cb func(SocketAddressEnumerator, AsyncResult) *SocketAddress) {
95		if cb == nil {	95		if cb == nil {

@@ -105,7 +105,7 @@ func (x SocketAddressEnumeratorClass) OverrideNextFinish(cb func(SocketAddress
105		}	105		}
106		}	106		}
107			107
108	-	// GetNextFinish gets the callback function.	108	+	// GetNextFinish gets the "next_finish" callback function.
109		// Virtual method for g_socket_address_enumerator_next_finish().	109		// Virtual method for g_socket_address_enumerator_next_finish().
110		func (x SocketAddressEnumeratorClass) GetNextFinish() func(SocketAddressEnumerator, AsyncResult) *SocketAddress {	110		func (x SocketAddressEnumeratorClass) GetNextFinish() func(SocketAddressEnumerator, AsyncResult) *SocketAddress {
111		if x.xNextFinish == 0 {	111		if x.xNextFinish == 0 {

M v4/gio/gsocketclient.go +61 -10

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideEvent sets the callback function.
+// OverrideEvent sets the "event" callback function.
 func (x *SocketClientClass) OverrideEvent(cb func(*SocketClient, SocketClientEvent, SocketConnectable, *IOStream)) {
 	if cb == nil {
 		x.xEvent = 0
 	}
 }
-// GetEvent gets the callback function.
+// GetEvent gets the "event" callback function.
 func (x *SocketClientClass) GetEvent() func(*SocketClient, SocketClientEvent, SocketConnectable, *IOStream) {
 	if x.xEvent == 0 {
 		return nil
 	}
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *SocketClientClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *SocketClientClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *SocketClientClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *SocketClientClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *SocketClientClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *SocketClientClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *SocketClientClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *SocketClientClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyEnableProxy sets the "enable-proxy" property.
+// Enable proxy support.
+func (x *SocketClient) SetPropertyEnableProxy(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("enable-proxy", &v)
+}
+// GetPropertyEnableProxy gets the "enable-proxy" property.
+// Enable proxy support.
+func (x *SocketClient) GetPropertyEnableProxy() bool {
+	var v gobject.Value
+	x.GetProperty("enable-proxy", &v)
+	return v.GetBoolean()
+}
+// SetPropertyTimeout sets the "timeout" property.
+// The I/O timeout for sockets, in seconds, or `0` for none.
+func (x *SocketClient) SetPropertyTimeout(value uint) {
+	var v gobject.Value
+	v.Init(gobject.TypeUintVal)
+	v.SetUint(value)
+	x.SetProperty("timeout", &v)
+}
+// GetPropertyTimeout gets the "timeout" property.
+// The I/O timeout for sockets, in seconds, or `0` for none.
+func (x *SocketClient) GetPropertyTimeout() uint {
+	var v gobject.Value
+	x.GetProperty("timeout", &v)
+	return v.GetUint()
+}
+// SetPropertyTls sets the "tls" property.
+// Whether to create TLS connections.
+func (x *SocketClient) SetPropertyTls(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("tls", &v)
+}
+// GetPropertyTls gets the "tls" property.
+// Whether to create TLS connections.
+func (x *SocketClient) GetPropertyTls() bool {
+	var v gobject.Value
+	x.GetProperty("tls", &v)
+	return v.GetBoolean()
+}
 // Emitted when @client's activity on @connectable changes state.
 // Among other things, this can be used to provide progress
 // information about a network connection in the UI. The meanings of

M v4/gio/gsocketconnectable.go +6 -6


@@ -28,7 +28,7 @@ func (x *SocketConnectableIface) GoPointer() uintptr {
28		return uintptr(unsafe.Pointer(x))	28		return uintptr(unsafe.Pointer(x))
29		}	29		}
30			30
31	-	// OverrideEnumerate sets the callback function.	31	+	// OverrideEnumerate sets the "enumerate" callback function.
32		// Creates a #GSocketAddressEnumerator	32		// Creates a #GSocketAddressEnumerator
33		func (x SocketConnectableIface) OverrideEnumerate(cb func(SocketConnectable) SocketAddressEnumerator) {	33		func (x SocketConnectableIface) OverrideEnumerate(cb func(SocketConnectable) SocketAddressEnumerator) {
34		if cb == nil {	34		if cb == nil {

@@ -44,7 +44,7 @@ func (x SocketConnectableIface) OverrideEnumerate(cb func(SocketConnectable) S
44		}	44		}
45		}	45		}
46			46
47	-	// GetEnumerate gets the callback function.	47	+	// GetEnumerate gets the "enumerate" callback function.
48		// Creates a #GSocketAddressEnumerator	48		// Creates a #GSocketAddressEnumerator
49		func (x SocketConnectableIface) GetEnumerate() func(SocketConnectable) SocketAddressEnumerator {	49		func (x SocketConnectableIface) GetEnumerate() func(SocketConnectable) SocketAddressEnumerator {
50		if x.xEnumerate == 0 {	50		if x.xEnumerate == 0 {

@@ -63,7 +63,7 @@ func (x SocketConnectableIface) GetEnumerate() func(SocketConnectable) SocketA
63		}	63		}
64		}	64		}
65			65
66	-	// OverrideProxyEnumerate sets the callback function.	66	+	// OverrideProxyEnumerate sets the "proxy_enumerate" callback function.
67		// Creates a #GProxyAddressEnumerator	67		// Creates a #GProxyAddressEnumerator
68		func (x SocketConnectableIface) OverrideProxyEnumerate(cb func(SocketConnectable) SocketAddressEnumerator) {	68		func (x SocketConnectableIface) OverrideProxyEnumerate(cb func(SocketConnectable) SocketAddressEnumerator) {
69		if cb == nil {	69		if cb == nil {

@@ -79,7 +79,7 @@ func (x *SocketConnectableIface) OverrideProxyEnumerate(cb func(SocketConnectabl
79		}	79		}
80		}	80		}
81			81
82	-	// GetProxyEnumerate gets the callback function.	82	+	// GetProxyEnumerate gets the "proxy_enumerate" callback function.
83		// Creates a #GProxyAddressEnumerator	83		// Creates a #GProxyAddressEnumerator
84		func (x SocketConnectableIface) GetProxyEnumerate() func(SocketConnectable) SocketAddressEnumerator {	84		func (x SocketConnectableIface) GetProxyEnumerate() func(SocketConnectable) SocketAddressEnumerator {
85		if x.xProxyEnumerate == 0 {	85		if x.xProxyEnumerate == 0 {

@@ -98,7 +98,7 @@ func (x SocketConnectableIface) GetProxyEnumerate() func(SocketConnectable) So
98		}	98		}
99		}	99		}
100			100
101	-	// OverrideToString sets the callback function.	101	+	// OverrideToString sets the "to_string" callback function.
102		// Format the connectable’s address as a string for debugging.	102		// Format the connectable’s address as a string for debugging.
103		//	103		//
104		// Implementing this is optional. (Since: 2.48)	104		// Implementing this is optional. (Since: 2.48)

@@ -112,7 +112,7 @@ func (x *SocketConnectableIface) OverrideToString(cb func(SocketConnectable) str
112		}	112		}
113		}	113		}
114			114
115	-	// GetToString gets the callback function.	115	+	// GetToString gets the "to_string" callback function.
116		// Format the connectable’s address as a string for debugging.	116		// Format the connectable’s address as a string for debugging.
117		//	117		//
118		// Implementing this is optional. (Since: 2.48)	118		// Implementing this is optional. (Since: 2.48)

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


@@ -34,7 +34,7 @@ func (x *SocketConnectionClass) GoPointer() uintptr {
34		return uintptr(unsafe.Pointer(x))	34		return uintptr(unsafe.Pointer(x))
35		}	35		}
36			36
37	-	// OverrideGReserved1 sets the callback function.	37	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
38		func (x *SocketConnectionClass) OverrideGReserved1(cb func()) {	38		func (x *SocketConnectionClass) OverrideGReserved1(cb func()) {
39		if cb == nil {	39		if cb == nil {
40		x.xGReserved1 = 0	40		x.xGReserved1 = 0

@@ -45,7 +45,7 @@ func (x *SocketConnectionClass) OverrideGReserved1(cb func()) {
45		}	45		}
46		}	46		}
47			47
48	-	// GetGReserved1 gets the callback function.	48	+	// GetGReserved1 gets the "_g_reserved1" callback function.
49		func (x *SocketConnectionClass) GetGReserved1() func() {	49		func (x *SocketConnectionClass) GetGReserved1() func() {
50		if x.xGReserved1 == 0 {	50		if x.xGReserved1 == 0 {
51		return nil	51		return nil

@@ -57,7 +57,7 @@ func (x *SocketConnectionClass) GetGReserved1() func() {
57		}	57		}
58		}	58		}
59			59
60	-	// OverrideGReserved2 sets the callback function.	60	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
61		func (x *SocketConnectionClass) OverrideGReserved2(cb func()) {	61		func (x *SocketConnectionClass) OverrideGReserved2(cb func()) {
62		if cb == nil {	62		if cb == nil {
63		x.xGReserved2 = 0	63		x.xGReserved2 = 0

@@ -68,7 +68,7 @@ func (x *SocketConnectionClass) OverrideGReserved2(cb func()) {
68		}	68		}
69		}	69		}
70			70
71	-	// GetGReserved2 gets the callback function.	71	+	// GetGReserved2 gets the "_g_reserved2" callback function.
72		func (x *SocketConnectionClass) GetGReserved2() func() {	72		func (x *SocketConnectionClass) GetGReserved2() func() {
73		if x.xGReserved2 == 0 {	73		if x.xGReserved2 == 0 {
74		return nil	74		return nil

@@ -80,7 +80,7 @@ func (x *SocketConnectionClass) GetGReserved2() func() {
80		}	80		}
81		}	81		}
82			82
83	-	// OverrideGReserved3 sets the callback function.	83	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
84		func (x *SocketConnectionClass) OverrideGReserved3(cb func()) {	84		func (x *SocketConnectionClass) OverrideGReserved3(cb func()) {
85		if cb == nil {	85		if cb == nil {
86		x.xGReserved3 = 0	86		x.xGReserved3 = 0

@@ -91,7 +91,7 @@ func (x *SocketConnectionClass) OverrideGReserved3(cb func()) {
91		}	91		}
92		}	92		}
93			93
94	-	// GetGReserved3 gets the callback function.	94	+	// GetGReserved3 gets the "_g_reserved3" callback function.
95		func (x *SocketConnectionClass) GetGReserved3() func() {	95		func (x *SocketConnectionClass) GetGReserved3() func() {
96		if x.xGReserved3 == 0 {	96		if x.xGReserved3 == 0 {
97		return nil	97		return nil

@@ -103,7 +103,7 @@ func (x *SocketConnectionClass) GetGReserved3() func() {
103		}	103		}
104		}	104		}
105			105
106	-	// OverrideGReserved4 sets the callback function.	106	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
107		func (x *SocketConnectionClass) OverrideGReserved4(cb func()) {	107		func (x *SocketConnectionClass) OverrideGReserved4(cb func()) {
108		if cb == nil {	108		if cb == nil {
109		x.xGReserved4 = 0	109		x.xGReserved4 = 0

@@ -114,7 +114,7 @@ func (x *SocketConnectionClass) OverrideGReserved4(cb func()) {
114		}	114		}
115		}	115		}
116			116
117	-	// GetGReserved4 gets the callback function.	117	+	// GetGReserved4 gets the "_g_reserved4" callback function.
118		func (x *SocketConnectionClass) GetGReserved4() func() {	118		func (x *SocketConnectionClass) GetGReserved4() func() {
119		if x.xGReserved4 == 0 {	119		if x.xGReserved4 == 0 {
120		return nil	120		return nil

@@ -126,7 +126,7 @@ func (x *SocketConnectionClass) GetGReserved4() func() {
126		}	126		}
127		}	127		}
128			128
129	-	// OverrideGReserved5 sets the callback function.	129	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
130		func (x *SocketConnectionClass) OverrideGReserved5(cb func()) {	130		func (x *SocketConnectionClass) OverrideGReserved5(cb func()) {
131		if cb == nil {	131		if cb == nil {
132		x.xGReserved5 = 0	132		x.xGReserved5 = 0

@@ -137,7 +137,7 @@ func (x *SocketConnectionClass) OverrideGReserved5(cb func()) {
137		}	137		}
138		}	138		}
139			139
140	-	// GetGReserved5 gets the callback function.	140	+	// GetGReserved5 gets the "_g_reserved5" callback function.
141		func (x *SocketConnectionClass) GetGReserved5() func() {	141		func (x *SocketConnectionClass) GetGReserved5() func() {
142		if x.xGReserved5 == 0 {	142		if x.xGReserved5 == 0 {
143		return nil	143		return nil

@@ -149,7 +149,7 @@ func (x *SocketConnectionClass) GetGReserved5() func() {
149		}	149		}
150		}	150		}
151			151
152	-	// OverrideGReserved6 sets the callback function.	152	+	// OverrideGReserved6 sets the "_g_reserved6" callback function.
153		func (x *SocketConnectionClass) OverrideGReserved6(cb func()) {	153		func (x *SocketConnectionClass) OverrideGReserved6(cb func()) {
154		if cb == nil {	154		if cb == nil {
155		x.xGReserved6 = 0	155		x.xGReserved6 = 0

@@ -160,7 +160,7 @@ func (x *SocketConnectionClass) OverrideGReserved6(cb func()) {
160		}	160		}
161		}	161		}
162			162
163	-	// GetGReserved6 gets the callback function.	163	+	// GetGReserved6 gets the "_g_reserved6" callback function.
164		func (x *SocketConnectionClass) GetGReserved6() func() {	164		func (x *SocketConnectionClass) GetGReserved6() func() {
165		if x.xGReserved6 == 0 {	165		if x.xGReserved6 == 0 {
166		return nil	166		return nil

M v4/gio/gsocketcontrolmessage.go +20 -20


@@ -42,7 +42,7 @@ func (x *SocketControlMessageClass) GoPointer() uintptr {
42		return uintptr(unsafe.Pointer(x))	42		return uintptr(unsafe.Pointer(x))
43		}	43		}
44			44
45	-	// OverrideGetSize sets the callback function.	45	+	// OverrideGetSize sets the "get_size" callback function.
46		// gets the size of the message.	46		// gets the size of the message.
47		func (x SocketControlMessageClass) OverrideGetSize(cb func(SocketControlMessage) uint) {	47		func (x SocketControlMessageClass) OverrideGetSize(cb func(SocketControlMessage) uint) {
48		if cb == nil {	48		if cb == nil {

@@ -54,7 +54,7 @@ func (x SocketControlMessageClass) OverrideGetSize(cb func(SocketControlMessag
54		}	54		}
55		}	55		}
56			56
57	-	// GetGetSize gets the callback function.	57	+	// GetGetSize gets the "get_size" callback function.
58		// gets the size of the message.	58		// gets the size of the message.
59		func (x SocketControlMessageClass) GetGetSize() func(SocketControlMessage) uint {	59		func (x SocketControlMessageClass) GetGetSize() func(SocketControlMessage) uint {
60		if x.xGetSize == 0 {	60		if x.xGetSize == 0 {

@@ -67,7 +67,7 @@ func (x SocketControlMessageClass) GetGetSize() func(SocketControlMessage) uin
67		}	67		}
68		}	68		}
69			69
70	-	// OverrideGetLevel sets the callback function.	70	+	// OverrideGetLevel sets the "get_level" callback function.
71		// gets the protocol of the message.	71		// gets the protocol of the message.
72		func (x SocketControlMessageClass) OverrideGetLevel(cb func(SocketControlMessage) int) {	72		func (x SocketControlMessageClass) OverrideGetLevel(cb func(SocketControlMessage) int) {
73		if cb == nil {	73		if cb == nil {

@@ -79,7 +79,7 @@ func (x SocketControlMessageClass) OverrideGetLevel(cb func(SocketControlMessa
79		}	79		}
80		}	80		}
81			81
82	-	// GetGetLevel gets the callback function.	82	+	// GetGetLevel gets the "get_level" callback function.
83		// gets the protocol of the message.	83		// gets the protocol of the message.
84		func (x SocketControlMessageClass) GetGetLevel() func(SocketControlMessage) int {	84		func (x SocketControlMessageClass) GetGetLevel() func(SocketControlMessage) int {
85		if x.xGetLevel == 0 {	85		if x.xGetLevel == 0 {

@@ -92,7 +92,7 @@ func (x SocketControlMessageClass) GetGetLevel() func(SocketControlMessage) in
92		}	92		}
93		}	93		}
94			94
95	-	// OverrideGetType sets the callback function.	95	+	// OverrideGetType sets the "get_type" callback function.
96		// gets the protocol specific type of the message.	96		// gets the protocol specific type of the message.
97		func (x SocketControlMessageClass) OverrideGetType(cb func(SocketControlMessage) int) {	97		func (x SocketControlMessageClass) OverrideGetType(cb func(SocketControlMessage) int) {
98		if cb == nil {	98		if cb == nil {

@@ -104,7 +104,7 @@ func (x SocketControlMessageClass) OverrideGetType(cb func(SocketControlMessag
104		}	104		}
105		}	105		}
106			106
107	-	// GetGetType gets the callback function.	107	+	// GetGetType gets the "get_type" callback function.
108		// gets the protocol specific type of the message.	108		// gets the protocol specific type of the message.
109		func (x SocketControlMessageClass) GetGetType() func(SocketControlMessage) int {	109		func (x SocketControlMessageClass) GetGetType() func(SocketControlMessage) int {
110		if x.xGetType == 0 {	110		if x.xGetType == 0 {

@@ -117,7 +117,7 @@ func (x SocketControlMessageClass) GetGetType() func(SocketControlMessage) int
117		}	117		}
118		}	118		}
119			119
120	-	// OverrideSerialize sets the callback function.	120	+	// OverrideSerialize sets the "serialize" callback function.
121		// Writes out the message data.	121		// Writes out the message data.
122		func (x SocketControlMessageClass) OverrideSerialize(cb func(SocketControlMessage, uintptr)) {	122		func (x SocketControlMessageClass) OverrideSerialize(cb func(SocketControlMessage, uintptr)) {
123		if cb == nil {	123		if cb == nil {

@@ -129,7 +129,7 @@ func (x SocketControlMessageClass) OverrideSerialize(cb func(SocketControlMess
129		}	129		}
130		}	130		}
131			131
132	-	// GetSerialize gets the callback function.	132	+	// GetSerialize gets the "serialize" callback function.
133		// Writes out the message data.	133		// Writes out the message data.
134		func (x SocketControlMessageClass) GetSerialize() func(SocketControlMessage, uintptr) {	134		func (x SocketControlMessageClass) GetSerialize() func(SocketControlMessage, uintptr) {
135		if x.xSerialize == 0 {	135		if x.xSerialize == 0 {

@@ -142,7 +142,7 @@ func (x SocketControlMessageClass) GetSerialize() func(SocketControlMessage, u
142		}	142		}
143		}	143		}
144			144
145	-	// OverrideDeserialize sets the callback function.	145	+	// OverrideDeserialize sets the "deserialize" callback function.
146		// Tries to deserialize a message.	146		// Tries to deserialize a message.
147		func (x SocketControlMessageClass) OverrideDeserialize(cb func(int, int, uint, uintptr) SocketControlMessage) {	147		func (x SocketControlMessageClass) OverrideDeserialize(cb func(int, int, uint, uintptr) SocketControlMessage) {
148		if cb == nil {	148		if cb == nil {

@@ -158,7 +158,7 @@ func (x *SocketControlMessageClass) OverrideDeserialize(cb func(int, int, uint,
158		}	158		}
159		}	159		}
160			160
161	-	// GetDeserialize gets the callback function.	161	+	// GetDeserialize gets the "deserialize" callback function.
162		// Tries to deserialize a message.	162		// Tries to deserialize a message.
163		func (x SocketControlMessageClass) GetDeserialize() func(int, int, uint, uintptr) SocketControlMessage {	163		func (x SocketControlMessageClass) GetDeserialize() func(int, int, uint, uintptr) SocketControlMessage {
164		if x.xDeserialize == 0 {	164		if x.xDeserialize == 0 {

@@ -177,7 +177,7 @@ func (x *SocketControlMessageClass) GetDeserialize() func(int, int, uint, uintpt
177		}	177		}
178		}	178		}
179			179
180	-	// OverrideGReserved1 sets the callback function.	180	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
181		func (x *SocketControlMessageClass) OverrideGReserved1(cb func()) {	181		func (x *SocketControlMessageClass) OverrideGReserved1(cb func()) {
182		if cb == nil {	182		if cb == nil {
183		x.xGReserved1 = 0	183		x.xGReserved1 = 0

@@ -188,7 +188,7 @@ func (x *SocketControlMessageClass) OverrideGReserved1(cb func()) {
188		}	188		}
189		}	189		}
190			190
191	-	// GetGReserved1 gets the callback function.	191	+	// GetGReserved1 gets the "_g_reserved1" callback function.
192		func (x *SocketControlMessageClass) GetGReserved1() func() {	192		func (x *SocketControlMessageClass) GetGReserved1() func() {
193		if x.xGReserved1 == 0 {	193		if x.xGReserved1 == 0 {
194		return nil	194		return nil

@@ -200,7 +200,7 @@ func (x *SocketControlMessageClass) GetGReserved1() func() {
200		}	200		}
201		}	201		}
202			202
203	-	// OverrideGReserved2 sets the callback function.	203	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
204		func (x *SocketControlMessageClass) OverrideGReserved2(cb func()) {	204		func (x *SocketControlMessageClass) OverrideGReserved2(cb func()) {
205		if cb == nil {	205		if cb == nil {
206		x.xGReserved2 = 0	206		x.xGReserved2 = 0

@@ -211,7 +211,7 @@ func (x *SocketControlMessageClass) OverrideGReserved2(cb func()) {
211		}	211		}
212		}	212		}
213			213
214	-	// GetGReserved2 gets the callback function.	214	+	// GetGReserved2 gets the "_g_reserved2" callback function.
215		func (x *SocketControlMessageClass) GetGReserved2() func() {	215		func (x *SocketControlMessageClass) GetGReserved2() func() {
216		if x.xGReserved2 == 0 {	216		if x.xGReserved2 == 0 {
217		return nil	217		return nil

@@ -223,7 +223,7 @@ func (x *SocketControlMessageClass) GetGReserved2() func() {
223		}	223		}
224		}	224		}
225			225
226	-	// OverrideGReserved3 sets the callback function.	226	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
227		func (x *SocketControlMessageClass) OverrideGReserved3(cb func()) {	227		func (x *SocketControlMessageClass) OverrideGReserved3(cb func()) {
228		if cb == nil {	228		if cb == nil {
229		x.xGReserved3 = 0	229		x.xGReserved3 = 0

@@ -234,7 +234,7 @@ func (x *SocketControlMessageClass) OverrideGReserved3(cb func()) {
234		}	234		}
235		}	235		}
236			236
237	-	// GetGReserved3 gets the callback function.	237	+	// GetGReserved3 gets the "_g_reserved3" callback function.
238		func (x *SocketControlMessageClass) GetGReserved3() func() {	238		func (x *SocketControlMessageClass) GetGReserved3() func() {
239		if x.xGReserved3 == 0 {	239		if x.xGReserved3 == 0 {
240		return nil	240		return nil

@@ -246,7 +246,7 @@ func (x *SocketControlMessageClass) GetGReserved3() func() {
246		}	246		}
247		}	247		}
248			248
249	-	// OverrideGReserved4 sets the callback function.	249	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
250		func (x *SocketControlMessageClass) OverrideGReserved4(cb func()) {	250		func (x *SocketControlMessageClass) OverrideGReserved4(cb func()) {
251		if cb == nil {	251		if cb == nil {
252		x.xGReserved4 = 0	252		x.xGReserved4 = 0

@@ -257,7 +257,7 @@ func (x *SocketControlMessageClass) OverrideGReserved4(cb func()) {
257		}	257		}
258		}	258		}
259			259
260	-	// GetGReserved4 gets the callback function.	260	+	// GetGReserved4 gets the "_g_reserved4" callback function.
261		func (x *SocketControlMessageClass) GetGReserved4() func() {	261		func (x *SocketControlMessageClass) GetGReserved4() func() {
262		if x.xGReserved4 == 0 {	262		if x.xGReserved4 == 0 {
263		return nil	263		return nil

@@ -269,7 +269,7 @@ func (x *SocketControlMessageClass) GetGReserved4() func() {
269		}	269		}
270		}	270		}
271			271
272	-	// OverrideGReserved5 sets the callback function.	272	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
273		func (x *SocketControlMessageClass) OverrideGReserved5(cb func()) {	273		func (x *SocketControlMessageClass) OverrideGReserved5(cb func()) {
274		if cb == nil {	274		if cb == nil {
275		x.xGReserved5 = 0	275		x.xGReserved5 = 0

@@ -280,7 +280,7 @@ func (x *SocketControlMessageClass) OverrideGReserved5(cb func()) {
280		}	280		}
281		}	281		}
282			282
283	-	// GetGReserved5 gets the callback function.	283	+	// GetGReserved5 gets the "_g_reserved5" callback function.
284		func (x *SocketControlMessageClass) GetGReserved5() func() {	284		func (x *SocketControlMessageClass) GetGReserved5() func() {
285		if x.xGReserved5 == 0 {	285		if x.xGReserved5 == 0 {
286		return nil	286		return nil

M v4/gio/gsocketlistener.go +41 -24

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideChanged sets the callback function.
+// OverrideChanged sets the "changed" callback function.
 // virtual method called when the set of socket listened to changes
 func (x *SocketListenerClass) OverrideChanged(cb func(*SocketListener)) {
 	if cb == nil {
 	}
 }
-// GetChanged gets the callback function.
+// GetChanged gets the "changed" callback function.
 // virtual method called when the set of socket listened to changes
 func (x *SocketListenerClass) GetChanged() func(*SocketListener) {
 	if x.xChanged == 0 {
 	}
 }
-// OverrideEvent sets the callback function.
+// OverrideEvent sets the "event" callback function.
 func (x *SocketListenerClass) OverrideEvent(cb func(*SocketListener, SocketListenerEvent, *Socket)) {
 	if cb == nil {
 		x.xEvent = 0
 	}
 }
-// GetEvent gets the callback function.
+// GetEvent gets the "event" callback function.
 func (x *SocketListenerClass) GetEvent() func(*SocketListener, SocketListenerEvent, *Socket) {
 	if x.xEvent == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *SocketListenerClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *SocketListenerClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *SocketListenerClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *SocketListenerClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *SocketListenerClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *SocketListenerClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *SocketListenerClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *SocketListenerClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved6 sets the callback function.
+// OverrideGReserved6 sets the "_g_reserved6" callback function.
 func (x *SocketListenerClass) OverrideGReserved6(cb func()) {
 	if cb == nil {
 		x.xGReserved6 = 0
 	}
 }
-// GetGReserved6 gets the callback function.
+// GetGReserved6 gets the "_g_reserved6" callback function.
 func (x *SocketListenerClass) GetGReserved6() func() {
 	if x.xGReserved6 == 0 {
 		return nil
 	return cls
 }
-var xSocketListenerAccept func(uintptr, uintptr, uintptr, **glib.Error) uintptr
+var xSocketListenerAccept func(uintptr, **gobject.Object, uintptr, **glib.Error) uintptr
 // Blocks waiting for a client to connect to any of the sockets added
 // to the listener. Returns a #GSocketConnection for the socket that was
 	var cls *SocketConnection
 	var cerr *glib.Error
-	cret := xSocketListenerAccept(x.GoPointer(), *gobject.ConvertPtr(SourceObjectVar), CancellableVar.GoPointer(), &cerr)
+	cret := xSocketListenerAccept(x.GoPointer(), SourceObjectVar, CancellableVar.GoPointer(), &cerr)
 	if cret == 0 {
 		return nil, cerr
 }
-var xSocketListenerAcceptFinish func(uintptr, uintptr, uintptr, **glib.Error) uintptr
+var xSocketListenerAcceptFinish func(uintptr, uintptr, **gobject.Object, **glib.Error) uintptr
 // Finishes an async accept operation. See g_socket_listener_accept_async()
 func (x *SocketListener) AcceptFinish(ResultVar AsyncResult, SourceObjectVar **gobject.Object) (*SocketConnection, error) {
 	var cls *SocketConnection
 	var cerr *glib.Error
-	cret := xSocketListenerAcceptFinish(x.GoPointer(), ResultVar.GoPointer(), *gobject.ConvertPtr(SourceObjectVar), &cerr)
+	cret := xSocketListenerAcceptFinish(x.GoPointer(), ResultVar.GoPointer(), SourceObjectVar, &cerr)
 	if cret == 0 {
 		return nil, cerr
 }
-var xSocketListenerAcceptSocket func(uintptr, uintptr, uintptr, **glib.Error) uintptr
+var xSocketListenerAcceptSocket func(uintptr, **gobject.Object, uintptr, **glib.Error) uintptr
 // Blocks waiting for a client to connect to any of the sockets added
 // to the listener. Returns the #GSocket that was accepted.
 	var cls *Socket
 	var cerr *glib.Error
-	cret := xSocketListenerAcceptSocket(x.GoPointer(), *gobject.ConvertPtr(SourceObjectVar), CancellableVar.GoPointer(), &cerr)
+	cret := xSocketListenerAcceptSocket(x.GoPointer(), SourceObjectVar, CancellableVar.GoPointer(), &cerr)
 	if cret == 0 {
 		return nil, cerr
 }
-var xSocketListenerAcceptSocketFinish func(uintptr, uintptr, uintptr, **glib.Error) uintptr
+var xSocketListenerAcceptSocketFinish func(uintptr, uintptr, **gobject.Object, **glib.Error) uintptr
 // Finishes an async accept operation. See g_socket_listener_accept_socket_async()
 func (x *SocketListener) AcceptSocketFinish(ResultVar AsyncResult, SourceObjectVar **gobject.Object) (*Socket, error) {
 	var cls *Socket
 	var cerr *glib.Error
-	cret := xSocketListenerAcceptSocketFinish(x.GoPointer(), ResultVar.GoPointer(), *gobject.ConvertPtr(SourceObjectVar), &cerr)
+	cret := xSocketListenerAcceptSocketFinish(x.GoPointer(), ResultVar.GoPointer(), SourceObjectVar, &cerr)
 	if cret == 0 {
 		return nil, cerr
 }
-var xSocketListenerAddAddress func(uintptr, uintptr, SocketType, SocketProtocol, uintptr, uintptr, **glib.Error) bool
+var xSocketListenerAddAddress func(uintptr, uintptr, SocketType, SocketProtocol, uintptr, **SocketAddress, **glib.Error) bool
 // Creates a socket of type @type and protocol @protocol, binds
 // it to @address and adds it to the set of sockets we're accepting
 func (x *SocketListener) AddAddress(AddressVar *SocketAddress, TypeVar SocketType, ProtocolVar SocketProtocol, SourceObjectVar *gobject.Object, EffectiveAddressVar **SocketAddress) (bool, error) {
 	var cerr *glib.Error
-	cret := xSocketListenerAddAddress(x.GoPointer(), AddressVar.GoPointer(), TypeVar, ProtocolVar, SourceObjectVar.GoPointer(), *gobject.ConvertPtr(EffectiveAddressVar), &cerr)
+	cret := xSocketListenerAddAddress(x.GoPointer(), AddressVar.GoPointer(), TypeVar, ProtocolVar, SourceObjectVar.GoPointer(), EffectiveAddressVar, &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 	c.Ptr = ptr
 }
+// SetPropertyListenBacklog sets the "listen-backlog" property.
+// The number of outstanding connections in the listen queue.
+func (x *SocketListener) SetPropertyListenBacklog(value int) {
+	var v gobject.Value
+	v.Init(gobject.TypeIntVal)
+	v.SetInt(value)
+	x.SetProperty("listen-backlog", &v)
+}
+// GetPropertyListenBacklog gets the "listen-backlog" property.
+// The number of outstanding connections in the listen queue.
+func (x *SocketListener) GetPropertyListenBacklog() int {
+	var v gobject.Value
+	x.GetProperty("listen-backlog", &v)
+	return v.GetInt()
+}
 // Emitted when @listener's activity on @socket changes state.
 // Note that when @listener is used to listen on both IPv4 and
 // IPv6, a separate set of signals will be emitted for each, and

M v4/gio/gsocketservice.go +31 -14

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideIncoming sets the callback function.
+// OverrideIncoming sets the "incoming" callback function.
 // signal emitted when new connections are accepted
 func (x *SocketServiceClass) OverrideIncoming(cb func(*SocketService, *SocketConnection, *gobject.Object) bool) {
 	if cb == nil {
 	}
 }
-// GetIncoming gets the callback function.
+// GetIncoming gets the "incoming" callback function.
 // signal emitted when new connections are accepted
 func (x *SocketServiceClass) GetIncoming() func(*SocketService, *SocketConnection, *gobject.Object) bool {
 	if x.xIncoming == 0 {
 	}
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *SocketServiceClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *SocketServiceClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *SocketServiceClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *SocketServiceClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *SocketServiceClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *SocketServiceClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *SocketServiceClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *SocketServiceClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *SocketServiceClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *SocketServiceClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved6 sets the callback function.
+// OverrideGReserved6 sets the "_g_reserved6" callback function.
 func (x *SocketServiceClass) OverrideGReserved6(cb func()) {
 	if cb == nil {
 		x.xGReserved6 = 0
 	}
 }
-// GetGReserved6 gets the callback function.
+// GetGReserved6 gets the "_g_reserved6" callback function.
 func (x *SocketServiceClass) GetGReserved6() func() {
 	if x.xGReserved6 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyActive sets the "active" property.
+// Whether the service is currently accepting connections.
+func (x *SocketService) SetPropertyActive(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("active", &v)
+}
+// GetPropertyActive gets the "active" property.
+// Whether the service is currently accepting connections.
+func (x *SocketService) GetPropertyActive() bool {
+	var v gobject.Value
+	x.GetProperty("active", &v)
+	return v.GetBoolean()
+}
 // The ::incoming signal is emitted when a new incoming connection
 // to @service needs to be handled. The handler must initiate the
 // handling of @connection, but may not block; in essence,

M v4/gio/gsubprocess.go +15 -4

 package gio
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/pkg/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 }
-var xSubprocessCommunicateUtf8 func(uintptr, string, uintptr, string, string, **glib.Error) bool
+var xSubprocessCommunicateUtf8 func(uintptr, string, uintptr, *string, *string, **glib.Error) bool
 // Like g_subprocess_communicate(), but validates the output of the
 // process as UTF-8, and returns it as a regular NUL terminated string.
 //
 // On error, @stdout_buf and @stderr_buf will be set to undefined values and
 // should not be used.
-func (x *Subprocess) CommunicateUtf8(StdinBufVar string, CancellableVar *Cancellable, StdoutBufVar string, StderrBufVar string) (bool, error) {
+func (x *Subprocess) CommunicateUtf8(StdinBufVar string, CancellableVar *Cancellable, StdoutBufVar *string, StderrBufVar *string) (bool, error) {
 	var cerr *glib.Error
 	cret := xSubprocessCommunicateUtf8(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), StdoutBufVar, StderrBufVar, &cerr)
 }
-var xSubprocessCommunicateUtf8Finish func(uintptr, uintptr, string, string, **glib.Error) bool
+var xSubprocessCommunicateUtf8Finish func(uintptr, uintptr, *string, *string, **glib.Error) bool
 // Complete an invocation of g_subprocess_communicate_utf8_async().
-func (x *Subprocess) CommunicateUtf8Finish(ResultVar AsyncResult, StdoutBufVar string, StderrBufVar string) (bool, error) {
+func (x *Subprocess) CommunicateUtf8Finish(ResultVar AsyncResult, StdoutBufVar *string, StderrBufVar *string) (bool, error) {
 	var cerr *glib.Error
 	cret := xSubprocessCommunicateUtf8Finish(x.GoPointer(), ResultVar.GoPointer(), StdoutBufVar, StderrBufVar, &cerr)
 	c.Ptr = ptr
 }
+// SetPropertyArgv sets the "argv" property.
+// Argument vector.
+func (x *Subprocess) SetPropertyArgv(value []string) {
+	var v gobject.Value
+	v.Init(glib.StrvGetType())
+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
+	x.SetProperty("argv", &v)
+}
 // Initializes the object implementing the interface.
 //
 // This method is intended for language bindings. If writing in C,

M v4/gio/gtask.go +25 -0


@@ -1212,6 +1212,31 @@ func (c *Task) SetGoPointer(ptr uintptr) {
1212	c.Ptr = ptr	1212		c.Ptr = ptr
1213	}	1213		}
1214		1214
		1215	+	// GetPropertyCompleted gets the "completed" property.
		1216	+	// Whether the task has completed, meaning its callback (if set) has been
		1217	+	// invoked.
		1218	+	//
		1219	+	// This can only happen after g_task_return_pointer(),
		1220	+	// g_task_return_error() or one of the other return functions have been called
		1221	+	// on the task. However, it is not guaranteed to happen immediately after
		1222	+	// those functions are called, as the task’s callback may need to be scheduled
		1223	+	// to run in a different thread.
		1224	+	//
		1225	+	// That means it is not safe to use this property to track whether a
		1226	+	// return function has been called on the #GTask. Callers must do that
		1227	+	// tracking themselves, typically by linking the lifetime of the #GTask to the
		1228	+	// control flow of their code.
		1229	+	//
		1230	+	// This property is guaranteed to change from %FALSE to %TRUE exactly once.
		1231	+	//
		1232	+	// The #GObject::notify signal for this change is emitted in the same main
		1233	+	// context as the task’s callback, immediately after that callback is invoked.
		1234	+	func (x *Task) GetPropertyCompleted() bool {
		1235	+	var v gobject.Value
		1236	+	x.GetProperty("completed", &v)
		1237	+	return v.GetBoolean()
		1238	+	}
		1239	+
1215	// Gets the user data from a [iface@Gio.AsyncResult].	1240		// Gets the user data from a [iface@Gio.AsyncResult].
1216	func (x *Task) GetUserData() uintptr {	1241		func (x *Task) GetUserData() uintptr {
1217		1242

M v4/gio/gtcpconnection.go +18 -0


@@ -7,6 +7,7 @@ import (
7		7
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
		10	+	"github.com/jwijenbergh/puregotk/v4/gobject"
10	"github.com/jwijenbergh/puregotk/v4/gobject/types"	11		"github.com/jwijenbergh/puregotk/v4/gobject/types"
11	)	12		)
12		13

@@ -84,6 +85,23 @@ func (c *TcpConnection) SetGoPointer(ptr uintptr) {
84	c.Ptr = ptr	85		c.Ptr = ptr
85	}	86		}
86		87
		88	+	// SetPropertyGracefulDisconnect sets the "graceful-disconnect" property.
		89	+	// Whether [method@Gio.IOStream.close] does a graceful disconnect.
		90	+	func (x *TcpConnection) SetPropertyGracefulDisconnect(value bool) {
		91	+	var v gobject.Value
		92	+	v.Init(gobject.TypeBooleanVal)
		93	+	v.SetBoolean(value)
		94	+	x.SetProperty("graceful-disconnect", &v)
		95	+	}
		96	+
		97	+	// GetPropertyGracefulDisconnect gets the "graceful-disconnect" property.
		98	+	// Whether [method@Gio.IOStream.close] does a graceful disconnect.
		99	+	func (x *TcpConnection) GetPropertyGracefulDisconnect() bool {
		100	+	var v gobject.Value
		101	+	x.GetProperty("graceful-disconnect", &v)
		102	+	return v.GetBoolean()
		103	+	}
		104	+
87	func init() {	105		func init() {
88	core.SetPackageName("GIO", "gio-2.0")	106		core.SetPackageName("GIO", "gio-2.0")
89	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})	107		core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})

M v4/gio/gthemedicon.go +75 -0


@@ -152,6 +152,81 @@ func (c *ThemedIcon) SetGoPointer(ptr uintptr) {
152	c.Ptr = ptr	152		c.Ptr = ptr
153	}	153		}
154		154
		155	+	// SetPropertyName sets the "name" property.
		156	+	// The icon name.
		157	+	func (x *ThemedIcon) SetPropertyName(value string) {
		158	+	var v gobject.Value
		159	+	v.Init(gobject.TypeStringVal)
		160	+	v.SetString(value)
		161	+	x.SetProperty("name", &v)
		162	+	}
		163	+
		164	+	// SetPropertyNames sets the "names" property.
		165	+	// A %NULL-terminated array of icon names.
		166	+	func (x *ThemedIcon) SetPropertyNames(value []string) {
		167	+	var v gobject.Value
		168	+	v.Init(glib.StrvGetType())
		169	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
		170	+	x.SetProperty("names", &v)
		171	+	}
		172	+
		173	+	// GetPropertyNames gets the "names" property.
		174	+	// A %NULL-terminated array of icon names.
		175	+	func (x *ThemedIcon) GetPropertyNames() []string {
		176	+	var v gobject.Value
		177	+	x.GetProperty("names", &v)
		178	+	return core.GoStringSlice(v.GetBoxed())
		179	+	}
		180	+
		181	+	// SetPropertyUseDefaultFallbacks sets the "use-default-fallbacks" property.
		182	+	// Whether to use the default fallbacks found by shortening the icon name
		183	+	// at '-' characters. If the "names" array has more than one element,
		184	+	// ignores any past the first.
		185	+	//
		186	+	// For example, if the icon name was "gnome-dev-cdrom-audio", the array
		187	+	// would become
		188	+	// \|[<!-- language="C" -->
		189	+	//
		190	+	// {
		191	+	// "gnome-dev-cdrom-audio",
		192	+	// "gnome-dev-cdrom",
		193	+	// "gnome-dev",
		194	+	// "gnome",
		195	+	// NULL
		196	+	// };
		197	+	//
		198	+	// ]\|
		199	+	func (x *ThemedIcon) SetPropertyUseDefaultFallbacks(value bool) {
		200	+	var v gobject.Value
		201	+	v.Init(gobject.TypeBooleanVal)
		202	+	v.SetBoolean(value)
		203	+	x.SetProperty("use-default-fallbacks", &v)
		204	+	}
		205	+
		206	+	// GetPropertyUseDefaultFallbacks gets the "use-default-fallbacks" property.
		207	+	// Whether to use the default fallbacks found by shortening the icon name
		208	+	// at '-' characters. If the "names" array has more than one element,
		209	+	// ignores any past the first.
		210	+	//
		211	+	// For example, if the icon name was "gnome-dev-cdrom-audio", the array
		212	+	// would become
		213	+	// \|[<!-- language="C" -->
		214	+	//
		215	+	// {
		216	+	// "gnome-dev-cdrom-audio",
		217	+	// "gnome-dev-cdrom",
		218	+	// "gnome-dev",
		219	+	// "gnome",
		220	+	// NULL
		221	+	// };
		222	+	//
		223	+	// ]\|
		224	+	func (x *ThemedIcon) GetPropertyUseDefaultFallbacks() bool {
		225	+	var v gobject.Value
		226	+	x.GetProperty("use-default-fallbacks", &v)
		227	+	return v.GetBoolean()
		228	+	}
		229	+
155	// Checks if two icons are equal.	230		// Checks if two icons are equal.
156	func (x *ThemedIcon) Equal(Icon2Var Icon) bool {	231		func (x *ThemedIcon) Equal(Icon2Var Icon) bool {
157		232

M v4/gio/gthreadedsocketservice.go +29 -12

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideRun sets the callback function.
+// OverrideRun sets the "run" callback function.
 func (x *ThreadedSocketServiceClass) OverrideRun(cb func(*ThreadedSocketService, *SocketConnection, *gobject.Object) bool) {
 	if cb == nil {
 		x.xRun = 0
 	}
 }
-// GetRun gets the callback function.
+// GetRun gets the "run" callback function.
 func (x *ThreadedSocketServiceClass) GetRun() func(*ThreadedSocketService, *SocketConnection, *gobject.Object) bool {
 	if x.xRun == 0 {
 		return nil
 	}
 }
-// OverrideGReserved1 sets the callback function.
+// OverrideGReserved1 sets the "_g_reserved1" callback function.
 func (x *ThreadedSocketServiceClass) OverrideGReserved1(cb func()) {
 	if cb == nil {
 		x.xGReserved1 = 0
 	}
 }
-// GetGReserved1 gets the callback function.
+// GetGReserved1 gets the "_g_reserved1" callback function.
 func (x *ThreadedSocketServiceClass) GetGReserved1() func() {
 	if x.xGReserved1 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved2 sets the callback function.
+// OverrideGReserved2 sets the "_g_reserved2" callback function.
 func (x *ThreadedSocketServiceClass) OverrideGReserved2(cb func()) {
 	if cb == nil {
 		x.xGReserved2 = 0
 	}
 }
-// GetGReserved2 gets the callback function.
+// GetGReserved2 gets the "_g_reserved2" callback function.
 func (x *ThreadedSocketServiceClass) GetGReserved2() func() {
 	if x.xGReserved2 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved3 sets the callback function.
+// OverrideGReserved3 sets the "_g_reserved3" callback function.
 func (x *ThreadedSocketServiceClass) OverrideGReserved3(cb func()) {
 	if cb == nil {
 		x.xGReserved3 = 0
 	}
 }
-// GetGReserved3 gets the callback function.
+// GetGReserved3 gets the "_g_reserved3" callback function.
 func (x *ThreadedSocketServiceClass) GetGReserved3() func() {
 	if x.xGReserved3 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved4 sets the callback function.
+// OverrideGReserved4 sets the "_g_reserved4" callback function.
 func (x *ThreadedSocketServiceClass) OverrideGReserved4(cb func()) {
 	if cb == nil {
 		x.xGReserved4 = 0
 	}
 }
-// GetGReserved4 gets the callback function.
+// GetGReserved4 gets the "_g_reserved4" callback function.
 func (x *ThreadedSocketServiceClass) GetGReserved4() func() {
 	if x.xGReserved4 == 0 {
 		return nil
 	}
 }
-// OverrideGReserved5 sets the callback function.
+// OverrideGReserved5 sets the "_g_reserved5" callback function.
 func (x *ThreadedSocketServiceClass) OverrideGReserved5(cb func()) {
 	if cb == nil {
 		x.xGReserved5 = 0
 	}
 }
-// GetGReserved5 gets the callback function.
+// GetGReserved5 gets the "_g_reserved5" callback function.
 func (x *ThreadedSocketServiceClass) GetGReserved5() func() {
 	if x.xGReserved5 == 0 {
 		return nil
 	c.Ptr = ptr
 }
+// SetPropertyMaxThreads sets the "max-threads" property.
+// The maximum number of threads handling clients for this service.
+func (x *ThreadedSocketService) SetPropertyMaxThreads(value int) {
+	var v gobject.Value
+	v.Init(gobject.TypeIntVal)
+	v.SetInt(value)
+	x.SetProperty("max-threads", &v)
+}
+// GetPropertyMaxThreads gets the "max-threads" property.
+// The maximum number of threads handling clients for this service.
+func (x *ThreadedSocketService) GetPropertyMaxThreads() int {
+	var v gobject.Value
+	x.GetProperty("max-threads", &v)
+	return v.GetInt()
+}
 // The ::run signal is emitted in a worker thread in response to an
 // incoming connection. This thread is dedicated to handling
 // @connection and may perform blocking IO. The signal handler need

M v4/gio/gtlsbackend.go +18 -18


@@ -40,7 +40,7 @@ func (x *TlsBackendInterface) GoPointer() uintptr {
40		return uintptr(unsafe.Pointer(x))	40		return uintptr(unsafe.Pointer(x))
41		}	41		}
42			42
43	-	// OverrideSupportsTls sets the callback function.	43	+	// OverrideSupportsTls sets the "supports_tls" callback function.
44		// returns whether the backend supports TLS.	44		// returns whether the backend supports TLS.
45		func (x *TlsBackendInterface) OverrideSupportsTls(cb func(TlsBackend) bool) {	45		func (x *TlsBackendInterface) OverrideSupportsTls(cb func(TlsBackend) bool) {
46		if cb == nil {	46		if cb == nil {

@@ -52,7 +52,7 @@ func (x *TlsBackendInterface) OverrideSupportsTls(cb func(TlsBackend) bool) {
52		}	52		}
53		}	53		}
54			54
55	-	// GetSupportsTls gets the callback function.	55	+	// GetSupportsTls gets the "supports_tls" callback function.
56		// returns whether the backend supports TLS.	56		// returns whether the backend supports TLS.
57		func (x *TlsBackendInterface) GetSupportsTls() func(TlsBackend) bool {	57		func (x *TlsBackendInterface) GetSupportsTls() func(TlsBackend) bool {
58		if x.xSupportsTls == 0 {	58		if x.xSupportsTls == 0 {

@@ -65,7 +65,7 @@ func (x *TlsBackendInterface) GetSupportsTls() func(TlsBackend) bool {
65		}	65		}
66		}	66		}
67			67
68	-	// OverrideGetCertificateType sets the callback function.	68	+	// OverrideGetCertificateType sets the "get_certificate_type" callback function.
69		// returns the #GTlsCertificate implementation type	69		// returns the #GTlsCertificate implementation type
70		func (x *TlsBackendInterface) OverrideGetCertificateType(cb func() types.GType) {	70		func (x *TlsBackendInterface) OverrideGetCertificateType(cb func() types.GType) {
71		if cb == nil {	71		if cb == nil {

@@ -77,7 +77,7 @@ func (x *TlsBackendInterface) OverrideGetCertificateType(cb func() types.GType)
77		}	77		}
78		}	78		}
79			79
80	-	// GetGetCertificateType gets the callback function.	80	+	// GetGetCertificateType gets the "get_certificate_type" callback function.
81		// returns the #GTlsCertificate implementation type	81		// returns the #GTlsCertificate implementation type
82		func (x *TlsBackendInterface) GetGetCertificateType() func() types.GType {	82		func (x *TlsBackendInterface) GetGetCertificateType() func() types.GType {
83		if x.xGetCertificateType == 0 {	83		if x.xGetCertificateType == 0 {

@@ -90,7 +90,7 @@ func (x *TlsBackendInterface) GetGetCertificateType() func() types.GType {
90		}	90		}
91		}	91		}
92			92
93	-	// OverrideGetClientConnectionType sets the callback function.	93	+	// OverrideGetClientConnectionType sets the "get_client_connection_type" callback function.
94		// returns the #GTlsClientConnection implementation type	94		// returns the #GTlsClientConnection implementation type
95		func (x *TlsBackendInterface) OverrideGetClientConnectionType(cb func() types.GType) {	95		func (x *TlsBackendInterface) OverrideGetClientConnectionType(cb func() types.GType) {
96		if cb == nil {	96		if cb == nil {

@@ -102,7 +102,7 @@ func (x *TlsBackendInterface) OverrideGetClientConnectionType(cb func() types.GT
102		}	102		}
103		}	103		}
104			104
105	-	// GetGetClientConnectionType gets the callback function.	105	+	// GetGetClientConnectionType gets the "get_client_connection_type" callback function.
106		// returns the #GTlsClientConnection implementation type	106		// returns the #GTlsClientConnection implementation type
107		func (x *TlsBackendInterface) GetGetClientConnectionType() func() types.GType {	107		func (x *TlsBackendInterface) GetGetClientConnectionType() func() types.GType {
108		if x.xGetClientConnectionType == 0 {	108		if x.xGetClientConnectionType == 0 {

@@ -115,7 +115,7 @@ func (x *TlsBackendInterface) GetGetClientConnectionType() func() types.GType {
115		}	115		}
116		}	116		}
117			117
118	-	// OverrideGetServerConnectionType sets the callback function.	118	+	// OverrideGetServerConnectionType sets the "get_server_connection_type" callback function.
119		// returns the #GTlsServerConnection implementation type	119		// returns the #GTlsServerConnection implementation type
120		func (x *TlsBackendInterface) OverrideGetServerConnectionType(cb func() types.GType) {	120		func (x *TlsBackendInterface) OverrideGetServerConnectionType(cb func() types.GType) {
121		if cb == nil {	121		if cb == nil {

@@ -127,7 +127,7 @@ func (x *TlsBackendInterface) OverrideGetServerConnectionType(cb func() types.GT
127		}	127		}
128		}	128		}
129			129
130	-	// GetGetServerConnectionType gets the callback function.	130	+	// GetGetServerConnectionType gets the "get_server_connection_type" callback function.
131		// returns the #GTlsServerConnection implementation type	131		// returns the #GTlsServerConnection implementation type
132		func (x *TlsBackendInterface) GetGetServerConnectionType() func() types.GType {	132		func (x *TlsBackendInterface) GetGetServerConnectionType() func() types.GType {
133		if x.xGetServerConnectionType == 0 {	133		if x.xGetServerConnectionType == 0 {

@@ -140,7 +140,7 @@ func (x *TlsBackendInterface) GetGetServerConnectionType() func() types.GType {
140		}	140		}
141		}	141		}
142			142
143	-	// OverrideGetFileDatabaseType sets the callback function.	143	+	// OverrideGetFileDatabaseType sets the "get_file_database_type" callback function.
144		// returns the #GTlsFileDatabase implementation type.	144		// returns the #GTlsFileDatabase implementation type.
145		func (x *TlsBackendInterface) OverrideGetFileDatabaseType(cb func() types.GType) {	145		func (x *TlsBackendInterface) OverrideGetFileDatabaseType(cb func() types.GType) {
146		if cb == nil {	146		if cb == nil {

@@ -152,7 +152,7 @@ func (x *TlsBackendInterface) OverrideGetFileDatabaseType(cb func() types.GType)
152		}	152		}
153		}	153		}
154			154
155	-	// GetGetFileDatabaseType gets the callback function.	155	+	// GetGetFileDatabaseType gets the "get_file_database_type" callback function.
156		// returns the #GTlsFileDatabase implementation type.	156		// returns the #GTlsFileDatabase implementation type.
157		func (x *TlsBackendInterface) GetGetFileDatabaseType() func() types.GType {	157		func (x *TlsBackendInterface) GetGetFileDatabaseType() func() types.GType {
158		if x.xGetFileDatabaseType == 0 {	158		if x.xGetFileDatabaseType == 0 {

@@ -165,7 +165,7 @@ func (x *TlsBackendInterface) GetGetFileDatabaseType() func() types.GType {
165		}	165		}
166		}	166		}
167			167
168	-	// OverrideGetDefaultDatabase sets the callback function.	168	+	// OverrideGetDefaultDatabase sets the "get_default_database" callback function.
169		// returns a default #GTlsDatabase instance.	169		// returns a default #GTlsDatabase instance.
170		func (x TlsBackendInterface) OverrideGetDefaultDatabase(cb func(TlsBackend) TlsDatabase) {	170		func (x TlsBackendInterface) OverrideGetDefaultDatabase(cb func(TlsBackend) TlsDatabase) {
171		if cb == nil {	171		if cb == nil {

@@ -181,7 +181,7 @@ func (x TlsBackendInterface) OverrideGetDefaultDatabase(cb func(TlsBackend) Tl
181		}	181		}
182		}	182		}
183			183
184	-	// GetGetDefaultDatabase gets the callback function.	184	+	// GetGetDefaultDatabase gets the "get_default_database" callback function.
185		// returns a default #GTlsDatabase instance.	185		// returns a default #GTlsDatabase instance.
186		func (x TlsBackendInterface) GetGetDefaultDatabase() func(TlsBackend) TlsDatabase {	186		func (x TlsBackendInterface) GetGetDefaultDatabase() func(TlsBackend) TlsDatabase {
187		if x.xGetDefaultDatabase == 0 {	187		if x.xGetDefaultDatabase == 0 {

@@ -200,7 +200,7 @@ func (x TlsBackendInterface) GetGetDefaultDatabase() func(TlsBackend) TlsDatab
200		}	200		}
201		}	201		}
202			202
203	-	// OverrideSupportsDtls sets the callback function.	203	+	// OverrideSupportsDtls sets the "supports_dtls" callback function.
204		// returns whether the backend supports DTLS	204		// returns whether the backend supports DTLS
205		func (x *TlsBackendInterface) OverrideSupportsDtls(cb func(TlsBackend) bool) {	205		func (x *TlsBackendInterface) OverrideSupportsDtls(cb func(TlsBackend) bool) {
206		if cb == nil {	206		if cb == nil {

@@ -212,7 +212,7 @@ func (x *TlsBackendInterface) OverrideSupportsDtls(cb func(TlsBackend) bool) {
212		}	212		}
213		}	213		}
214			214
215	-	// GetSupportsDtls gets the callback function.	215	+	// GetSupportsDtls gets the "supports_dtls" callback function.
216		// returns whether the backend supports DTLS	216		// returns whether the backend supports DTLS
217		func (x *TlsBackendInterface) GetSupportsDtls() func(TlsBackend) bool {	217		func (x *TlsBackendInterface) GetSupportsDtls() func(TlsBackend) bool {
218		if x.xSupportsDtls == 0 {	218		if x.xSupportsDtls == 0 {

@@ -225,7 +225,7 @@ func (x *TlsBackendInterface) GetSupportsDtls() func(TlsBackend) bool {
225		}	225		}
226		}	226		}
227			227
228	-	// OverrideGetDtlsClientConnectionType sets the callback function.	228	+	// OverrideGetDtlsClientConnectionType sets the "get_dtls_client_connection_type" callback function.
229		// returns the #GDtlsClientConnection implementation type	229		// returns the #GDtlsClientConnection implementation type
230		func (x *TlsBackendInterface) OverrideGetDtlsClientConnectionType(cb func() types.GType) {	230		func (x *TlsBackendInterface) OverrideGetDtlsClientConnectionType(cb func() types.GType) {
231		if cb == nil {	231		if cb == nil {

@@ -237,7 +237,7 @@ func (x *TlsBackendInterface) OverrideGetDtlsClientConnectionType(cb func() type
237		}	237		}
238		}	238		}
239			239
240	-	// GetGetDtlsClientConnectionType gets the callback function.	240	+	// GetGetDtlsClientConnectionType gets the "get_dtls_client_connection_type" callback function.
241		// returns the #GDtlsClientConnection implementation type	241		// returns the #GDtlsClientConnection implementation type
242		func (x *TlsBackendInterface) GetGetDtlsClientConnectionType() func() types.GType {	242		func (x *TlsBackendInterface) GetGetDtlsClientConnectionType() func() types.GType {
243		if x.xGetDtlsClientConnectionType == 0 {	243		if x.xGetDtlsClientConnectionType == 0 {

@@ -250,7 +250,7 @@ func (x *TlsBackendInterface) GetGetDtlsClientConnectionType() func() types.GTyp
250		}	250		}
251		}	251		}
252			252
253	-	// OverrideGetDtlsServerConnectionType sets the callback function.	253	+	// OverrideGetDtlsServerConnectionType sets the "get_dtls_server_connection_type" callback function.
254		// returns the #GDtlsServerConnection implementation type	254		// returns the #GDtlsServerConnection implementation type
255		func (x *TlsBackendInterface) OverrideGetDtlsServerConnectionType(cb func() types.GType) {	255		func (x *TlsBackendInterface) OverrideGetDtlsServerConnectionType(cb func() types.GType) {
256		if cb == nil {	256		if cb == nil {

@@ -262,7 +262,7 @@ func (x *TlsBackendInterface) OverrideGetDtlsServerConnectionType(cb func() type
262		}	262		}
263		}	263		}
264			264
265	-	// GetGetDtlsServerConnectionType gets the callback function.	265	+	// GetGetDtlsServerConnectionType gets the "get_dtls_server_connection_type" callback function.
266		// returns the #GDtlsServerConnection implementation type	266		// returns the #GDtlsServerConnection implementation type
267		func (x *TlsBackendInterface) GetGetDtlsServerConnectionType() func() types.GType {	267		func (x *TlsBackendInterface) GetGetDtlsServerConnectionType() func() types.GType {
268		if x.xGetDtlsServerConnectionType == 0 {	268		if x.xGetDtlsServerConnectionType == 0 {

M v4/gio/gtlscertificate.go +278 -2


@@ -26,7 +26,7 @@ func (x *TlsCertificateClass) GoPointer() uintptr {
26		return uintptr(unsafe.Pointer(x))	26		return uintptr(unsafe.Pointer(x))
27		}	27		}
28			28
29	-	// OverrideVerify sets the callback function.	29	+	// OverrideVerify sets the "verify" callback function.
30		func (x TlsCertificateClass) OverrideVerify(cb func(TlsCertificate, SocketConnectable, *TlsCertificate) TlsCertificateFlags) {	30		func (x TlsCertificateClass) OverrideVerify(cb func(TlsCertificate, SocketConnectable, *TlsCertificate) TlsCertificateFlags) {
31		if cb == nil {	31		if cb == nil {
32		x.xVerify = 0	32		x.xVerify = 0

@@ -37,7 +37,7 @@ func (x TlsCertificateClass) OverrideVerify(cb func(TlsCertificate, SocketConn
37		}	37		}
38		}	38		}
39			39
40	-	// GetVerify gets the callback function.	40	+	// GetVerify gets the "verify" callback function.
41		func (x TlsCertificateClass) GetVerify() func(TlsCertificate, SocketConnectable, *TlsCertificate) TlsCertificateFlags {	41		func (x TlsCertificateClass) GetVerify() func(TlsCertificate, SocketConnectable, *TlsCertificate) TlsCertificateFlags {
42		if x.xVerify == 0 {	42		if x.xVerify == 0 {
43		return nil	43		return nil

@@ -423,6 +423,282 @@ func (c *TlsCertificate) SetGoPointer(ptr uintptr) {
423		c.Ptr = ptr	423		c.Ptr = ptr
424		}	424		}
425			425
			426	+	// SetPropertyCertificate sets the "certificate" property.
			427	+	// The DER (binary) encoded representation of the certificate.
			428	+	// This property and the #GTlsCertificate:certificate-pem property
			429	+	// represent the same data, just in different forms.
			430	+	func (x *TlsCertificate) SetPropertyCertificate(value []byte) {
			431	+	var v gobject.Value
			432	+	v.Init(glib.ByteArrayGLibType())
			433	+	v.SetBoxed(uintptr(unsafe.Pointer(&value[0])))
			434	+	x.SetProperty("certificate", &v)
			435	+	}
			436	+
			437	+	// GetPropertyCertificate gets the "certificate" property.
			438	+	// The DER (binary) encoded representation of the certificate.
			439	+	// This property and the #GTlsCertificate:certificate-pem property
			440	+	// represent the same data, just in different forms.
			441	+	func (x *TlsCertificate) GetPropertyCertificate() []byte {
			442	+	var v gobject.Value
			443	+	x.GetProperty("certificate", &v)
			444	+	ptr := v.GetBoxed()
			445	+	if ptr == 0 {
			446	+	return nil
			447	+	}
			448	+	return unsafe.Slice((*byte)(unsafe.Pointer(ptr)), 0)[:0]
			449	+	}
			450	+
			451	+	// SetPropertyCertificatePem sets the "certificate-pem" property.
			452	+	// The PEM (ASCII) encoded representation of the certificate.
			453	+	// This property and the #GTlsCertificate:certificate
			454	+	// property represent the same data, just in different forms.
			455	+	func (x *TlsCertificate) SetPropertyCertificatePem(value string) {
			456	+	var v gobject.Value
			457	+	v.Init(gobject.TypeStringVal)
			458	+	v.SetString(value)
			459	+	x.SetProperty("certificate-pem", &v)
			460	+	}
			461	+
			462	+	// GetPropertyCertificatePem gets the "certificate-pem" property.
			463	+	// The PEM (ASCII) encoded representation of the certificate.
			464	+	// This property and the #GTlsCertificate:certificate
			465	+	// property represent the same data, just in different forms.
			466	+	func (x *TlsCertificate) GetPropertyCertificatePem() string {
			467	+	var v gobject.Value
			468	+	x.GetProperty("certificate-pem", &v)
			469	+	return v.GetString()
			470	+	}
			471	+
			472	+	// GetPropertyDnsNames gets the "dns-names" property.
			473	+	// The DNS names from the certificate's Subject Alternative Names (SANs),
			474	+	// %NULL if unavailable.
			475	+	func (x *TlsCertificate) GetPropertyDnsNames() []uintptr {
			476	+	var v gobject.Value
			477	+	x.GetProperty("dns-names", &v)
			478	+	ptr := v.GetBoxed()
			479	+	if ptr == 0 {
			480	+	return nil
			481	+	}
			482	+	return unsafe.Slice((*uintptr)(unsafe.Pointer(ptr)), 0)[:0]
			483	+	}
			484	+
			485	+	// GetPropertyIpAddresses gets the "ip-addresses" property.
			486	+	// The IP addresses from the certificate's Subject Alternative Names (SANs),
			487	+	// %NULL if unavailable.
			488	+	func (x *TlsCertificate) GetPropertyIpAddresses() []uintptr {
			489	+	var v gobject.Value
			490	+	x.GetProperty("ip-addresses", &v)
			491	+	ptr := v.GetBoxed()
			492	+	if ptr == 0 {
			493	+	return nil
			494	+	}
			495	+	return unsafe.Slice((*uintptr)(unsafe.Pointer(ptr)), 0)[:0]
			496	+	}
			497	+
			498	+	// GetPropertyIssuerName gets the "issuer-name" property.
			499	+	// The issuer from the certificate,
			500	+	// %NULL if unavailable.
			501	+	func (x *TlsCertificate) GetPropertyIssuerName() string {
			502	+	var v gobject.Value
			503	+	x.GetProperty("issuer-name", &v)
			504	+	return v.GetString()
			505	+	}
			506	+
			507	+	// GetPropertyNotValidAfter gets the "not-valid-after" property.
			508	+	// The time at which this cert is no longer valid,
			509	+	// %NULL if unavailable.
			510	+	func (x *TlsCertificate) GetPropertyNotValidAfter() uintptr {
			511	+	var v gobject.Value
			512	+	x.GetProperty("not-valid-after", &v)
			513	+	return v.GetPointer()
			514	+	}
			515	+
			516	+	// GetPropertyNotValidBefore gets the "not-valid-before" property.
			517	+	// The time at which this cert is considered to be valid,
			518	+	// %NULL if unavailable.
			519	+	func (x *TlsCertificate) GetPropertyNotValidBefore() uintptr {
			520	+	var v gobject.Value
			521	+	x.GetProperty("not-valid-before", &v)
			522	+	return v.GetPointer()
			523	+	}
			524	+
			525	+	// SetPropertyPassword sets the "password" property.
			526	+	// An optional password used when constructed with GTlsCertificate:pkcs12-data.
			527	+	func (x *TlsCertificate) SetPropertyPassword(value string) {
			528	+	var v gobject.Value
			529	+	v.Init(gobject.TypeStringVal)
			530	+	v.SetString(value)
			531	+	x.SetProperty("password", &v)
			532	+	}
			533	+
			534	+	// SetPropertyPkcs11Uri sets the "pkcs11-uri" property.
			535	+	// A URI referencing the [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
			536	+	// objects containing an X.509 certificate and optionally a private key.
			537	+	//
			538	+	// If %NULL, the certificate is either not backed by PKCS \#11 or the
			539	+	// #GTlsBackend does not support PKCS \#11.
			540	+	func (x *TlsCertificate) SetPropertyPkcs11Uri(value string) {
			541	+	var v gobject.Value
			542	+	v.Init(gobject.TypeStringVal)
			543	+	v.SetString(value)
			544	+	x.SetProperty("pkcs11-uri", &v)
			545	+	}
			546	+
			547	+	// GetPropertyPkcs11Uri gets the "pkcs11-uri" property.
			548	+	// A URI referencing the [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
			549	+	// objects containing an X.509 certificate and optionally a private key.
			550	+	//
			551	+	// If %NULL, the certificate is either not backed by PKCS \#11 or the
			552	+	// #GTlsBackend does not support PKCS \#11.
			553	+	func (x *TlsCertificate) GetPropertyPkcs11Uri() string {
			554	+	var v gobject.Value
			555	+	x.GetProperty("pkcs11-uri", &v)
			556	+	return v.GetString()
			557	+	}
			558	+
			559	+	// SetPropertyPkcs12Data sets the "pkcs12-data" property.
			560	+	// The PKCS #12 formatted data used to construct the object.
			561	+	//
			562	+	// See also: g_tls_certificate_new_from_pkcs12()
			563	+	func (x *TlsCertificate) SetPropertyPkcs12Data(value []byte) {
			564	+	var v gobject.Value
			565	+	v.Init(glib.ByteArrayGLibType())
			566	+	v.SetBoxed(uintptr(unsafe.Pointer(&value[0])))
			567	+	x.SetProperty("pkcs12-data", &v)
			568	+	}
			569	+
			570	+	// SetPropertyPrivateKey sets the "private-key" property.
			571	+	// The DER (binary) encoded representation of the certificate's
			572	+	// private key, in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
			573	+	// or unencrypted [PKCS \#8 format.](https://datatracker.ietf.org/doc/html/rfc5208)
			574	+	// PKCS \#8 format is supported since 2.32; earlier releases only
			575	+	// support PKCS \#1. You can use the `openssl rsa` tool to convert
			576	+	// PKCS \#8 keys to PKCS \#1.
			577	+	//
			578	+	// This property (or the #GTlsCertificate:private-key-pem property)
			579	+	// can be set when constructing a key (for example, from a file).
			580	+	// Since GLib 2.70, it is now also readable; however, be aware that if
			581	+	// the private key is backed by a PKCS \#11 URI – for example, if it
			582	+	// is stored on a smartcard – then this property will be %NULL. If so,
			583	+	// the private key must be referenced via its PKCS \#11 URI,
			584	+	// #GTlsCertificate:private-key-pkcs11-uri. You must check both
			585	+	// properties to see if the certificate really has a private key.
			586	+	// When this property is read, the output format will be unencrypted
			587	+	// PKCS \#8.
			588	+	func (x *TlsCertificate) SetPropertyPrivateKey(value []byte) {
			589	+	var v gobject.Value
			590	+	v.Init(glib.ByteArrayGLibType())
			591	+	v.SetBoxed(uintptr(unsafe.Pointer(&value[0])))
			592	+	x.SetProperty("private-key", &v)
			593	+	}
			594	+
			595	+	// GetPropertyPrivateKey gets the "private-key" property.
			596	+	// The DER (binary) encoded representation of the certificate's
			597	+	// private key, in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
			598	+	// or unencrypted [PKCS \#8 format.](https://datatracker.ietf.org/doc/html/rfc5208)
			599	+	// PKCS \#8 format is supported since 2.32; earlier releases only
			600	+	// support PKCS \#1. You can use the `openssl rsa` tool to convert
			601	+	// PKCS \#8 keys to PKCS \#1.
			602	+	//
			603	+	// This property (or the #GTlsCertificate:private-key-pem property)
			604	+	// can be set when constructing a key (for example, from a file).
			605	+	// Since GLib 2.70, it is now also readable; however, be aware that if
			606	+	// the private key is backed by a PKCS \#11 URI – for example, if it
			607	+	// is stored on a smartcard – then this property will be %NULL. If so,
			608	+	// the private key must be referenced via its PKCS \#11 URI,
			609	+	// #GTlsCertificate:private-key-pkcs11-uri. You must check both
			610	+	// properties to see if the certificate really has a private key.
			611	+	// When this property is read, the output format will be unencrypted
			612	+	// PKCS \#8.
			613	+	func (x *TlsCertificate) GetPropertyPrivateKey() []byte {
			614	+	var v gobject.Value
			615	+	x.GetProperty("private-key", &v)
			616	+	ptr := v.GetBoxed()
			617	+	if ptr == 0 {
			618	+	return nil
			619	+	}
			620	+	return unsafe.Slice((*byte)(unsafe.Pointer(ptr)), 0)[:0]
			621	+	}
			622	+
			623	+	// SetPropertyPrivateKeyPem sets the "private-key-pem" property.
			624	+	// The PEM (ASCII) encoded representation of the certificate's
			625	+	// private key in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
			626	+	// ("`BEGIN RSA PRIVATE KEY`") or unencrypted
			627	+	// [PKCS \#8 format](https://datatracker.ietf.org/doc/html/rfc5208)
			628	+	// ("`BEGIN PRIVATE KEY`"). PKCS \#8 format is supported since 2.32;
			629	+	// earlier releases only support PKCS \#1. You can use the `openssl rsa`
			630	+	// tool to convert PKCS \#8 keys to PKCS \#1.
			631	+	//
			632	+	// This property (or the #GTlsCertificate:private-key property)
			633	+	// can be set when constructing a key (for example, from a file).
			634	+	// Since GLib 2.70, it is now also readable; however, be aware that if
			635	+	// the private key is backed by a PKCS \#11 URI - for example, if it
			636	+	// is stored on a smartcard - then this property will be %NULL. If so,
			637	+	// the private key must be referenced via its PKCS \#11 URI,
			638	+	// #GTlsCertificate:private-key-pkcs11-uri. You must check both
			639	+	// properties to see if the certificate really has a private key.
			640	+	// When this property is read, the output format will be unencrypted
			641	+	// PKCS \#8.
			642	+	func (x *TlsCertificate) SetPropertyPrivateKeyPem(value string) {
			643	+	var v gobject.Value
			644	+	v.Init(gobject.TypeStringVal)
			645	+	v.SetString(value)
			646	+	x.SetProperty("private-key-pem", &v)
			647	+	}
			648	+
			649	+	// GetPropertyPrivateKeyPem gets the "private-key-pem" property.
			650	+	// The PEM (ASCII) encoded representation of the certificate's
			651	+	// private key in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
			652	+	// ("`BEGIN RSA PRIVATE KEY`") or unencrypted
			653	+	// [PKCS \#8 format](https://datatracker.ietf.org/doc/html/rfc5208)
			654	+	// ("`BEGIN PRIVATE KEY`"). PKCS \#8 format is supported since 2.32;
			655	+	// earlier releases only support PKCS \#1. You can use the `openssl rsa`
			656	+	// tool to convert PKCS \#8 keys to PKCS \#1.
			657	+	//
			658	+	// This property (or the #GTlsCertificate:private-key property)
			659	+	// can be set when constructing a key (for example, from a file).
			660	+	// Since GLib 2.70, it is now also readable; however, be aware that if
			661	+	// the private key is backed by a PKCS \#11 URI - for example, if it
			662	+	// is stored on a smartcard - then this property will be %NULL. If so,
			663	+	// the private key must be referenced via its PKCS \#11 URI,
			664	+	// #GTlsCertificate:private-key-pkcs11-uri. You must check both
			665	+	// properties to see if the certificate really has a private key.
			666	+	// When this property is read, the output format will be unencrypted
			667	+	// PKCS \#8.
			668	+	func (x *TlsCertificate) GetPropertyPrivateKeyPem() string {
			669	+	var v gobject.Value
			670	+	x.GetProperty("private-key-pem", &v)
			671	+	return v.GetString()
			672	+	}
			673	+
			674	+	// SetPropertyPrivateKeyPkcs11Uri sets the "private-key-pkcs11-uri" property.
			675	+	// A URI referencing a [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
			676	+	// object containing a private key.
			677	+	func (x *TlsCertificate) SetPropertyPrivateKeyPkcs11Uri(value string) {
			678	+	var v gobject.Value
			679	+	v.Init(gobject.TypeStringVal)
			680	+	v.SetString(value)
			681	+	x.SetProperty("private-key-pkcs11-uri", &v)
			682	+	}
			683	+
			684	+	// GetPropertyPrivateKeyPkcs11Uri gets the "private-key-pkcs11-uri" property.
			685	+	// A URI referencing a [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
			686	+	// object containing a private key.
			687	+	func (x *TlsCertificate) GetPropertyPrivateKeyPkcs11Uri() string {
			688	+	var v gobject.Value
			689	+	x.GetProperty("private-key-pkcs11-uri", &v)
			690	+	return v.GetString()
			691	+	}
			692	+
			693	+	// GetPropertySubjectName gets the "subject-name" property.
			694	+	// The subject from the cert,
			695	+	// %NULL if unavailable.
			696	+	func (x *TlsCertificate) GetPropertySubjectName() string {
			697	+	var v gobject.Value
			698	+	x.GetProperty("subject-name", &v)
			699	+	return v.GetString()
			700	+	}
			701	+
426		var xTlsCertificateListNewFromFile func(string, *glib.Error) glib.List	702		var xTlsCertificateListNewFromFile func(string, *glib.Error) glib.List
427			703
428		// Creates one or more #GTlsCertificates from the PEM-encoded	704		// Creates one or more #GTlsCertificates from the PEM-encoded

M v4/gio/gtlsclientconnection.go +25 -2


@@ -25,7 +25,7 @@ func (x *TlsClientConnectionInterface) GoPointer() uintptr {
25		return uintptr(unsafe.Pointer(x))	25		return uintptr(unsafe.Pointer(x))
26		}	26		}
27			27
28	-	// OverrideCopySessionState sets the callback function.	28	+	// OverrideCopySessionState sets the "copy_session_state" callback function.
29		// Copies session state from one #GTlsClientConnection to another.	29		// Copies session state from one #GTlsClientConnection to another.
30		func (x *TlsClientConnectionInterface) OverrideCopySessionState(cb func(TlsClientConnection, TlsClientConnection)) {	30		func (x *TlsClientConnectionInterface) OverrideCopySessionState(cb func(TlsClientConnection, TlsClientConnection)) {
31		if cb == nil {	31		if cb == nil {

@@ -37,7 +37,7 @@ func (x *TlsClientConnectionInterface) OverrideCopySessionState(cb func(TlsClien
37		}	37		}
38		}	38		}
39			39
40	-	// GetCopySessionState gets the callback function.	40	+	// GetCopySessionState gets the "copy_session_state" callback function.
41		// Copies session state from one #GTlsClientConnection to another.	41		// Copies session state from one #GTlsClientConnection to another.
42		func (x *TlsClientConnectionInterface) GetCopySessionState() func(TlsClientConnection, TlsClientConnection) {	42		func (x *TlsClientConnectionInterface) GetCopySessionState() func(TlsClientConnection, TlsClientConnection) {
43		if x.xCopySessionState == 0 {	43		if x.xCopySessionState == 0 {

@@ -206,6 +206,29 @@ func (x *TlsClientConnectionBase) SetValidationFlags(FlagsVar TlsCertificateFlag
206			206
207		}	207		}
208			208
			209	+	// SetPropertyUseSsl3 sets the "use-ssl3" property.
			210	+	// SSL 3.0 is no longer supported. See
			211	+	// g_tls_client_connection_set_use_ssl3() for details.
			212	+	func (x *TlsClientConnectionBase) SetPropertyUseSsl3(value bool) {
			213	+	obj := gobject.Object{}
			214	+	obj.Ptr = x.GoPointer()
			215	+	var v gobject.Value
			216	+	v.Init(gobject.TypeBooleanVal)
			217	+	v.SetBoolean(value)
			218	+	obj.SetProperty("use-ssl3", &v)
			219	+	}
			220	+
			221	+	// GetPropertyUseSsl3 gets the "use-ssl3" property.
			222	+	// SSL 3.0 is no longer supported. See
			223	+	// g_tls_client_connection_set_use_ssl3() for details.
			224	+	func (x *TlsClientConnectionBase) GetPropertyUseSsl3() bool {
			225	+	obj := gobject.Object{}
			226	+	obj.Ptr = x.GoPointer()
			227	+	var v gobject.Value
			228	+	obj.GetProperty("use-ssl3", &v)
			229	+	return v.GetBoolean()
			230	+	}
			231	+
209		var XGTlsClientConnectionCopySessionState func(uintptr, uintptr)	232		var XGTlsClientConnectionCopySessionState func(uintptr, uintptr)
210		var XGTlsClientConnectionGetAcceptedCas func(uintptr) *glib.List	233		var XGTlsClientConnectionGetAcceptedCas func(uintptr) *glib.List
211		var XGTlsClientConnectionGetServerIdentity func(uintptr) uintptr	234		var XGTlsClientConnectionGetServerIdentity func(uintptr) uintptr

M v4/gio/gtlsconnection.go +92 -14

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideAcceptCertificate sets the callback function.
+// OverrideAcceptCertificate sets the "accept_certificate" callback function.
 // Check whether to accept a certificate.
 func (x *TlsConnectionClass) OverrideAcceptCertificate(cb func(*TlsConnection, *TlsCertificate, TlsCertificateFlags) bool) {
 	if cb == nil {
 	}
 }
-// GetAcceptCertificate gets the callback function.
+// GetAcceptCertificate gets the "accept_certificate" callback function.
 // Check whether to accept a certificate.
 func (x *TlsConnectionClass) GetAcceptCertificate() func(*TlsConnection, *TlsCertificate, TlsCertificateFlags) bool {
 	if x.xAcceptCertificate == 0 {
 	}
 }
-// OverrideHandshake sets the callback function.
+// OverrideHandshake sets the "handshake" callback function.
 // Perform a handshake operation.
 func (x *TlsConnectionClass) OverrideHandshake(cb func(*TlsConnection, *Cancellable) bool) {
 	if cb == nil {
 	}
 }
-// GetHandshake gets the callback function.
+// GetHandshake gets the "handshake" callback function.
 // Perform a handshake operation.
 func (x *TlsConnectionClass) GetHandshake() func(*TlsConnection, *Cancellable) bool {
 	if x.xHandshake == 0 {
 	}
 }
-// OverrideHandshakeAsync sets the callback function.
+// OverrideHandshakeAsync sets the "handshake_async" callback function.
 // Start an asynchronous handshake operation.
 func (x *TlsConnectionClass) OverrideHandshakeAsync(cb func(*TlsConnection, int, *Cancellable, *AsyncReadyCallback, uintptr)) {
 	if cb == nil {
 	}
 }
-// GetHandshakeAsync gets the callback function.
+// GetHandshakeAsync gets the "handshake_async" callback function.
 // Start an asynchronous handshake operation.
 func (x *TlsConnectionClass) GetHandshakeAsync() func(*TlsConnection, int, *Cancellable, *AsyncReadyCallback, uintptr) {
 	if x.xHandshakeAsync == 0 {
 	}
 }
-// OverrideHandshakeFinish sets the callback function.
+// OverrideHandshakeFinish sets the "handshake_finish" callback function.
 // Finish an asynchronous handshake operation.
 func (x *TlsConnectionClass) OverrideHandshakeFinish(cb func(*TlsConnection, AsyncResult) bool) {
 	if cb == nil {
 	}
 }
-// GetHandshakeFinish gets the callback function.
+// GetHandshakeFinish gets the "handshake_finish" callback function.
 // Finish an asynchronous handshake operation.
 func (x *TlsConnectionClass) GetHandshakeFinish() func(*TlsConnection, AsyncResult) bool {
 	if x.xHandshakeFinish == 0 {
 	}
 }
-// OverrideGetBindingData sets the callback function.
+// OverrideGetBindingData sets the "get_binding_data" callback function.
 // Retrieve TLS channel binding data (Since: 2.66)
 func (x *TlsConnectionClass) OverrideGetBindingData(cb func(*TlsConnection, TlsChannelBindingType, []byte) bool) {
 	if cb == nil {
 	}
 }
-// GetGetBindingData gets the callback function.
+// GetGetBindingData gets the "get_binding_data" callback function.
 // Retrieve TLS channel binding data (Since: 2.66)
 func (x *TlsConnectionClass) GetGetBindingData() func(*TlsConnection, TlsChannelBindingType, []byte) bool {
 	if x.xGetBindingData == 0 {
 	}
 }
-// OverrideGetNegotiatedProtocol sets the callback function.
+// OverrideGetNegotiatedProtocol sets the "get_negotiated_protocol" callback function.
 // Get ALPN-negotiated protocol (Since: 2.70)
 func (x *TlsConnectionClass) OverrideGetNegotiatedProtocol(cb func(*TlsConnection) string) {
 	if cb == nil {
 	}
 }
-// GetGetNegotiatedProtocol gets the callback function.
+// GetGetNegotiatedProtocol gets the "get_negotiated_protocol" callback function.
 // Get ALPN-negotiated protocol (Since: 2.70)
 func (x *TlsConnectionClass) GetGetNegotiatedProtocol() func(*TlsConnection) string {
 	if x.xGetNegotiatedProtocol == 0 {
 	return cls
 }
-var xTlsConnectionGetChannelBindingData func(uintptr, TlsChannelBindingType, []byte, **glib.Error) bool
+var xTlsConnectionGetChannelBindingData func(uintptr, TlsChannelBindingType, *[]byte, **glib.Error) bool
 // Query the TLS backend for TLS channel binding data of @type for @conn.
 //
 // will be available though.  That could happen if TLS connection does not
 // support @type or the binding data is not available yet due to additional
 // negotiation or input required.
-func (x *TlsConnection) GetChannelBindingData(TypeVar TlsChannelBindingType, DataVar []byte) (bool, error) {
+func (x *TlsConnection) GetChannelBindingData(TypeVar TlsChannelBindingType, DataVar *[]byte) (bool, error) {
 	var cerr *glib.Error
 	cret := xTlsConnectionGetChannelBindingData(x.GoPointer(), TypeVar, DataVar, &cerr)
 	c.Ptr = ptr
 }
+// SetPropertyAdvertisedProtocols sets the "advertised-protocols" property.
+// The list of application-layer protocols that the connection
+// advertises that it is willing to speak. See
+// g_tls_connection_set_advertised_protocols().
+func (x *TlsConnection) SetPropertyAdvertisedProtocols(value []string) {
+	var v gobject.Value
+	v.Init(glib.StrvGetType())
+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
+	x.SetProperty("advertised-protocols", &v)
+}
+// GetPropertyAdvertisedProtocols gets the "advertised-protocols" property.
+// The list of application-layer protocols that the connection
+// advertises that it is willing to speak. See
+// g_tls_connection_set_advertised_protocols().
+func (x *TlsConnection) GetPropertyAdvertisedProtocols() []string {
+	var v gobject.Value
+	x.GetProperty("advertised-protocols", &v)
+	return core.GoStringSlice(v.GetBoxed())
+}
+// GetPropertyCiphersuiteName gets the "ciphersuite-name" property.
+// The name of the TLS ciphersuite in use. See g_tls_connection_get_ciphersuite_name().
+func (x *TlsConnection) GetPropertyCiphersuiteName() string {
+	var v gobject.Value
+	x.GetProperty("ciphersuite-name", &v)
+	return v.GetString()
+}
+// GetPropertyNegotiatedProtocol gets the "negotiated-protocol" property.
+// The application-layer protocol negotiated during the TLS
+// handshake. See g_tls_connection_get_negotiated_protocol().
+func (x *TlsConnection) GetPropertyNegotiatedProtocol() string {
+	var v gobject.Value
+	x.GetProperty("negotiated-protocol", &v)
+	return v.GetString()
+}
+// SetPropertyRequireCloseNotify sets the "require-close-notify" property.
+// Whether or not proper TLS close notification is required.
+// See g_tls_connection_set_require_close_notify().
+func (x *TlsConnection) SetPropertyRequireCloseNotify(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("require-close-notify", &v)
+}
+// GetPropertyRequireCloseNotify gets the "require-close-notify" property.
+// Whether or not proper TLS close notification is required.
+// See g_tls_connection_set_require_close_notify().
+func (x *TlsConnection) GetPropertyRequireCloseNotify() bool {
+	var v gobject.Value
+	x.GetProperty("require-close-notify", &v)
+	return v.GetBoolean()
+}
+// SetPropertyUseSystemCertdb sets the "use-system-certdb" property.
+// Whether or not the system certificate database will be used to
+// verify peer certificates. See
+// g_tls_connection_set_use_system_certdb().
+func (x *TlsConnection) SetPropertyUseSystemCertdb(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("use-system-certdb", &v)
+}
+// GetPropertyUseSystemCertdb gets the "use-system-certdb" property.
+// Whether or not the system certificate database will be used to
+// verify peer certificates. See
+// g_tls_connection_set_use_system_certdb().
+func (x *TlsConnection) GetPropertyUseSystemCertdb() bool {
+	var v gobject.Value
+	x.GetProperty("use-system-certdb", &v)
+	return v.GetBoolean()
+}
 // Emitted during the TLS handshake after the peer certificate has
 // been received. You can examine @peer_cert's certification path by
 // calling g_tls_certificate_get_issuer() on it.

M v4/gio/gtlsdatabase.go +26 -26


@@ -53,7 +53,7 @@ func (x *TlsDatabaseClass) GoPointer() uintptr {
53		return uintptr(unsafe.Pointer(x))	53		return uintptr(unsafe.Pointer(x))
54		}	54		}
55			55
56	-	// OverrideVerifyChain sets the callback function.	56	+	// OverrideVerifyChain sets the "verify_chain" callback function.
57		// Virtual method implementing	57		// Virtual method implementing
58		//	58		//
59		// g_tls_database_verify_chain().	59		// g_tls_database_verify_chain().

@@ -67,7 +67,7 @@ func (x TlsDatabaseClass) OverrideVerifyChain(cb func(TlsDatabase, *TlsCertifi
67		}	67		}
68		}	68		}
69			69
70	-	// GetVerifyChain gets the callback function.	70	+	// GetVerifyChain gets the "verify_chain" callback function.
71		// Virtual method implementing	71		// Virtual method implementing
72		//	72		//
73		// g_tls_database_verify_chain().	73		// g_tls_database_verify_chain().

@@ -82,7 +82,7 @@ func (x TlsDatabaseClass) GetVerifyChain() func(TlsDatabase, *TlsCertificate,
82		}	82		}
83		}	83		}
84			84
85	-	// OverrideVerifyChainAsync sets the callback function.	85	+	// OverrideVerifyChainAsync sets the "verify_chain_async" callback function.
86		// Virtual method implementing	86		// Virtual method implementing
87		//	87		//
88		// g_tls_database_verify_chain_async().	88		// g_tls_database_verify_chain_async().

@@ -96,7 +96,7 @@ func (x TlsDatabaseClass) OverrideVerifyChainAsync(cb func(TlsDatabase, *TlsCe
96		}	96		}
97		}	97		}
98			98
99	-	// GetVerifyChainAsync gets the callback function.	99	+	// GetVerifyChainAsync gets the "verify_chain_async" callback function.
100		// Virtual method implementing	100		// Virtual method implementing
101		//	101		//
102		// g_tls_database_verify_chain_async().	102		// g_tls_database_verify_chain_async().

@@ -111,7 +111,7 @@ func (x TlsDatabaseClass) GetVerifyChainAsync() func(TlsDatabase, *TlsCertific
111		}	111		}
112		}	112		}
113			113
114	-	// OverrideVerifyChainFinish sets the callback function.	114	+	// OverrideVerifyChainFinish sets the "verify_chain_finish" callback function.
115		// Virtual method implementing	115		// Virtual method implementing
116		//	116		//
117		// g_tls_database_verify_chain_finish().	117		// g_tls_database_verify_chain_finish().

@@ -125,7 +125,7 @@ func (x TlsDatabaseClass) OverrideVerifyChainFinish(cb func(TlsDatabase, Async
125		}	125		}
126		}	126		}
127			127
128	-	// GetVerifyChainFinish gets the callback function.	128	+	// GetVerifyChainFinish gets the "verify_chain_finish" callback function.
129		// Virtual method implementing	129		// Virtual method implementing
130		//	130		//
131		// g_tls_database_verify_chain_finish().	131		// g_tls_database_verify_chain_finish().

@@ -140,7 +140,7 @@ func (x TlsDatabaseClass) GetVerifyChainFinish() func(TlsDatabase, AsyncResult
140		}	140		}
141		}	141		}
142			142
143	-	// OverrideCreateCertificateHandle sets the callback function.	143	+	// OverrideCreateCertificateHandle sets the "create_certificate_handle" callback function.
144		// Virtual method implementing	144		// Virtual method implementing
145		//	145		//
146		// g_tls_database_create_certificate_handle().	146		// g_tls_database_create_certificate_handle().

@@ -154,7 +154,7 @@ func (x TlsDatabaseClass) OverrideCreateCertificateHandle(cb func(TlsDatabase,
154		}	154		}
155		}	155		}
156			156
157	-	// GetCreateCertificateHandle gets the callback function.	157	+	// GetCreateCertificateHandle gets the "create_certificate_handle" callback function.
158		// Virtual method implementing	158		// Virtual method implementing
159		//	159		//
160		// g_tls_database_create_certificate_handle().	160		// g_tls_database_create_certificate_handle().

@@ -169,7 +169,7 @@ func (x TlsDatabaseClass) GetCreateCertificateHandle() func(TlsDatabase, *TlsC
169		}	169		}
170		}	170		}
171			171
172	-	// OverrideLookupCertificateForHandle sets the callback function.	172	+	// OverrideLookupCertificateForHandle sets the "lookup_certificate_for_handle" callback function.
173		// Virtual method implementing	173		// Virtual method implementing
174		//	174		//
175		// g_tls_database_lookup_certificate_for_handle().	175		// g_tls_database_lookup_certificate_for_handle().

@@ -187,7 +187,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificateForHandle(cb func(TlsDataba
187		}	187		}
188		}	188		}
189			189
190	-	// GetLookupCertificateForHandle gets the callback function.	190	+	// GetLookupCertificateForHandle gets the "lookup_certificate_for_handle" callback function.
191		// Virtual method implementing	191		// Virtual method implementing
192		//	192		//
193		// g_tls_database_lookup_certificate_for_handle().	193		// g_tls_database_lookup_certificate_for_handle().

@@ -208,7 +208,7 @@ func (x TlsDatabaseClass) GetLookupCertificateForHandle() func(TlsDatabase, st
208		}	208		}
209		}	209		}
210			210
211	-	// OverrideLookupCertificateForHandleAsync sets the callback function.	211	+	// OverrideLookupCertificateForHandleAsync sets the "lookup_certificate_for_handle_async" callback function.
212		// Virtual method implementing	212		// Virtual method implementing
213		//	213		//
214		// g_tls_database_lookup_certificate_for_handle_async().	214		// g_tls_database_lookup_certificate_for_handle_async().

@@ -222,7 +222,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificateForHandleAsync(cb func(TlsD
222		}	222		}
223		}	223		}
224			224
225	-	// GetLookupCertificateForHandleAsync gets the callback function.	225	+	// GetLookupCertificateForHandleAsync gets the "lookup_certificate_for_handle_async" callback function.
226		// Virtual method implementing	226		// Virtual method implementing
227		//	227		//
228		// g_tls_database_lookup_certificate_for_handle_async().	228		// g_tls_database_lookup_certificate_for_handle_async().

@@ -237,7 +237,7 @@ func (x TlsDatabaseClass) GetLookupCertificateForHandleAsync() func(TlsDatabas
237		}	237		}
238		}	238		}
239			239
240	-	// OverrideLookupCertificateForHandleFinish sets the callback function.	240	+	// OverrideLookupCertificateForHandleFinish sets the "lookup_certificate_for_handle_finish" callback function.
241		// Virtual method implementing	241		// Virtual method implementing
242		//	242		//
243		// g_tls_database_lookup_certificate_for_handle_finish().	243		// g_tls_database_lookup_certificate_for_handle_finish().

@@ -255,7 +255,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificateForHandleFinish(cb func(Tls
255		}	255		}
256		}	256		}
257			257
258	-	// GetLookupCertificateForHandleFinish gets the callback function.	258	+	// GetLookupCertificateForHandleFinish gets the "lookup_certificate_for_handle_finish" callback function.
259		// Virtual method implementing	259		// Virtual method implementing
260		//	260		//
261		// g_tls_database_lookup_certificate_for_handle_finish().	261		// g_tls_database_lookup_certificate_for_handle_finish().

@@ -276,7 +276,7 @@ func (x TlsDatabaseClass) GetLookupCertificateForHandleFinish() func(TlsDataba
276		}	276		}
277		}	277		}
278			278
279	-	// OverrideLookupCertificateIssuer sets the callback function.	279	+	// OverrideLookupCertificateIssuer sets the "lookup_certificate_issuer" callback function.
280		// Virtual method implementing	280		// Virtual method implementing
281		//	281		//
282		// g_tls_database_lookup_certificate_issuer().	282		// g_tls_database_lookup_certificate_issuer().

@@ -294,7 +294,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificateIssuer(cb func(TlsDatabase,
294		}	294		}
295		}	295		}
296			296
297	-	// GetLookupCertificateIssuer gets the callback function.	297	+	// GetLookupCertificateIssuer gets the "lookup_certificate_issuer" callback function.
298		// Virtual method implementing	298		// Virtual method implementing
299		//	299		//
300		// g_tls_database_lookup_certificate_issuer().	300		// g_tls_database_lookup_certificate_issuer().

@@ -315,7 +315,7 @@ func (x TlsDatabaseClass) GetLookupCertificateIssuer() func(TlsDatabase, *TlsC
315		}	315		}
316		}	316		}
317			317
318	-	// OverrideLookupCertificateIssuerAsync sets the callback function.	318	+	// OverrideLookupCertificateIssuerAsync sets the "lookup_certificate_issuer_async" callback function.
319		// Virtual method implementing	319		// Virtual method implementing
320		//	320		//
321		// g_tls_database_lookup_certificate_issuer_async().	321		// g_tls_database_lookup_certificate_issuer_async().

@@ -329,7 +329,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificateIssuerAsync(cb func(TlsData
329		}	329		}
330		}	330		}
331			331
332	-	// GetLookupCertificateIssuerAsync gets the callback function.	332	+	// GetLookupCertificateIssuerAsync gets the "lookup_certificate_issuer_async" callback function.
333		// Virtual method implementing	333		// Virtual method implementing
334		//	334		//
335		// g_tls_database_lookup_certificate_issuer_async().	335		// g_tls_database_lookup_certificate_issuer_async().

@@ -344,7 +344,7 @@ func (x TlsDatabaseClass) GetLookupCertificateIssuerAsync() func(TlsDatabase,
344		}	344		}
345		}	345		}
346			346
347	-	// OverrideLookupCertificateIssuerFinish sets the callback function.	347	+	// OverrideLookupCertificateIssuerFinish sets the "lookup_certificate_issuer_finish" callback function.
348		// Virtual method implementing	348		// Virtual method implementing
349		//	349		//
350		// g_tls_database_lookup_certificate_issuer_finish().	350		// g_tls_database_lookup_certificate_issuer_finish().

@@ -362,7 +362,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificateIssuerFinish(cb func(TlsDat
362		}	362		}
363		}	363		}
364			364
365	-	// GetLookupCertificateIssuerFinish gets the callback function.	365	+	// GetLookupCertificateIssuerFinish gets the "lookup_certificate_issuer_finish" callback function.
366		// Virtual method implementing	366		// Virtual method implementing
367		//	367		//
368		// g_tls_database_lookup_certificate_issuer_finish().	368		// g_tls_database_lookup_certificate_issuer_finish().

@@ -383,7 +383,7 @@ func (x TlsDatabaseClass) GetLookupCertificateIssuerFinish() func(TlsDatabase,
383		}	383		}
384		}	384		}
385			385
386	-	// OverrideLookupCertificatesIssuedBy sets the callback function.	386	+	// OverrideLookupCertificatesIssuedBy sets the "lookup_certificates_issued_by" callback function.
387		// Virtual method implementing	387		// Virtual method implementing
388		//	388		//
389		// g_tls_database_lookup_certificates_issued_by().	389		// g_tls_database_lookup_certificates_issued_by().

@@ -397,7 +397,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificatesIssuedBy(cb func(TlsDataba
397		}	397		}
398		}	398		}
399			399
400	-	// GetLookupCertificatesIssuedBy gets the callback function.	400	+	// GetLookupCertificatesIssuedBy gets the "lookup_certificates_issued_by" callback function.
401		// Virtual method implementing	401		// Virtual method implementing
402		//	402		//
403		// g_tls_database_lookup_certificates_issued_by().	403		// g_tls_database_lookup_certificates_issued_by().

@@ -412,7 +412,7 @@ func (x TlsDatabaseClass) GetLookupCertificatesIssuedBy() func(TlsDatabase, []
412		}	412		}
413		}	413		}
414			414
415	-	// OverrideLookupCertificatesIssuedByAsync sets the callback function.	415	+	// OverrideLookupCertificatesIssuedByAsync sets the "lookup_certificates_issued_by_async" callback function.
416		// Virtual method implementing	416		// Virtual method implementing
417		//	417		//
418		// g_tls_database_lookup_certificates_issued_by_async().	418		// g_tls_database_lookup_certificates_issued_by_async().

@@ -426,7 +426,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificatesIssuedByAsync(cb func(TlsD
426		}	426		}
427		}	427		}
428			428
429	-	// GetLookupCertificatesIssuedByAsync gets the callback function.	429	+	// GetLookupCertificatesIssuedByAsync gets the "lookup_certificates_issued_by_async" callback function.
430		// Virtual method implementing	430		// Virtual method implementing
431		//	431		//
432		// g_tls_database_lookup_certificates_issued_by_async().	432		// g_tls_database_lookup_certificates_issued_by_async().

@@ -441,7 +441,7 @@ func (x TlsDatabaseClass) GetLookupCertificatesIssuedByAsync() func(TlsDatabas
441		}	441		}
442		}	442		}
443			443
444	-	// OverrideLookupCertificatesIssuedByFinish sets the callback function.	444	+	// OverrideLookupCertificatesIssuedByFinish sets the "lookup_certificates_issued_by_finish" callback function.
445		// Virtual method implementing	445		// Virtual method implementing
446		//	446		//
447		// g_tls_database_lookup_certificates_issued_by_finish().	447		// g_tls_database_lookup_certificates_issued_by_finish().

@@ -455,7 +455,7 @@ func (x TlsDatabaseClass) OverrideLookupCertificatesIssuedByFinish(cb func(Tls
455		}	455		}
456		}	456		}
457			457
458	-	// GetLookupCertificatesIssuedByFinish gets the callback function.	458	+	// GetLookupCertificatesIssuedByFinish gets the "lookup_certificates_issued_by_finish" callback function.
459		// Virtual method implementing	459		// Virtual method implementing
460		//	460		//
461		// g_tls_database_lookup_certificates_issued_by_finish().	461		// g_tls_database_lookup_certificates_issued_by_finish().

M v4/gio/gtlsfiledatabase.go +28 -0


@@ -8,6 +8,7 @@ import (
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
10	"github.com/jwijenbergh/puregotk/v4/glib"	10		"github.com/jwijenbergh/puregotk/v4/glib"
		11	+	"github.com/jwijenbergh/puregotk/v4/gobject"
11	"github.com/jwijenbergh/puregotk/v4/gobject/types"	12		"github.com/jwijenbergh/puregotk/v4/gobject/types"
12	)	13		)
13		14

@@ -53,6 +54,33 @@ func (x *TlsFileDatabaseBase) SetGoPointer(ptr uintptr) {
53	x.Ptr = ptr	54		x.Ptr = ptr
54	}	55		}
55		56
		57	+	// SetPropertyAnchors sets the "anchors" property.
		58	+	// The path to a file containing PEM encoded certificate authority
		59	+	// root anchors. The certificates in this file will be treated as
		60	+	// root authorities for the purpose of verifying other certificates
		61	+	// via the g_tls_database_verify_chain() operation.
		62	+	func (x *TlsFileDatabaseBase) SetPropertyAnchors(value string) {
		63	+	obj := gobject.Object{}
		64	+	obj.Ptr = x.GoPointer()
		65	+	var v gobject.Value
		66	+	v.Init(gobject.TypeStringVal)
		67	+	v.SetString(value)
		68	+	obj.SetProperty("anchors", &v)
		69	+	}
		70	+
		71	+	// GetPropertyAnchors gets the "anchors" property.
		72	+	// The path to a file containing PEM encoded certificate authority
		73	+	// root anchors. The certificates in this file will be treated as
		74	+	// root authorities for the purpose of verifying other certificates
		75	+	// via the g_tls_database_verify_chain() operation.
		76	+	func (x *TlsFileDatabaseBase) GetPropertyAnchors() string {
		77	+	obj := gobject.Object{}
		78	+	obj.Ptr = x.GoPointer()
		79	+	var v gobject.Value
		80	+	obj.GetProperty("anchors", &v)
		81	+	return v.GetString()
		82	+	}
		83	+
56	var xTlsFileDatabaseNew func(string, **glib.Error) uintptr	84		var xTlsFileDatabaseNew func(string, **glib.Error) uintptr
57		85
58	// Creates a new #GTlsFileDatabase which uses anchor certificate authorities	86		// Creates a new #GTlsFileDatabase which uses anchor certificate authorities

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


@@ -50,7 +50,7 @@ func (x *TlsInteractionClass) GoPointer() uintptr {
50		return uintptr(unsafe.Pointer(x))	50		return uintptr(unsafe.Pointer(x))
51		}	51		}
52			52
53	-	// OverrideAskPassword sets the callback function.	53	+	// OverrideAskPassword sets the "ask_password" callback function.
54		// ask for a password synchronously. If the implementation	54		// ask for a password synchronously. If the implementation
55		//	55		//
56		// returns %G_TLS_INTERACTION_HANDLED, then the password argument should	56		// returns %G_TLS_INTERACTION_HANDLED, then the password argument should

@@ -66,7 +66,7 @@ func (x TlsInteractionClass) OverrideAskPassword(cb func(TlsInteraction, *TlsP
66		}	66		}
67		}	67		}
68			68
69	-	// GetAskPassword gets the callback function.	69	+	// GetAskPassword gets the "ask_password" callback function.
70		// ask for a password synchronously. If the implementation	70		// ask for a password synchronously. If the implementation
71		//	71		//
72		// returns %G_TLS_INTERACTION_HANDLED, then the password argument should	72		// returns %G_TLS_INTERACTION_HANDLED, then the password argument should

@@ -83,7 +83,7 @@ func (x TlsInteractionClass) GetAskPassword() func(TlsInteraction, *TlsPasswor
83		}	83		}
84		}	84		}
85			85
86	-	// OverrideAskPasswordAsync sets the callback function.	86	+	// OverrideAskPasswordAsync sets the "ask_password_async" callback function.
87		// ask for a password asynchronously.	87		// ask for a password asynchronously.
88		func (x TlsInteractionClass) OverrideAskPasswordAsync(cb func(TlsInteraction, TlsPassword, Cancellable, *AsyncReadyCallback, uintptr)) {	88		func (x TlsInteractionClass) OverrideAskPasswordAsync(cb func(TlsInteraction, TlsPassword, Cancellable, *AsyncReadyCallback, uintptr)) {
89		if cb == nil {	89		if cb == nil {

@@ -95,7 +95,7 @@ func (x TlsInteractionClass) OverrideAskPasswordAsync(cb func(TlsInteraction,
95		}	95		}
96		}	96		}
97			97
98	-	// GetAskPasswordAsync gets the callback function.	98	+	// GetAskPasswordAsync gets the "ask_password_async" callback function.
99		// ask for a password asynchronously.	99		// ask for a password asynchronously.
100		func (x TlsInteractionClass) GetAskPasswordAsync() func(TlsInteraction, TlsPassword, Cancellable, *AsyncReadyCallback, uintptr) {	100		func (x TlsInteractionClass) GetAskPasswordAsync() func(TlsInteraction, TlsPassword, Cancellable, *AsyncReadyCallback, uintptr) {
101		if x.xAskPasswordAsync == 0 {	101		if x.xAskPasswordAsync == 0 {

@@ -108,7 +108,7 @@ func (x TlsInteractionClass) GetAskPasswordAsync() func(TlsInteraction, *TlsPa
108		}	108		}
109		}	109		}
110			110
111	-	// OverrideAskPasswordFinish sets the callback function.	111	+	// OverrideAskPasswordFinish sets the "ask_password_finish" callback function.
112		// complete operation to ask for a password asynchronously.	112		// complete operation to ask for a password asynchronously.
113		//	113		//
114		// If the implementation returns %G_TLS_INTERACTION_HANDLED, then the	114		// If the implementation returns %G_TLS_INTERACTION_HANDLED, then the

@@ -124,7 +124,7 @@ func (x TlsInteractionClass) OverrideAskPasswordFinish(cb func(TlsInteraction,
124		}	124		}
125		}	125		}
126			126
127	-	// GetAskPasswordFinish gets the callback function.	127	+	// GetAskPasswordFinish gets the "ask_password_finish" callback function.
128		// complete operation to ask for a password asynchronously.	128		// complete operation to ask for a password asynchronously.
129		//	129		//
130		// If the implementation returns %G_TLS_INTERACTION_HANDLED, then the	130		// If the implementation returns %G_TLS_INTERACTION_HANDLED, then the

@@ -141,7 +141,7 @@ func (x TlsInteractionClass) GetAskPasswordFinish() func(TlsInteraction, Async
141		}	141		}
142		}	142		}
143			143
144	-	// OverrideRequestCertificate sets the callback function.	144	+	// OverrideRequestCertificate sets the "request_certificate" callback function.
145		// ask for a certificate synchronously. If the	145		// ask for a certificate synchronously. If the
146		//	146		//
147		// implementation returns %G_TLS_INTERACTION_HANDLED, then the connection	147		// implementation returns %G_TLS_INTERACTION_HANDLED, then the connection

@@ -157,7 +157,7 @@ func (x TlsInteractionClass) OverrideRequestCertificate(cb func(TlsInteraction
157		}	157		}
158		}	158		}
159			159
160	-	// GetRequestCertificate gets the callback function.	160	+	// GetRequestCertificate gets the "request_certificate" callback function.
161		// ask for a certificate synchronously. If the	161		// ask for a certificate synchronously. If the
162		//	162		//
163		// implementation returns %G_TLS_INTERACTION_HANDLED, then the connection	163		// implementation returns %G_TLS_INTERACTION_HANDLED, then the connection

@@ -174,7 +174,7 @@ func (x TlsInteractionClass) GetRequestCertificate() func(TlsInteraction, *Tls
174		}	174		}
175		}	175		}
176			176
177	-	// OverrideRequestCertificateAsync sets the callback function.	177	+	// OverrideRequestCertificateAsync sets the "request_certificate_async" callback function.
178		// ask for a certificate asynchronously.	178		// ask for a certificate asynchronously.
179		func (x TlsInteractionClass) OverrideRequestCertificateAsync(cb func(TlsInteraction, TlsConnection, TlsCertificateRequestFlags, Cancellable, *AsyncReadyCallback, uintptr)) {	179		func (x TlsInteractionClass) OverrideRequestCertificateAsync(cb func(TlsInteraction, TlsConnection, TlsCertificateRequestFlags, Cancellable, *AsyncReadyCallback, uintptr)) {
180		if cb == nil {	180		if cb == nil {

@@ -186,7 +186,7 @@ func (x TlsInteractionClass) OverrideRequestCertificateAsync(cb func(TlsIntera
186		}	186		}
187		}	187		}
188			188
189	-	// GetRequestCertificateAsync gets the callback function.	189	+	// GetRequestCertificateAsync gets the "request_certificate_async" callback function.
190		// ask for a certificate asynchronously.	190		// ask for a certificate asynchronously.
191		func (x TlsInteractionClass) GetRequestCertificateAsync() func(TlsInteraction, TlsConnection, TlsCertificateRequestFlags, Cancellable, *AsyncReadyCallback, uintptr) {	191		func (x TlsInteractionClass) GetRequestCertificateAsync() func(TlsInteraction, TlsConnection, TlsCertificateRequestFlags, Cancellable, *AsyncReadyCallback, uintptr) {
192		if x.xRequestCertificateAsync == 0 {	192		if x.xRequestCertificateAsync == 0 {

@@ -199,7 +199,7 @@ func (x TlsInteractionClass) GetRequestCertificateAsync() func(TlsInteraction,
199		}	199		}
200		}	200		}
201			201
202	-	// OverrideRequestCertificateFinish sets the callback function.	202	+	// OverrideRequestCertificateFinish sets the "request_certificate_finish" callback function.
203		// complete operation to ask for a certificate	203		// complete operation to ask for a certificate
204		//	204		//
205		// asynchronously. If the implementation returns %G_TLS_INTERACTION_HANDLED,	205		// asynchronously. If the implementation returns %G_TLS_INTERACTION_HANDLED,

@@ -215,7 +215,7 @@ func (x TlsInteractionClass) OverrideRequestCertificateFinish(cb func(TlsInter
215		}	215		}
216		}	216		}
217			217
218	-	// GetRequestCertificateFinish gets the callback function.	218	+	// GetRequestCertificateFinish gets the "request_certificate_finish" callback function.
219		// complete operation to ask for a certificate	219		// complete operation to ask for a certificate
220		//	220		//
221		// asynchronously. If the implementation returns %G_TLS_INTERACTION_HANDLED,	221		// asynchronously. If the implementation returns %G_TLS_INTERACTION_HANDLED,

M v4/gio/gtlspassword.go +47 -13

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGetValue sets the callback function.
+// OverrideGetValue sets the "get_value" callback function.
 // virtual method for g_tls_password_get_value()
-func (x *TlsPasswordClass) OverrideGetValue(cb func(*TlsPassword, uint) uintptr) {
+func (x *TlsPasswordClass) OverrideGetValue(cb func(*TlsPassword, *uint) uintptr) {
 	if cb == nil {
 		x.xGetValue = 0
 	} else {
-		x.xGetValue = purego.NewCallback(func(PasswordVarp uintptr, LengthVarp uint) uintptr {
+		x.xGetValue = purego.NewCallback(func(PasswordVarp uintptr, LengthVarp *uint) uintptr {
 			return cb(TlsPasswordNewFromInternalPtr(PasswordVarp), LengthVarp)
 		})
 	}
 }
-// GetGetValue gets the callback function.
+// GetGetValue gets the "get_value" callback function.
 // virtual method for g_tls_password_get_value()
-func (x *TlsPasswordClass) GetGetValue() func(*TlsPassword, uint) uintptr {
+func (x *TlsPasswordClass) GetGetValue() func(*TlsPassword, *uint) uintptr {
 	if x.xGetValue == 0 {
 		return nil
 	}
-	var rawCallback func(PasswordVarp uintptr, LengthVarp uint) uintptr
+	var rawCallback func(PasswordVarp uintptr, LengthVarp *uint) uintptr
 	purego.RegisterFunc(&rawCallback, x.xGetValue)
-	return func(PasswordVar *TlsPassword, LengthVar uint) uintptr {
+	return func(PasswordVar *TlsPassword, LengthVar *uint) uintptr {
 		return rawCallback(PasswordVar.GoPointer(), LengthVar)
 	}
 }
-// OverrideSetValue sets the callback function.
+// OverrideSetValue sets the "set_value" callback function.
 // virtual method for g_tls_password_set_value()
 func (x *TlsPasswordClass) OverrideSetValue(cb func(*TlsPassword, []byte, int, *glib.DestroyNotify)) {
 	if cb == nil {
 	}
 }
-// GetSetValue gets the callback function.
+// GetSetValue gets the "set_value" callback function.
 // virtual method for g_tls_password_set_value()
 func (x *TlsPasswordClass) GetSetValue() func(*TlsPassword, []byte, int, *glib.DestroyNotify) {
 	if x.xSetValue == 0 {
 	}
 }
-// OverrideGetDefaultWarning sets the callback function.
+// OverrideGetDefaultWarning sets the "get_default_warning" callback function.
 // virtual method for g_tls_password_get_warning() if no
 //
 //	value has been set using g_tls_password_set_warning()
 	}
 }
-// GetGetDefaultWarning gets the callback function.
+// GetGetDefaultWarning gets the "get_default_warning" callback function.
 // virtual method for g_tls_password_get_warning() if no
 //
 //	value has been set using g_tls_password_set_warning()
 	return cret
 }
-var xTlsPasswordGetValue func(uintptr, uint) uintptr
+var xTlsPasswordGetValue func(uintptr, *uint) uintptr
 // Get the password value. If @length is not %NULL then it will be
 // filled in with the length of the password value. (Note that the
 // password value is not nul-terminated, so you can only pass %NULL
 // for @length in contexts where you know the password will have a
 // certain fixed length.)
-func (x *TlsPassword) GetValue(LengthVar uint) uintptr {
+func (x *TlsPassword) GetValue(LengthVar *uint) uintptr {
 	cret := xTlsPasswordGetValue(x.GoPointer(), LengthVar)
 	return cret
 	c.Ptr = ptr
 }
+// SetPropertyDescription sets the "description" property.
+// Description of what the password is for.
+func (x *TlsPassword) SetPropertyDescription(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("description", &v)
+}
+// GetPropertyDescription gets the "description" property.
+// Description of what the password is for.
+func (x *TlsPassword) GetPropertyDescription() string {
+	var v gobject.Value
+	x.GetProperty("description", &v)
+	return v.GetString()
+}
+// SetPropertyWarning sets the "warning" property.
+// Warning about the password.
+func (x *TlsPassword) SetPropertyWarning(value string) {
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	x.SetProperty("warning", &v)
+}
+// GetPropertyWarning gets the "warning" property.
+// Warning about the password.
+func (x *TlsPassword) GetPropertyWarning() string {
+	var v gobject.Value
+	x.GetProperty("warning", &v)
+	return v.GetString()
+}
 func init() {
 	core.SetPackageName("GIO", "gio-2.0")
 	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})

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


@@ -26,7 +26,7 @@ func (x *UnixCredentialsMessageClass) GoPointer() uintptr {
26		return uintptr(unsafe.Pointer(x))	26		return uintptr(unsafe.Pointer(x))
27		}	27		}
28			28
29	-	// OverrideGReserved1 sets the callback function.	29	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
30		func (x *UnixCredentialsMessageClass) OverrideGReserved1(cb func()) {	30		func (x *UnixCredentialsMessageClass) OverrideGReserved1(cb func()) {
31		if cb == nil {	31		if cb == nil {
32		x.xGReserved1 = 0	32		x.xGReserved1 = 0

@@ -37,7 +37,7 @@ func (x *UnixCredentialsMessageClass) OverrideGReserved1(cb func()) {
37		}	37		}
38		}	38		}
39			39
40	-	// GetGReserved1 gets the callback function.	40	+	// GetGReserved1 gets the "_g_reserved1" callback function.
41		func (x *UnixCredentialsMessageClass) GetGReserved1() func() {	41		func (x *UnixCredentialsMessageClass) GetGReserved1() func() {
42		if x.xGReserved1 == 0 {	42		if x.xGReserved1 == 0 {
43		return nil	43		return nil

@@ -49,7 +49,7 @@ func (x *UnixCredentialsMessageClass) GetGReserved1() func() {
49		}	49		}
50		}	50		}
51			51
52	-	// OverrideGReserved2 sets the callback function.	52	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
53		func (x *UnixCredentialsMessageClass) OverrideGReserved2(cb func()) {	53		func (x *UnixCredentialsMessageClass) OverrideGReserved2(cb func()) {
54		if cb == nil {	54		if cb == nil {
55		x.xGReserved2 = 0	55		x.xGReserved2 = 0

@@ -60,7 +60,7 @@ func (x *UnixCredentialsMessageClass) OverrideGReserved2(cb func()) {
60		}	60		}
61		}	61		}
62			62
63	-	// GetGReserved2 gets the callback function.	63	+	// GetGReserved2 gets the "_g_reserved2" callback function.
64		func (x *UnixCredentialsMessageClass) GetGReserved2() func() {	64		func (x *UnixCredentialsMessageClass) GetGReserved2() func() {
65		if x.xGReserved2 == 0 {	65		if x.xGReserved2 == 0 {
66		return nil	66		return nil

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


@@ -32,7 +32,7 @@ func (x *UnixFDListClass) GoPointer() uintptr {
32		return uintptr(unsafe.Pointer(x))	32		return uintptr(unsafe.Pointer(x))
33		}	33		}
34			34
35	-	// OverrideGReserved1 sets the callback function.	35	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
36		func (x *UnixFDListClass) OverrideGReserved1(cb func()) {	36		func (x *UnixFDListClass) OverrideGReserved1(cb func()) {
37		if cb == nil {	37		if cb == nil {
38		x.xGReserved1 = 0	38		x.xGReserved1 = 0

@@ -43,7 +43,7 @@ func (x *UnixFDListClass) OverrideGReserved1(cb func()) {
43		}	43		}
44		}	44		}
45			45
46	-	// GetGReserved1 gets the callback function.	46	+	// GetGReserved1 gets the "_g_reserved1" callback function.
47		func (x *UnixFDListClass) GetGReserved1() func() {	47		func (x *UnixFDListClass) GetGReserved1() func() {
48		if x.xGReserved1 == 0 {	48		if x.xGReserved1 == 0 {
49		return nil	49		return nil

@@ -55,7 +55,7 @@ func (x *UnixFDListClass) GetGReserved1() func() {
55		}	55		}
56		}	56		}
57			57
58	-	// OverrideGReserved2 sets the callback function.	58	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
59		func (x *UnixFDListClass) OverrideGReserved2(cb func()) {	59		func (x *UnixFDListClass) OverrideGReserved2(cb func()) {
60		if cb == nil {	60		if cb == nil {
61		x.xGReserved2 = 0	61		x.xGReserved2 = 0

@@ -66,7 +66,7 @@ func (x *UnixFDListClass) OverrideGReserved2(cb func()) {
66		}	66		}
67		}	67		}
68			68
69	-	// GetGReserved2 gets the callback function.	69	+	// GetGReserved2 gets the "_g_reserved2" callback function.
70		func (x *UnixFDListClass) GetGReserved2() func() {	70		func (x *UnixFDListClass) GetGReserved2() func() {
71		if x.xGReserved2 == 0 {	71		if x.xGReserved2 == 0 {
72		return nil	72		return nil

@@ -78,7 +78,7 @@ func (x *UnixFDListClass) GetGReserved2() func() {
78		}	78		}
79		}	79		}
80			80
81	-	// OverrideGReserved3 sets the callback function.	81	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
82		func (x *UnixFDListClass) OverrideGReserved3(cb func()) {	82		func (x *UnixFDListClass) OverrideGReserved3(cb func()) {
83		if cb == nil {	83		if cb == nil {
84		x.xGReserved3 = 0	84		x.xGReserved3 = 0

@@ -89,7 +89,7 @@ func (x *UnixFDListClass) OverrideGReserved3(cb func()) {
89		}	89		}
90		}	90		}
91			91
92	-	// GetGReserved3 gets the callback function.	92	+	// GetGReserved3 gets the "_g_reserved3" callback function.
93		func (x *UnixFDListClass) GetGReserved3() func() {	93		func (x *UnixFDListClass) GetGReserved3() func() {
94		if x.xGReserved3 == 0 {	94		if x.xGReserved3 == 0 {
95		return nil	95		return nil

@@ -101,7 +101,7 @@ func (x *UnixFDListClass) GetGReserved3() func() {
101		}	101		}
102		}	102		}
103			103
104	-	// OverrideGReserved4 sets the callback function.	104	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
105		func (x *UnixFDListClass) OverrideGReserved4(cb func()) {	105		func (x *UnixFDListClass) OverrideGReserved4(cb func()) {
106		if cb == nil {	106		if cb == nil {
107		x.xGReserved4 = 0	107		x.xGReserved4 = 0

@@ -112,7 +112,7 @@ func (x *UnixFDListClass) OverrideGReserved4(cb func()) {
112		}	112		}
113		}	113		}
114			114
115	-	// GetGReserved4 gets the callback function.	115	+	// GetGReserved4 gets the "_g_reserved4" callback function.
116		func (x *UnixFDListClass) GetGReserved4() func() {	116		func (x *UnixFDListClass) GetGReserved4() func() {
117		if x.xGReserved4 == 0 {	117		if x.xGReserved4 == 0 {
118		return nil	118		return nil

@@ -124,7 +124,7 @@ func (x *UnixFDListClass) GetGReserved4() func() {
124		}	124		}
125		}	125		}
126			126
127	-	// OverrideGReserved5 sets the callback function.	127	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
128		func (x *UnixFDListClass) OverrideGReserved5(cb func()) {	128		func (x *UnixFDListClass) OverrideGReserved5(cb func()) {
129		if cb == nil {	129		if cb == nil {
130		x.xGReserved5 = 0	130		x.xGReserved5 = 0

@@ -135,7 +135,7 @@ func (x *UnixFDListClass) OverrideGReserved5(cb func()) {
135		}	135		}
136		}	136		}
137			137
138	-	// GetGReserved5 gets the callback function.	138	+	// GetGReserved5 gets the "_g_reserved5" callback function.
139		func (x *UnixFDListClass) GetGReserved5() func() {	139		func (x *UnixFDListClass) GetGReserved5() func() {
140		if x.xGReserved5 == 0 {	140		if x.xGReserved5 == 0 {
141		return nil	141		return nil

@@ -284,7 +284,7 @@ func (x *UnixFDList) GetLength() int {
284		return cret	284		return cret
285		}	285		}
286			286
287	-	var xUnixFDListPeekFds func(uintptr, int) uintptr	287	+	var xUnixFDListPeekFds func(uintptr, *int) uintptr
288			288
289		// Returns the array of file descriptors that is contained in this	289		// Returns the array of file descriptors that is contained in this
290		// object.	290		// object.

@@ -299,13 +299,13 @@ var xUnixFDListPeekFds func(uintptr, int) uintptr
299		//	299		//
300		// This function never returns %NULL. In case there are no file	300		// This function never returns %NULL. In case there are no file
301		// descriptors contained in @list, an empty array is returned.	301		// descriptors contained in @list, an empty array is returned.
302	-	func (x *UnixFDList) PeekFds(LengthVar int) uintptr {	302	+	func (x UnixFDList) PeekFds(LengthVar int) uintptr {
303			303
304		cret := xUnixFDListPeekFds(x.GoPointer(), LengthVar)	304		cret := xUnixFDListPeekFds(x.GoPointer(), LengthVar)
305		return cret	305		return cret
306		}	306		}
307			307
308	-	var xUnixFDListStealFds func(uintptr, int) uintptr	308	+	var xUnixFDListStealFds func(uintptr, *int) uintptr
309			309
310		// Returns the array of file descriptors that is contained in this	310		// Returns the array of file descriptors that is contained in this
311		// object.	311		// object.

@@ -325,7 +325,7 @@ var xUnixFDListStealFds func(uintptr, int) uintptr
325		//	325		//
326		// This function never returns %NULL. In case there are no file	326		// This function never returns %NULL. In case there are no file
327		// descriptors contained in @list, an empty array is returned.	327		// descriptors contained in @list, an empty array is returned.
328	-	func (x *UnixFDList) StealFds(LengthVar int) uintptr {	328	+	func (x UnixFDList) StealFds(LengthVar int) uintptr {
329			329
330		cret := xUnixFDListStealFds(x.GoPointer(), LengthVar)	330		cret := xUnixFDListStealFds(x.GoPointer(), LengthVar)
331		return cret	331		return cret

M v4/gio/gunixsocketaddress.go +57 -0


@@ -7,6 +7,8 @@ import (
7		7
8	"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"
9	"github.com/jwijenbergh/puregotk/pkg/core"	9		"github.com/jwijenbergh/puregotk/pkg/core"
		10	+	"github.com/jwijenbergh/puregotk/v4/glib"
		11	+	"github.com/jwijenbergh/puregotk/v4/gobject"
10	"github.com/jwijenbergh/puregotk/v4/gobject/types"	12		"github.com/jwijenbergh/puregotk/v4/gobject/types"
11	)	13		)
12		14

@@ -199,6 +201,61 @@ func (c *UnixSocketAddress) SetGoPointer(ptr uintptr) {
199	c.Ptr = ptr	201		c.Ptr = ptr
200	}	202		}
201		203
		204	+	// SetPropertyAbstract sets the "abstract" property.
		205	+	// Whether or not this is an abstract address
		206	+	func (x *UnixSocketAddress) SetPropertyAbstract(value bool) {
		207	+	var v gobject.Value
		208	+	v.Init(gobject.TypeBooleanVal)
		209	+	v.SetBoolean(value)
		210	+	x.SetProperty("abstract", &v)
		211	+	}
		212	+
		213	+	// GetPropertyAbstract gets the "abstract" property.
		214	+	// Whether or not this is an abstract address
		215	+	func (x *UnixSocketAddress) GetPropertyAbstract() bool {
		216	+	var v gobject.Value
		217	+	x.GetProperty("abstract", &v)
		218	+	return v.GetBoolean()
		219	+	}
		220	+
		221	+	// SetPropertyPath sets the "path" property.
		222	+	// Unix socket path.
		223	+	func (x *UnixSocketAddress) SetPropertyPath(value string) {
		224	+	var v gobject.Value
		225	+	v.Init(gobject.TypeStringVal)
		226	+	v.SetString(value)
		227	+	x.SetProperty("path", &v)
		228	+	}
		229	+
		230	+	// GetPropertyPath gets the "path" property.
		231	+	// Unix socket path.
		232	+	func (x *UnixSocketAddress) GetPropertyPath() string {
		233	+	var v gobject.Value
		234	+	x.GetProperty("path", &v)
		235	+	return v.GetString()
		236	+	}
		237	+
		238	+	// SetPropertyPathAsArray sets the "path-as-array" property.
		239	+	// Unix socket path, as a byte array.
		240	+	func (x *UnixSocketAddress) SetPropertyPathAsArray(value []byte) {
		241	+	var v gobject.Value
		242	+	v.Init(glib.ByteArrayGLibType())
		243	+	v.SetBoxed(uintptr(unsafe.Pointer(&value[0])))
		244	+	x.SetProperty("path-as-array", &v)
		245	+	}
		246	+
		247	+	// GetPropertyPathAsArray gets the "path-as-array" property.
		248	+	// Unix socket path, as a byte array.
		249	+	func (x *UnixSocketAddress) GetPropertyPathAsArray() []byte {
		250	+	var v gobject.Value
		251	+	x.GetProperty("path-as-array", &v)
		252	+	ptr := v.GetBoxed()
		253	+	if ptr == 0 {
		254	+	return nil
		255	+	}
		256	+	return unsafe.Slice((*byte)(unsafe.Pointer(ptr)), 0)[:0]
		257	+	}
		258	+
202	// Creates a #GSocketAddressEnumerator for @connectable.	259		// Creates a #GSocketAddressEnumerator for @connectable.
203	func (x UnixSocketAddress) Enumerate() SocketAddressEnumerator {	260		func (x UnixSocketAddress) Enumerate() SocketAddressEnumerator {
204	var cls *SocketAddressEnumerator	261		var cls *SocketAddressEnumerator

M v4/gio/gvfs.go +34 -34


@@ -64,7 +64,7 @@ func (x *VfsClass) GoPointer() uintptr {
64		return uintptr(unsafe.Pointer(x))	64		return uintptr(unsafe.Pointer(x))
65		}	65		}
66			66
67	-	// OverrideIsActive sets the callback function.	67	+	// OverrideIsActive sets the "is_active" callback function.
68		func (x VfsClass) OverrideIsActive(cb func(Vfs) bool) {	68		func (x VfsClass) OverrideIsActive(cb func(Vfs) bool) {
69		if cb == nil {	69		if cb == nil {
70		x.xIsActive = 0	70		x.xIsActive = 0

@@ -75,7 +75,7 @@ func (x VfsClass) OverrideIsActive(cb func(Vfs) bool) {
75		}	75		}
76		}	76		}
77			77
78	-	// GetIsActive gets the callback function.	78	+	// GetIsActive gets the "is_active" callback function.
79		func (x VfsClass) GetIsActive() func(Vfs) bool {	79		func (x VfsClass) GetIsActive() func(Vfs) bool {
80		if x.xIsActive == 0 {	80		if x.xIsActive == 0 {
81		return nil	81		return nil

@@ -87,7 +87,7 @@ func (x VfsClass) GetIsActive() func(Vfs) bool {
87		}	87		}
88		}	88		}
89			89
90	-	// OverrideGetFileForPath sets the callback function.	90	+	// OverrideGetFileForPath sets the "get_file_for_path" callback function.
91		func (x VfsClass) OverrideGetFileForPath(cb func(Vfs, string) *FileBase) {	91		func (x VfsClass) OverrideGetFileForPath(cb func(Vfs, string) *FileBase) {
92		if cb == nil {	92		if cb == nil {
93		x.xGetFileForPath = 0	93		x.xGetFileForPath = 0

@@ -102,7 +102,7 @@ func (x VfsClass) OverrideGetFileForPath(cb func(Vfs, string) *FileBase) {
102		}	102		}
103		}	103		}
104			104
105	-	// GetGetFileForPath gets the callback function.	105	+	// GetGetFileForPath gets the "get_file_for_path" callback function.
106		func (x VfsClass) GetGetFileForPath() func(Vfs, string) *FileBase {	106		func (x VfsClass) GetGetFileForPath() func(Vfs, string) *FileBase {
107		if x.xGetFileForPath == 0 {	107		if x.xGetFileForPath == 0 {
108		return nil	108		return nil

@@ -120,7 +120,7 @@ func (x VfsClass) GetGetFileForPath() func(Vfs, string) *FileBase {
120		}	120		}
121		}	121		}
122			122
123	-	// OverrideGetFileForUri sets the callback function.	123	+	// OverrideGetFileForUri sets the "get_file_for_uri" callback function.
124		func (x VfsClass) OverrideGetFileForUri(cb func(Vfs, string) *FileBase) {	124		func (x VfsClass) OverrideGetFileForUri(cb func(Vfs, string) *FileBase) {
125		if cb == nil {	125		if cb == nil {
126		x.xGetFileForUri = 0	126		x.xGetFileForUri = 0

@@ -135,7 +135,7 @@ func (x VfsClass) OverrideGetFileForUri(cb func(Vfs, string) *FileBase) {
135		}	135		}
136		}	136		}
137			137
138	-	// GetGetFileForUri gets the callback function.	138	+	// GetGetFileForUri gets the "get_file_for_uri" callback function.
139		func (x VfsClass) GetGetFileForUri() func(Vfs, string) *FileBase {	139		func (x VfsClass) GetGetFileForUri() func(Vfs, string) *FileBase {
140		if x.xGetFileForUri == 0 {	140		if x.xGetFileForUri == 0 {
141		return nil	141		return nil

@@ -153,7 +153,7 @@ func (x VfsClass) GetGetFileForUri() func(Vfs, string) *FileBase {
153		}	153		}
154		}	154		}
155			155
156	-	// OverrideGetSupportedUriSchemes sets the callback function.	156	+	// OverrideGetSupportedUriSchemes sets the "get_supported_uri_schemes" callback function.
157		func (x VfsClass) OverrideGetSupportedUriSchemes(cb func(Vfs) []string) {	157		func (x VfsClass) OverrideGetSupportedUriSchemes(cb func(Vfs) []string) {
158		if cb == nil {	158		if cb == nil {
159		x.xGetSupportedUriSchemes = 0	159		x.xGetSupportedUriSchemes = 0

@@ -164,7 +164,7 @@ func (x VfsClass) OverrideGetSupportedUriSchemes(cb func(Vfs) []string) {
164		}	164		}
165		}	165		}
166			166
167	-	// GetGetSupportedUriSchemes gets the callback function.	167	+	// GetGetSupportedUriSchemes gets the "get_supported_uri_schemes" callback function.
168		func (x VfsClass) GetGetSupportedUriSchemes() func(Vfs) []string {	168		func (x VfsClass) GetGetSupportedUriSchemes() func(Vfs) []string {
169		if x.xGetSupportedUriSchemes == 0 {	169		if x.xGetSupportedUriSchemes == 0 {
170		return nil	170		return nil

@@ -176,7 +176,7 @@ func (x VfsClass) GetGetSupportedUriSchemes() func(Vfs) []string {
176		}	176		}
177		}	177		}
178			178
179	-	// OverrideParseName sets the callback function.	179	+	// OverrideParseName sets the "parse_name" callback function.
180		func (x VfsClass) OverrideParseName(cb func(Vfs, string) *FileBase) {	180		func (x VfsClass) OverrideParseName(cb func(Vfs, string) *FileBase) {
181		if cb == nil {	181		if cb == nil {
182		x.xParseName = 0	182		x.xParseName = 0

@@ -191,7 +191,7 @@ func (x VfsClass) OverrideParseName(cb func(Vfs, string) *FileBase) {
191		}	191		}
192		}	192		}
193			193
194	-	// GetParseName gets the callback function.	194	+	// GetParseName gets the "parse_name" callback function.
195		func (x VfsClass) GetParseName() func(Vfs, string) *FileBase {	195		func (x VfsClass) GetParseName() func(Vfs, string) *FileBase {
196		if x.xParseName == 0 {	196		if x.xParseName == 0 {
197		return nil	197		return nil

@@ -209,7 +209,7 @@ func (x VfsClass) GetParseName() func(Vfs, string) *FileBase {
209		}	209		}
210		}	210		}
211			211
212	-	// OverrideLocalFileAddInfo sets the callback function.	212	+	// OverrideLocalFileAddInfo sets the "local_file_add_info" callback function.
213		func (x VfsClass) OverrideLocalFileAddInfo(cb func(Vfs, string, uint64, FileAttributeMatcher, FileInfo, Cancellable, uintptr, glib.DestroyNotify)) {	213		func (x VfsClass) OverrideLocalFileAddInfo(cb func(Vfs, string, uint64, FileAttributeMatcher, FileInfo, Cancellable, uintptr, glib.DestroyNotify)) {
214		if cb == nil {	214		if cb == nil {
215		x.xLocalFileAddInfo = 0	215		x.xLocalFileAddInfo = 0

@@ -220,7 +220,7 @@ func (x VfsClass) OverrideLocalFileAddInfo(cb func(Vfs, string, uint64, *FileA
220		}	220		}
221		}	221		}
222			222
223	-	// GetLocalFileAddInfo gets the callback function.	223	+	// GetLocalFileAddInfo gets the "local_file_add_info" callback function.
224		func (x VfsClass) GetLocalFileAddInfo() func(Vfs, string, uint64, FileAttributeMatcher, FileInfo, Cancellable, uintptr, glib.DestroyNotify) {	224		func (x VfsClass) GetLocalFileAddInfo() func(Vfs, string, uint64, FileAttributeMatcher, FileInfo, Cancellable, uintptr, glib.DestroyNotify) {
225		if x.xLocalFileAddInfo == 0 {	225		if x.xLocalFileAddInfo == 0 {
226		return nil	226		return nil

@@ -232,7 +232,7 @@ func (x VfsClass) GetLocalFileAddInfo() func(Vfs, string, uint64, *FileAttribu
232		}	232		}
233		}	233		}
234			234
235	-	// OverrideAddWritableNamespaces sets the callback function.	235	+	// OverrideAddWritableNamespaces sets the "add_writable_namespaces" callback function.
236		func (x VfsClass) OverrideAddWritableNamespaces(cb func(Vfs, *FileAttributeInfoList)) {	236		func (x VfsClass) OverrideAddWritableNamespaces(cb func(Vfs, *FileAttributeInfoList)) {
237		if cb == nil {	237		if cb == nil {
238		x.xAddWritableNamespaces = 0	238		x.xAddWritableNamespaces = 0

@@ -243,7 +243,7 @@ func (x VfsClass) OverrideAddWritableNamespaces(cb func(Vfs, *FileAttributeInf
243		}	243		}
244		}	244		}
245			245
246	-	// GetAddWritableNamespaces gets the callback function.	246	+	// GetAddWritableNamespaces gets the "add_writable_namespaces" callback function.
247		func (x VfsClass) GetAddWritableNamespaces() func(Vfs, *FileAttributeInfoList) {	247		func (x VfsClass) GetAddWritableNamespaces() func(Vfs, *FileAttributeInfoList) {
248		if x.xAddWritableNamespaces == 0 {	248		if x.xAddWritableNamespaces == 0 {
249		return nil	249		return nil

@@ -255,7 +255,7 @@ func (x VfsClass) GetAddWritableNamespaces() func(Vfs, *FileAttributeInfoList)
255		}	255		}
256		}	256		}
257			257
258	-	// OverrideLocalFileSetAttributes sets the callback function.	258	+	// OverrideLocalFileSetAttributes sets the "local_file_set_attributes" callback function.
259		func (x VfsClass) OverrideLocalFileSetAttributes(cb func(Vfs, string, FileInfo, FileQueryInfoFlags, Cancellable) bool) {	259		func (x VfsClass) OverrideLocalFileSetAttributes(cb func(Vfs, string, FileInfo, FileQueryInfoFlags, Cancellable) bool) {
260		if cb == nil {	260		if cb == nil {
261		x.xLocalFileSetAttributes = 0	261		x.xLocalFileSetAttributes = 0

@@ -266,7 +266,7 @@ func (x VfsClass) OverrideLocalFileSetAttributes(cb func(Vfs, string, *FileInf
266		}	266		}
267		}	267		}
268			268
269	-	// GetLocalFileSetAttributes gets the callback function.	269	+	// GetLocalFileSetAttributes gets the "local_file_set_attributes" callback function.
270		func (x VfsClass) GetLocalFileSetAttributes() func(Vfs, string, FileInfo, FileQueryInfoFlags, Cancellable) bool {	270		func (x VfsClass) GetLocalFileSetAttributes() func(Vfs, string, FileInfo, FileQueryInfoFlags, Cancellable) bool {
271		if x.xLocalFileSetAttributes == 0 {	271		if x.xLocalFileSetAttributes == 0 {
272		return nil	272		return nil

@@ -278,7 +278,7 @@ func (x VfsClass) GetLocalFileSetAttributes() func(Vfs, string, *FileInfo, Fil
278		}	278		}
279		}	279		}
280			280
281	-	// OverrideLocalFileRemoved sets the callback function.	281	+	// OverrideLocalFileRemoved sets the "local_file_removed" callback function.
282		func (x VfsClass) OverrideLocalFileRemoved(cb func(Vfs, string)) {	282		func (x VfsClass) OverrideLocalFileRemoved(cb func(Vfs, string)) {
283		if cb == nil {	283		if cb == nil {
284		x.xLocalFileRemoved = 0	284		x.xLocalFileRemoved = 0

@@ -289,7 +289,7 @@ func (x VfsClass) OverrideLocalFileRemoved(cb func(Vfs, string)) {
289		}	289		}
290		}	290		}
291			291
292	-	// GetLocalFileRemoved gets the callback function.	292	+	// GetLocalFileRemoved gets the "local_file_removed" callback function.
293		func (x VfsClass) GetLocalFileRemoved() func(Vfs, string) {	293		func (x VfsClass) GetLocalFileRemoved() func(Vfs, string) {
294		if x.xLocalFileRemoved == 0 {	294		if x.xLocalFileRemoved == 0 {
295		return nil	295		return nil

@@ -301,7 +301,7 @@ func (x VfsClass) GetLocalFileRemoved() func(Vfs, string) {
301		}	301		}
302		}	302		}
303			303
304	-	// OverrideLocalFileMoved sets the callback function.	304	+	// OverrideLocalFileMoved sets the "local_file_moved" callback function.
305		func (x VfsClass) OverrideLocalFileMoved(cb func(Vfs, string, string)) {	305		func (x VfsClass) OverrideLocalFileMoved(cb func(Vfs, string, string)) {
306		if cb == nil {	306		if cb == nil {
307		x.xLocalFileMoved = 0	307		x.xLocalFileMoved = 0

@@ -312,7 +312,7 @@ func (x VfsClass) OverrideLocalFileMoved(cb func(Vfs, string, string)) {
312		}	312		}
313		}	313		}
314			314
315	-	// GetLocalFileMoved gets the callback function.	315	+	// GetLocalFileMoved gets the "local_file_moved" callback function.
316		func (x VfsClass) GetLocalFileMoved() func(Vfs, string, string) {	316		func (x VfsClass) GetLocalFileMoved() func(Vfs, string, string) {
317		if x.xLocalFileMoved == 0 {	317		if x.xLocalFileMoved == 0 {
318		return nil	318		return nil

@@ -324,7 +324,7 @@ func (x VfsClass) GetLocalFileMoved() func(Vfs, string, string) {
324		}	324		}
325		}	325		}
326			326
327	-	// OverrideDeserializeIcon sets the callback function.	327	+	// OverrideDeserializeIcon sets the "deserialize_icon" callback function.
328		func (x VfsClass) OverrideDeserializeIcon(cb func(Vfs, glib.Variant) IconBase) {	328		func (x VfsClass) OverrideDeserializeIcon(cb func(Vfs, glib.Variant) IconBase) {
329		if cb == nil {	329		if cb == nil {
330		x.xDeserializeIcon = 0	330		x.xDeserializeIcon = 0

@@ -339,7 +339,7 @@ func (x VfsClass) OverrideDeserializeIcon(cb func(Vfs, glib.Variant) IconBas
339		}	339		}
340		}	340		}
341			341
342	-	// GetDeserializeIcon gets the callback function.	342	+	// GetDeserializeIcon gets the "deserialize_icon" callback function.
343		func (x VfsClass) GetDeserializeIcon() func(Vfs, glib.Variant) IconBase {	343		func (x VfsClass) GetDeserializeIcon() func(Vfs, glib.Variant) IconBase {
344		if x.xDeserializeIcon == 0 {	344		if x.xDeserializeIcon == 0 {
345		return nil	345		return nil

@@ -357,7 +357,7 @@ func (x VfsClass) GetDeserializeIcon() func(Vfs, glib.Variant) IconBase {
357		}	357		}
358		}	358		}
359			359
360	-	// OverrideGReserved1 sets the callback function.	360	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
361		func (x *VfsClass) OverrideGReserved1(cb func()) {	361		func (x *VfsClass) OverrideGReserved1(cb func()) {
362		if cb == nil {	362		if cb == nil {
363		x.xGReserved1 = 0	363		x.xGReserved1 = 0

@@ -368,7 +368,7 @@ func (x *VfsClass) OverrideGReserved1(cb func()) {
368		}	368		}
369		}	369		}
370			370
371	-	// GetGReserved1 gets the callback function.	371	+	// GetGReserved1 gets the "_g_reserved1" callback function.
372		func (x *VfsClass) GetGReserved1() func() {	372		func (x *VfsClass) GetGReserved1() func() {
373		if x.xGReserved1 == 0 {	373		if x.xGReserved1 == 0 {
374		return nil	374		return nil

@@ -380,7 +380,7 @@ func (x *VfsClass) GetGReserved1() func() {
380		}	380		}
381		}	381		}
382			382
383	-	// OverrideGReserved2 sets the callback function.	383	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
384		func (x *VfsClass) OverrideGReserved2(cb func()) {	384		func (x *VfsClass) OverrideGReserved2(cb func()) {
385		if cb == nil {	385		if cb == nil {
386		x.xGReserved2 = 0	386		x.xGReserved2 = 0

@@ -391,7 +391,7 @@ func (x *VfsClass) OverrideGReserved2(cb func()) {
391		}	391		}
392		}	392		}
393			393
394	-	// GetGReserved2 gets the callback function.	394	+	// GetGReserved2 gets the "_g_reserved2" callback function.
395		func (x *VfsClass) GetGReserved2() func() {	395		func (x *VfsClass) GetGReserved2() func() {
396		if x.xGReserved2 == 0 {	396		if x.xGReserved2 == 0 {
397		return nil	397		return nil

@@ -403,7 +403,7 @@ func (x *VfsClass) GetGReserved2() func() {
403		}	403		}
404		}	404		}
405			405
406	-	// OverrideGReserved3 sets the callback function.	406	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
407		func (x *VfsClass) OverrideGReserved3(cb func()) {	407		func (x *VfsClass) OverrideGReserved3(cb func()) {
408		if cb == nil {	408		if cb == nil {
409		x.xGReserved3 = 0	409		x.xGReserved3 = 0

@@ -414,7 +414,7 @@ func (x *VfsClass) OverrideGReserved3(cb func()) {
414		}	414		}
415		}	415		}
416			416
417	-	// GetGReserved3 gets the callback function.	417	+	// GetGReserved3 gets the "_g_reserved3" callback function.
418		func (x *VfsClass) GetGReserved3() func() {	418		func (x *VfsClass) GetGReserved3() func() {
419		if x.xGReserved3 == 0 {	419		if x.xGReserved3 == 0 {
420		return nil	420		return nil

@@ -426,7 +426,7 @@ func (x *VfsClass) GetGReserved3() func() {
426		}	426		}
427		}	427		}
428			428
429	-	// OverrideGReserved4 sets the callback function.	429	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
430		func (x *VfsClass) OverrideGReserved4(cb func()) {	430		func (x *VfsClass) OverrideGReserved4(cb func()) {
431		if cb == nil {	431		if cb == nil {
432		x.xGReserved4 = 0	432		x.xGReserved4 = 0

@@ -437,7 +437,7 @@ func (x *VfsClass) OverrideGReserved4(cb func()) {
437		}	437		}
438		}	438		}
439			439
440	-	// GetGReserved4 gets the callback function.	440	+	// GetGReserved4 gets the "_g_reserved4" callback function.
441		func (x *VfsClass) GetGReserved4() func() {	441		func (x *VfsClass) GetGReserved4() func() {
442		if x.xGReserved4 == 0 {	442		if x.xGReserved4 == 0 {
443		return nil	443		return nil

@@ -449,7 +449,7 @@ func (x *VfsClass) GetGReserved4() func() {
449		}	449		}
450		}	450		}
451			451
452	-	// OverrideGReserved5 sets the callback function.	452	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
453		func (x *VfsClass) OverrideGReserved5(cb func()) {	453		func (x *VfsClass) OverrideGReserved5(cb func()) {
454		if cb == nil {	454		if cb == nil {
455		x.xGReserved5 = 0	455		x.xGReserved5 = 0

@@ -460,7 +460,7 @@ func (x *VfsClass) OverrideGReserved5(cb func()) {
460		}	460		}
461		}	461		}
462			462
463	-	// GetGReserved5 gets the callback function.	463	+	// GetGReserved5 gets the "_g_reserved5" callback function.
464		func (x *VfsClass) GetGReserved5() func() {	464		func (x *VfsClass) GetGReserved5() func() {
465		if x.xGReserved5 == 0 {	465		if x.xGReserved5 == 0 {
466		return nil	466		return nil

@@ -472,7 +472,7 @@ func (x *VfsClass) GetGReserved5() func() {
472		}	472		}
473		}	473		}
474			474
475	-	// OverrideGReserved6 sets the callback function.	475	+	// OverrideGReserved6 sets the "_g_reserved6" callback function.
476		func (x *VfsClass) OverrideGReserved6(cb func()) {	476		func (x *VfsClass) OverrideGReserved6(cb func()) {
477		if cb == nil {	477		if cb == nil {
478		x.xGReserved6 = 0	478		x.xGReserved6 = 0

@@ -483,7 +483,7 @@ func (x *VfsClass) OverrideGReserved6(cb func()) {
483		}	483		}
484		}	484		}
485			485
486	-	// GetGReserved6 gets the callback function.	486	+	// GetGReserved6 gets the "_g_reserved6" callback function.
487		func (x *VfsClass) GetGReserved6() func() {	487		func (x *VfsClass) GetGReserved6() func() {
488		if x.xGReserved6 == 0 {	488		if x.xGReserved6 == 0 {
489		return nil	489		return nil

M v4/gio/gvolume.go +42 -42


@@ -64,7 +64,7 @@ func (x *VolumeIface) GoPointer() uintptr {
64		return uintptr(unsafe.Pointer(x))	64		return uintptr(unsafe.Pointer(x))
65		}	65		}
66			66
67	-	// OverrideChanged sets the callback function.	67	+	// OverrideChanged sets the "changed" callback function.
68		// Changed signal that is emitted when the volume's state has changed.	68		// Changed signal that is emitted when the volume's state has changed.
69		func (x *VolumeIface) OverrideChanged(cb func(Volume)) {	69		func (x *VolumeIface) OverrideChanged(cb func(Volume)) {
70		if cb == nil {	70		if cb == nil {

@@ -76,7 +76,7 @@ func (x *VolumeIface) OverrideChanged(cb func(Volume)) {
76		}	76		}
77		}	77		}
78			78
79	-	// GetChanged gets the callback function.	79	+	// GetChanged gets the "changed" callback function.
80		// Changed signal that is emitted when the volume's state has changed.	80		// Changed signal that is emitted when the volume's state has changed.
81		func (x *VolumeIface) GetChanged() func(Volume) {	81		func (x *VolumeIface) GetChanged() func(Volume) {
82		if x.xChanged == 0 {	82		if x.xChanged == 0 {

@@ -89,7 +89,7 @@ func (x *VolumeIface) GetChanged() func(Volume) {
89		}	89		}
90		}	90		}
91			91
92	-	// OverrideRemoved sets the callback function.	92	+	// OverrideRemoved sets the "removed" callback function.
93		// The removed signal that is emitted when the #GVolume have been removed. If the recipient is holding references to the object they should release them so the object can be finalized.	93		// The removed signal that is emitted when the #GVolume have been removed. If the recipient is holding references to the object they should release them so the object can be finalized.
94		func (x *VolumeIface) OverrideRemoved(cb func(Volume)) {	94		func (x *VolumeIface) OverrideRemoved(cb func(Volume)) {
95		if cb == nil {	95		if cb == nil {

@@ -101,7 +101,7 @@ func (x *VolumeIface) OverrideRemoved(cb func(Volume)) {
101		}	101		}
102		}	102		}
103			103
104	-	// GetRemoved gets the callback function.	104	+	// GetRemoved gets the "removed" callback function.
105		// The removed signal that is emitted when the #GVolume have been removed. If the recipient is holding references to the object they should release them so the object can be finalized.	105		// The removed signal that is emitted when the #GVolume have been removed. If the recipient is holding references to the object they should release them so the object can be finalized.
106		func (x *VolumeIface) GetRemoved() func(Volume) {	106		func (x *VolumeIface) GetRemoved() func(Volume) {
107		if x.xRemoved == 0 {	107		if x.xRemoved == 0 {

@@ -114,7 +114,7 @@ func (x *VolumeIface) GetRemoved() func(Volume) {
114		}	114		}
115		}	115		}
116			116
117	-	// OverrideGetName sets the callback function.	117	+	// OverrideGetName sets the "get_name" callback function.
118		// Gets a string containing the name of the #GVolume.	118		// Gets a string containing the name of the #GVolume.
119		func (x *VolumeIface) OverrideGetName(cb func(Volume) string) {	119		func (x *VolumeIface) OverrideGetName(cb func(Volume) string) {
120		if cb == nil {	120		if cb == nil {

@@ -126,7 +126,7 @@ func (x *VolumeIface) OverrideGetName(cb func(Volume) string) {
126		}	126		}
127		}	127		}
128			128
129	-	// GetGetName gets the callback function.	129	+	// GetGetName gets the "get_name" callback function.
130		// Gets a string containing the name of the #GVolume.	130		// Gets a string containing the name of the #GVolume.
131		func (x *VolumeIface) GetGetName() func(Volume) string {	131		func (x *VolumeIface) GetGetName() func(Volume) string {
132		if x.xGetName == 0 {	132		if x.xGetName == 0 {

@@ -139,7 +139,7 @@ func (x *VolumeIface) GetGetName() func(Volume) string {
139		}	139		}
140		}	140		}
141			141
142	-	// OverrideGetIcon sets the callback function.	142	+	// OverrideGetIcon sets the "get_icon" callback function.
143		// Gets a #GIcon for the #GVolume.	143		// Gets a #GIcon for the #GVolume.
144		func (x VolumeIface) OverrideGetIcon(cb func(Volume) IconBase) {	144		func (x VolumeIface) OverrideGetIcon(cb func(Volume) IconBase) {
145		if cb == nil {	145		if cb == nil {

@@ -155,7 +155,7 @@ func (x VolumeIface) OverrideGetIcon(cb func(Volume) IconBase) {
155		}	155		}
156		}	156		}
157			157
158	-	// GetGetIcon gets the callback function.	158	+	// GetGetIcon gets the "get_icon" callback function.
159		// Gets a #GIcon for the #GVolume.	159		// Gets a #GIcon for the #GVolume.
160		func (x VolumeIface) GetGetIcon() func(Volume) IconBase {	160		func (x VolumeIface) GetGetIcon() func(Volume) IconBase {
161		if x.xGetIcon == 0 {	161		if x.xGetIcon == 0 {

@@ -174,7 +174,7 @@ func (x VolumeIface) GetGetIcon() func(Volume) IconBase {
174		}	174		}
175		}	175		}
176			176
177	-	// OverrideGetUuid sets the callback function.	177	+	// OverrideGetUuid sets the "get_uuid" callback function.
178		// Gets the UUID for the #GVolume. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.	178		// Gets the UUID for the #GVolume. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.
179		func (x *VolumeIface) OverrideGetUuid(cb func(Volume) string) {	179		func (x *VolumeIface) OverrideGetUuid(cb func(Volume) string) {
180		if cb == nil {	180		if cb == nil {

@@ -186,7 +186,7 @@ func (x *VolumeIface) OverrideGetUuid(cb func(Volume) string) {
186		}	186		}
187		}	187		}
188			188
189	-	// GetGetUuid gets the callback function.	189	+	// GetGetUuid gets the "get_uuid" callback function.
190		// Gets the UUID for the #GVolume. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.	190		// Gets the UUID for the #GVolume. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.
191		func (x *VolumeIface) GetGetUuid() func(Volume) string {	191		func (x *VolumeIface) GetGetUuid() func(Volume) string {
192		if x.xGetUuid == 0 {	192		if x.xGetUuid == 0 {

@@ -199,7 +199,7 @@ func (x *VolumeIface) GetGetUuid() func(Volume) string {
199		}	199		}
200		}	200		}
201			201
202	-	// OverrideGetDrive sets the callback function.	202	+	// OverrideGetDrive sets the "get_drive" callback function.
203		// Gets a #GDrive the volume is located on. Returns %NULL if the #GVolume is not associated with a #GDrive.	203		// Gets a #GDrive the volume is located on. Returns %NULL if the #GVolume is not associated with a #GDrive.
204		func (x VolumeIface) OverrideGetDrive(cb func(Volume) DriveBase) {	204		func (x VolumeIface) OverrideGetDrive(cb func(Volume) DriveBase) {
205		if cb == nil {	205		if cb == nil {

@@ -215,7 +215,7 @@ func (x VolumeIface) OverrideGetDrive(cb func(Volume) DriveBase) {
215		}	215		}
216		}	216		}
217			217
218	-	// GetGetDrive gets the callback function.	218	+	// GetGetDrive gets the "get_drive" callback function.
219		// Gets a #GDrive the volume is located on. Returns %NULL if the #GVolume is not associated with a #GDrive.	219		// Gets a #GDrive the volume is located on. Returns %NULL if the #GVolume is not associated with a #GDrive.
220		func (x VolumeIface) GetGetDrive() func(Volume) DriveBase {	220		func (x VolumeIface) GetGetDrive() func(Volume) DriveBase {
221		if x.xGetDrive == 0 {	221		if x.xGetDrive == 0 {

@@ -234,7 +234,7 @@ func (x VolumeIface) GetGetDrive() func(Volume) DriveBase {
234		}	234		}
235		}	235		}
236			236
237	-	// OverrideGetMount sets the callback function.	237	+	// OverrideGetMount sets the "get_mount" callback function.
238		// Gets a #GMount representing the mounted volume. Returns %NULL if the #GVolume is not mounted.	238		// Gets a #GMount representing the mounted volume. Returns %NULL if the #GVolume is not mounted.
239		func (x VolumeIface) OverrideGetMount(cb func(Volume) MountBase) {	239		func (x VolumeIface) OverrideGetMount(cb func(Volume) MountBase) {
240		if cb == nil {	240		if cb == nil {

@@ -250,7 +250,7 @@ func (x VolumeIface) OverrideGetMount(cb func(Volume) MountBase) {
250		}	250		}
251		}	251		}
252			252
253	-	// GetGetMount gets the callback function.	253	+	// GetGetMount gets the "get_mount" callback function.
254		// Gets a #GMount representing the mounted volume. Returns %NULL if the #GVolume is not mounted.	254		// Gets a #GMount representing the mounted volume. Returns %NULL if the #GVolume is not mounted.
255		func (x VolumeIface) GetGetMount() func(Volume) MountBase {	255		func (x VolumeIface) GetGetMount() func(Volume) MountBase {
256		if x.xGetMount == 0 {	256		if x.xGetMount == 0 {

@@ -269,7 +269,7 @@ func (x VolumeIface) GetGetMount() func(Volume) MountBase {
269		}	269		}
270		}	270		}
271			271
272	-	// OverrideCanMount sets the callback function.	272	+	// OverrideCanMount sets the "can_mount" callback function.
273		// Returns %TRUE if the #GVolume can be mounted.	273		// Returns %TRUE if the #GVolume can be mounted.
274		func (x *VolumeIface) OverrideCanMount(cb func(Volume) bool) {	274		func (x *VolumeIface) OverrideCanMount(cb func(Volume) bool) {
275		if cb == nil {	275		if cb == nil {

@@ -281,7 +281,7 @@ func (x *VolumeIface) OverrideCanMount(cb func(Volume) bool) {
281		}	281		}
282		}	282		}
283			283
284	-	// GetCanMount gets the callback function.	284	+	// GetCanMount gets the "can_mount" callback function.
285		// Returns %TRUE if the #GVolume can be mounted.	285		// Returns %TRUE if the #GVolume can be mounted.
286		func (x *VolumeIface) GetCanMount() func(Volume) bool {	286		func (x *VolumeIface) GetCanMount() func(Volume) bool {
287		if x.xCanMount == 0 {	287		if x.xCanMount == 0 {

@@ -294,7 +294,7 @@ func (x *VolumeIface) GetCanMount() func(Volume) bool {
294		}	294		}
295		}	295		}
296			296
297	-	// OverrideCanEject sets the callback function.	297	+	// OverrideCanEject sets the "can_eject" callback function.
298		// Checks if a #GVolume can be ejected.	298		// Checks if a #GVolume can be ejected.
299		func (x *VolumeIface) OverrideCanEject(cb func(Volume) bool) {	299		func (x *VolumeIface) OverrideCanEject(cb func(Volume) bool) {
300		if cb == nil {	300		if cb == nil {

@@ -306,7 +306,7 @@ func (x *VolumeIface) OverrideCanEject(cb func(Volume) bool) {
306		}	306		}
307		}	307		}
308			308
309	-	// GetCanEject gets the callback function.	309	+	// GetCanEject gets the "can_eject" callback function.
310		// Checks if a #GVolume can be ejected.	310		// Checks if a #GVolume can be ejected.
311		func (x *VolumeIface) GetCanEject() func(Volume) bool {	311		func (x *VolumeIface) GetCanEject() func(Volume) bool {
312		if x.xCanEject == 0 {	312		if x.xCanEject == 0 {

@@ -319,7 +319,7 @@ func (x *VolumeIface) GetCanEject() func(Volume) bool {
319		}	319		}
320		}	320		}
321			321
322	-	// OverrideMountFn sets the callback function.	322	+	// OverrideMountFn sets the "mount_fn" callback function.
323		// Mounts a given #GVolume.	323		// Mounts a given #GVolume.
324		//	324		//
325		// #GVolume implementations must emit the #GMountOperation::aborted	325		// #GVolume implementations must emit the #GMountOperation::aborted

@@ -335,7 +335,7 @@ func (x VolumeIface) OverrideMountFn(cb func(Volume, MountMountFlags, MountOpe
335		}	335		}
336		}	336		}
337			337
338	-	// GetMountFn gets the callback function.	338	+	// GetMountFn gets the "mount_fn" callback function.
339		// Mounts a given #GVolume.	339		// Mounts a given #GVolume.
340		//	340		//
341		// #GVolume implementations must emit the #GMountOperation::aborted	341		// #GVolume implementations must emit the #GMountOperation::aborted

@@ -352,7 +352,7 @@ func (x VolumeIface) GetMountFn() func(Volume, MountMountFlags, MountOperation
352		}	352		}
353		}	353		}
354			354
355	-	// OverrideMountFinish sets the callback function.	355	+	// OverrideMountFinish sets the "mount_finish" callback function.
356		// Finishes a mount operation.	356		// Finishes a mount operation.
357		func (x *VolumeIface) OverrideMountFinish(cb func(Volume, AsyncResult) bool) {	357		func (x *VolumeIface) OverrideMountFinish(cb func(Volume, AsyncResult) bool) {
358		if cb == nil {	358		if cb == nil {

@@ -364,7 +364,7 @@ func (x *VolumeIface) OverrideMountFinish(cb func(Volume, AsyncResult) bool) {
364		}	364		}
365		}	365		}
366			366
367	-	// GetMountFinish gets the callback function.	367	+	// GetMountFinish gets the "mount_finish" callback function.
368		// Finishes a mount operation.	368		// Finishes a mount operation.
369		func (x *VolumeIface) GetMountFinish() func(Volume, AsyncResult) bool {	369		func (x *VolumeIface) GetMountFinish() func(Volume, AsyncResult) bool {
370		if x.xMountFinish == 0 {	370		if x.xMountFinish == 0 {

@@ -377,7 +377,7 @@ func (x *VolumeIface) GetMountFinish() func(Volume, AsyncResult) bool {
377		}	377		}
378		}	378		}
379			379
380	-	// OverrideEject sets the callback function.	380	+	// OverrideEject sets the "eject" callback function.
381		// Ejects a given #GVolume.	381		// Ejects a given #GVolume.
382		func (x VolumeIface) OverrideEject(cb func(Volume, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {	382		func (x VolumeIface) OverrideEject(cb func(Volume, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr)) {
383		if cb == nil {	383		if cb == nil {

@@ -389,7 +389,7 @@ func (x VolumeIface) OverrideEject(cb func(Volume, MountUnmountFlags, Cancella
389		}	389		}
390		}	390		}
391			391
392	-	// GetEject gets the callback function.	392	+	// GetEject gets the "eject" callback function.
393		// Ejects a given #GVolume.	393		// Ejects a given #GVolume.
394		func (x VolumeIface) GetEject() func(Volume, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {	394		func (x VolumeIface) GetEject() func(Volume, MountUnmountFlags, Cancellable, *AsyncReadyCallback, uintptr) {
395		if x.xEject == 0 {	395		if x.xEject == 0 {

@@ -402,7 +402,7 @@ func (x VolumeIface) GetEject() func(Volume, MountUnmountFlags, Cancellable, *
402		}	402		}
403		}	403		}
404			404
405	-	// OverrideEjectFinish sets the callback function.	405	+	// OverrideEjectFinish sets the "eject_finish" callback function.
406		// Finishes an eject operation.	406		// Finishes an eject operation.
407		func (x *VolumeIface) OverrideEjectFinish(cb func(Volume, AsyncResult) bool) {	407		func (x *VolumeIface) OverrideEjectFinish(cb func(Volume, AsyncResult) bool) {
408		if cb == nil {	408		if cb == nil {

@@ -414,7 +414,7 @@ func (x *VolumeIface) OverrideEjectFinish(cb func(Volume, AsyncResult) bool) {
414		}	414		}
415		}	415		}
416			416
417	-	// GetEjectFinish gets the callback function.	417	+	// GetEjectFinish gets the "eject_finish" callback function.
418		// Finishes an eject operation.	418		// Finishes an eject operation.
419		func (x *VolumeIface) GetEjectFinish() func(Volume, AsyncResult) bool {	419		func (x *VolumeIface) GetEjectFinish() func(Volume, AsyncResult) bool {
420		if x.xEjectFinish == 0 {	420		if x.xEjectFinish == 0 {

@@ -427,7 +427,7 @@ func (x *VolumeIface) GetEjectFinish() func(Volume, AsyncResult) bool {
427		}	427		}
428		}	428		}
429			429
430	-	// OverrideGetIdentifier sets the callback function.	430	+	// OverrideGetIdentifier sets the "get_identifier" callback function.
431		// Returns the [identifier](#volume-identifiers) of the given kind, or %NULL if	431		// Returns the [identifier](#volume-identifiers) of the given kind, or %NULL if
432		//	432		//
433		// the #GVolume doesn't have one.	433		// the #GVolume doesn't have one.

@@ -441,7 +441,7 @@ func (x *VolumeIface) OverrideGetIdentifier(cb func(Volume, string) string) {
441		}	441		}
442		}	442		}
443			443
444	-	// GetGetIdentifier gets the callback function.	444	+	// GetGetIdentifier gets the "get_identifier" callback function.
445		// Returns the [identifier](#volume-identifiers) of the given kind, or %NULL if	445		// Returns the [identifier](#volume-identifiers) of the given kind, or %NULL if
446		//	446		//
447		// the #GVolume doesn't have one.	447		// the #GVolume doesn't have one.

@@ -456,7 +456,7 @@ func (x *VolumeIface) GetGetIdentifier() func(Volume, string) string {
456		}	456		}
457		}	457		}
458			458
459	-	// OverrideEnumerateIdentifiers sets the callback function.	459	+	// OverrideEnumerateIdentifiers sets the "enumerate_identifiers" callback function.
460		// Returns an array strings listing the kinds	460		// Returns an array strings listing the kinds
461		//	461		//
462		// of [identifiers](#volume-identifiers) which the #GVolume has.	462		// of [identifiers](#volume-identifiers) which the #GVolume has.

@@ -470,7 +470,7 @@ func (x *VolumeIface) OverrideEnumerateIdentifiers(cb func(Volume) []string) {
470		}	470		}
471		}	471		}
472			472
473	-	// GetEnumerateIdentifiers gets the callback function.	473	+	// GetEnumerateIdentifiers gets the "enumerate_identifiers" callback function.
474		// Returns an array strings listing the kinds	474		// Returns an array strings listing the kinds
475		//	475		//
476		// of [identifiers](#volume-identifiers) which the #GVolume has.	476		// of [identifiers](#volume-identifiers) which the #GVolume has.

@@ -485,7 +485,7 @@ func (x *VolumeIface) GetEnumerateIdentifiers() func(Volume) []string {
485		}	485		}
486		}	486		}
487			487
488	-	// OverrideShouldAutomount sets the callback function.	488	+	// OverrideShouldAutomount sets the "should_automount" callback function.
489		// Returns %TRUE if the #GVolume should be automatically mounted.	489		// Returns %TRUE if the #GVolume should be automatically mounted.
490		func (x *VolumeIface) OverrideShouldAutomount(cb func(Volume) bool) {	490		func (x *VolumeIface) OverrideShouldAutomount(cb func(Volume) bool) {
491		if cb == nil {	491		if cb == nil {

@@ -497,7 +497,7 @@ func (x *VolumeIface) OverrideShouldAutomount(cb func(Volume) bool) {
497		}	497		}
498		}	498		}
499			499
500	-	// GetShouldAutomount gets the callback function.	500	+	// GetShouldAutomount gets the "should_automount" callback function.
501		// Returns %TRUE if the #GVolume should be automatically mounted.	501		// Returns %TRUE if the #GVolume should be automatically mounted.
502		func (x *VolumeIface) GetShouldAutomount() func(Volume) bool {	502		func (x *VolumeIface) GetShouldAutomount() func(Volume) bool {
503		if x.xShouldAutomount == 0 {	503		if x.xShouldAutomount == 0 {

@@ -510,7 +510,7 @@ func (x *VolumeIface) GetShouldAutomount() func(Volume) bool {
510		}	510		}
511		}	511		}
512			512
513	-	// OverrideGetActivationRoot sets the callback function.	513	+	// OverrideGetActivationRoot sets the "get_activation_root" callback function.
514		// Returns the activation root for the #GVolume if it is known in advance or %NULL if	514		// Returns the activation root for the #GVolume if it is known in advance or %NULL if
515		//	515		//
516		// it is not known.	516		// it is not known.

@@ -528,7 +528,7 @@ func (x VolumeIface) OverrideGetActivationRoot(cb func(Volume) FileBase) {
528		}	528		}
529		}	529		}
530			530
531	-	// GetGetActivationRoot gets the callback function.	531	+	// GetGetActivationRoot gets the "get_activation_root" callback function.
532		// Returns the activation root for the #GVolume if it is known in advance or %NULL if	532		// Returns the activation root for the #GVolume if it is known in advance or %NULL if
533		//	533		//
534		// it is not known.	534		// it is not known.

@@ -549,7 +549,7 @@ func (x VolumeIface) GetGetActivationRoot() func(Volume) FileBase {
549		}	549		}
550		}	550		}
551			551
552	-	// OverrideEjectWithOperation sets the callback function.	552	+	// OverrideEjectWithOperation sets the "eject_with_operation" callback function.
553		// Starts ejecting a #GVolume using a #GMountOperation. Since 2.22.	553		// Starts ejecting a #GVolume using a #GMountOperation. Since 2.22.
554		func (x VolumeIface) OverrideEjectWithOperation(cb func(Volume, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {	554		func (x VolumeIface) OverrideEjectWithOperation(cb func(Volume, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr)) {
555		if cb == nil {	555		if cb == nil {

@@ -561,7 +561,7 @@ func (x *VolumeIface) OverrideEjectWithOperation(cb func(Volume, MountUnmountFla
561		}	561		}
562		}	562		}
563			563
564	-	// GetEjectWithOperation gets the callback function.	564	+	// GetEjectWithOperation gets the "eject_with_operation" callback function.
565		// Starts ejecting a #GVolume using a #GMountOperation. Since 2.22.	565		// Starts ejecting a #GVolume using a #GMountOperation. Since 2.22.
566		func (x VolumeIface) GetEjectWithOperation() func(Volume, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {	566		func (x VolumeIface) GetEjectWithOperation() func(Volume, MountUnmountFlags, MountOperation, Cancellable, AsyncReadyCallback, uintptr) {
567		if x.xEjectWithOperation == 0 {	567		if x.xEjectWithOperation == 0 {

@@ -574,7 +574,7 @@ func (x VolumeIface) GetEjectWithOperation() func(Volume, MountUnmountFlags, M
574		}	574		}
575		}	575		}
576			576
577	-	// OverrideEjectWithOperationFinish sets the callback function.	577	+	// OverrideEjectWithOperationFinish sets the "eject_with_operation_finish" callback function.
578		// Finishes an eject operation using a #GMountOperation. Since 2.22.	578		// Finishes an eject operation using a #GMountOperation. Since 2.22.
579		func (x *VolumeIface) OverrideEjectWithOperationFinish(cb func(Volume, AsyncResult) bool) {	579		func (x *VolumeIface) OverrideEjectWithOperationFinish(cb func(Volume, AsyncResult) bool) {
580		if cb == nil {	580		if cb == nil {

@@ -586,7 +586,7 @@ func (x *VolumeIface) OverrideEjectWithOperationFinish(cb func(Volume, AsyncResu
586		}	586		}
587		}	587		}
588			588
589	-	// GetEjectWithOperationFinish gets the callback function.	589	+	// GetEjectWithOperationFinish gets the "eject_with_operation_finish" callback function.
590		// Finishes an eject operation using a #GMountOperation. Since 2.22.	590		// Finishes an eject operation using a #GMountOperation. Since 2.22.
591		func (x *VolumeIface) GetEjectWithOperationFinish() func(Volume, AsyncResult) bool {	591		func (x *VolumeIface) GetEjectWithOperationFinish() func(Volume, AsyncResult) bool {
592		if x.xEjectWithOperationFinish == 0 {	592		if x.xEjectWithOperationFinish == 0 {

@@ -599,7 +599,7 @@ func (x *VolumeIface) GetEjectWithOperationFinish() func(Volume, AsyncResult) bo
599		}	599		}
600		}	600		}
601			601
602	-	// OverrideGetSortKey sets the callback function.	602	+	// OverrideGetSortKey sets the "get_sort_key" callback function.
603		// Gets a key used for sorting #GVolume instance or %NULL if no such key exists. Since 2.32.	603		// Gets a key used for sorting #GVolume instance or %NULL if no such key exists. Since 2.32.
604		func (x *VolumeIface) OverrideGetSortKey(cb func(Volume) string) {	604		func (x *VolumeIface) OverrideGetSortKey(cb func(Volume) string) {
605		if cb == nil {	605		if cb == nil {

@@ -611,7 +611,7 @@ func (x *VolumeIface) OverrideGetSortKey(cb func(Volume) string) {
611		}	611		}
612		}	612		}
613			613
614	-	// GetGetSortKey gets the callback function.	614	+	// GetGetSortKey gets the "get_sort_key" callback function.
615		// Gets a key used for sorting #GVolume instance or %NULL if no such key exists. Since 2.32.	615		// Gets a key used for sorting #GVolume instance or %NULL if no such key exists. Since 2.32.
616		func (x *VolumeIface) GetGetSortKey() func(Volume) string {	616		func (x *VolumeIface) GetGetSortKey() func(Volume) string {
617		if x.xGetSortKey == 0 {	617		if x.xGetSortKey == 0 {

@@ -624,7 +624,7 @@ func (x *VolumeIface) GetGetSortKey() func(Volume) string {
624		}	624		}
625		}	625		}
626			626
627	-	// OverrideGetSymbolicIcon sets the callback function.	627	+	// OverrideGetSymbolicIcon sets the "get_symbolic_icon" callback function.
628		// Gets a symbolic #GIcon for the #GVolume. Since 2.34.	628		// Gets a symbolic #GIcon for the #GVolume. Since 2.34.
629		func (x VolumeIface) OverrideGetSymbolicIcon(cb func(Volume) IconBase) {	629		func (x VolumeIface) OverrideGetSymbolicIcon(cb func(Volume) IconBase) {
630		if cb == nil {	630		if cb == nil {

@@ -640,7 +640,7 @@ func (x VolumeIface) OverrideGetSymbolicIcon(cb func(Volume) IconBase) {
640		}	640		}
641		}	641		}
642			642
643	-	// GetGetSymbolicIcon gets the callback function.	643	+	// GetGetSymbolicIcon gets the "get_symbolic_icon" callback function.
644		// Gets a symbolic #GIcon for the #GVolume. Since 2.34.	644		// Gets a symbolic #GIcon for the #GVolume. Since 2.34.
645		func (x VolumeIface) GetGetSymbolicIcon() func(Volume) IconBase {	645		func (x VolumeIface) GetGetSymbolicIcon() func(Volume) IconBase {
646		if x.xGetSymbolicIcon == 0 {	646		if x.xGetSymbolicIcon == 0 {

M v4/gio/gvolumemonitor.go +50 -50


@@ -72,7 +72,7 @@ func (x *VolumeMonitorClass) GoPointer() uintptr {
72		return uintptr(unsafe.Pointer(x))	72		return uintptr(unsafe.Pointer(x))
73		}	73		}
74			74
75	-	// OverrideVolumeAdded sets the callback function.	75	+	// OverrideVolumeAdded sets the "volume_added" callback function.
76		func (x VolumeMonitorClass) OverrideVolumeAdded(cb func(VolumeMonitor, Volume)) {	76		func (x VolumeMonitorClass) OverrideVolumeAdded(cb func(VolumeMonitor, Volume)) {
77		if cb == nil {	77		if cb == nil {
78		x.xVolumeAdded = 0	78		x.xVolumeAdded = 0

@@ -83,7 +83,7 @@ func (x VolumeMonitorClass) OverrideVolumeAdded(cb func(VolumeMonitor, Volume)
83		}	83		}
84		}	84		}
85			85
86	-	// GetVolumeAdded gets the callback function.	86	+	// GetVolumeAdded gets the "volume_added" callback function.
87		func (x VolumeMonitorClass) GetVolumeAdded() func(VolumeMonitor, Volume) {	87		func (x VolumeMonitorClass) GetVolumeAdded() func(VolumeMonitor, Volume) {
88		if x.xVolumeAdded == 0 {	88		if x.xVolumeAdded == 0 {
89		return nil	89		return nil

@@ -95,7 +95,7 @@ func (x VolumeMonitorClass) GetVolumeAdded() func(VolumeMonitor, Volume) {
95		}	95		}
96		}	96		}
97			97
98	-	// OverrideVolumeRemoved sets the callback function.	98	+	// OverrideVolumeRemoved sets the "volume_removed" callback function.
99		func (x VolumeMonitorClass) OverrideVolumeRemoved(cb func(VolumeMonitor, Volume)) {	99		func (x VolumeMonitorClass) OverrideVolumeRemoved(cb func(VolumeMonitor, Volume)) {
100		if cb == nil {	100		if cb == nil {
101		x.xVolumeRemoved = 0	101		x.xVolumeRemoved = 0

@@ -106,7 +106,7 @@ func (x VolumeMonitorClass) OverrideVolumeRemoved(cb func(VolumeMonitor, Volum
106		}	106		}
107		}	107		}
108			108
109	-	// GetVolumeRemoved gets the callback function.	109	+	// GetVolumeRemoved gets the "volume_removed" callback function.
110		func (x VolumeMonitorClass) GetVolumeRemoved() func(VolumeMonitor, Volume) {	110		func (x VolumeMonitorClass) GetVolumeRemoved() func(VolumeMonitor, Volume) {
111		if x.xVolumeRemoved == 0 {	111		if x.xVolumeRemoved == 0 {
112		return nil	112		return nil

@@ -118,7 +118,7 @@ func (x VolumeMonitorClass) GetVolumeRemoved() func(VolumeMonitor, Volume) {
118		}	118		}
119		}	119		}
120			120
121	-	// OverrideVolumeChanged sets the callback function.	121	+	// OverrideVolumeChanged sets the "volume_changed" callback function.
122		func (x VolumeMonitorClass) OverrideVolumeChanged(cb func(VolumeMonitor, Volume)) {	122		func (x VolumeMonitorClass) OverrideVolumeChanged(cb func(VolumeMonitor, Volume)) {
123		if cb == nil {	123		if cb == nil {
124		x.xVolumeChanged = 0	124		x.xVolumeChanged = 0

@@ -129,7 +129,7 @@ func (x VolumeMonitorClass) OverrideVolumeChanged(cb func(VolumeMonitor, Volum
129		}	129		}
130		}	130		}
131			131
132	-	// GetVolumeChanged gets the callback function.	132	+	// GetVolumeChanged gets the "volume_changed" callback function.
133		func (x VolumeMonitorClass) GetVolumeChanged() func(VolumeMonitor, Volume) {	133		func (x VolumeMonitorClass) GetVolumeChanged() func(VolumeMonitor, Volume) {
134		if x.xVolumeChanged == 0 {	134		if x.xVolumeChanged == 0 {
135		return nil	135		return nil

@@ -141,7 +141,7 @@ func (x VolumeMonitorClass) GetVolumeChanged() func(VolumeMonitor, Volume) {
141		}	141		}
142		}	142		}
143			143
144	-	// OverrideMountAdded sets the callback function.	144	+	// OverrideMountAdded sets the "mount_added" callback function.
145		func (x VolumeMonitorClass) OverrideMountAdded(cb func(VolumeMonitor, Mount)) {	145		func (x VolumeMonitorClass) OverrideMountAdded(cb func(VolumeMonitor, Mount)) {
146		if cb == nil {	146		if cb == nil {
147		x.xMountAdded = 0	147		x.xMountAdded = 0

@@ -152,7 +152,7 @@ func (x VolumeMonitorClass) OverrideMountAdded(cb func(VolumeMonitor, Mount))
152		}	152		}
153		}	153		}
154			154
155	-	// GetMountAdded gets the callback function.	155	+	// GetMountAdded gets the "mount_added" callback function.
156		func (x VolumeMonitorClass) GetMountAdded() func(VolumeMonitor, Mount) {	156		func (x VolumeMonitorClass) GetMountAdded() func(VolumeMonitor, Mount) {
157		if x.xMountAdded == 0 {	157		if x.xMountAdded == 0 {
158		return nil	158		return nil

@@ -164,7 +164,7 @@ func (x VolumeMonitorClass) GetMountAdded() func(VolumeMonitor, Mount) {
164		}	164		}
165		}	165		}
166			166
167	-	// OverrideMountRemoved sets the callback function.	167	+	// OverrideMountRemoved sets the "mount_removed" callback function.
168		func (x VolumeMonitorClass) OverrideMountRemoved(cb func(VolumeMonitor, Mount)) {	168		func (x VolumeMonitorClass) OverrideMountRemoved(cb func(VolumeMonitor, Mount)) {
169		if cb == nil {	169		if cb == nil {
170		x.xMountRemoved = 0	170		x.xMountRemoved = 0

@@ -175,7 +175,7 @@ func (x VolumeMonitorClass) OverrideMountRemoved(cb func(VolumeMonitor, Mount)
175		}	175		}
176		}	176		}
177			177
178	-	// GetMountRemoved gets the callback function.	178	+	// GetMountRemoved gets the "mount_removed" callback function.
179		func (x VolumeMonitorClass) GetMountRemoved() func(VolumeMonitor, Mount) {	179		func (x VolumeMonitorClass) GetMountRemoved() func(VolumeMonitor, Mount) {
180		if x.xMountRemoved == 0 {	180		if x.xMountRemoved == 0 {
181		return nil	181		return nil

@@ -187,7 +187,7 @@ func (x VolumeMonitorClass) GetMountRemoved() func(VolumeMonitor, Mount) {
187		}	187		}
188		}	188		}
189			189
190	-	// OverrideMountPreUnmount sets the callback function.	190	+	// OverrideMountPreUnmount sets the "mount_pre_unmount" callback function.
191		func (x VolumeMonitorClass) OverrideMountPreUnmount(cb func(VolumeMonitor, Mount)) {	191		func (x VolumeMonitorClass) OverrideMountPreUnmount(cb func(VolumeMonitor, Mount)) {
192		if cb == nil {	192		if cb == nil {
193		x.xMountPreUnmount = 0	193		x.xMountPreUnmount = 0

@@ -198,7 +198,7 @@ func (x VolumeMonitorClass) OverrideMountPreUnmount(cb func(VolumeMonitor, Mou
198		}	198		}
199		}	199		}
200			200
201	-	// GetMountPreUnmount gets the callback function.	201	+	// GetMountPreUnmount gets the "mount_pre_unmount" callback function.
202		func (x VolumeMonitorClass) GetMountPreUnmount() func(VolumeMonitor, Mount) {	202		func (x VolumeMonitorClass) GetMountPreUnmount() func(VolumeMonitor, Mount) {
203		if x.xMountPreUnmount == 0 {	203		if x.xMountPreUnmount == 0 {
204		return nil	204		return nil

@@ -210,7 +210,7 @@ func (x VolumeMonitorClass) GetMountPreUnmount() func(VolumeMonitor, Mount) {
210		}	210		}
211		}	211		}
212			212
213	-	// OverrideMountChanged sets the callback function.	213	+	// OverrideMountChanged sets the "mount_changed" callback function.
214		func (x VolumeMonitorClass) OverrideMountChanged(cb func(VolumeMonitor, Mount)) {	214		func (x VolumeMonitorClass) OverrideMountChanged(cb func(VolumeMonitor, Mount)) {
215		if cb == nil {	215		if cb == nil {
216		x.xMountChanged = 0	216		x.xMountChanged = 0

@@ -221,7 +221,7 @@ func (x VolumeMonitorClass) OverrideMountChanged(cb func(VolumeMonitor, Mount)
221		}	221		}
222		}	222		}
223			223
224	-	// GetMountChanged gets the callback function.	224	+	// GetMountChanged gets the "mount_changed" callback function.
225		func (x VolumeMonitorClass) GetMountChanged() func(VolumeMonitor, Mount) {	225		func (x VolumeMonitorClass) GetMountChanged() func(VolumeMonitor, Mount) {
226		if x.xMountChanged == 0 {	226		if x.xMountChanged == 0 {
227		return nil	227		return nil

@@ -233,7 +233,7 @@ func (x VolumeMonitorClass) GetMountChanged() func(VolumeMonitor, Mount) {
233		}	233		}
234		}	234		}
235			235
236	-	// OverrideDriveConnected sets the callback function.	236	+	// OverrideDriveConnected sets the "drive_connected" callback function.
237		func (x VolumeMonitorClass) OverrideDriveConnected(cb func(VolumeMonitor, Drive)) {	237		func (x VolumeMonitorClass) OverrideDriveConnected(cb func(VolumeMonitor, Drive)) {
238		if cb == nil {	238		if cb == nil {
239		x.xDriveConnected = 0	239		x.xDriveConnected = 0

@@ -244,7 +244,7 @@ func (x VolumeMonitorClass) OverrideDriveConnected(cb func(VolumeMonitor, Driv
244		}	244		}
245		}	245		}
246			246
247	-	// GetDriveConnected gets the callback function.	247	+	// GetDriveConnected gets the "drive_connected" callback function.
248		func (x VolumeMonitorClass) GetDriveConnected() func(VolumeMonitor, Drive) {	248		func (x VolumeMonitorClass) GetDriveConnected() func(VolumeMonitor, Drive) {
249		if x.xDriveConnected == 0 {	249		if x.xDriveConnected == 0 {
250		return nil	250		return nil

@@ -256,7 +256,7 @@ func (x VolumeMonitorClass) GetDriveConnected() func(VolumeMonitor, Drive) {
256		}	256		}
257		}	257		}
258			258
259	-	// OverrideDriveDisconnected sets the callback function.	259	+	// OverrideDriveDisconnected sets the "drive_disconnected" callback function.
260		func (x VolumeMonitorClass) OverrideDriveDisconnected(cb func(VolumeMonitor, Drive)) {	260		func (x VolumeMonitorClass) OverrideDriveDisconnected(cb func(VolumeMonitor, Drive)) {
261		if cb == nil {	261		if cb == nil {
262		x.xDriveDisconnected = 0	262		x.xDriveDisconnected = 0

@@ -267,7 +267,7 @@ func (x VolumeMonitorClass) OverrideDriveDisconnected(cb func(VolumeMonitor, D
267		}	267		}
268		}	268		}
269			269
270	-	// GetDriveDisconnected gets the callback function.	270	+	// GetDriveDisconnected gets the "drive_disconnected" callback function.
271		func (x VolumeMonitorClass) GetDriveDisconnected() func(VolumeMonitor, Drive) {	271		func (x VolumeMonitorClass) GetDriveDisconnected() func(VolumeMonitor, Drive) {
272		if x.xDriveDisconnected == 0 {	272		if x.xDriveDisconnected == 0 {
273		return nil	273		return nil

@@ -279,7 +279,7 @@ func (x VolumeMonitorClass) GetDriveDisconnected() func(VolumeMonitor, Drive)
279		}	279		}
280		}	280		}
281			281
282	-	// OverrideDriveChanged sets the callback function.	282	+	// OverrideDriveChanged sets the "drive_changed" callback function.
283		func (x VolumeMonitorClass) OverrideDriveChanged(cb func(VolumeMonitor, Drive)) {	283		func (x VolumeMonitorClass) OverrideDriveChanged(cb func(VolumeMonitor, Drive)) {
284		if cb == nil {	284		if cb == nil {
285		x.xDriveChanged = 0	285		x.xDriveChanged = 0

@@ -290,7 +290,7 @@ func (x VolumeMonitorClass) OverrideDriveChanged(cb func(VolumeMonitor, Drive)
290		}	290		}
291		}	291		}
292			292
293	-	// GetDriveChanged gets the callback function.	293	+	// GetDriveChanged gets the "drive_changed" callback function.
294		func (x VolumeMonitorClass) GetDriveChanged() func(VolumeMonitor, Drive) {	294		func (x VolumeMonitorClass) GetDriveChanged() func(VolumeMonitor, Drive) {
295		if x.xDriveChanged == 0 {	295		if x.xDriveChanged == 0 {
296		return nil	296		return nil

@@ -302,7 +302,7 @@ func (x VolumeMonitorClass) GetDriveChanged() func(VolumeMonitor, Drive) {
302		}	302		}
303		}	303		}
304			304
305	-	// OverrideIsSupported sets the callback function.	305	+	// OverrideIsSupported sets the "is_supported" callback function.
306		func (x *VolumeMonitorClass) OverrideIsSupported(cb func() bool) {	306		func (x *VolumeMonitorClass) OverrideIsSupported(cb func() bool) {
307		if cb == nil {	307		if cb == nil {
308		x.xIsSupported = 0	308		x.xIsSupported = 0

@@ -313,7 +313,7 @@ func (x *VolumeMonitorClass) OverrideIsSupported(cb func() bool) {
313		}	313		}
314		}	314		}
315			315
316	-	// GetIsSupported gets the callback function.	316	+	// GetIsSupported gets the "is_supported" callback function.
317		func (x *VolumeMonitorClass) GetIsSupported() func() bool {	317		func (x *VolumeMonitorClass) GetIsSupported() func() bool {
318		if x.xIsSupported == 0 {	318		if x.xIsSupported == 0 {
319		return nil	319		return nil

@@ -325,7 +325,7 @@ func (x *VolumeMonitorClass) GetIsSupported() func() bool {
325		}	325		}
326		}	326		}
327			327
328	-	// OverrideGetConnectedDrives sets the callback function.	328	+	// OverrideGetConnectedDrives sets the "get_connected_drives" callback function.
329		func (x VolumeMonitorClass) OverrideGetConnectedDrives(cb func(VolumeMonitor) *glib.List) {	329		func (x VolumeMonitorClass) OverrideGetConnectedDrives(cb func(VolumeMonitor) *glib.List) {
330		if cb == nil {	330		if cb == nil {
331		x.xGetConnectedDrives = 0	331		x.xGetConnectedDrives = 0

@@ -336,7 +336,7 @@ func (x VolumeMonitorClass) OverrideGetConnectedDrives(cb func(VolumeMonitor)
336		}	336		}
337		}	337		}
338			338
339	-	// GetGetConnectedDrives gets the callback function.	339	+	// GetGetConnectedDrives gets the "get_connected_drives" callback function.
340		func (x VolumeMonitorClass) GetGetConnectedDrives() func(VolumeMonitor) *glib.List {	340		func (x VolumeMonitorClass) GetGetConnectedDrives() func(VolumeMonitor) *glib.List {
341		if x.xGetConnectedDrives == 0 {	341		if x.xGetConnectedDrives == 0 {
342		return nil	342		return nil

@@ -348,7 +348,7 @@ func (x VolumeMonitorClass) GetGetConnectedDrives() func(VolumeMonitor) *glib.
348		}	348		}
349		}	349		}
350			350
351	-	// OverrideGetVolumes sets the callback function.	351	+	// OverrideGetVolumes sets the "get_volumes" callback function.
352		func (x VolumeMonitorClass) OverrideGetVolumes(cb func(VolumeMonitor) *glib.List) {	352		func (x VolumeMonitorClass) OverrideGetVolumes(cb func(VolumeMonitor) *glib.List) {
353		if cb == nil {	353		if cb == nil {
354		x.xGetVolumes = 0	354		x.xGetVolumes = 0

@@ -359,7 +359,7 @@ func (x VolumeMonitorClass) OverrideGetVolumes(cb func(VolumeMonitor) *glib.Li
359		}	359		}
360		}	360		}
361			361
362	-	// GetGetVolumes gets the callback function.	362	+	// GetGetVolumes gets the "get_volumes" callback function.
363		func (x VolumeMonitorClass) GetGetVolumes() func(VolumeMonitor) *glib.List {	363		func (x VolumeMonitorClass) GetGetVolumes() func(VolumeMonitor) *glib.List {
364		if x.xGetVolumes == 0 {	364		if x.xGetVolumes == 0 {
365		return nil	365		return nil

@@ -371,7 +371,7 @@ func (x VolumeMonitorClass) GetGetVolumes() func(VolumeMonitor) *glib.List {
371		}	371		}
372		}	372		}
373			373
374	-	// OverrideGetMounts sets the callback function.	374	+	// OverrideGetMounts sets the "get_mounts" callback function.
375		func (x VolumeMonitorClass) OverrideGetMounts(cb func(VolumeMonitor) *glib.List) {	375		func (x VolumeMonitorClass) OverrideGetMounts(cb func(VolumeMonitor) *glib.List) {
376		if cb == nil {	376		if cb == nil {
377		x.xGetMounts = 0	377		x.xGetMounts = 0

@@ -382,7 +382,7 @@ func (x VolumeMonitorClass) OverrideGetMounts(cb func(VolumeMonitor) *glib.Lis
382		}	382		}
383		}	383		}
384			384
385	-	// GetGetMounts gets the callback function.	385	+	// GetGetMounts gets the "get_mounts" callback function.
386		func (x VolumeMonitorClass) GetGetMounts() func(VolumeMonitor) *glib.List {	386		func (x VolumeMonitorClass) GetGetMounts() func(VolumeMonitor) *glib.List {
387		if x.xGetMounts == 0 {	387		if x.xGetMounts == 0 {
388		return nil	388		return nil

@@ -394,7 +394,7 @@ func (x VolumeMonitorClass) GetGetMounts() func(VolumeMonitor) *glib.List {
394		}	394		}
395		}	395		}
396			396
397	-	// OverrideGetVolumeForUuid sets the callback function.	397	+	// OverrideGetVolumeForUuid sets the "get_volume_for_uuid" callback function.
398		func (x VolumeMonitorClass) OverrideGetVolumeForUuid(cb func(VolumeMonitor, string) *VolumeBase) {	398		func (x VolumeMonitorClass) OverrideGetVolumeForUuid(cb func(VolumeMonitor, string) *VolumeBase) {
399		if cb == nil {	399		if cb == nil {
400		x.xGetVolumeForUuid = 0	400		x.xGetVolumeForUuid = 0

@@ -409,7 +409,7 @@ func (x VolumeMonitorClass) OverrideGetVolumeForUuid(cb func(VolumeMonitor, st
409		}	409		}
410		}	410		}
411			411
412	-	// GetGetVolumeForUuid gets the callback function.	412	+	// GetGetVolumeForUuid gets the "get_volume_for_uuid" callback function.
413		func (x VolumeMonitorClass) GetGetVolumeForUuid() func(VolumeMonitor, string) *VolumeBase {	413		func (x VolumeMonitorClass) GetGetVolumeForUuid() func(VolumeMonitor, string) *VolumeBase {
414		if x.xGetVolumeForUuid == 0 {	414		if x.xGetVolumeForUuid == 0 {
415		return nil	415		return nil

@@ -427,7 +427,7 @@ func (x VolumeMonitorClass) GetGetVolumeForUuid() func(VolumeMonitor, string)
427		}	427		}
428		}	428		}
429			429
430	-	// OverrideGetMountForUuid sets the callback function.	430	+	// OverrideGetMountForUuid sets the "get_mount_for_uuid" callback function.
431		func (x VolumeMonitorClass) OverrideGetMountForUuid(cb func(VolumeMonitor, string) *MountBase) {	431		func (x VolumeMonitorClass) OverrideGetMountForUuid(cb func(VolumeMonitor, string) *MountBase) {
432		if cb == nil {	432		if cb == nil {
433		x.xGetMountForUuid = 0	433		x.xGetMountForUuid = 0

@@ -442,7 +442,7 @@ func (x VolumeMonitorClass) OverrideGetMountForUuid(cb func(VolumeMonitor, str
442		}	442		}
443		}	443		}
444			444
445	-	// GetGetMountForUuid gets the callback function.	445	+	// GetGetMountForUuid gets the "get_mount_for_uuid" callback function.
446		func (x VolumeMonitorClass) GetGetMountForUuid() func(VolumeMonitor, string) *MountBase {	446		func (x VolumeMonitorClass) GetGetMountForUuid() func(VolumeMonitor, string) *MountBase {
447		if x.xGetMountForUuid == 0 {	447		if x.xGetMountForUuid == 0 {
448		return nil	448		return nil

@@ -460,7 +460,7 @@ func (x VolumeMonitorClass) GetGetMountForUuid() func(VolumeMonitor, string) *
460		}	460		}
461		}	461		}
462			462
463	-	// OverrideAdoptOrphanMount sets the callback function.	463	+	// OverrideAdoptOrphanMount sets the "adopt_orphan_mount" callback function.
464		func (x VolumeMonitorClass) OverrideAdoptOrphanMount(cb func(Mount, VolumeMonitor) *VolumeBase) {	464		func (x VolumeMonitorClass) OverrideAdoptOrphanMount(cb func(Mount, VolumeMonitor) *VolumeBase) {
465		if cb == nil {	465		if cb == nil {
466		x.xAdoptOrphanMount = 0	466		x.xAdoptOrphanMount = 0

@@ -475,7 +475,7 @@ func (x VolumeMonitorClass) OverrideAdoptOrphanMount(cb func(Mount, VolumeMoni
475		}	475		}
476		}	476		}
477			477
478	-	// GetAdoptOrphanMount gets the callback function.	478	+	// GetAdoptOrphanMount gets the "adopt_orphan_mount" callback function.
479		func (x VolumeMonitorClass) GetAdoptOrphanMount() func(Mount, VolumeMonitor) *VolumeBase {	479		func (x VolumeMonitorClass) GetAdoptOrphanMount() func(Mount, VolumeMonitor) *VolumeBase {
480		if x.xAdoptOrphanMount == 0 {	480		if x.xAdoptOrphanMount == 0 {
481		return nil	481		return nil

@@ -493,7 +493,7 @@ func (x VolumeMonitorClass) GetAdoptOrphanMount() func(Mount, VolumeMonitor) *
493		}	493		}
494		}	494		}
495			495
496	-	// OverrideDriveEjectButton sets the callback function.	496	+	// OverrideDriveEjectButton sets the "drive_eject_button" callback function.
497		func (x VolumeMonitorClass) OverrideDriveEjectButton(cb func(VolumeMonitor, Drive)) {	497		func (x VolumeMonitorClass) OverrideDriveEjectButton(cb func(VolumeMonitor, Drive)) {
498		if cb == nil {	498		if cb == nil {
499		x.xDriveEjectButton = 0	499		x.xDriveEjectButton = 0

@@ -504,7 +504,7 @@ func (x VolumeMonitorClass) OverrideDriveEjectButton(cb func(VolumeMonitor, Dr
504		}	504		}
505		}	505		}
506			506
507	-	// GetDriveEjectButton gets the callback function.	507	+	// GetDriveEjectButton gets the "drive_eject_button" callback function.
508		func (x VolumeMonitorClass) GetDriveEjectButton() func(VolumeMonitor, Drive) {	508		func (x VolumeMonitorClass) GetDriveEjectButton() func(VolumeMonitor, Drive) {
509		if x.xDriveEjectButton == 0 {	509		if x.xDriveEjectButton == 0 {
510		return nil	510		return nil

@@ -516,7 +516,7 @@ func (x VolumeMonitorClass) GetDriveEjectButton() func(VolumeMonitor, Drive) {
516		}	516		}
517		}	517		}
518			518
519	-	// OverrideDriveStopButton sets the callback function.	519	+	// OverrideDriveStopButton sets the "drive_stop_button" callback function.
520		func (x VolumeMonitorClass) OverrideDriveStopButton(cb func(VolumeMonitor, Drive)) {	520		func (x VolumeMonitorClass) OverrideDriveStopButton(cb func(VolumeMonitor, Drive)) {
521		if cb == nil {	521		if cb == nil {
522		x.xDriveStopButton = 0	522		x.xDriveStopButton = 0

@@ -527,7 +527,7 @@ func (x VolumeMonitorClass) OverrideDriveStopButton(cb func(VolumeMonitor, Dri
527		}	527		}
528		}	528		}
529			529
530	-	// GetDriveStopButton gets the callback function.	530	+	// GetDriveStopButton gets the "drive_stop_button" callback function.
531		func (x VolumeMonitorClass) GetDriveStopButton() func(VolumeMonitor, Drive) {	531		func (x VolumeMonitorClass) GetDriveStopButton() func(VolumeMonitor, Drive) {
532		if x.xDriveStopButton == 0 {	532		if x.xDriveStopButton == 0 {
533		return nil	533		return nil

@@ -539,7 +539,7 @@ func (x VolumeMonitorClass) GetDriveStopButton() func(VolumeMonitor, Drive) {
539		}	539		}
540		}	540		}
541			541
542	-	// OverrideGReserved1 sets the callback function.	542	+	// OverrideGReserved1 sets the "_g_reserved1" callback function.
543		func (x *VolumeMonitorClass) OverrideGReserved1(cb func()) {	543		func (x *VolumeMonitorClass) OverrideGReserved1(cb func()) {
544		if cb == nil {	544		if cb == nil {
545		x.xGReserved1 = 0	545		x.xGReserved1 = 0

@@ -550,7 +550,7 @@ func (x *VolumeMonitorClass) OverrideGReserved1(cb func()) {
550		}	550		}
551		}	551		}
552			552
553	-	// GetGReserved1 gets the callback function.	553	+	// GetGReserved1 gets the "_g_reserved1" callback function.
554		func (x *VolumeMonitorClass) GetGReserved1() func() {	554		func (x *VolumeMonitorClass) GetGReserved1() func() {
555		if x.xGReserved1 == 0 {	555		if x.xGReserved1 == 0 {
556		return nil	556		return nil

@@ -562,7 +562,7 @@ func (x *VolumeMonitorClass) GetGReserved1() func() {
562		}	562		}
563		}	563		}
564			564
565	-	// OverrideGReserved2 sets the callback function.	565	+	// OverrideGReserved2 sets the "_g_reserved2" callback function.
566		func (x *VolumeMonitorClass) OverrideGReserved2(cb func()) {	566		func (x *VolumeMonitorClass) OverrideGReserved2(cb func()) {
567		if cb == nil {	567		if cb == nil {
568		x.xGReserved2 = 0	568		x.xGReserved2 = 0

@@ -573,7 +573,7 @@ func (x *VolumeMonitorClass) OverrideGReserved2(cb func()) {
573		}	573		}
574		}	574		}
575			575
576	-	// GetGReserved2 gets the callback function.	576	+	// GetGReserved2 gets the "_g_reserved2" callback function.
577		func (x *VolumeMonitorClass) GetGReserved2() func() {	577		func (x *VolumeMonitorClass) GetGReserved2() func() {
578		if x.xGReserved2 == 0 {	578		if x.xGReserved2 == 0 {
579		return nil	579		return nil

@@ -585,7 +585,7 @@ func (x *VolumeMonitorClass) GetGReserved2() func() {
585		}	585		}
586		}	586		}
587			587
588	-	// OverrideGReserved3 sets the callback function.	588	+	// OverrideGReserved3 sets the "_g_reserved3" callback function.
589		func (x *VolumeMonitorClass) OverrideGReserved3(cb func()) {	589		func (x *VolumeMonitorClass) OverrideGReserved3(cb func()) {
590		if cb == nil {	590		if cb == nil {
591		x.xGReserved3 = 0	591		x.xGReserved3 = 0

@@ -596,7 +596,7 @@ func (x *VolumeMonitorClass) OverrideGReserved3(cb func()) {
596		}	596		}
597		}	597		}
598			598
599	-	// GetGReserved3 gets the callback function.	599	+	// GetGReserved3 gets the "_g_reserved3" callback function.
600		func (x *VolumeMonitorClass) GetGReserved3() func() {	600		func (x *VolumeMonitorClass) GetGReserved3() func() {
601		if x.xGReserved3 == 0 {	601		if x.xGReserved3 == 0 {
602		return nil	602		return nil

@@ -608,7 +608,7 @@ func (x *VolumeMonitorClass) GetGReserved3() func() {
608		}	608		}
609		}	609		}
610			610
611	-	// OverrideGReserved4 sets the callback function.	611	+	// OverrideGReserved4 sets the "_g_reserved4" callback function.
612		func (x *VolumeMonitorClass) OverrideGReserved4(cb func()) {	612		func (x *VolumeMonitorClass) OverrideGReserved4(cb func()) {
613		if cb == nil {	613		if cb == nil {
614		x.xGReserved4 = 0	614		x.xGReserved4 = 0

@@ -619,7 +619,7 @@ func (x *VolumeMonitorClass) OverrideGReserved4(cb func()) {
619		}	619		}
620		}	620		}
621			621
622	-	// GetGReserved4 gets the callback function.	622	+	// GetGReserved4 gets the "_g_reserved4" callback function.
623		func (x *VolumeMonitorClass) GetGReserved4() func() {	623		func (x *VolumeMonitorClass) GetGReserved4() func() {
624		if x.xGReserved4 == 0 {	624		if x.xGReserved4 == 0 {
625		return nil	625		return nil

@@ -631,7 +631,7 @@ func (x *VolumeMonitorClass) GetGReserved4() func() {
631		}	631		}
632		}	632		}
633			633
634	-	// OverrideGReserved5 sets the callback function.	634	+	// OverrideGReserved5 sets the "_g_reserved5" callback function.
635		func (x *VolumeMonitorClass) OverrideGReserved5(cb func()) {	635		func (x *VolumeMonitorClass) OverrideGReserved5(cb func()) {
636		if cb == nil {	636		if cb == nil {
637		x.xGReserved5 = 0	637		x.xGReserved5 = 0

@@ -642,7 +642,7 @@ func (x *VolumeMonitorClass) OverrideGReserved5(cb func()) {
642		}	642		}
643		}	643		}
644			644
645	-	// GetGReserved5 gets the callback function.	645	+	// GetGReserved5 gets the "_g_reserved5" callback function.
646		func (x *VolumeMonitorClass) GetGReserved5() func() {	646		func (x *VolumeMonitorClass) GetGReserved5() func() {
647		if x.xGReserved5 == 0 {	647		if x.xGReserved5 == 0 {
648		return nil	648		return nil

@@ -654,7 +654,7 @@ func (x *VolumeMonitorClass) GetGReserved5() func() {
654		}	654		}
655		}	655		}
656			656
657	-	// OverrideGReserved6 sets the callback function.	657	+	// OverrideGReserved6 sets the "_g_reserved6" callback function.
658		func (x *VolumeMonitorClass) OverrideGReserved6(cb func()) {	658		func (x *VolumeMonitorClass) OverrideGReserved6(cb func()) {
659		if cb == nil {	659		if cb == nil {
660		x.xGReserved6 = 0	660		x.xGReserved6 = 0

@@ -665,7 +665,7 @@ func (x *VolumeMonitorClass) OverrideGReserved6(cb func()) {
665		}	665		}
666		}	666		}
667			667
668	-	// GetGReserved6 gets the callback function.	668	+	// GetGReserved6 gets the "_g_reserved6" callback function.
669		func (x *VolumeMonitorClass) GetGReserved6() func() {	669		func (x *VolumeMonitorClass) GetGReserved6() func() {
670		if x.xGReserved6 == 0 {	670		if x.xGReserved6 == 0 {
671		return nil	671		return nil

M v4/gio/gzlibcompressor.go +59 -1


@@ -119,6 +119,64 @@ func (c *ZlibCompressor) SetGoPointer(ptr uintptr) {
119		c.Ptr = ptr	119		c.Ptr = ptr
120		}	120		}
121			121
			122	+	// SetPropertyLevel sets the "level" property.
			123	+	// The level of compression from `0` (no compression) to `9` (most
			124	+	// compression).
			125	+	//
			126	+	// `-1` for the default level.
			127	+	func (x *ZlibCompressor) SetPropertyLevel(value int) {
			128	+	var v gobject.Value
			129	+	v.Init(gobject.TypeIntVal)
			130	+	v.SetInt(value)
			131	+	x.SetProperty("level", &v)
			132	+	}
			133	+
			134	+	// GetPropertyLevel gets the "level" property.
			135	+	// The level of compression from `0` (no compression) to `9` (most
			136	+	// compression).
			137	+	//
			138	+	// `-1` for the default level.
			139	+	func (x *ZlibCompressor) GetPropertyLevel() int {
			140	+	var v gobject.Value
			141	+	x.GetProperty("level", &v)
			142	+	return v.GetInt()
			143	+	}
			144	+
			145	+	// SetPropertyOs sets the "os" property.
			146	+	// The OS code of the gzip header.
			147	+	//
			148	+	// This will be used if set to a non-negative value, and if
			149	+	// [property@Gio.ZlibCompressor:format] is
			150	+	// [enum@Gio.ZlibCompressorFormat.GZIP], the compressor will set the OS code of
			151	+	// the gzip header to this value.
			152	+	//
			153	+	// If the value is unset, zlib will set the OS code depending on the platform.
			154	+	// This may be undesirable when reproducible output is desired. In that case setting
			155	+	// the OS code to `3` (for Unix) is recommended.
			156	+	func (x *ZlibCompressor) SetPropertyOs(value int) {
			157	+	var v gobject.Value
			158	+	v.Init(gobject.TypeIntVal)
			159	+	v.SetInt(value)
			160	+	x.SetProperty("os", &v)
			161	+	}
			162	+
			163	+	// GetPropertyOs gets the "os" property.
			164	+	// The OS code of the gzip header.
			165	+	//
			166	+	// This will be used if set to a non-negative value, and if
			167	+	// [property@Gio.ZlibCompressor:format] is
			168	+	// [enum@Gio.ZlibCompressorFormat.GZIP], the compressor will set the OS code of
			169	+	// the gzip header to this value.
			170	+	//
			171	+	// If the value is unset, zlib will set the OS code depending on the platform.
			172	+	// This may be undesirable when reproducible output is desired. In that case setting
			173	+	// the OS code to `3` (for Unix) is recommended.
			174	+	func (x *ZlibCompressor) GetPropertyOs() int {
			175	+	var v gobject.Value
			176	+	x.GetProperty("os", &v)
			177	+	return v.GetInt()
			178	+	}
			179	+
122		// This is the main operation used when converting data. It is to be called	180		// This is the main operation used when converting data. It is to be called
123		// multiple times in a loop, and each time it will do some work, i.e.	181		// multiple times in a loop, and each time it will do some work, i.e.
124		// producing some output (in @outbuf) or consuming some input (from @inbuf) or	182		// producing some output (in @outbuf) or consuming some input (from @inbuf) or

@@ -201,7 +259,7 @@ func (c *ZlibCompressor) SetGoPointer(ptr uintptr) {
201		// at a partial multibyte sequence). Converters are supposed to try	259		// at a partial multibyte sequence). Converters are supposed to try
202		// to produce as much output as possible and then return an error	260		// to produce as much output as possible and then return an error
203		// (typically %G_IO_ERROR_PARTIAL_INPUT).	261		// (typically %G_IO_ERROR_PARTIAL_INPUT).
204	-	func (x *ZlibCompressor) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar uint) (ConverterResult, error) {	262	+	func (x ZlibCompressor) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar *uint) (ConverterResult, error) {
205		var cerr *glib.Error	263		var cerr *glib.Error
206			264
207		cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)	265		cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)

M v4/gio/gzlibdecompressor.go +1 -1


@@ -166,7 +166,7 @@ func (c *ZlibDecompressor) SetGoPointer(ptr uintptr) {
166		// at a partial multibyte sequence). Converters are supposed to try	166		// at a partial multibyte sequence). Converters are supposed to try
167		// to produce as much output as possible and then return an error	167		// to produce as much output as possible and then return an error
168		// (typically %G_IO_ERROR_PARTIAL_INPUT).	168		// (typically %G_IO_ERROR_PARTIAL_INPUT).
169	-	func (x *ZlibDecompressor) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar uint) (ConverterResult, error) {	169	+	func (x ZlibDecompressor) Convert(InbufVar []byte, InbufSizeVar uint, OutbufVar []byte, OutbufSizeVar uint, FlagsVar ConverterFlags, BytesReadVar uint, BytesWrittenVar *uint) (ConverterResult, error) {
170		var cerr *glib.Error	170		var cerr *glib.Error
171			171
172		cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)	172		cret := XGConverterConvert(x.GoPointer(), InbufVar, InbufSizeVar, OutbufVar, OutbufSizeVar, FlagsVar, BytesReadVar, BytesWrittenVar, &cerr)

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


@@ -183,7 +183,7 @@ func (x *Bytes) Equal(Bytes2Var uintptr) bool {
183		return cret	183		return cret
184		}	184		}
185			185
186	-	var xBytesGetData func(uintptr, uint) uintptr	186	+	var xBytesGetData func(uintptr, *uint) uintptr
187			187
188		// Get the byte data in the [struct@GLib.Bytes].	188		// Get the byte data in the [struct@GLib.Bytes].
189		//	189		//

@@ -194,7 +194,7 @@ var xBytesGetData func(uintptr, uint) uintptr
194		// `NULL` may be returned if @size is 0. This is not guaranteed, as the `GBytes`	194		// `NULL` may be returned if @size is 0. This is not guaranteed, as the `GBytes`
195		// may represent an empty string with @data non-`NULL` and @size as 0. `NULL`	195		// may represent an empty string with @data non-`NULL` and @size as 0. `NULL`
196		// will not be returned if @size is non-zero.	196		// will not be returned if @size is non-zero.
197	-	func (x *Bytes) GetData(SizeVar uint) uintptr {	197	+	func (x Bytes) GetData(SizeVar uint) uintptr {
198			198
199		cret := xBytesGetData(x.GoPointer(), SizeVar)	199		cret := xBytesGetData(x.GoPointer(), SizeVar)
200		return cret	200		return cret

@@ -314,7 +314,7 @@ func (x *Bytes) UnrefToArray() uintptr {
314		return cret	314		return cret
315		}	315		}
316			316
317	-	var xBytesUnrefToData func(uintptr, uint) uintptr	317	+	var xBytesUnrefToData func(uintptr, *uint) uintptr
318			318
319		// Unreferences the bytes, and returns a pointer the same byte data	319		// Unreferences the bytes, and returns a pointer the same byte data
320		// contents.	320		// contents.

@@ -325,7 +325,7 @@ var xBytesUnrefToData func(uintptr, uint) uintptr
325		// [func@GLib.ByteArray.free_to_bytes] and the buffer was larger than the size	325		// [func@GLib.ByteArray.free_to_bytes] and the buffer was larger than the size
326		// [struct@GLib.Bytes] may internalize within its allocation. In all other cases	326		// [struct@GLib.Bytes] may internalize within its allocation. In all other cases
327		// the data is copied.	327		// the data is copied.
328	-	func (x *Bytes) UnrefToData(SizeVar uint) uintptr {	328	+	func (x Bytes) UnrefToData(SizeVar uint) uintptr {
329			329
330		cret := xBytesUnrefToData(x.GoPointer(), SizeVar)	330		cret := xBytesUnrefToData(x.GoPointer(), SizeVar)
331		return cret	331		return cret

@@ -567,12 +567,12 @@ func ByteArraySortWithData(ArrayVar []byte, CompareFuncVar *CompareDataFunc, Use
567			567
568		}	568		}
569			569
570	-	var xByteArraySteal func([]byte, uint) uintptr	570	+	var xByteArraySteal func([]byte, *uint) uintptr
571			571
572		// Frees the data in the array and resets the size to zero, while	572		// Frees the data in the array and resets the size to zero, while
573		// the underlying array is preserved for use elsewhere and returned	573		// the underlying array is preserved for use elsewhere and returned
574		// to the caller.	574		// to the caller.
575	-	func ByteArraySteal(ArrayVar []byte, LenVar uint) uintptr {	575	+	func ByteArraySteal(ArrayVar []byte, LenVar *uint) uintptr {
576			576
577		cret := xByteArraySteal(ArrayVar, LenVar)	577		cret := xByteArraySteal(ArrayVar, LenVar)
578		return cret	578		return cret

@@ -590,7 +590,7 @@ func ByteArrayUnref(ArrayVar []byte) {
590			590
591		}	591		}
592			592
593	-	var xPtrArrayFind func([]uintptr, uintptr, uint) bool	593	+	var xPtrArrayFind func([]uintptr, uintptr, *uint) bool
594			594
595		// Checks whether @needle exists in @haystack. If the element is found, true	595		// Checks whether @needle exists in @haystack. If the element is found, true
596		// is returned and the element’s index is returned in @index_ (if non-`NULL`).	596		// is returned and the element’s index is returned in @index_ (if non-`NULL`).

@@ -600,13 +600,13 @@ var xPtrArrayFind func([]uintptr, uintptr, uint) bool
600		// This does pointer comparisons only. If you want to use more complex equality	600		// This does pointer comparisons only. If you want to use more complex equality
601		// checks, such as string comparisons, use	601		// checks, such as string comparisons, use
602		// [func@GLib.PtrArray.find_with_equal_func].	602		// [func@GLib.PtrArray.find_with_equal_func].
603	-	func PtrArrayFind(HaystackVar []uintptr, NeedleVar uintptr, IndexVar uint) bool {	603	+	func PtrArrayFind(HaystackVar []uintptr, NeedleVar uintptr, IndexVar *uint) bool {
604			604
605		cret := xPtrArrayFind(HaystackVar, NeedleVar, IndexVar)	605		cret := xPtrArrayFind(HaystackVar, NeedleVar, IndexVar)
606		return cret	606		return cret
607		}	607		}
608			608
609	-	var xPtrArrayFindWithEqualFunc func([]uintptr, uintptr, uintptr, uint) bool	609	+	var xPtrArrayFindWithEqualFunc func([]uintptr, uintptr, uintptr, *uint) bool
610			610
611		// Checks whether @needle exists in @haystack, using the given @equal_func.	611		// Checks whether @needle exists in @haystack, using the given @equal_func.
612		// If the element is found, true is returned and the element’s index is	612		// If the element is found, true is returned and the element’s index is

@@ -617,7 +617,7 @@ var xPtrArrayFindWithEqualFunc func([]uintptr, uintptr, uintptr, uint) bool
617		// @equal_func is called with the element from the array as its first parameter,	617		// @equal_func is called with the element from the array as its first parameter,
618		// and @needle as its second parameter. If @equal_func is `NULL`, pointer	618		// and @needle as its second parameter. If @equal_func is `NULL`, pointer
619		// equality is used.	619		// equality is used.
620	-	func PtrArrayFindWithEqualFunc(HaystackVar []uintptr, NeedleVar uintptr, EqualFuncVar *EqualFunc, IndexVar uint) bool {	620	+	func PtrArrayFindWithEqualFunc(HaystackVar []uintptr, NeedleVar uintptr, EqualFuncVar EqualFunc, IndexVar uint) bool {
621			621
622		cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, NewCallbackNullable(EqualFuncVar), IndexVar)	622		cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, NewCallbackNullable(EqualFuncVar), IndexVar)
623		return cret	623		return cret

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


@@ -64,7 +64,7 @@ func AtomicIntCompareAndExchange(AtomicVar uintptr, OldvalVar int, NewvalVar int
64		return cret	64		return cret
65		}	65		}
66			66
67	-	var xAtomicIntCompareAndExchangeFull func(uintptr, int, int, int) bool	67	+	var xAtomicIntCompareAndExchangeFull func(uintptr, int, int, *int) bool
68			68
69		// Compares @atomic to @oldval and, if equal, sets it to @newval.	69		// Compares @atomic to @oldval and, if equal, sets it to @newval.
70		// If @atomic was not equal to @oldval then no change occurs.	70		// If @atomic was not equal to @oldval then no change occurs.

@@ -78,7 +78,7 @@ var xAtomicIntCompareAndExchangeFull func(uintptr, int, int, int) bool
78		// This call acts as a full compiler and hardware memory barrier.	78		// This call acts as a full compiler and hardware memory barrier.
79		//	79		//
80		// See also g_atomic_int_compare_and_exchange()	80		// See also g_atomic_int_compare_and_exchange()
81	-	func AtomicIntCompareAndExchangeFull(AtomicVar uintptr, OldvalVar int, NewvalVar int, PrevalVar int) bool {	81	+	func AtomicIntCompareAndExchangeFull(AtomicVar uintptr, OldvalVar int, NewvalVar int, PrevalVar *int) bool {
82			82
83		cret := xAtomicIntCompareAndExchangeFull(AtomicVar, OldvalVar, NewvalVar, PrevalVar)	83		cret := xAtomicIntCompareAndExchangeFull(AtomicVar, OldvalVar, NewvalVar, PrevalVar)
84		return cret	84		return cret

@@ -273,7 +273,7 @@ func AtomicPointerCompareAndExchange(AtomicVar uintptr, OldvalVar uintptr, Newva
273		return cret	273		return cret
274		}	274		}
275			275
276	-	var xAtomicPointerCompareAndExchangeFull func(uintptr, uintptr, uintptr, uintptr) bool	276	+	var xAtomicPointerCompareAndExchangeFull func(uintptr, uintptr, uintptr, *uintptr) bool
277			277
278		// Compares @atomic to @oldval and, if equal, sets it to @newval.	278		// Compares @atomic to @oldval and, if equal, sets it to @newval.
279		// If @atomic was not equal to @oldval then no change occurs.	279		// If @atomic was not equal to @oldval then no change occurs.

@@ -287,7 +287,7 @@ var xAtomicPointerCompareAndExchangeFull func(uintptr, uintptr, uintptr, uintptr
287		// This call acts as a full compiler and hardware memory barrier.	287		// This call acts as a full compiler and hardware memory barrier.
288		//	288		//
289		// See also g_atomic_pointer_compare_and_exchange()	289		// See also g_atomic_pointer_compare_and_exchange()
290	-	func AtomicPointerCompareAndExchangeFull(AtomicVar uintptr, OldvalVar uintptr, NewvalVar uintptr, PrevalVar uintptr) bool {	290	+	func AtomicPointerCompareAndExchangeFull(AtomicVar uintptr, OldvalVar uintptr, NewvalVar uintptr, PrevalVar *uintptr) bool {
291			291
292		cret := xAtomicPointerCompareAndExchangeFull(AtomicVar, OldvalVar, NewvalVar, PrevalVar)	292		cret := xAtomicPointerCompareAndExchangeFull(AtomicVar, OldvalVar, NewvalVar, PrevalVar)
293		return cret	293		return cret

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


@@ -6,12 +6,12 @@ import (
6		"github.com/jwijenbergh/puregotk/pkg/core"	6		"github.com/jwijenbergh/puregotk/pkg/core"
7		)	7		)
8			8
9	-	var xBase64Decode func(string, uint) uintptr	9	+	var xBase64Decode func(string, *uint) uintptr
10			10
11		// Decode a sequence of Base-64 encoded text into binary data. Note	11		// Decode a sequence of Base-64 encoded text into binary data. Note
12		// that the returned binary data is not necessarily zero-terminated,	12		// that the returned binary data is not necessarily zero-terminated,
13		// so it should not be used as a character string.	13		// so it should not be used as a character string.
14	-	func Base64Decode(TextVar string, OutLenVar uint) uintptr {	14	+	func Base64Decode(TextVar string, OutLenVar *uint) uintptr {
15			15
16		cret := xBase64Decode(TextVar, OutLenVar)	16		cret := xBase64Decode(TextVar, OutLenVar)
17		return cret	17		return cret

@@ -27,7 +27,7 @@ func Base64DecodeInplace(TextVar []byte, OutLenVar uint) byte {
27		return cret	27		return cret
28		}	28		}
29			29
30	-	var xBase64DecodeStep func([]byte, uint, []byte, int, uint) uint	30	+	var xBase64DecodeStep func([]byte, uint, *[]byte, int, uint) uint
31			31
32		// Incrementally decode a sequence of binary data from its Base-64 stringified	32		// Incrementally decode a sequence of binary data from its Base-64 stringified
33		// representation. By calling this function multiple times you can convert	33		// representation. By calling this function multiple times you can convert

@@ -37,7 +37,7 @@ var xBase64DecodeStep func([]byte, uint, []byte, int, uint) uint
37		// be written to it. Since base64 encodes 3 bytes in 4 chars you need	37		// be written to it. Since base64 encodes 3 bytes in 4 chars you need
38		// at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero	38		// at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero
39		// state).	39		// state).
40	-	func Base64DecodeStep(InVar []byte, LenVar uint, OutVar []byte, StateVar int, SaveVar uint) uint {	40	+	func Base64DecodeStep(InVar []byte, LenVar uint, OutVar *[]byte, StateVar int, SaveVar uint) uint {
41			41
42		cret := xBase64DecodeStep(InVar, LenVar, OutVar, StateVar, SaveVar)	42		cret := xBase64DecodeStep(InVar, LenVar, OutVar, StateVar, SaveVar)
43		return cret	43		return cret

@@ -53,7 +53,7 @@ func Base64Encode(DataVar []byte, LenVar uint) string {
53		return cret	53		return cret
54		}	54		}
55			55
56	-	var xBase64EncodeClose func(bool, []byte, int, int) uint	56	+	var xBase64EncodeClose func(bool, *[]byte, int, int) uint
57			57
58		// Flush the status from a sequence of calls to g_base64_encode_step().	58		// Flush the status from a sequence of calls to g_base64_encode_step().
59		//	59		//

@@ -62,13 +62,13 @@ var xBase64EncodeClose func(bool, []byte, int, int) uint
62		// line-breaking is enabled.	62		// line-breaking is enabled.
63		//	63		//
64		// The @out array will not be automatically nul-terminated.	64		// The @out array will not be automatically nul-terminated.
65	-	func Base64EncodeClose(BreakLinesVar bool, OutVar []byte, StateVar int, SaveVar int) uint {	65	+	func Base64EncodeClose(BreakLinesVar bool, OutVar *[]byte, StateVar int, SaveVar int) uint {
66			66
67		cret := xBase64EncodeClose(BreakLinesVar, OutVar, StateVar, SaveVar)	67		cret := xBase64EncodeClose(BreakLinesVar, OutVar, StateVar, SaveVar)
68		return cret	68		return cret
69		}	69		}
70			70
71	-	var xBase64EncodeStep func([]byte, uint, bool, []byte, int, int) uint	71	+	var xBase64EncodeStep func([]byte, uint, bool, *[]byte, int, int) uint
72			72
73		// Incrementally encode a sequence of binary data into its Base-64 stringified	73		// Incrementally encode a sequence of binary data into its Base-64 stringified
74		// representation. By calling this function multiple times you can convert	74		// representation. By calling this function multiple times you can convert

@@ -89,7 +89,7 @@ var xBase64EncodeStep func([]byte, uint, bool, []byte, int, int) uint
89		// Note however that it breaks the lines with `LF` characters, not	89		// Note however that it breaks the lines with `LF` characters, not
90		// `CR LF` sequences, so the result cannot be passed directly to SMTP	90		// `CR LF` sequences, so the result cannot be passed directly to SMTP
91		// or certain other protocols.	91		// or certain other protocols.
92	-	func Base64EncodeStep(InVar []byte, LenVar uint, BreakLinesVar bool, OutVar []byte, StateVar int, SaveVar int) uint {	92	+	func Base64EncodeStep(InVar []byte, LenVar uint, BreakLinesVar bool, OutVar *[]byte, StateVar int, SaveVar int) uint {
93			93
94		cret := xBase64EncodeStep(InVar, LenVar, BreakLinesVar, OutVar, StateVar, SaveVar)	94		cret := xBase64EncodeStep(InVar, LenVar, BreakLinesVar, OutVar, StateVar, SaveVar)
95		return cret	95		return cret

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


@@ -28,14 +28,14 @@ func BitLock(AddressVar uintptr, LockBitVar int) {
28			28
29		}	29		}
30			30
31	-	var xBitLockAndGet func(uintptr, uint, int)	31	+	var xBitLockAndGet func(uintptr, uint, *int)
32			32
33		// Sets the indicated @lock_bit in @address and atomically returns the new value.	33		// Sets the indicated @lock_bit in @address and atomically returns the new value.
34		//	34		//
35		// This is like [func@GLib.bit_lock], except it can atomically return the new value at	35		// This is like [func@GLib.bit_lock], except it can atomically return the new value at
36		// @address (right after obtaining the lock). Thus the value returned in @out_val	36		// @address (right after obtaining the lock). Thus the value returned in @out_val
37		// always has the @lock_bit set.	37		// always has the @lock_bit set.
38	-	func BitLockAndGet(AddressVar uintptr, LockBitVar uint, OutValVar int) {	38	+	func BitLockAndGet(AddressVar uintptr, LockBitVar uint, OutValVar *int) {
39			39
40		xBitLockAndGet(AddressVar, LockBitVar, OutValVar)	40		xBitLockAndGet(AddressVar, LockBitVar, OutValVar)
41			41

@@ -110,14 +110,14 @@ func PointerBitLock(AddressVar uintptr, LockBitVar int) {
110			110
111		}	111		}
112			112
113	-	var xPointerBitLockAndGet func(uintptr, uint, uintptr)	113	+	var xPointerBitLockAndGet func(uintptr, uint, *uintptr)
114			114
115		// This is equivalent to g_bit_lock, but working on pointers (or other	115		// This is equivalent to g_bit_lock, but working on pointers (or other
116		// pointer-sized values).	116		// pointer-sized values).
117		//	117		//
118		// For portability reasons, you may only lock on the bottom 32 bits of	118		// For portability reasons, you may only lock on the bottom 32 bits of
119		// the pointer.	119		// the pointer.
120	-	func PointerBitLockAndGet(AddressVar uintptr, LockBitVar uint, OutPtrVar uintptr) {	120	+	func PointerBitLockAndGet(AddressVar uintptr, LockBitVar uint, OutPtrVar *uintptr) {
121			121
122		xPointerBitLockAndGet(AddressVar, LockBitVar, OutPtrVar)	122		xPointerBitLockAndGet(AddressVar, LockBitVar, OutPtrVar)
123			123

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


@@ -168,7 +168,7 @@ func (x BookmarkFile) GetAddedDateTime(UriVar string) (DateTime, error) {
168			168
169		}	169		}
170			170
171	-	var xBookmarkFileGetAppInfo func(uintptr, string, string, string, uint, int, **Error) bool	171	+	var xBookmarkFileGetAppInfo func(uintptr, string, string, string, uint, int, *Error) bool
172			172
173		// Gets the registration information of @app_name for the bookmark for	173		// Gets the registration information of @app_name for the bookmark for
174		// @uri. See g_bookmark_file_set_application_info() for more information about	174		// @uri. See g_bookmark_file_set_application_info() for more information about

@@ -183,7 +183,7 @@ var xBookmarkFileGetAppInfo func(uintptr, string, string, string, uint, int, **E
183		// %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting	183		// %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
184		// the command line fails, an error of the %G_SHELL_ERROR domain is	184		// the command line fails, an error of the %G_SHELL_ERROR domain is
185		// set and %FALSE is returned.	185		// set and %FALSE is returned.
186	-	func (x *BookmarkFile) GetAppInfo(UriVar string, NameVar string, ExecVar string, CountVar uint, StampVar int) (bool, error) {	186	+	func (x BookmarkFile) GetAppInfo(UriVar string, NameVar string, ExecVar string, CountVar uint, StampVar int) (bool, error) {
187		var cerr *Error	187		var cerr *Error
188			188
189		cret := xBookmarkFileGetAppInfo(x.GoPointer(), UriVar, NameVar, ExecVar, CountVar, StampVar, &cerr)	189		cret := xBookmarkFileGetAppInfo(x.GoPointer(), UriVar, NameVar, ExecVar, CountVar, StampVar, &cerr)

@@ -194,7 +194,7 @@ func (x *BookmarkFile) GetAppInfo(UriVar string, NameVar string, ExecVar string,
194			194
195		}	195		}
196			196
197	-	var xBookmarkFileGetApplicationInfo func(uintptr, string, string, string, uint, DateTime, Error) bool	197	+	var xBookmarkFileGetApplicationInfo func(uintptr, string, string, string, uint, DateTime, Error) bool
198			198
199		// Gets the registration information of @app_name for the bookmark for	199		// Gets the registration information of @app_name for the bookmark for
200		// @uri. See g_bookmark_file_set_application_info() for more information about	200		// @uri. See g_bookmark_file_set_application_info() for more information about

@@ -209,7 +209,7 @@ var xBookmarkFileGetApplicationInfo func(uintptr, string, string, string, uint,
209		// %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting	209		// %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
210		// the command line fails, an error of the %G_SHELL_ERROR domain is	210		// the command line fails, an error of the %G_SHELL_ERROR domain is
211		// set and %FALSE is returned.	211		// set and %FALSE is returned.
212	-	func (x BookmarkFile) GetApplicationInfo(UriVar string, NameVar string, ExecVar string, CountVar uint, StampVar *DateTime) (bool, error) {	212	+	func (x BookmarkFile) GetApplicationInfo(UriVar string, NameVar string, ExecVar string, CountVar uint, StampVar *DateTime) (bool, error) {
213		var cerr *Error	213		var cerr *Error
214			214
215		cret := xBookmarkFileGetApplicationInfo(x.GoPointer(), UriVar, NameVar, ExecVar, CountVar, StampVar, &cerr)	215		cret := xBookmarkFileGetApplicationInfo(x.GoPointer(), UriVar, NameVar, ExecVar, CountVar, StampVar, &cerr)

@@ -220,14 +220,14 @@ func (x *BookmarkFile) GetApplicationInfo(UriVar string, NameVar string, ExecVar
220			220
221		}	221		}
222			222
223	-	var xBookmarkFileGetApplications func(uintptr, string, uint, **Error) []string	223	+	var xBookmarkFileGetApplications func(uintptr, string, uint, *Error) []string
224			224
225		// Retrieves the names of the applications that have registered the	225		// Retrieves the names of the applications that have registered the
226		// bookmark for @uri.	226		// bookmark for @uri.
227		//	227		//
228		// In the event the URI cannot be found, %NULL is returned and	228		// In the event the URI cannot be found, %NULL is returned and
229		// @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.	229		// @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
230	-	func (x *BookmarkFile) GetApplications(UriVar string, LengthVar uint) ([]string, error) {	230	+	func (x BookmarkFile) GetApplications(UriVar string, LengthVar uint) ([]string, error) {
231		var cerr *Error	231		var cerr *Error
232			232
233		cret := xBookmarkFileGetApplications(x.GoPointer(), UriVar, LengthVar, &cerr)	233		cret := xBookmarkFileGetApplications(x.GoPointer(), UriVar, LengthVar, &cerr)

@@ -255,7 +255,7 @@ func (x *BookmarkFile) GetDescription(UriVar string) (string, error) {
255			255
256		}	256		}
257			257
258	-	var xBookmarkFileGetGroups func(uintptr, string, uint, **Error) []string	258	+	var xBookmarkFileGetGroups func(uintptr, string, uint, *Error) []string
259			259
260		// Retrieves the list of group names of the bookmark for @uri.	260		// Retrieves the list of group names of the bookmark for @uri.
261		//	261		//

@@ -264,7 +264,7 @@ var xBookmarkFileGetGroups func(uintptr, string, uint, **Error) []string
264		//	264		//
265		// The returned array is %NULL terminated, so @length may optionally	265		// The returned array is %NULL terminated, so @length may optionally
266		// be %NULL.	266		// be %NULL.
267	-	func (x *BookmarkFile) GetGroups(UriVar string, LengthVar uint) ([]string, error) {	267	+	func (x BookmarkFile) GetGroups(UriVar string, LengthVar uint) ([]string, error) {
268		var cerr *Error	268		var cerr *Error
269			269
270		cret := xBookmarkFileGetGroups(x.GoPointer(), UriVar, LengthVar, &cerr)	270		cret := xBookmarkFileGetGroups(x.GoPointer(), UriVar, LengthVar, &cerr)

@@ -275,13 +275,13 @@ func (x *BookmarkFile) GetGroups(UriVar string, LengthVar uint) ([]string, error
275			275
276		}	276		}
277			277
278	-	var xBookmarkFileGetIcon func(uintptr, string, string, string, **Error) bool	278	+	var xBookmarkFileGetIcon func(uintptr, string, string, string, **Error) bool
279			279
280		// Gets the icon of the bookmark for @uri.	280		// Gets the icon of the bookmark for @uri.
281		//	281		//
282		// In the event the URI cannot be found, %FALSE is returned and	282		// In the event the URI cannot be found, %FALSE is returned and
283		// @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.	283		// @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
284	-	func (x *BookmarkFile) GetIcon(UriVar string, HrefVar string, MimeTypeVar string) (bool, error) {	284	+	func (x BookmarkFile) GetIcon(UriVar string, HrefVar string, MimeTypeVar *string) (bool, error) {
285		var cerr *Error	285		var cerr *Error
286			286
287		cret := xBookmarkFileGetIcon(x.GoPointer(), UriVar, HrefVar, MimeTypeVar, &cerr)	287		cret := xBookmarkFileGetIcon(x.GoPointer(), UriVar, HrefVar, MimeTypeVar, &cerr)

@@ -392,12 +392,12 @@ func (x *BookmarkFile) GetTitle(UriVar string) (string, error) {
392			392
393		}	393		}
394			394
395	-	var xBookmarkFileGetUris func(uintptr, uint) []string	395	+	var xBookmarkFileGetUris func(uintptr, *uint) []string
396			396
397		// Returns all URIs of the bookmarks in the bookmark file @bookmark.	397		// Returns all URIs of the bookmarks in the bookmark file @bookmark.
398		// The array of returned URIs will be %NULL-terminated, so @length may	398		// The array of returned URIs will be %NULL-terminated, so @length may
399		// optionally be %NULL.	399		// optionally be %NULL.
400	-	func (x *BookmarkFile) GetUris(LengthVar uint) []string {	400	+	func (x BookmarkFile) GetUris(LengthVar uint) []string {
401			401
402		cret := xBookmarkFileGetUris(x.GoPointer(), LengthVar)	402		cret := xBookmarkFileGetUris(x.GoPointer(), LengthVar)
403		return cret	403		return cret

@@ -498,14 +498,14 @@ func (x *BookmarkFile) LoadFromData(DataVar []byte, LengthVar uint) (bool, error
498			498
499		}	499		}
500			500
501	-	var xBookmarkFileLoadFromDataDirs func(uintptr, string, string, **Error) bool	501	+	var xBookmarkFileLoadFromDataDirs func(uintptr, string, string, *Error) bool
502			502
503		// This function looks for a desktop bookmark file named @file in the	503		// This function looks for a desktop bookmark file named @file in the
504		// paths returned from g_get_user_data_dir() and g_get_system_data_dirs(),	504		// paths returned from g_get_user_data_dir() and g_get_system_data_dirs(),
505		// loads the file into @bookmark and returns the file's full path in	505		// loads the file into @bookmark and returns the file's full path in
506		// @full_path. If the file could not be loaded then @error is	506		// @full_path. If the file could not be loaded then @error is
507		// set to either a #GFileError or #GBookmarkFileError.	507		// set to either a #GFileError or #GBookmarkFileError.
508	-	func (x *BookmarkFile) LoadFromDataDirs(FileVar string, FullPathVar string) (bool, error) {	508	+	func (x BookmarkFile) LoadFromDataDirs(FileVar string, FullPathVar string) (bool, error) {
509		var cerr *Error	509		var cerr *Error
510			510
511		cret := xBookmarkFileLoadFromDataDirs(x.GoPointer(), FileVar, FullPathVar, &cerr)	511		cret := xBookmarkFileLoadFromDataDirs(x.GoPointer(), FileVar, FullPathVar, &cerr)

@@ -849,10 +849,10 @@ func (x BookmarkFile) SetVisitedDateTime(UriVar string, VisitedVar DateTime) {
849			849
850		}	850		}
851			851
852	-	var xBookmarkFileToData func(uintptr, uint, **Error) uintptr	852	+	var xBookmarkFileToData func(uintptr, uint, *Error) uintptr
853			853
854		// This function outputs @bookmark as a string.	854		// This function outputs @bookmark as a string.
855	-	func (x *BookmarkFile) ToData(LengthVar uint) (uintptr, error) {	855	+	func (x BookmarkFile) ToData(LengthVar uint) (uintptr, error) {
856		var cerr *Error	856		var cerr *Error
857			857
858		cret := xBookmarkFileToData(x.GoPointer(), LengthVar, &cerr)	858		cret := xBookmarkFileToData(x.GoPointer(), LengthVar, &cerr)

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


@@ -6,7 +6,7 @@ import (
6		"github.com/jwijenbergh/puregotk/pkg/core"	6		"github.com/jwijenbergh/puregotk/pkg/core"
7		)	7		)
8			8
9	-	var xGetCharset func(string) bool	9	+	var xGetCharset func(*string) bool
10			10
11		// Obtains the character set for the [current locale](running.html#locale);	11		// Obtains the character set for the [current locale](running.html#locale);
12		// you might use this character set as an argument to g_convert(), to convert	12		// you might use this character set as an argument to g_convert(), to convert

@@ -29,7 +29,7 @@ var xGetCharset func(string) bool
29		//	29		//
30		// The string returned in @charset is not allocated, and should not be	30		// The string returned in @charset is not allocated, and should not be
31		// freed.	31		// freed.
32	-	func GetCharset(CharsetVar string) bool {	32	+	func GetCharset(CharsetVar *string) bool {
33			33
34		cret := xGetCharset(CharsetVar)	34		cret := xGetCharset(CharsetVar)
35		return cret	35		return cret

@@ -44,7 +44,7 @@ func GetCodeset() string {
44		return cret	44		return cret
45		}	45		}
46			46
47	-	var xGetConsoleCharset func(string) bool	47	+	var xGetConsoleCharset func(*string) bool
48			48
49		// Obtains the character set used by the console attached to the process,	49		// Obtains the character set used by the console attached to the process,
50		// which is suitable for printing output to the terminal.	50		// which is suitable for printing output to the terminal.

@@ -63,7 +63,7 @@ var xGetConsoleCharset func(string) bool
63		//	63		//
64		// The string returned in @charset is not allocated, and should not be	64		// The string returned in @charset is not allocated, and should not be
65		// freed.	65		// freed.
66	-	func GetConsoleCharset(CharsetVar string) bool {	66	+	func GetConsoleCharset(CharsetVar *string) bool {
67			67
68		cret := xGetConsoleCharset(CharsetVar)	68		cret := xGetConsoleCharset(CharsetVar)
69		return cret	69		return cret

M v4/glib/gconvert.go +18 -18


@@ -87,7 +87,7 @@ const (
87		GConvertErrorEmbeddedNulValue ConvertError = 7	87		GConvertErrorEmbeddedNulValue ConvertError = 7
88		)	88		)
89			89
90	-	var xConvert func([]byte, int, string, string, uint, uint, **Error) uintptr	90	+	var xConvert func([]byte, int, string, string, uint, uint, **Error) uintptr
91			91
92		// Converts a string from one character set to another.	92		// Converts a string from one character set to another.
93		//	93		//

@@ -103,7 +103,7 @@ var xConvert func([]byte, int, string, string, uint, uint, **Error) uintptr
103		//	103		//
104		// Using extensions such as "//TRANSLIT" may not work (or may not work	104		// Using extensions such as "//TRANSLIT" may not work (or may not work
105		// well) on many platforms. Consider using g_str_to_ascii() instead.	105		// well) on many platforms. Consider using g_str_to_ascii() instead.
106	-	func Convert(StrVar []byte, LenVar int, ToCodesetVar string, FromCodesetVar string, BytesReadVar uint, BytesWrittenVar uint) (uintptr, error) {	106	+	func Convert(StrVar []byte, LenVar int, ToCodesetVar string, FromCodesetVar string, BytesReadVar uint, BytesWrittenVar uint) (uintptr, error) {
107		var cerr *Error	107		var cerr *Error
108			108
109		cret := xConvert(StrVar, LenVar, ToCodesetVar, FromCodesetVar, BytesReadVar, BytesWrittenVar, &cerr)	109		cret := xConvert(StrVar, LenVar, ToCodesetVar, FromCodesetVar, BytesReadVar, BytesWrittenVar, &cerr)

@@ -114,7 +114,7 @@ func Convert(StrVar []byte, LenVar int, ToCodesetVar string, FromCodesetVar stri
114			114
115		}	115		}
116			116
117	-	var xConvertWithFallback func([]byte, int, string, string, string, uint, uint, **Error) uintptr	117	+	var xConvertWithFallback func([]byte, int, string, string, string, uint, uint, **Error) uintptr
118			118
119		// Converts a string from one character set to another, possibly	119		// Converts a string from one character set to another, possibly
120		// including fallback sequences for characters not representable	120		// including fallback sequences for characters not representable

@@ -133,7 +133,7 @@ var xConvertWithFallback func([]byte, int, string, string, string, uint, uint, *
133		// this is the GNU C converter for CP1255 which does not emit a base	133		// this is the GNU C converter for CP1255 which does not emit a base
134		// character until it knows that the next character is not a mark that	134		// character until it knows that the next character is not a mark that
135		// could combine with the base character.)	135		// could combine with the base character.)
136	-	func ConvertWithFallback(StrVar []byte, LenVar int, ToCodesetVar string, FromCodesetVar string, FallbackVar string, BytesReadVar uint, BytesWrittenVar uint) (uintptr, error) {	136	+	func ConvertWithFallback(StrVar []byte, LenVar int, ToCodesetVar string, FromCodesetVar string, FallbackVar string, BytesReadVar uint, BytesWrittenVar uint) (uintptr, error) {
137		var cerr *Error	137		var cerr *Error
138			138
139		cret := xConvertWithFallback(StrVar, LenVar, ToCodesetVar, FromCodesetVar, FallbackVar, BytesReadVar, BytesWrittenVar, &cerr)	139		cret := xConvertWithFallback(StrVar, LenVar, ToCodesetVar, FromCodesetVar, FallbackVar, BytesReadVar, BytesWrittenVar, &cerr)

@@ -144,7 +144,7 @@ func ConvertWithFallback(StrVar []byte, LenVar int, ToCodesetVar string, FromCod
144			144
145		}	145		}
146			146
147	-	var xConvertWithIconv func([]byte, int, uintptr, uint, uint, **Error) uintptr	147	+	var xConvertWithIconv func([]byte, int, uintptr, uint, uint, **Error) uintptr
148			148
149		// Converts a string from one character set to another.	149		// Converts a string from one character set to another.
150		//	150		//

@@ -165,7 +165,7 @@ var xConvertWithIconv func([]byte, int, uintptr, uint, uint, **Error) uintptr
165		// this is the same error code as is returned for an invalid byte sequence in	165		// this is the same error code as is returned for an invalid byte sequence in
166		// the input character set. To get defined behaviour for conversion of	166		// the input character set. To get defined behaviour for conversion of
167		// unrepresentable characters, use g_convert_with_fallback().	167		// unrepresentable characters, use g_convert_with_fallback().
168	-	func ConvertWithIconv(StrVar []byte, LenVar int, ConverterVar uintptr, BytesReadVar uint, BytesWrittenVar uint) (uintptr, error) {	168	+	func ConvertWithIconv(StrVar []byte, LenVar int, ConverterVar uintptr, BytesReadVar uint, BytesWrittenVar uint) (uintptr, error) {
169		var cerr *Error	169		var cerr *Error
170			170
171		cret := xConvertWithIconv(StrVar, LenVar, ConverterVar, BytesReadVar, BytesWrittenVar, &cerr)	171		cret := xConvertWithIconv(StrVar, LenVar, ConverterVar, BytesReadVar, BytesWrittenVar, &cerr)

@@ -223,7 +223,7 @@ func FilenameDisplayName(FilenameVar string) string {
223		return cret	223		return cret
224		}	224		}
225			225
226	-	var xFilenameFromUri func(string, string, **Error) string	226	+	var xFilenameFromUri func(string, string, *Error) string
227			227
228		// Converts an escaped ASCII-encoded URI to a local filename in the	228		// Converts an escaped ASCII-encoded URI to a local filename in the
229		// encoding used for filenames.	229		// encoding used for filenames.

@@ -232,7 +232,7 @@ var xFilenameFromUri func(string, string, **Error) string
232		// but are not part of the resulting filename.	232		// but are not part of the resulting filename.
233		// We take inspiration from https://url.spec.whatwg.org/#file-state,	233		// We take inspiration from https://url.spec.whatwg.org/#file-state,
234		// but we don't support the entire standard.	234		// but we don't support the entire standard.
235	-	func FilenameFromUri(UriVar string, HostnameVar string) (string, error) {	235	+	func FilenameFromUri(UriVar string, HostnameVar *string) (string, error) {
236		var cerr *Error	236		var cerr *Error
237			237
238		cret := xFilenameFromUri(UriVar, HostnameVar, &cerr)	238		cret := xFilenameFromUri(UriVar, HostnameVar, &cerr)

@@ -243,7 +243,7 @@ func FilenameFromUri(UriVar string, HostnameVar string) (string, error) {
243			243
244		}	244		}
245			245
246	-	var xFilenameFromUtf8 func(string, int, uint, uint, **Error) string	246	+	var xFilenameFromUtf8 func(string, int, uint, uint, **Error) string
247			247
248		// Converts a string from UTF-8 to the encoding GLib uses for	248		// Converts a string from UTF-8 to the encoding GLib uses for
249		// filenames. Note that on Windows GLib uses UTF-8 for filenames;	249		// filenames. Note that on Windows GLib uses UTF-8 for filenames;

@@ -255,7 +255,7 @@ var xFilenameFromUtf8 func(string, int, uint, uint, **Error) string
255		// in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. If the filename encoding is	255		// in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. If the filename encoding is
256		// not UTF-8 and the conversion output contains a nul character, the error	256		// not UTF-8 and the conversion output contains a nul character, the error
257		// %G_CONVERT_ERROR_EMBEDDED_NUL is set and the function returns %NULL.	257		// %G_CONVERT_ERROR_EMBEDDED_NUL is set and the function returns %NULL.
258	-	func FilenameFromUtf8(Utf8stringVar string, LenVar int, BytesReadVar uint, BytesWrittenVar uint) (string, error) {	258	+	func FilenameFromUtf8(Utf8stringVar string, LenVar int, BytesReadVar uint, BytesWrittenVar uint) (string, error) {
259		var cerr *Error	259		var cerr *Error
260			260
261		cret := xFilenameFromUtf8(Utf8stringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)	261		cret := xFilenameFromUtf8(Utf8stringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)

@@ -281,7 +281,7 @@ func FilenameToUri(FilenameVar string, HostnameVar string) (string, error) {
281			281
282		}	282		}
283			283
284	-	var xFilenameToUtf8 func(string, int, uint, uint, **Error) string	284	+	var xFilenameToUtf8 func(string, int, uint, uint, **Error) string
285			285
286		// Converts a string which is in the encoding used by GLib for	286		// Converts a string which is in the encoding used by GLib for
287		// filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8	287		// filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8

@@ -295,7 +295,7 @@ var xFilenameToUtf8 func(string, int, uint, uint, **Error) string
295		// nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the	295		// nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the
296		// function returns %NULL. Use g_convert() to produce output that	296		// function returns %NULL. Use g_convert() to produce output that
297		// may contain embedded nul characters.	297		// may contain embedded nul characters.
298	-	func FilenameToUtf8(OpsysstringVar string, LenVar int, BytesReadVar uint, BytesWrittenVar uint) (string, error) {	298	+	func FilenameToUtf8(OpsysstringVar string, LenVar int, BytesReadVar uint, BytesWrittenVar uint) (string, error) {
299		var cerr *Error	299		var cerr *Error
300			300
301		cret := xFilenameToUtf8(OpsysstringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)	301		cret := xFilenameToUtf8(OpsysstringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)

@@ -306,7 +306,7 @@ func FilenameToUtf8(OpsysstringVar string, LenVar int, BytesReadVar uint, BytesW
306			306
307		}	307		}
308			308
309	-	var xGetFilenameCharsets func([]string) bool	309	+	var xGetFilenameCharsets func(*[]string) bool
310			310
311		// Determines the preferred character sets used for filenames.	311		// Determines the preferred character sets used for filenames.
312		// The first character set from the @charsets is the filename encoding, the	312		// The first character set from the @charsets is the filename encoding, the

@@ -332,7 +332,7 @@ var xGetFilenameCharsets func([]string) bool
332		// Note that on Unix, regardless of the locale character set or	332		// Note that on Unix, regardless of the locale character set or
333		// `G_FILENAME_ENCODING` value, the actual file names present	333		// `G_FILENAME_ENCODING` value, the actual file names present
334		// on a system might be in any random encoding or just gibberish.	334		// on a system might be in any random encoding or just gibberish.
335	-	func GetFilenameCharsets(FilenameCharsetsVar []string) bool {	335	+	func GetFilenameCharsets(FilenameCharsetsVar *[]string) bool {
336			336
337		cret := xGetFilenameCharsets(FilenameCharsetsVar)	337		cret := xGetFilenameCharsets(FilenameCharsetsVar)
338		return cret	338		return cret

@@ -376,7 +376,7 @@ func IconvOpen(ToCodesetVar string, FromCodesetVar string) uintptr {
376		return cret	376		return cret
377		}	377		}
378			378
379	-	var xLocaleFromUtf8 func(string, int, uint, uint, **Error) uintptr	379	+	var xLocaleFromUtf8 func(string, int, uint, uint, **Error) uintptr
380			380
381		// Converts a string from UTF-8 to the encoding used for strings by	381		// Converts a string from UTF-8 to the encoding used for strings by
382		// the C runtime (usually the same as that used by the operating	382		// the C runtime (usually the same as that used by the operating

@@ -387,7 +387,7 @@ var xLocaleFromUtf8 func(string, int, uint, uint, **Error) uintptr
387		// argument is positive. A nul character found inside the string will result	387		// argument is positive. A nul character found inside the string will result
388		// in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Use g_convert() to convert	388		// in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Use g_convert() to convert
389		// input that may contain embedded nul characters.	389		// input that may contain embedded nul characters.
390	-	func LocaleFromUtf8(Utf8stringVar string, LenVar int, BytesReadVar uint, BytesWrittenVar uint) (uintptr, error) {	390	+	func LocaleFromUtf8(Utf8stringVar string, LenVar int, BytesReadVar uint, BytesWrittenVar uint) (uintptr, error) {
391		var cerr *Error	391		var cerr *Error
392			392
393		cret := xLocaleFromUtf8(Utf8stringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)	393		cret := xLocaleFromUtf8(Utf8stringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)

@@ -398,7 +398,7 @@ func LocaleFromUtf8(Utf8stringVar string, LenVar int, BytesReadVar uint, BytesWr
398			398
399		}	399		}
400			400
401	-	var xLocaleToUtf8 func([]byte, int, uint, uint, **Error) string	401	+	var xLocaleToUtf8 func([]byte, int, uint, uint, **Error) string
402			402
403		// Converts a string which is in the encoding used for strings by	403		// Converts a string which is in the encoding used for strings by
404		// the C runtime (usually the same as that used by the operating	404		// the C runtime (usually the same as that used by the operating

@@ -411,7 +411,7 @@ var xLocaleToUtf8 func([]byte, int, uint, uint, **Error) string
411		// the %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error for backward compatibility with	411		// the %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error for backward compatibility with
412		// earlier versions of this library. Use g_convert() to produce output that	412		// earlier versions of this library. Use g_convert() to produce output that
413		// may contain embedded nul characters.	413		// may contain embedded nul characters.
414	-	func LocaleToUtf8(OpsysstringVar []byte, LenVar int, BytesReadVar uint, BytesWrittenVar uint) (string, error) {	414	+	func LocaleToUtf8(OpsysstringVar []byte, LenVar int, BytesReadVar uint, BytesWrittenVar uint) (string, error) {
415		var cerr *Error	415		var cerr *Error
416			416
417		cret := xLocaleToUtf8(OpsysstringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)	417		cret := xLocaleToUtf8(OpsysstringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)

M v4/glib/gdataset.go +2 -2


@@ -142,7 +142,7 @@ func DatalistIdRemoveNoNotify(DatalistVar **Data, KeyIdVar Quark) uintptr {
142		return cret	142		return cret
143		}	143		}
144			144
145	-	var xDatalistIdReplaceData func(**Data, Quark, uintptr, uintptr, uintptr, uintptr) bool	145	+	var xDatalistIdReplaceData func(*Data, Quark, uintptr, uintptr, uintptr, DestroyNotify) bool
146			146
147		// Compares the member that is associated with @key_id in	147		// Compares the member that is associated with @key_id in
148		// @datalist to @oldval, and if they are the same, replace	148		// @datalist to @oldval, and if they are the same, replace

@@ -159,7 +159,7 @@ var xDatalistIdReplaceData func(**Data, Quark, uintptr, uintptr, uintptr, uintpt
159		// should not destroy the object in the normal way.	159		// should not destroy the object in the normal way.
160		func DatalistIdReplaceData(DatalistVar *Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar DestroyNotify, OldDestroyVar *DestroyNotify) bool {	160		func DatalistIdReplaceData(DatalistVar *Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar DestroyNotify, OldDestroyVar *DestroyNotify) bool {
161			161
162	-	cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, NewCallbackNullable(DestroyVar), NewCallback(OldDestroyVar))	162	+	cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, NewCallbackNullable(DestroyVar), OldDestroyVar)
163		return cret	163		return cret
164		}	164		}
165			165

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


@@ -787,10 +787,10 @@ func (x *DateTime) GetYear() int {
787		return cret	787		return cret
788		}	788		}
789			789
790	-	var xDateTimeGetYmd func(uintptr, int, int, int)	790	+	var xDateTimeGetYmd func(uintptr, int, int, *int)
791			791
792		// Retrieves the Gregorian day, month, and year of a given #GDateTime.	792		// Retrieves the Gregorian day, month, and year of a given #GDateTime.
793	-	func (x *DateTime) GetYmd(YearVar int, MonthVar int, DayVar int) {	793	+	func (x DateTime) GetYmd(YearVar int, MonthVar int, DayVar int) {
794			794
795		xDateTimeGetYmd(x.GoPointer(), YearVar, MonthVar, DayVar)	795		xDateTimeGetYmd(x.GoPointer(), YearVar, MonthVar, DayVar)
796			796

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


@@ -345,7 +345,7 @@ func FileErrorFromErrno(ErrNoVar int) FileError {
345		return cret	345		return cret
346		}	346		}
347			347
348	-	var xFileGetContents func(string, []byte, uint, **Error) bool	348	+	var xFileGetContents func(string, []byte, uint, **Error) bool
349			349
350		// Reads an entire file into allocated memory, with good error	350		// Reads an entire file into allocated memory, with good error
351		// checking.	351		// checking.

@@ -357,7 +357,7 @@ var xFileGetContents func(string, []byte, uint, **Error) bool
357		// %FALSE and sets @error. The error domain is %G_FILE_ERROR. Possible error	357		// %FALSE and sets @error. The error domain is %G_FILE_ERROR. Possible error
358		// codes are those in the #GFileError enumeration. In the error case,	358		// codes are those in the #GFileError enumeration. In the error case,
359		// @contents is set to %NULL and @length is set to zero.	359		// @contents is set to %NULL and @length is set to zero.
360	-	func FileGetContents(FilenameVar string, ContentsVar []byte, LengthVar uint) (bool, error) {	360	+	func FileGetContents(FilenameVar string, ContentsVar []byte, LengthVar uint) (bool, error) {
361		var cerr *Error	361		var cerr *Error
362			362
363		cret := xFileGetContents(FilenameVar, ContentsVar, LengthVar, &cerr)	363		cret := xFileGetContents(FilenameVar, ContentsVar, LengthVar, &cerr)

@@ -368,7 +368,7 @@ func FileGetContents(FilenameVar string, ContentsVar []byte, LengthVar uint) (bo
368			368
369		}	369		}
370			370
371	-	var xFileOpenTmp func(string, string, **Error) int	371	+	var xFileOpenTmp func(string, string, *Error) int
372			372
373		// Opens a file for writing in the preferred directory for temporary	373		// Opens a file for writing in the preferred directory for temporary
374		// files (as returned by g_get_tmp_dir()).	374		// files (as returned by g_get_tmp_dir()).

@@ -386,7 +386,7 @@ var xFileOpenTmp func(string, string, **Error) int
386		// is returned in @name_used. This string should be freed with g_free()	386		// is returned in @name_used. This string should be freed with g_free()
387		// when not needed any longer. The returned name is in the GLib file	387		// when not needed any longer. The returned name is in the GLib file
388		// name encoding.	388		// name encoding.
389	-	func FileOpenTmp(TmplVar string, NameUsedVar string) (int, error) {	389	+	func FileOpenTmp(TmplVar string, NameUsedVar *string) (int, error) {
390		var cerr *Error	390		var cerr *Error
391			391
392		cret := xFileOpenTmp(TmplVar, NameUsedVar, &cerr)	392		cret := xFileOpenTmp(TmplVar, NameUsedVar, &cerr)

M v4/glib/ghash.go +6 -6


@@ -102,12 +102,12 @@ func (x HashTableIter) Init(HashTableVar HashTable) {
102			102
103		}	103		}
104			104
105	-	var xHashTableIterNext func(uintptr, uintptr, uintptr) bool	105	+	var xHashTableIterNext func(uintptr, uintptr, uintptr) bool
106			106
107		// Advances @iter and retrieves the key and/or value that are now	107		// Advances @iter and retrieves the key and/or value that are now
108		// pointed to as a result of this advancement. If %FALSE is returned,	108		// pointed to as a result of this advancement. If %FALSE is returned,
109		// @key and @value are not set, and the iterator becomes invalid.	109		// @key and @value are not set, and the iterator becomes invalid.
110	-	func (x *HashTableIter) Next(KeyVar uintptr, ValueVar uintptr) bool {	110	+	func (x HashTableIter) Next(KeyVar uintptr, ValueVar *uintptr) bool {
111			111
112		cret := xHashTableIterNext(x.GoPointer(), KeyVar, ValueVar)	112		cret := xHashTableIterNext(x.GoPointer(), KeyVar, ValueVar)
113		return cret	113		return cret

@@ -405,7 +405,7 @@ func HashTableLookup(HashTableVar *HashTable, KeyVar uintptr) uintptr {
405		return cret	405		return cret
406		}	406		}
407			407
408	-	var xHashTableLookupExtended func(*HashTable, uintptr, uintptr, uintptr) bool	408	+	var xHashTableLookupExtended func(HashTable, uintptr, uintptr, *uintptr) bool
409			409
410		// Looks up a key in the #GHashTable, returning the original key and the	410		// Looks up a key in the #GHashTable, returning the original key and the
411		// associated value and a #gboolean which is %TRUE if the key was found. This	411		// associated value and a #gboolean which is %TRUE if the key was found. This

@@ -415,7 +415,7 @@ var xHashTableLookupExtended func(*HashTable, uintptr, uintptr, uintptr) bool
415		// You can actually pass %NULL for @lookup_key to test	415		// You can actually pass %NULL for @lookup_key to test
416		// whether the %NULL key exists, provided the hash and equal functions	416		// whether the %NULL key exists, provided the hash and equal functions
417		// of @hash_table are %NULL-safe.	417		// of @hash_table are %NULL-safe.
418	-	func HashTableLookupExtended(HashTableVar *HashTable, LookupKeyVar uintptr, OrigKeyVar uintptr, ValueVar uintptr) bool {	418	+	func HashTableLookupExtended(HashTableVar HashTable, LookupKeyVar uintptr, OrigKeyVar uintptr, ValueVar *uintptr) bool {
419			419
420		cret := xHashTableLookupExtended(HashTableVar, LookupKeyVar, OrigKeyVar, ValueVar)	420		cret := xHashTableLookupExtended(HashTableVar, LookupKeyVar, OrigKeyVar, ValueVar)
421		return cret	421		return cret

@@ -547,7 +547,7 @@ func HashTableStealAllValues(HashTableVar *HashTable) uintptr {
547		return cret	547		return cret
548		}	548		}
549			549
550	-	var xHashTableStealExtended func(*HashTable, uintptr, uintptr, uintptr) bool	550	+	var xHashTableStealExtended func(HashTable, uintptr, uintptr, *uintptr) bool
551			551
552		// Looks up a key in the #GHashTable, stealing the original key and the	552		// Looks up a key in the #GHashTable, stealing the original key and the
553		// associated value and returning %TRUE if the key was found. If the key was	553		// associated value and returning %TRUE if the key was found. If the key was

@@ -566,7 +566,7 @@ var xHashTableStealExtended func(*HashTable, uintptr, uintptr, uintptr) bool
566		// their keys, for example by using g_hash_table_add(). Before 2.82, when	566		// their keys, for example by using g_hash_table_add(). Before 2.82, when
567		// stealing both the key and the value from such a dictionary, the value was	567		// stealing both the key and the value from such a dictionary, the value was
568		// %NULL. Since 2.82, the returned value and key will be the same.	568		// %NULL. Since 2.82, the returned value and key will be the same.
569	-	func HashTableStealExtended(HashTableVar *HashTable, LookupKeyVar uintptr, StolenKeyVar uintptr, StolenValueVar uintptr) bool {	569	+	func HashTableStealExtended(HashTableVar HashTable, LookupKeyVar uintptr, StolenKeyVar uintptr, StolenValueVar *uintptr) bool {
570			570
571		cret := xHashTableStealExtended(HashTableVar, LookupKeyVar, StolenKeyVar, StolenValueVar)	571		cret := xHashTableStealExtended(HashTableVar, LookupKeyVar, StolenKeyVar, StolenValueVar)
572		return cret	572		return cret

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


@@ -247,13 +247,13 @@ func (x *IOChannel) GetFlags() IOFlags {
247		return cret	247		return cret
248		}	248		}
249			249
250	-	var xIOChannelGetLineTerm func(uintptr, int) string	250	+	var xIOChannelGetLineTerm func(uintptr, *int) string
251			251
252		// This returns the string that #GIOChannel uses to determine	252		// This returns the string that #GIOChannel uses to determine
253		// where in the file a line break occurs. A value of %NULL	253		// where in the file a line break occurs. A value of %NULL
254		// indicates autodetection. Since 2.84, the return value is always	254		// indicates autodetection. Since 2.84, the return value is always
255		// nul-terminated.	255		// nul-terminated.
256	-	func (x *IOChannel) GetLineTerm(LengthVar int) string {	256	+	func (x IOChannel) GetLineTerm(LengthVar int) string {
257			257
258		cret := xIOChannelGetLineTerm(x.GoPointer(), LengthVar)	258		cret := xIOChannelGetLineTerm(x.GoPointer(), LengthVar)
259		return cret	259		return cret

@@ -281,10 +281,10 @@ func (x *IOChannel) Read(BufVar string, CountVar uint, BytesReadVar uint) IOErro
281		return cret	281		return cret
282		}	282		}
283			283
284	-	var xIOChannelReadChars func(uintptr, []byte, uint, uint, **Error) IOStatus	284	+	var xIOChannelReadChars func(uintptr, []byte, uint, uint, **Error) IOStatus
285			285
286		// Replacement for g_io_channel_read() with the new API.	286		// Replacement for g_io_channel_read() with the new API.
287	-	func (x *IOChannel) ReadChars(BufVar []byte, CountVar uint, BytesReadVar uint) (IOStatus, error) {	287	+	func (x IOChannel) ReadChars(BufVar []byte, CountVar uint, BytesReadVar *uint) (IOStatus, error) {
288		var cerr *Error	288		var cerr *Error
289			289
290		cret := xIOChannelReadChars(x.GoPointer(), BufVar, CountVar, BytesReadVar, &cerr)	290		cret := xIOChannelReadChars(x.GoPointer(), BufVar, CountVar, BytesReadVar, &cerr)

@@ -295,13 +295,13 @@ func (x *IOChannel) ReadChars(BufVar []byte, CountVar uint, BytesReadVar uint) (
295			295
296		}	296		}
297			297
298	-	var xIOChannelReadLine func(uintptr, string, uint, uint, **Error) IOStatus	298	+	var xIOChannelReadLine func(uintptr, string, uint, uint, *Error) IOStatus
299			299
300		// Reads a line, including the terminating character(s),	300		// Reads a line, including the terminating character(s),
301		// from a #GIOChannel into a newly-allocated string.	301		// from a #GIOChannel into a newly-allocated string.
302		// @str_return will contain allocated memory if the return	302		// @str_return will contain allocated memory if the return
303		// is %G_IO_STATUS_NORMAL.	303		// is %G_IO_STATUS_NORMAL.
304	-	func (x *IOChannel) ReadLine(StrReturnVar string, LengthVar uint, TerminatorPosVar uint) (IOStatus, error) {	304	+	func (x IOChannel) ReadLine(StrReturnVar string, LengthVar uint, TerminatorPosVar uint) (IOStatus, error) {
305		var cerr *Error	305		var cerr *Error
306			306
307		cret := xIOChannelReadLine(x.GoPointer(), StrReturnVar, LengthVar, TerminatorPosVar, &cerr)	307		cret := xIOChannelReadLine(x.GoPointer(), StrReturnVar, LengthVar, TerminatorPosVar, &cerr)

@@ -326,10 +326,10 @@ func (x IOChannel) ReadLineString(BufferVar String, TerminatorPosVar uint) (IO
326			326
327		}	327		}
328			328
329	-	var xIOChannelReadToEnd func(uintptr, []byte, uint, **Error) IOStatus	329	+	var xIOChannelReadToEnd func(uintptr, []byte, uint, **Error) IOStatus
330			330
331		// Reads all the remaining data from the file.	331		// Reads all the remaining data from the file.
332	-	func (x *IOChannel) ReadToEnd(StrReturnVar []byte, LengthVar uint) (IOStatus, error) {	332	+	func (x IOChannel) ReadToEnd(StrReturnVar []byte, LengthVar *uint) (IOStatus, error) {
333		var cerr *Error	333		var cerr *Error
334			334
335		cret := xIOChannelReadToEnd(x.GoPointer(), StrReturnVar, LengthVar, &cerr)	335		cret := xIOChannelReadToEnd(x.GoPointer(), StrReturnVar, LengthVar, &cerr)

@@ -340,11 +340,11 @@ func (x *IOChannel) ReadToEnd(StrReturnVar []byte, LengthVar uint) (IOStatus, er
340			340
341		}	341		}
342			342
343	-	var xIOChannelReadUnichar func(uintptr, uint32, **Error) IOStatus	343	+	var xIOChannelReadUnichar func(uintptr, uint32, *Error) IOStatus
344			344
345		// Reads a Unicode character from @channel.	345		// Reads a Unicode character from @channel.
346		// This function cannot be called on a channel with %NULL encoding.	346		// This function cannot be called on a channel with %NULL encoding.
347	-	func (x *IOChannel) ReadUnichar(ThecharVar uint32) (IOStatus, error) {	347	+	func (x IOChannel) ReadUnichar(ThecharVar uint32) (IOStatus, error) {
348		var cerr *Error	348		var cerr *Error
349			349
350		cret := xIOChannelReadUnichar(x.GoPointer(), ThecharVar, &cerr)	350		cret := xIOChannelReadUnichar(x.GoPointer(), ThecharVar, &cerr)

@@ -555,7 +555,7 @@ func (x *IOChannel) Write(BufVar string, CountVar uint, BytesWrittenVar uint) IO
555		return cret	555		return cret
556		}	556		}
557			557
558	-	var xIOChannelWriteChars func(uintptr, []byte, int, uint, **Error) IOStatus	558	+	var xIOChannelWriteChars func(uintptr, []byte, int, uint, *Error) IOStatus
559			559
560		// Replacement for g_io_channel_write() with the new API.	560		// Replacement for g_io_channel_write() with the new API.
561		//	561		//

@@ -563,7 +563,7 @@ var xIOChannelWriteChars func(uintptr, []byte, int, uint, **Error) IOStatus
563		// mixing of reading and writing is not allowed. A call to g_io_channel_write_chars ()	563		// mixing of reading and writing is not allowed. A call to g_io_channel_write_chars ()
564		// may only be made on a channel from which data has been read in the	564		// may only be made on a channel from which data has been read in the
565		// cases described in the documentation for g_io_channel_set_encoding ().	565		// cases described in the documentation for g_io_channel_set_encoding ().
566	-	func (x *IOChannel) WriteChars(BufVar []byte, CountVar int, BytesWrittenVar uint) (IOStatus, error) {	566	+	func (x IOChannel) WriteChars(BufVar []byte, CountVar int, BytesWrittenVar uint) (IOStatus, error) {
567		var cerr *Error	567		var cerr *Error
568			568
569		cret := xIOChannelWriteChars(x.GoPointer(), BufVar, CountVar, BytesWrittenVar, &cerr)	569		cret := xIOChannelWriteChars(x.GoPointer(), BufVar, CountVar, BytesWrittenVar, &cerr)

@@ -615,7 +615,7 @@ func (x *IOFuncs) GoPointer() uintptr {
615		return uintptr(unsafe.Pointer(x))	615		return uintptr(unsafe.Pointer(x))
616		}	616		}
617			617
618	-	// OverrideIoRead sets the callback function.	618	+	// OverrideIoRead sets the "io_read" callback function.
619		// reads raw bytes from the channel. This is called from	619		// reads raw bytes from the channel. This is called from
620		//	620		//
621		// various functions such as g_io_channel_read_chars() to	621		// various functions such as g_io_channel_read_chars() to

@@ -631,7 +631,7 @@ func (x IOFuncs) OverrideIoRead(cb func(IOChannel, string, uint, uint) IOStatu
631		}	631		}
632		}	632		}
633			633
634	-	// GetIoRead gets the callback function.	634	+	// GetIoRead gets the "io_read" callback function.
635		// reads raw bytes from the channel. This is called from	635		// reads raw bytes from the channel. This is called from
636		//	636		//
637		// various functions such as g_io_channel_read_chars() to	637		// various functions such as g_io_channel_read_chars() to

@@ -648,7 +648,7 @@ func (x IOFuncs) GetIoRead() func(IOChannel, string, uint, uint) IOStatus {
648		}	648		}
649		}	649		}
650			650
651	-	// OverrideIoWrite sets the callback function.	651	+	// OverrideIoWrite sets the "io_write" callback function.
652		// writes raw bytes to the channel. This is called from	652		// writes raw bytes to the channel. This is called from
653		//	653		//
654		// various functions such as g_io_channel_write_chars() to	654		// various functions such as g_io_channel_write_chars() to

@@ -664,7 +664,7 @@ func (x IOFuncs) OverrideIoWrite(cb func(IOChannel, string, uint, uint) IOStat
664		}	664		}
665		}	665		}
666			666
667	-	// GetIoWrite gets the callback function.	667	+	// GetIoWrite gets the "io_write" callback function.
668		// writes raw bytes to the channel. This is called from	668		// writes raw bytes to the channel. This is called from
669		//	669		//
670		// various functions such as g_io_channel_write_chars() to	670		// various functions such as g_io_channel_write_chars() to

@@ -681,7 +681,7 @@ func (x IOFuncs) GetIoWrite() func(IOChannel, string, uint, uint) IOStatus {
681		}	681		}
682		}	682		}
683			683
684	-	// OverrideIoSeek sets the callback function.	684	+	// OverrideIoSeek sets the "io_seek" callback function.
685		// seeks the channel. This is called from	685		// seeks the channel. This is called from
686		//	686		//
687		// g_io_channel_seek() on channels that support it.	687		// g_io_channel_seek() on channels that support it.

@@ -695,7 +695,7 @@ func (x IOFuncs) OverrideIoSeek(cb func(IOChannel, int64, SeekType) IOStatus)
695		}	695		}
696		}	696		}
697			697
698	-	// GetIoSeek gets the callback function.	698	+	// GetIoSeek gets the "io_seek" callback function.
699		// seeks the channel. This is called from	699		// seeks the channel. This is called from
700		//	700		//
701		// g_io_channel_seek() on channels that support it.	701		// g_io_channel_seek() on channels that support it.

@@ -710,7 +710,7 @@ func (x IOFuncs) GetIoSeek() func(IOChannel, int64, SeekType) IOStatus {
710		}	710		}
711		}	711		}
712			712
713	-	// OverrideIoClose sets the callback function.	713	+	// OverrideIoClose sets the "io_close" callback function.
714		// closes the channel. This is called from	714		// closes the channel. This is called from
715		//	715		//
716		// g_io_channel_close() after flushing the buffers.	716		// g_io_channel_close() after flushing the buffers.

@@ -724,7 +724,7 @@ func (x IOFuncs) OverrideIoClose(cb func(IOChannel) IOStatus) {
724		}	724		}
725		}	725		}
726			726
727	-	// GetIoClose gets the callback function.	727	+	// GetIoClose gets the "io_close" callback function.
728		// closes the channel. This is called from	728		// closes the channel. This is called from
729		//	729		//
730		// g_io_channel_close() after flushing the buffers.	730		// g_io_channel_close() after flushing the buffers.

@@ -739,7 +739,7 @@ func (x IOFuncs) GetIoClose() func(IOChannel) IOStatus {
739		}	739		}
740		}	740		}
741			741
742	-	// OverrideIoCreateWatch sets the callback function.	742	+	// OverrideIoCreateWatch sets the "io_create_watch" callback function.
743		// creates a watch on the channel. This call	743		// creates a watch on the channel. This call
744		//	744		//
745		// corresponds directly to g_io_create_watch().	745		// corresponds directly to g_io_create_watch().

@@ -753,7 +753,7 @@ func (x IOFuncs) OverrideIoCreateWatch(cb func(IOChannel, IOCondition) *Source
753		}	753		}
754		}	754		}
755			755
756	-	// GetIoCreateWatch gets the callback function.	756	+	// GetIoCreateWatch gets the "io_create_watch" callback function.
757		// creates a watch on the channel. This call	757		// creates a watch on the channel. This call
758		//	758		//
759		// corresponds directly to g_io_create_watch().	759		// corresponds directly to g_io_create_watch().

@@ -768,7 +768,7 @@ func (x IOFuncs) GetIoCreateWatch() func(IOChannel, IOCondition) *Source {
768		}	768		}
769		}	769		}
770			770
771	-	// OverrideIoFree sets the callback function.	771	+	// OverrideIoFree sets the "io_free" callback function.
772		// called from g_io_channel_unref() when the channel needs to	772		// called from g_io_channel_unref() when the channel needs to
773		//	773		//
774		// be freed. This function must free the memory associated	774		// be freed. This function must free the memory associated

@@ -786,7 +786,7 @@ func (x IOFuncs) OverrideIoFree(cb func(IOChannel)) {
786		}	786		}
787		}	787		}
788			788
789	-	// GetIoFree gets the callback function.	789	+	// GetIoFree gets the "io_free" callback function.
790		// called from g_io_channel_unref() when the channel needs to	790		// called from g_io_channel_unref() when the channel needs to
791		//	791		//
792		// be freed. This function must free the memory associated	792		// be freed. This function must free the memory associated

@@ -805,7 +805,7 @@ func (x IOFuncs) GetIoFree() func(IOChannel) {
805		}	805		}
806		}	806		}
807			807
808	-	// OverrideIoSetFlags sets the callback function.	808	+	// OverrideIoSetFlags sets the "io_set_flags" callback function.
809		// sets the #GIOFlags on the channel. This is called	809		// sets the #GIOFlags on the channel. This is called
810		//	810		//
811		// from g_io_channel_set_flags() with all flags except	811		// from g_io_channel_set_flags() with all flags except

@@ -821,7 +821,7 @@ func (x IOFuncs) OverrideIoSetFlags(cb func(IOChannel, IOFlags) IOStatus) {
821		}	821		}
822		}	822		}
823			823
824	-	// GetIoSetFlags gets the callback function.	824	+	// GetIoSetFlags gets the "io_set_flags" callback function.
825		// sets the #GIOFlags on the channel. This is called	825		// sets the #GIOFlags on the channel. This is called
826		//	826		//
827		// from g_io_channel_set_flags() with all flags except	827		// from g_io_channel_set_flags() with all flags except

@@ -838,7 +838,7 @@ func (x IOFuncs) GetIoSetFlags() func(IOChannel, IOFlags) IOStatus {
838		}	838		}
839		}	839		}
840			840
841	-	// OverrideIoGetFlags sets the callback function.	841	+	// OverrideIoGetFlags sets the "io_get_flags" callback function.
842		// gets the #GIOFlags for the channel. This function	842		// gets the #GIOFlags for the channel. This function
843		//	843		//
844		// need only return the %G_IO_FLAG_APPEND and	844		// need only return the %G_IO_FLAG_APPEND and

@@ -854,7 +854,7 @@ func (x IOFuncs) OverrideIoGetFlags(cb func(IOChannel) IOFlags) {
854		}	854		}
855		}	855		}
856			856
857	-	// GetIoGetFlags gets the callback function.	857	+	// GetIoGetFlags gets the "io_get_flags" callback function.
858		// gets the #GIOFlags for the channel. This function	858		// gets the #GIOFlags for the channel. This function
859		//	859		//
860		// need only return the %G_IO_FLAG_APPEND and	860		// need only return the %G_IO_FLAG_APPEND and

M v4/glib/gkeyfile.go +20 -20


@@ -211,7 +211,7 @@ func (x *KeyFile) GetBoolean(GroupNameVar string, KeyVar string) (bool, error) {
211			211
212		}	212		}
213			213
214	-	var xKeyFileGetBooleanList func(uintptr, string, string, uint, **Error) uintptr	214	+	var xKeyFileGetBooleanList func(uintptr, string, string, uint, *Error) uintptr
215			215
216		// Returns the values associated with @key under @group_name as	216		// Returns the values associated with @key under @group_name as
217		// booleans.	217		// booleans.

@@ -219,7 +219,7 @@ var xKeyFileGetBooleanList func(uintptr, string, string, uint, **Error) uintptr
219		// If @key cannot be found then [error@GLib.KeyFileError.KEY_NOT_FOUND] is	219		// If @key cannot be found then [error@GLib.KeyFileError.KEY_NOT_FOUND] is
220		// returned. Likewise, if the values associated with @key cannot be interpreted	220		// returned. Likewise, if the values associated with @key cannot be interpreted
221		// as booleans then [error@GLib.KeyFileError.INVALID_VALUE] is returned.	221		// as booleans then [error@GLib.KeyFileError.INVALID_VALUE] is returned.
222	-	func (x *KeyFile) GetBooleanList(GroupNameVar string, KeyVar string, LengthVar uint) (uintptr, error) {	222	+	func (x KeyFile) GetBooleanList(GroupNameVar string, KeyVar string, LengthVar uint) (uintptr, error) {
223		var cerr *Error	223		var cerr *Error
224			224
225		cret := xKeyFileGetBooleanList(x.GoPointer(), GroupNameVar, KeyVar, LengthVar, &cerr)	225		cret := xKeyFileGetBooleanList(x.GoPointer(), GroupNameVar, KeyVar, LengthVar, &cerr)

@@ -270,7 +270,7 @@ func (x *KeyFile) GetDouble(GroupNameVar string, KeyVar string) (float64, error)
270			270
271		}	271		}
272			272
273	-	var xKeyFileGetDoubleList func(uintptr, string, string, uint, **Error) uintptr	273	+	var xKeyFileGetDoubleList func(uintptr, string, string, uint, *Error) uintptr
274			274
275		// Returns the values associated with @key under @group_name as	275		// Returns the values associated with @key under @group_name as
276		// doubles.	276		// doubles.

@@ -278,7 +278,7 @@ var xKeyFileGetDoubleList func(uintptr, string, string, uint, **Error) uintptr
278		// If @key cannot be found then [error@GLib.KeyFileError.KEY_NOT_FOUND] is	278		// If @key cannot be found then [error@GLib.KeyFileError.KEY_NOT_FOUND] is
279		// returned. Likewise, if the values associated with @key cannot be interpreted	279		// returned. Likewise, if the values associated with @key cannot be interpreted
280		// as doubles then [error@GLib.KeyFileError.INVALID_VALUE] is returned.	280		// as doubles then [error@GLib.KeyFileError.INVALID_VALUE] is returned.
281	-	func (x *KeyFile) GetDoubleList(GroupNameVar string, KeyVar string, LengthVar uint) (uintptr, error) {	281	+	func (x KeyFile) GetDoubleList(GroupNameVar string, KeyVar string, LengthVar uint) (uintptr, error) {
282		var cerr *Error	282		var cerr *Error
283			283
284		cret := xKeyFileGetDoubleList(x.GoPointer(), GroupNameVar, KeyVar, LengthVar, &cerr)	284		cret := xKeyFileGetDoubleList(x.GoPointer(), GroupNameVar, KeyVar, LengthVar, &cerr)

@@ -289,13 +289,13 @@ func (x *KeyFile) GetDoubleList(GroupNameVar string, KeyVar string, LengthVar ui
289			289
290		}	290		}
291			291
292	-	var xKeyFileGetGroups func(uintptr, uint) []string	292	+	var xKeyFileGetGroups func(uintptr, *uint) []string
293			293
294		// Returns all groups in the key file loaded with @key_file.	294		// Returns all groups in the key file loaded with @key_file.
295		//	295		//
296		// The array of returned groups will be `NULL`-terminated, so	296		// The array of returned groups will be `NULL`-terminated, so
297		// @length may optionally be `NULL`.	297		// @length may optionally be `NULL`.
298	-	func (x *KeyFile) GetGroups(LengthVar uint) []string {	298	+	func (x KeyFile) GetGroups(LengthVar uint) []string {
299			299
300		cret := xKeyFileGetGroups(x.GoPointer(), LengthVar)	300		cret := xKeyFileGetGroups(x.GoPointer(), LengthVar)
301		return cret	301		return cret

@@ -339,7 +339,7 @@ func (x *KeyFile) GetInteger(GroupNameVar string, KeyVar string) (int, error) {
339			339
340		}	340		}
341			341
342	-	var xKeyFileGetIntegerList func(uintptr, string, string, uint, **Error) uintptr	342	+	var xKeyFileGetIntegerList func(uintptr, string, string, uint, *Error) uintptr
343			343
344		// Returns the values associated with @key under @group_name as	344		// Returns the values associated with @key under @group_name as
345		// integers.	345		// integers.

@@ -348,7 +348,7 @@ var xKeyFileGetIntegerList func(uintptr, string, string, uint, **Error) uintptr
348		// returned. Likewise, if the values associated with @key cannot be interpreted	348		// returned. Likewise, if the values associated with @key cannot be interpreted
349		// as integers, or are out of range for `gint`, then	349		// as integers, or are out of range for `gint`, then
350		// [error@GLib.KeyFileError.INVALID_VALUE] is returned.	350		// [error@GLib.KeyFileError.INVALID_VALUE] is returned.
351	-	func (x *KeyFile) GetIntegerList(GroupNameVar string, KeyVar string, LengthVar uint) (uintptr, error) {	351	+	func (x KeyFile) GetIntegerList(GroupNameVar string, KeyVar string, LengthVar uint) (uintptr, error) {
352		var cerr *Error	352		var cerr *Error
353			353
354		cret := xKeyFileGetIntegerList(x.GoPointer(), GroupNameVar, KeyVar, LengthVar, &cerr)	354		cret := xKeyFileGetIntegerList(x.GoPointer(), GroupNameVar, KeyVar, LengthVar, &cerr)

@@ -359,14 +359,14 @@ func (x *KeyFile) GetIntegerList(GroupNameVar string, KeyVar string, LengthVar u
359			359
360		}	360		}
361			361
362	-	var xKeyFileGetKeys func(uintptr, string, uint, **Error) []string	362	+	var xKeyFileGetKeys func(uintptr, string, uint, *Error) []string
363			363
364		// Returns all keys for the group name @group_name.	364		// Returns all keys for the group name @group_name.
365		//	365		//
366		// The array of returned keys will be `NULL`-terminated, so @length may	366		// The array of returned keys will be `NULL`-terminated, so @length may
367		// optionally be `NULL`. If the @group_name cannot be found,	367		// optionally be `NULL`. If the @group_name cannot be found,
368		// [error@GLib.KeyFileError.GROUP_NOT_FOUND] is returned.	368		// [error@GLib.KeyFileError.GROUP_NOT_FOUND] is returned.
369	-	func (x *KeyFile) GetKeys(GroupNameVar string, LengthVar uint) ([]string, error) {	369	+	func (x KeyFile) GetKeys(GroupNameVar string, LengthVar uint) ([]string, error) {
370		var cerr *Error	370		var cerr *Error
371			371
372		cret := xKeyFileGetKeys(x.GoPointer(), GroupNameVar, LengthVar, &cerr)	372		cret := xKeyFileGetKeys(x.GoPointer(), GroupNameVar, LengthVar, &cerr)

@@ -423,7 +423,7 @@ func (x *KeyFile) GetLocaleString(GroupNameVar string, KeyVar string, LocaleVar
423			423
424		}	424		}
425			425
426	-	var xKeyFileGetLocaleStringList func(uintptr, string, string, string, uint, **Error) []string	426	+	var xKeyFileGetLocaleStringList func(uintptr, string, string, string, uint, *Error) []string
427			427
428		// Returns the values associated with @key under @group_name	428		// Returns the values associated with @key under @group_name
429		// translated in the given @locale if available.	429		// translated in the given @locale if available.

@@ -443,7 +443,7 @@ var xKeyFileGetLocaleStringList func(uintptr, string, string, string, uint, **Er
443		// can be found then the untranslated values are returned. The	443		// can be found then the untranslated values are returned. The
444		// returned array is `NULL`-terminated, so @length may optionally	444		// returned array is `NULL`-terminated, so @length may optionally
445		// be `NULL`.	445		// be `NULL`.
446	-	func (x *KeyFile) GetLocaleStringList(GroupNameVar string, KeyVar string, LocaleVar string, LengthVar uint) ([]string, error) {	446	+	func (x KeyFile) GetLocaleStringList(GroupNameVar string, KeyVar string, LocaleVar string, LengthVar uint) ([]string, error) {
447		var cerr *Error	447		var cerr *Error
448			448
449		cret := xKeyFileGetLocaleStringList(x.GoPointer(), GroupNameVar, KeyVar, LocaleVar, LengthVar, &cerr)	449		cret := xKeyFileGetLocaleStringList(x.GoPointer(), GroupNameVar, KeyVar, LocaleVar, LengthVar, &cerr)

@@ -484,14 +484,14 @@ func (x *KeyFile) GetString(GroupNameVar string, KeyVar string) (string, error)
484			484
485		}	485		}
486			486
487	-	var xKeyFileGetStringList func(uintptr, string, string, uint, **Error) []string	487	+	var xKeyFileGetStringList func(uintptr, string, string, uint, *Error) []string
488			488
489		// Returns the values associated with @key under @group_name.	489		// Returns the values associated with @key under @group_name.
490		//	490		//
491		// If the key cannot be found, [error@GLib.KeyFileError.KEY_NOT_FOUND] is	491		// If the key cannot be found, [error@GLib.KeyFileError.KEY_NOT_FOUND] is
492		// returned. If the @group_name cannot be found,	492		// returned. If the @group_name cannot be found,
493		// [error@GLib.KeyFileError.GROUP_NOT_FOUND] is returned.	493		// [error@GLib.KeyFileError.GROUP_NOT_FOUND] is returned.
494	-	func (x *KeyFile) GetStringList(GroupNameVar string, KeyVar string, LengthVar uint) ([]string, error) {	494	+	func (x KeyFile) GetStringList(GroupNameVar string, KeyVar string, LengthVar uint) ([]string, error) {
495		var cerr *Error	495		var cerr *Error
496			496
497		cret := xKeyFileGetStringList(x.GoPointer(), GroupNameVar, KeyVar, LengthVar, &cerr)	497		cret := xKeyFileGetStringList(x.GoPointer(), GroupNameVar, KeyVar, LengthVar, &cerr)

@@ -606,7 +606,7 @@ func (x *KeyFile) LoadFromData(DataVar string, LengthVar uint, FlagsVar KeyFileF
606			606
607		}	607		}
608			608
609	-	var xKeyFileLoadFromDataDirs func(uintptr, string, string, KeyFileFlags, **Error) bool	609	+	var xKeyFileLoadFromDataDirs func(uintptr, string, string, KeyFileFlags, *Error) bool
610			610
611		// Looks for a key file named @file in the paths returned from	611		// Looks for a key file named @file in the paths returned from
612		// [func@GLib.get_user_data_dir] and [func@GLib.get_system_data_dirs].	612		// [func@GLib.get_user_data_dir] and [func@GLib.get_system_data_dirs].

@@ -617,7 +617,7 @@ var xKeyFileLoadFromDataDirs func(uintptr, string, string, KeyFileFlags, **Error
617		//	617		//
618		// If the file could not be loaded then either a [error@GLib.FileError] or	618		// If the file could not be loaded then either a [error@GLib.FileError] or
619		// [error@GLib.KeyFileError] is returned.	619		// [error@GLib.KeyFileError] is returned.
620	-	func (x *KeyFile) LoadFromDataDirs(FileVar string, FullPathVar string, FlagsVar KeyFileFlags) (bool, error) {	620	+	func (x KeyFile) LoadFromDataDirs(FileVar string, FullPathVar string, FlagsVar KeyFileFlags) (bool, error) {
621		var cerr *Error	621		var cerr *Error
622			622
623		cret := xKeyFileLoadFromDataDirs(x.GoPointer(), FileVar, FullPathVar, FlagsVar, &cerr)	623		cret := xKeyFileLoadFromDataDirs(x.GoPointer(), FileVar, FullPathVar, FlagsVar, &cerr)

@@ -628,7 +628,7 @@ func (x *KeyFile) LoadFromDataDirs(FileVar string, FullPathVar string, FlagsVar
628			628
629		}	629		}
630			630
631	-	var xKeyFileLoadFromDirs func(uintptr, string, []string, string, KeyFileFlags, **Error) bool	631	+	var xKeyFileLoadFromDirs func(uintptr, string, []string, string, KeyFileFlags, *Error) bool
632			632
633		// Looks for a key file named @file in the paths specified in @search_dirs,	633		// Looks for a key file named @file in the paths specified in @search_dirs,
634		// loads the file into @key_file and returns the file’s full path in @full_path.	634		// loads the file into @key_file and returns the file’s full path in @full_path.

@@ -645,7 +645,7 @@ var xKeyFileLoadFromDirs func(uintptr, string, []string, string, KeyFileFlags, *
645		// the file is found but the OS returns an error when opening or reading the	645		// the file is found but the OS returns an error when opening or reading the
646		// file, a [error@GLib.FileError] is returned. If there is a problem parsing the	646		// file, a [error@GLib.FileError] is returned. If there is a problem parsing the
647		// file, a [error@GLib.KeyFileError] is returned.	647		// file, a [error@GLib.KeyFileError] is returned.
648	-	func (x *KeyFile) LoadFromDirs(FileVar string, SearchDirsVar []string, FullPathVar string, FlagsVar KeyFileFlags) (bool, error) {	648	+	func (x KeyFile) LoadFromDirs(FileVar string, SearchDirsVar []string, FullPathVar string, FlagsVar KeyFileFlags) (bool, error) {
649		var cerr *Error	649		var cerr *Error
650			650
651		cret := xKeyFileLoadFromDirs(x.GoPointer(), FileVar, SearchDirsVar, FullPathVar, FlagsVar, &cerr)	651		cret := xKeyFileLoadFromDirs(x.GoPointer(), FileVar, SearchDirsVar, FullPathVar, FlagsVar, &cerr)

@@ -949,12 +949,12 @@ func (x *KeyFile) SetValue(GroupNameVar string, KeyVar string, ValueVar string)
949			949
950		}	950		}
951			951
952	-	var xKeyFileToData func(uintptr, uint, **Error) string	952	+	var xKeyFileToData func(uintptr, uint, *Error) string
953			953
954		// Outputs @key_file as a string.	954		// Outputs @key_file as a string.
955		//	955		//
956		// Note that this function never reports an error.	956		// Note that this function never reports an error.
957	-	func (x *KeyFile) ToData(LengthVar uint) (string, error) {	957	+	func (x KeyFile) ToData(LengthVar uint) (string, error) {
958		var cerr *Error	958		var cerr *Error
959			959
960		cret := xKeyFileToData(x.GoPointer(), LengthVar, &cerr)	960		cret := xKeyFileToData(x.GoPointer(), LengthVar, &cerr)

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


@@ -88,7 +88,7 @@ type SourceFuncsFinalizeFunc func(*Source)
88		//	88		//
89		// Since 2.36 this may be `NULL`, in which case the effect is as if the	89		// Since 2.36 this may be `NULL`, in which case the effect is as if the
90		// function always returns `FALSE` with a timeout of `-1`.	90		// function always returns `FALSE` with a timeout of `-1`.
91	-	type SourceFuncsPrepareFunc func(*Source, int) bool	91	+	type SourceFuncsPrepareFunc func(Source, int) bool
92			92
93		// A source function that is only called once before being removed from the main	93		// A source function that is only called once before being removed from the main
94		// context automatically.	94		// context automatically.

@@ -355,7 +355,7 @@ func (x *MainContext) PopThreadDefault() {
355			355
356		}	356		}
357			357
358	-	var xMainContextPrepare func(uintptr, int) bool	358	+	var xMainContextPrepare func(uintptr, *int) bool
359			359
360		// Prepares to poll sources within a main loop.	360		// Prepares to poll sources within a main loop.
361		//	361		//

@@ -364,7 +364,7 @@ var xMainContextPrepare func(uintptr, int) bool
364		//	364		//
365		// You must have successfully acquired the context with	365		// You must have successfully acquired the context with
366		// [method@GLib.MainContext.acquire] before you may call this function.	366		// [method@GLib.MainContext.acquire] before you may call this function.
367	-	func (x *MainContext) Prepare(PriorityVar int) bool {	367	+	func (x MainContext) Prepare(PriorityVar int) bool {
368			368
369		cret := xMainContextPrepare(x.GoPointer(), PriorityVar)	369		cret := xMainContextPrepare(x.GoPointer(), PriorityVar)
370		return cret	370		return cret

@@ -465,7 +465,7 @@ func (x MainContext) PusherNew() MainContextPusher {
465		return cret	465		return cret
466		}	466		}
467			467
468	-	var xMainContextQuery func(uintptr, int, int, []PollFD, int) int	468	+	var xMainContextQuery func(uintptr, int, int, []PollFD, int) int
469			469
470		// Determines information necessary to poll this main loop.	470		// Determines information necessary to poll this main loop.
471		//	471		//

@@ -476,7 +476,7 @@ var xMainContextQuery func(uintptr, int, int, []PollFD, int) int
476		//	476		//
477		// You must have successfully acquired the context with	477		// You must have successfully acquired the context with
478		// [method@GLib.MainContext.acquire] before you may call this function.	478		// [method@GLib.MainContext.acquire] before you may call this function.
479	-	func (x *MainContext) Query(MaxPriorityVar int, TimeoutVar int, FdsVar []PollFD, NFdsVar int) int {	479	+	func (x MainContext) Query(MaxPriorityVar int, TimeoutVar int, FdsVar *[]PollFD, NFdsVar int) int {
480			480
481		cret := xMainContextQuery(x.GoPointer(), MaxPriorityVar, TimeoutVar, FdsVar, NFdsVar)	481		cret := xMainContextQuery(x.GoPointer(), MaxPriorityVar, TimeoutVar, FdsVar, NFdsVar)
482		return cret	482		return cret

@@ -1390,7 +1390,7 @@ func (x *SourceCallbackFuncs) GoPointer() uintptr {
1390		return uintptr(unsafe.Pointer(x))	1390		return uintptr(unsafe.Pointer(x))
1391		}	1391		}
1392			1392
1393	-	// OverrideRef sets the callback function.	1393	+	// OverrideRef sets the "ref" callback function.
1394		// Called when a reference is added to the callback object	1394		// Called when a reference is added to the callback object
1395		func (x *SourceCallbackFuncs) OverrideRef(cb func(uintptr)) {	1395		func (x *SourceCallbackFuncs) OverrideRef(cb func(uintptr)) {
1396		if cb == nil {	1396		if cb == nil {

@@ -1402,7 +1402,7 @@ func (x *SourceCallbackFuncs) OverrideRef(cb func(uintptr)) {
1402		}	1402		}
1403		}	1403		}
1404			1404
1405	-	// GetRef gets the callback function.	1405	+	// GetRef gets the "ref" callback function.
1406		// Called when a reference is added to the callback object	1406		// Called when a reference is added to the callback object
1407		func (x *SourceCallbackFuncs) GetRef() func(uintptr) {	1407		func (x *SourceCallbackFuncs) GetRef() func(uintptr) {
1408		if x.xRef == 0 {	1408		if x.xRef == 0 {

@@ -1415,7 +1415,7 @@ func (x *SourceCallbackFuncs) GetRef() func(uintptr) {
1415		}	1415		}
1416		}	1416		}
1417			1417
1418	-	// OverrideUnref sets the callback function.	1418	+	// OverrideUnref sets the "unref" callback function.
1419		// Called when a reference to the callback object is dropped	1419		// Called when a reference to the callback object is dropped
1420		func (x *SourceCallbackFuncs) OverrideUnref(cb func(uintptr)) {	1420		func (x *SourceCallbackFuncs) OverrideUnref(cb func(uintptr)) {
1421		if cb == nil {	1421		if cb == nil {

@@ -1427,7 +1427,7 @@ func (x *SourceCallbackFuncs) OverrideUnref(cb func(uintptr)) {
1427		}	1427		}
1428		}	1428		}
1429			1429
1430	-	// GetUnref gets the callback function.	1430	+	// GetUnref gets the "unref" callback function.
1431		// Called when a reference to the callback object is dropped	1431		// Called when a reference to the callback object is dropped
1432		func (x *SourceCallbackFuncs) GetUnref() func(uintptr) {	1432		func (x *SourceCallbackFuncs) GetUnref() func(uintptr) {
1433		if x.xUnref == 0 {	1433		if x.xUnref == 0 {

@@ -1440,7 +1440,7 @@ func (x *SourceCallbackFuncs) GetUnref() func(uintptr) {
1440		}	1440		}
1441		}	1441		}
1442			1442
1443	-	// OverrideGet sets the callback function.	1443	+	// OverrideGet sets the "get" callback function.
1444		// Called to extract the callback function and data from the	1444		// Called to extract the callback function and data from the
1445		//	1445		//
1446		// callback object.	1446		// callback object.

@@ -1454,7 +1454,7 @@ func (x SourceCallbackFuncs) OverrideGet(cb func(uintptr, Source, *SourceFunc,
1454		}	1454		}
1455		}	1455		}
1456			1456
1457	-	// GetGet gets the callback function.	1457	+	// GetGet gets the "get" callback function.
1458		// Called to extract the callback function and data from the	1458		// Called to extract the callback function and data from the
1459		//	1459		//
1460		// callback object.	1460		// callback object.

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


@@ -104,13 +104,13 @@ func (x MarkupParseContext) GetElementStack() SList {
104		return cret	104		return cret
105		}	105		}
106			106
107	-	var xMarkupParseContextGetPosition func(uintptr, int, int)	107	+	var xMarkupParseContextGetPosition func(uintptr, int, int)
108			108
109		// Retrieves the current line number and the number of the character on	109		// Retrieves the current line number and the number of the character on
110		// that line. Intended for use in error messages; there are no strict	110		// that line. Intended for use in error messages; there are no strict
111		// semantics for what constitutes the "current" line number other than	111		// semantics for what constitutes the "current" line number other than
112		// "the best number we could come up with for error messages."	112		// "the best number we could come up with for error messages."
113	-	func (x *MarkupParseContext) GetPosition(LineNumberVar int, CharNumberVar int) {	113	+	func (x MarkupParseContext) GetPosition(LineNumberVar int, CharNumberVar *int) {
114			114
115		xMarkupParseContextGetPosition(x.GoPointer(), LineNumberVar, CharNumberVar)	115		xMarkupParseContextGetPosition(x.GoPointer(), LineNumberVar, CharNumberVar)
116			116

@@ -356,7 +356,7 @@ func (x *MarkupParser) GoPointer() uintptr {
356		return uintptr(unsafe.Pointer(x))	356		return uintptr(unsafe.Pointer(x))
357		}	357		}
358			358
359	-	// OverrideStartElement sets the callback function.	359	+	// OverrideStartElement sets the "start_element" callback function.
360		// Callback to invoke when the opening tag of an element	360		// Callback to invoke when the opening tag of an element
361		//	361		//
362		// is seen. The callback's @attribute_names and @attribute_values parameters	362		// is seen. The callback's @attribute_names and @attribute_values parameters

@@ -371,7 +371,7 @@ func (x MarkupParser) OverrideStartElement(cb func(MarkupParseContext, string,
371		}	371		}
372		}	372		}
373			373
374	-	// GetStartElement gets the callback function.	374	+	// GetStartElement gets the "start_element" callback function.
375		// Callback to invoke when the opening tag of an element	375		// Callback to invoke when the opening tag of an element
376		//	376		//
377		// is seen. The callback's @attribute_names and @attribute_values parameters	377		// is seen. The callback's @attribute_names and @attribute_values parameters

@@ -387,7 +387,7 @@ func (x MarkupParser) GetStartElement() func(MarkupParseContext, string, strin
387		}	387		}
388		}	388		}
389			389
390	-	// OverrideEndElement sets the callback function.	390	+	// OverrideEndElement sets the "end_element" callback function.
391		// Callback to invoke when the closing tag of an element	391		// Callback to invoke when the closing tag of an element
392		//	392		//
393		// is seen. Note that this is also called for empty tags like	393		// is seen. Note that this is also called for empty tags like

@@ -402,7 +402,7 @@ func (x MarkupParser) OverrideEndElement(cb func(MarkupParseContext, string, u
402		}	402		}
403		}	403		}
404			404
405	-	// GetEndElement gets the callback function.	405	+	// GetEndElement gets the "end_element" callback function.
406		// Callback to invoke when the closing tag of an element	406		// Callback to invoke when the closing tag of an element
407		//	407		//
408		// is seen. Note that this is also called for empty tags like	408		// is seen. Note that this is also called for empty tags like

@@ -418,7 +418,7 @@ func (x MarkupParser) GetEndElement() func(MarkupParseContext, string, uintptr
418		}	418		}
419		}	419		}
420			420
421	-	// OverrideText sets the callback function.	421	+	// OverrideText sets the "text" callback function.
422		// Callback to invoke when some text is seen (text is always	422		// Callback to invoke when some text is seen (text is always
423		//	423		//
424		// inside an element). Note that the text of an element may be spread	424		// inside an element). Note that the text of an element may be spread

@@ -435,7 +435,7 @@ func (x MarkupParser) OverrideText(cb func(MarkupParseContext, string, uint, u
435		}	435		}
436		}	436		}
437			437
438	-	// GetText gets the callback function.	438	+	// GetText gets the "text" callback function.
439		// Callback to invoke when some text is seen (text is always	439		// Callback to invoke when some text is seen (text is always
440		//	440		//
441		// inside an element). Note that the text of an element may be spread	441		// inside an element). Note that the text of an element may be spread

@@ -453,7 +453,7 @@ func (x MarkupParser) GetText() func(MarkupParseContext, string, uint, uintptr
453		}	453		}
454		}	454		}
455			455
456	-	// OverridePassthrough sets the callback function.	456	+	// OverridePassthrough sets the "passthrough" callback function.
457		// Callback to invoke for comments, processing instructions	457		// Callback to invoke for comments, processing instructions
458		//	458		//
459		// and doctype declarations; if you're re-writing the parsed document,	459		// and doctype declarations; if you're re-writing the parsed document,

@@ -470,7 +470,7 @@ func (x MarkupParser) OverridePassthrough(cb func(MarkupParseContext, string,
470		}	470		}
471		}	471		}
472			472
473	-	// GetPassthrough gets the callback function.	473	+	// GetPassthrough gets the "passthrough" callback function.
474		// Callback to invoke for comments, processing instructions	474		// Callback to invoke for comments, processing instructions
475		//	475		//
476		// and doctype declarations; if you're re-writing the parsed document,	476		// and doctype declarations; if you're re-writing the parsed document,

@@ -488,7 +488,7 @@ func (x MarkupParser) GetPassthrough() func(MarkupParseContext, string, uint,
488		}	488		}
489		}	489		}
490			490
491	-	// OverrideError sets the callback function.	491	+	// OverrideError sets the "error" callback function.
492		// Callback to invoke when an error occurs.	492		// Callback to invoke when an error occurs.
493		func (x MarkupParser) OverrideError(cb func(MarkupParseContext, *Error, uintptr)) {	493		func (x MarkupParser) OverrideError(cb func(MarkupParseContext, *Error, uintptr)) {
494		if cb == nil {	494		if cb == nil {

@@ -500,7 +500,7 @@ func (x MarkupParser) OverrideError(cb func(MarkupParseContext, *Error, uintpt
500		}	500		}
501		}	501		}
502			502
503	-	// GetError gets the callback function.	503	+	// GetError gets the "error" callback function.
504		// Callback to invoke when an error occurs.	504		// Callback to invoke when an error occurs.
505		func (x MarkupParser) GetError() func(MarkupParseContext, *Error, uintptr) {	505		func (x MarkupParser) GetError() func(MarkupParseContext, *Error, uintptr) {
506		if x.xError == 0 {	506		if x.xError == 0 {

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


@@ -34,7 +34,7 @@ func (x *MemVTable) GoPointer() uintptr {
34		return uintptr(unsafe.Pointer(x))	34		return uintptr(unsafe.Pointer(x))
35		}	35		}
36			36
37	-	// OverrideMalloc sets the callback function.	37	+	// OverrideMalloc sets the "malloc" callback function.
38		// function to use for allocating memory.	38		// function to use for allocating memory.
39		func (x *MemVTable) OverrideMalloc(cb func(uint) uintptr) {	39		func (x *MemVTable) OverrideMalloc(cb func(uint) uintptr) {
40		if cb == nil {	40		if cb == nil {

@@ -46,7 +46,7 @@ func (x *MemVTable) OverrideMalloc(cb func(uint) uintptr) {
46		}	46		}
47		}	47		}
48			48
49	-	// GetMalloc gets the callback function.	49	+	// GetMalloc gets the "malloc" callback function.
50		// function to use for allocating memory.	50		// function to use for allocating memory.
51		func (x *MemVTable) GetMalloc() func(uint) uintptr {	51		func (x *MemVTable) GetMalloc() func(uint) uintptr {
52		if x.xMalloc == 0 {	52		if x.xMalloc == 0 {

@@ -59,7 +59,7 @@ func (x *MemVTable) GetMalloc() func(uint) uintptr {
59		}	59		}
60		}	60		}
61			61
62	-	// OverrideRealloc sets the callback function.	62	+	// OverrideRealloc sets the "realloc" callback function.
63		// function to use for reallocating memory.	63		// function to use for reallocating memory.
64		func (x *MemVTable) OverrideRealloc(cb func(uintptr, uint) uintptr) {	64		func (x *MemVTable) OverrideRealloc(cb func(uintptr, uint) uintptr) {
65		if cb == nil {	65		if cb == nil {

@@ -71,7 +71,7 @@ func (x *MemVTable) OverrideRealloc(cb func(uintptr, uint) uintptr) {
71		}	71		}
72		}	72		}
73			73
74	-	// GetRealloc gets the callback function.	74	+	// GetRealloc gets the "realloc" callback function.
75		// function to use for reallocating memory.	75		// function to use for reallocating memory.
76		func (x *MemVTable) GetRealloc() func(uintptr, uint) uintptr {	76		func (x *MemVTable) GetRealloc() func(uintptr, uint) uintptr {
77		if x.xRealloc == 0 {	77		if x.xRealloc == 0 {

@@ -84,7 +84,7 @@ func (x *MemVTable) GetRealloc() func(uintptr, uint) uintptr {
84		}	84		}
85		}	85		}
86			86
87	-	// OverrideFree sets the callback function.	87	+	// OverrideFree sets the "free" callback function.
88		// function to use to free memory.	88		// function to use to free memory.
89		func (x *MemVTable) OverrideFree(cb func(uintptr)) {	89		func (x *MemVTable) OverrideFree(cb func(uintptr)) {
90		if cb == nil {	90		if cb == nil {

@@ -96,7 +96,7 @@ func (x *MemVTable) OverrideFree(cb func(uintptr)) {
96		}	96		}
97		}	97		}
98			98
99	-	// GetFree gets the callback function.	99	+	// GetFree gets the "free" callback function.
100		// function to use to free memory.	100		// function to use to free memory.
101		func (x *MemVTable) GetFree() func(uintptr) {	101		func (x *MemVTable) GetFree() func(uintptr) {
102		if x.xFree == 0 {	102		if x.xFree == 0 {

@@ -109,7 +109,7 @@ func (x *MemVTable) GetFree() func(uintptr) {
109		}	109		}
110		}	110		}
111			111
112	-	// OverrideCalloc sets the callback function.	112	+	// OverrideCalloc sets the "calloc" callback function.
113		// function to use for allocating zero-filled memory.	113		// function to use for allocating zero-filled memory.
114		func (x *MemVTable) OverrideCalloc(cb func(uint, uint) uintptr) {	114		func (x *MemVTable) OverrideCalloc(cb func(uint, uint) uintptr) {
115		if cb == nil {	115		if cb == nil {

@@ -121,7 +121,7 @@ func (x *MemVTable) OverrideCalloc(cb func(uint, uint) uintptr) {
121		}	121		}
122		}	122		}
123			123
124	-	// GetCalloc gets the callback function.	124	+	// GetCalloc gets the "calloc" callback function.
125		// function to use for allocating zero-filled memory.	125		// function to use for allocating zero-filled memory.
126		func (x *MemVTable) GetCalloc() func(uint, uint) uintptr {	126		func (x *MemVTable) GetCalloc() func(uint, uint) uintptr {
127		if x.xCalloc == 0 {	127		if x.xCalloc == 0 {

@@ -134,7 +134,7 @@ func (x *MemVTable) GetCalloc() func(uint, uint) uintptr {
134		}	134		}
135		}	135		}
136			136
137	-	// OverrideTryMalloc sets the callback function.	137	+	// OverrideTryMalloc sets the "try_malloc" callback function.
138		// function to use for allocating memory without a default error handler.	138		// function to use for allocating memory without a default error handler.
139		func (x *MemVTable) OverrideTryMalloc(cb func(uint) uintptr) {	139		func (x *MemVTable) OverrideTryMalloc(cb func(uint) uintptr) {
140		if cb == nil {	140		if cb == nil {

@@ -146,7 +146,7 @@ func (x *MemVTable) OverrideTryMalloc(cb func(uint) uintptr) {
146		}	146		}
147		}	147		}
148			148
149	-	// GetTryMalloc gets the callback function.	149	+	// GetTryMalloc gets the "try_malloc" callback function.
150		// function to use for allocating memory without a default error handler.	150		// function to use for allocating memory without a default error handler.
151		func (x *MemVTable) GetTryMalloc() func(uint) uintptr {	151		func (x *MemVTable) GetTryMalloc() func(uint) uintptr {
152		if x.xTryMalloc == 0 {	152		if x.xTryMalloc == 0 {

@@ -159,7 +159,7 @@ func (x *MemVTable) GetTryMalloc() func(uint) uintptr {
159		}	159		}
160		}	160		}
161			161
162	-	// OverrideTryRealloc sets the callback function.	162	+	// OverrideTryRealloc sets the "try_realloc" callback function.
163		// function to use for reallocating memory without a default error handler.	163		// function to use for reallocating memory without a default error handler.
164		func (x *MemVTable) OverrideTryRealloc(cb func(uintptr, uint) uintptr) {	164		func (x *MemVTable) OverrideTryRealloc(cb func(uintptr, uint) uintptr) {
165		if cb == nil {	165		if cb == nil {

@@ -171,7 +171,7 @@ func (x *MemVTable) OverrideTryRealloc(cb func(uintptr, uint) uintptr) {
171		}	171		}
172		}	172		}
173			173
174	-	// GetTryRealloc gets the callback function.	174	+	// GetTryRealloc gets the "try_realloc" callback function.
175		// function to use for reallocating memory without a default error handler.	175		// function to use for reallocating memory without a default error handler.
176		func (x *MemVTable) GetTryRealloc() func(uintptr, uint) uintptr {	176		func (x *MemVTable) GetTryRealloc() func(uintptr, uint) uintptr {
177		if x.xTryRealloc == 0 {	177		if x.xTryRealloc == 0 {

M v4/glib/gprintf.go +2 -2


@@ -51,7 +51,7 @@ func Sprintf(StringVar string, FormatVar string, varArgs ...interface{}) int {
51		return cret	51		return cret
52		}	52		}
53			53
54	-	var xVasprintf func(string, string, []interface{}) int	54	+	var xVasprintf func(*string, string, []interface{}) int
55			55
56		// An implementation of the GNU `vasprintf()` function which supports	56		// An implementation of the GNU `vasprintf()` function which supports
57		// positional parameters, as specified in the Single Unix Specification.	57		// positional parameters, as specified in the Single Unix Specification.

@@ -64,7 +64,7 @@ var xVasprintf func(string, string, []interface{}) int
64		// multibyte representation is available for the given character.	64		// multibyte representation is available for the given character.
65		//	65		//
66		// `glib/gprintf.h` must be explicitly included in order to use this function.	66		// `glib/gprintf.h` must be explicitly included in order to use this function.
67	-	func Vasprintf(StringVar string, FormatVar string, ArgsVar []interface{}) int {	67	+	func Vasprintf(StringVar *string, FormatVar string, ArgsVar []interface{}) int {
68			68
69		cret := xVasprintf(StringVar, FormatVar, ArgsVar)	69		cret := xVasprintf(StringVar, FormatVar, ArgsVar)
70		return cret	70		return cret

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


@@ -78,10 +78,10 @@ func AtomicRefCountInc(ArcVar int) {
78			78
79		}	79		}
80			80
81	-	var xAtomicRefCountInit func(int)	81	+	var xAtomicRefCountInit func(*int)
82			82
83		// Initializes a reference count variable to 1.	83		// Initializes a reference count variable to 1.
84	-	func AtomicRefCountInit(ArcVar int) {	84	+	func AtomicRefCountInit(ArcVar *int) {
85			85
86		xAtomicRefCountInit(ArcVar)	86		xAtomicRefCountInit(ArcVar)
87			87

@@ -118,10 +118,10 @@ func RefCountInc(RcVar int) {
118			118
119		}	119		}
120			120
121	-	var xRefCountInit func(int)	121	+	var xRefCountInit func(*int)
122			122
123		// Initializes a reference count variable to 1.	123		// Initializes a reference count variable to 1.
124	-	func RefCountInit(RcVar int) {	124	+	func RefCountInit(RcVar *int) {
125			125
126		xRefCountInit(RcVar)	126		xRefCountInit(RcVar)
127			127

M v4/glib/gregex.go +6 -6


@@ -126,7 +126,7 @@ func (x *MatchInfo) FetchNamed(NameVar string) string {
126		return cret	126		return cret
127		}	127		}
128			128
129	-	var xMatchInfoFetchNamedPos func(uintptr, string, int, int) bool	129	+	var xMatchInfoFetchNamedPos func(uintptr, string, int, int) bool
130			130
131		// Retrieves the position in bytes of the capturing parentheses named @name.	131		// Retrieves the position in bytes of the capturing parentheses named @name.
132		//	132		//

@@ -136,13 +136,13 @@ var xMatchInfoFetchNamedPos func(uintptr, string, int, int) bool
136		//	136		//
137		// As @end_pos is set to the byte after the final byte of the match (on success),	137		// As @end_pos is set to the byte after the final byte of the match (on success),
138		// the length of the match can be calculated as `end_pos - start_pos`.	138		// the length of the match can be calculated as `end_pos - start_pos`.
139	-	func (x *MatchInfo) FetchNamedPos(NameVar string, StartPosVar int, EndPosVar int) bool {	139	+	func (x MatchInfo) FetchNamedPos(NameVar string, StartPosVar int, EndPosVar *int) bool {
140			140
141		cret := xMatchInfoFetchNamedPos(x.GoPointer(), NameVar, StartPosVar, EndPosVar)	141		cret := xMatchInfoFetchNamedPos(x.GoPointer(), NameVar, StartPosVar, EndPosVar)
142		return cret	142		return cret
143		}	143		}
144			144
145	-	var xMatchInfoFetchPos func(uintptr, int, int, int) bool	145	+	var xMatchInfoFetchPos func(uintptr, int, int, int) bool
146			146
147		// Returns the start and end positions (in bytes) of a successfully matching	147		// Returns the start and end positions (in bytes) of a successfully matching
148		// capture parenthesis.	148		// capture parenthesis.

@@ -351,7 +351,7 @@ var xMatchInfoFetchPos func(uintptr, int, int, int) bool
351		// 2 <a> 1 0 3	351		// 2 <a> 1 0 3
352		// 3 N/A 0 2147483647 2147483647	352		// 3 N/A 0 2147483647 2147483647
353		// ```	353		// ```
354	-	func (x *MatchInfo) FetchPos(MatchNumVar int, StartPosVar int, EndPosVar int) bool {	354	+	func (x MatchInfo) FetchPos(MatchNumVar int, StartPosVar int, EndPosVar *int) bool {
355			355
356		cret := xMatchInfoFetchPos(x.GoPointer(), MatchNumVar, StartPosVar, EndPosVar)	356		cret := xMatchInfoFetchPos(x.GoPointer(), MatchNumVar, StartPosVar, EndPosVar)
357		return cret	357		return cret

@@ -1474,7 +1474,7 @@ const (
1474		GRegexErrorCharacterValueTooLargeValue RegexError = 176	1474		GRegexErrorCharacterValueTooLargeValue RegexError = 176
1475		)	1475		)
1476			1476
1477	-	var xRegexCheckReplacement func(string, bool, **Error) bool	1477	+	var xRegexCheckReplacement func(string, bool, *Error) bool
1478			1478
1479		// Checks whether @replacement is a valid replacement string	1479		// Checks whether @replacement is a valid replacement string
1480		// (see g_regex_replace()), i.e. that all escape sequences in	1480		// (see g_regex_replace()), i.e. that all escape sequences in

@@ -1485,7 +1485,7 @@ var xRegexCheckReplacement func(string, bool, **Error) bool
1485		// does not contain references and may be evaluated without information	1485		// does not contain references and may be evaluated without information
1486		// about actual match, but '\0\1' (whole match followed by first	1486		// about actual match, but '\0\1' (whole match followed by first
1487		// subpattern) requires valid #GMatchInfo object.	1487		// subpattern) requires valid #GMatchInfo object.
1488	-	func RegexCheckReplacement(ReplacementVar string, HasReferencesVar bool) (bool, error) {	1488	+	func RegexCheckReplacement(ReplacementVar string, HasReferencesVar *bool) (bool, error) {
1489		var cerr *Error	1489		var cerr *Error
1490			1490
1491		cret := xRegexCheckReplacement(ReplacementVar, HasReferencesVar, &cerr)	1491		cret := xRegexCheckReplacement(ReplacementVar, HasReferencesVar, &cerr)

M v4/glib/gshell.go +2 -2


@@ -19,7 +19,7 @@ const (
19		GShellErrorFailedValue ShellError = 2	19		GShellErrorFailedValue ShellError = 2
20		)	20		)
21			21
22	-	var xShellParseArgv func(string, int, []string, **Error) bool	22	+	var xShellParseArgv func(string, int, []string, **Error) bool
23			23
24		// Parses a command line into an argument vector, in much the same way	24		// Parses a command line into an argument vector, in much the same way
25		// the shell would, but without many of the expansions the shell would	25		// the shell would, but without many of the expansions the shell would

@@ -39,7 +39,7 @@ var xShellParseArgv func(string, int, []string, **Error) bool
39		// successfully.	39		// successfully.
40		//	40		//
41		// Free the returned vector with g_strfreev().	41		// Free the returned vector with g_strfreev().
42	-	func ShellParseArgv(CommandLineVar string, ArgcpVar int, ArgvpVar []string) (bool, error) {	42	+	func ShellParseArgv(CommandLineVar string, ArgcpVar int, ArgvpVar []string) (bool, error) {
43		var cerr *Error	43		var cerr *Error
44			44
45		cret := xShellParseArgv(CommandLineVar, ArgcpVar, ArgvpVar, &cerr)	45		cret := xShellParseArgv(CommandLineVar, ArgcpVar, ArgvpVar, &cerr)

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


@@ -181,11 +181,11 @@ func SpawnAsyncWithFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []s
181			181
182		}	182		}
183			183
184	-	var xSpawnAsyncWithPipes func(string, []string, []string, SpawnFlags, uintptr, uintptr, Pid, int, int, int, *Error) bool	184	+	var xSpawnAsyncWithPipes func(string, []string, []string, SpawnFlags, uintptr, uintptr, Pid, int, int, int, **Error) bool
185			185
186		// Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,	186		// Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
187		// so no FD assignments are used.	187		// so no FD assignments are used.
188	-	func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar Pid, StandardInputVar int, StandardOutputVar int, StandardErrorVar int) (bool, error) {	188	+	func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar Pid, StandardInputVar int, StandardOutputVar int, StandardErrorVar *int) (bool, error) {
189		var cerr *Error	189		var cerr *Error
190			190
191		cret := xSpawnAsyncWithPipes(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)	191		cret := xSpawnAsyncWithPipes(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)

@@ -196,7 +196,7 @@ func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar []string, EnvpVar [
196			196
197		}	197		}
198			198
199	-	var xSpawnAsyncWithPipesAndFds func(string, []string, []string, SpawnFlags, uintptr, uintptr, int, int, int, []int, []int, uint, Pid, int, int, int, *Error) bool	199	+	var xSpawnAsyncWithPipesAndFds func(string, []string, []string, SpawnFlags, uintptr, uintptr, int, int, int, []int, []int, uint, Pid, int, int, int, **Error) bool
200			200
201		// Executes a child program asynchronously (your program will not	201		// Executes a child program asynchronously (your program will not
202		// block waiting for the child to exit).	202		// block waiting for the child to exit).

@@ -392,7 +392,7 @@ var xSpawnAsyncWithPipesAndFds func(string, []string, []string, SpawnFlags, uint
392		// graphical application too, then to ensure that the spawned program opens its	392		// graphical application too, then to ensure that the spawned program opens its
393		// windows on the right screen, you may want to use #GdkAppLaunchContext,	393		// windows on the right screen, you may want to use #GdkAppLaunchContext,
394		// #GAppLaunchContext, or set the `DISPLAY` environment variable.	394		// #GAppLaunchContext, or set the `DISPLAY` environment variable.
395	-	func SpawnAsyncWithPipesAndFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int, SourceFdsVar []int, TargetFdsVar []int, NFdsVar uint, ChildPidOutVar Pid, StdinPipeOutVar int, StdoutPipeOutVar int, StderrPipeOutVar int) (bool, error) {	395	+	func SpawnAsyncWithPipesAndFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int, SourceFdsVar []int, TargetFdsVar []int, NFdsVar uint, ChildPidOutVar Pid, StdinPipeOutVar int, StdoutPipeOutVar int, StderrPipeOutVar *int) (bool, error) {
396		var cerr *Error	396		var cerr *Error
397			397
398		cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)	398		cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)

@@ -511,7 +511,7 @@ func SpawnCommandLineAsync(CommandLineVar string) (bool, error) {
511			511
512		}	512		}
513			513
514	-	var xSpawnCommandLineSync func(string, []byte, []byte, int, **Error) bool	514	+	var xSpawnCommandLineSync func(string, []byte, []byte, int, *Error) bool
515			515
516		// A simple version of g_spawn_sync() with little-used parameters	516		// A simple version of g_spawn_sync() with little-used parameters
517		// removed, taking a command line instead of an argument vector.	517		// removed, taking a command line instead of an argument vector.

@@ -542,7 +542,7 @@ var xSpawnCommandLineSync func(string, []byte, []byte, int, **Error) bool
542		// the backslashes will be eaten, and the space will act as a	542		// the backslashes will be eaten, and the space will act as a
543		// separator. You need to enclose such paths with single quotes, like	543		// separator. You need to enclose such paths with single quotes, like
544		// "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".	544		// "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".
545	-	func SpawnCommandLineSync(CommandLineVar string, StandardOutputVar []byte, StandardErrorVar []byte, WaitStatusVar int) (bool, error) {	545	+	func SpawnCommandLineSync(CommandLineVar string, StandardOutputVar []byte, StandardErrorVar []byte, WaitStatusVar *int) (bool, error) {
546		var cerr *Error	546		var cerr *Error
547			547
548		cret := xSpawnCommandLineSync(CommandLineVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)	548		cret := xSpawnCommandLineSync(CommandLineVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)

@@ -553,7 +553,7 @@ func SpawnCommandLineSync(CommandLineVar string, StandardOutputVar []byte, Stand
553			553
554		}	554		}
555			555
556	-	var xSpawnSync func(string, []string, []string, SpawnFlags, uintptr, uintptr, []byte, []byte, int, **Error) bool	556	+	var xSpawnSync func(string, []string, []string, SpawnFlags, uintptr, uintptr, []byte, []byte, int, *Error) bool
557			557
558		// Executes a child synchronously (waits for the child to exit before returning).	558		// Executes a child synchronously (waits for the child to exit before returning).
559		//	559		//

@@ -578,7 +578,7 @@ var xSpawnSync func(string, []string, []string, SpawnFlags, uintptr, uintptr, []
578		// This function calls g_spawn_async_with_pipes() internally; see that	578		// This function calls g_spawn_async_with_pipes() internally; see that
579		// function for full details on the other parameters and details on	579		// function for full details on the other parameters and details on
580		// how these functions work on Windows.	580		// how these functions work on Windows.
581	-	func SpawnSync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar []byte, StandardErrorVar []byte, WaitStatusVar int) (bool, error) {	581	+	func SpawnSync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar []byte, StandardErrorVar []byte, WaitStatusVar int) (bool, error) {
582		var cerr *Error	582		var cerr *Error
583			583
584		cret := xSpawnSync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)	584		cret := xSpawnSync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)

M v4/glib/gstrfuncs.go +14 -14


@@ -147,7 +147,7 @@ func AsciiStrdown(StrVar string, LenVar int) string {
147		return cret	147		return cret
148		}	148		}
149			149
150	-	var xAsciiStringToSigned func(string, uint, int64, int64, int64, **Error) bool	150	+	var xAsciiStringToSigned func(string, uint, int64, int64, int64, *Error) bool
151			151
152		// A convenience function for converting a string to a signed number.	152		// A convenience function for converting a string to a signed number.
153		//	153		//

@@ -170,7 +170,7 @@ var xAsciiStringToSigned func(string, uint, int64, int64, int64, **Error) bool
170		// See [func@GLib.ascii_strtoll] if you have more complex needs such as	170		// See [func@GLib.ascii_strtoll] if you have more complex needs such as
171		// parsing a string which starts with a number, but then has other	171		// parsing a string which starts with a number, but then has other
172		// characters.	172		// characters.
173	-	func AsciiStringToSigned(StrVar string, BaseVar uint, MinVar int64, MaxVar int64, OutNumVar int64) (bool, error) {	173	+	func AsciiStringToSigned(StrVar string, BaseVar uint, MinVar int64, MaxVar int64, OutNumVar *int64) (bool, error) {
174		var cerr *Error	174		var cerr *Error
175			175
176		cret := xAsciiStringToSigned(StrVar, BaseVar, MinVar, MaxVar, OutNumVar, &cerr)	176		cret := xAsciiStringToSigned(StrVar, BaseVar, MinVar, MaxVar, OutNumVar, &cerr)

@@ -181,7 +181,7 @@ func AsciiStringToSigned(StrVar string, BaseVar uint, MinVar int64, MaxVar int64
181			181
182		}	182		}
183			183
184	-	var xAsciiStringToUnsigned func(string, uint, uint64, uint64, uint64, **Error) bool	184	+	var xAsciiStringToUnsigned func(string, uint, uint64, uint64, uint64, *Error) bool
185			185
186		// A convenience function for converting a string to an unsigned number.	186		// A convenience function for converting a string to an unsigned number.
187		//	187		//

@@ -205,7 +205,7 @@ var xAsciiStringToUnsigned func(string, uint, uint64, uint64, uint64, **Error) b
205		// See [func@GLib.ascii_strtoull] if you have more complex needs such as	205		// See [func@GLib.ascii_strtoull] if you have more complex needs such as
206		// parsing a string which starts with a number, but then has other	206		// parsing a string which starts with a number, but then has other
207		// characters.	207		// characters.
208	-	func AsciiStringToUnsigned(StrVar string, BaseVar uint, MinVar uint64, MaxVar uint64, OutNumVar uint64) (bool, error) {	208	+	func AsciiStringToUnsigned(StrVar string, BaseVar uint, MinVar uint64, MaxVar uint64, OutNumVar *uint64) (bool, error) {
209		var cerr *Error	209		var cerr *Error
210			210
211		cret := xAsciiStringToUnsigned(StrVar, BaseVar, MinVar, MaxVar, OutNumVar, &cerr)	211		cret := xAsciiStringToUnsigned(StrVar, BaseVar, MinVar, MaxVar, OutNumVar, &cerr)

@@ -236,7 +236,7 @@ func AsciiStrncasecmp(S1Var string, S2Var string, NVar uint) int {
236		return cret	236		return cret
237		}	237		}
238			238
239	-	var xAsciiStrtod func(string, string) float64	239	+	var xAsciiStrtod func(string, *string) float64
240			240
241		// Converts a string to a floating point value.	241		// Converts a string to a floating point value.
242		//	242		//

@@ -261,13 +261,13 @@ var xAsciiStrtod func(string, string) float64
261		//	261		//
262		// This function resets `errno` before calling `strtod()` so that	262		// This function resets `errno` before calling `strtod()` so that
263		// you can reliably detect overflow and underflow.	263		// you can reliably detect overflow and underflow.
264	-	func AsciiStrtod(NptrVar string, EndptrVar string) float64 {	264	+	func AsciiStrtod(NptrVar string, EndptrVar *string) float64 {
265			265
266		cret := xAsciiStrtod(NptrVar, EndptrVar)	266		cret := xAsciiStrtod(NptrVar, EndptrVar)
267		return cret	267		return cret
268		}	268		}
269			269
270	-	var xAsciiStrtoll func(string, string, uint) int64	270	+	var xAsciiStrtoll func(string, *string, uint) int64
271			271
272		// Converts a string to a `gint64` value.	272		// Converts a string to a `gint64` value.
273		//	273		//

@@ -287,13 +287,13 @@ var xAsciiStrtoll func(string, string, uint) int64
287		// `EINVAL` is stored in `errno`. If the	287		// `EINVAL` is stored in `errno`. If the
288		// string conversion fails, zero is returned, and @endptr returns @nptr	288		// string conversion fails, zero is returned, and @endptr returns @nptr
289		// (if @endptr is non-`NULL`).	289		// (if @endptr is non-`NULL`).
290	-	func AsciiStrtoll(NptrVar string, EndptrVar string, BaseVar uint) int64 {	290	+	func AsciiStrtoll(NptrVar string, EndptrVar *string, BaseVar uint) int64 {
291			291
292		cret := xAsciiStrtoll(NptrVar, EndptrVar, BaseVar)	292		cret := xAsciiStrtoll(NptrVar, EndptrVar, BaseVar)
293		return cret	293		return cret
294		}	294		}
295			295
296	-	var xAsciiStrtoull func(string, string, uint) uint64	296	+	var xAsciiStrtoull func(string, *string, uint) uint64
297			297
298		// Converts a string to a `guint64` value.	298		// Converts a string to a `guint64` value.
299		//	299		//

@@ -318,7 +318,7 @@ var xAsciiStrtoull func(string, string, uint) uint64
318		// `EINVAL` is stored in `errno`.	318		// `EINVAL` is stored in `errno`.
319		// If the string conversion fails, zero is returned, and @endptr returns	319		// If the string conversion fails, zero is returned, and @endptr returns
320		// @nptr (if @endptr is non-`NULL`).	320		// @nptr (if @endptr is non-`NULL`).
321	-	func AsciiStrtoull(NptrVar string, EndptrVar string, BaseVar uint) uint64 {	321	+	func AsciiStrtoull(NptrVar string, EndptrVar *string, BaseVar uint) uint64 {
322			322
323		cret := xAsciiStrtoull(NptrVar, EndptrVar, BaseVar)	323		cret := xAsciiStrtoull(NptrVar, EndptrVar, BaseVar)
324		return cret	324		return cret

@@ -506,7 +506,7 @@ func StrToAscii(StrVar string, FromLocaleVar string) string {
506		return cret	506		return cret
507		}	507		}
508			508
509	-	var xStrTokenizeAndFold func(string, string, []string) []string	509	+	var xStrTokenizeAndFold func(string, string, *[]string) []string
510			510
511		// Tokenizes @string and performs folding on each token.	511		// Tokenizes @string and performs folding on each token.
512		//	512		//

@@ -523,7 +523,7 @@ var xStrTokenizeAndFold func(string, string, []string) []string
523		// for doing so is unspecified, but @translit_locale (if specified) may	523		// for doing so is unspecified, but @translit_locale (if specified) may
524		// improve the transliteration if the language of the source string is	524		// improve the transliteration if the language of the source string is
525		// known.	525		// known.
526	-	func StrTokenizeAndFold(StringVar string, TranslitLocaleVar string, AsciiAlternatesVar []string) []string {	526	+	func StrTokenizeAndFold(StringVar string, TranslitLocaleVar string, AsciiAlternatesVar *[]string) []string {
527			527
528		cret := xStrTokenizeAndFold(StringVar, TranslitLocaleVar, AsciiAlternatesVar)	528		cret := xStrTokenizeAndFold(StringVar, TranslitLocaleVar, AsciiAlternatesVar)
529		return cret	529		return cret

@@ -1014,7 +1014,7 @@ func StrstrLen(HaystackVar string, HaystackLenVar int, NeedleVar string) string
1014		return cret	1014		return cret
1015		}	1015		}
1016			1016
1017	-	var xStrtod func(string, string) float64	1017	+	var xStrtod func(string, *string) float64
1018			1018
1019		// Converts a string to a floating point value.	1019		// Converts a string to a floating point value.
1020		//	1020		//

@@ -1028,7 +1028,7 @@ var xStrtod func(string, string) float64
1028		// should you use this. Make sure that you don't pass strings such as comma	1028		// should you use this. Make sure that you don't pass strings such as comma
1029		// separated lists of values, since the commas may be interpreted as a decimal	1029		// separated lists of values, since the commas may be interpreted as a decimal
1030		// point in some locales, causing unexpected results.	1030		// point in some locales, causing unexpected results.
1031	-	func Strtod(NptrVar string, EndptrVar string) float64 {	1031	+	func Strtod(NptrVar string, EndptrVar *string) float64 {
1032			1032
1033		cret := xStrtod(NptrVar, EndptrVar)	1033		cret := xStrtod(NptrVar, EndptrVar)
1034		return cret	1034		return cret

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


@@ -1391,7 +1391,7 @@ func (x *ThreadFunctions) GoPointer() uintptr {
1391		return uintptr(unsafe.Pointer(x))	1391		return uintptr(unsafe.Pointer(x))
1392		}	1392		}
1393			1393
1394	-	// OverrideMutexNew sets the callback function.	1394	+	// OverrideMutexNew sets the "mutex_new" callback function.
1395		// virtual function pointer for g_mutex_new()	1395		// virtual function pointer for g_mutex_new()
1396		func (x ThreadFunctions) OverrideMutexNew(cb func() Mutex) {	1396		func (x ThreadFunctions) OverrideMutexNew(cb func() Mutex) {
1397		if cb == nil {	1397		if cb == nil {

@@ -1403,7 +1403,7 @@ func (x ThreadFunctions) OverrideMutexNew(cb func() Mutex) {
1403		}	1403		}
1404		}	1404		}
1405			1405
1406	-	// GetMutexNew gets the callback function.	1406	+	// GetMutexNew gets the "mutex_new" callback function.
1407		// virtual function pointer for g_mutex_new()	1407		// virtual function pointer for g_mutex_new()
1408		func (x ThreadFunctions) GetMutexNew() func() Mutex {	1408		func (x ThreadFunctions) GetMutexNew() func() Mutex {
1409		if x.xMutexNew == 0 {	1409		if x.xMutexNew == 0 {

@@ -1416,7 +1416,7 @@ func (x ThreadFunctions) GetMutexNew() func() Mutex {
1416		}	1416		}
1417		}	1417		}
1418			1418
1419	-	// OverrideMutexLock sets the callback function.	1419	+	// OverrideMutexLock sets the "mutex_lock" callback function.
1420		// virtual function pointer for g_mutex_lock()	1420		// virtual function pointer for g_mutex_lock()
1421		func (x ThreadFunctions) OverrideMutexLock(cb func(Mutex)) {	1421		func (x ThreadFunctions) OverrideMutexLock(cb func(Mutex)) {
1422		if cb == nil {	1422		if cb == nil {

@@ -1428,7 +1428,7 @@ func (x ThreadFunctions) OverrideMutexLock(cb func(Mutex)) {
1428		}	1428		}
1429		}	1429		}
1430			1430
1431	-	// GetMutexLock gets the callback function.	1431	+	// GetMutexLock gets the "mutex_lock" callback function.
1432		// virtual function pointer for g_mutex_lock()	1432		// virtual function pointer for g_mutex_lock()
1433		func (x ThreadFunctions) GetMutexLock() func(Mutex) {	1433		func (x ThreadFunctions) GetMutexLock() func(Mutex) {
1434		if x.xMutexLock == 0 {	1434		if x.xMutexLock == 0 {

@@ -1441,7 +1441,7 @@ func (x ThreadFunctions) GetMutexLock() func(Mutex) {
1441		}	1441		}
1442		}	1442		}
1443			1443
1444	-	// OverrideMutexTrylock sets the callback function.	1444	+	// OverrideMutexTrylock sets the "mutex_trylock" callback function.
1445		// virtual function pointer for g_mutex_trylock()	1445		// virtual function pointer for g_mutex_trylock()
1446		func (x ThreadFunctions) OverrideMutexTrylock(cb func(Mutex) bool) {	1446		func (x ThreadFunctions) OverrideMutexTrylock(cb func(Mutex) bool) {
1447		if cb == nil {	1447		if cb == nil {

@@ -1453,7 +1453,7 @@ func (x ThreadFunctions) OverrideMutexTrylock(cb func(Mutex) bool) {
1453		}	1453		}
1454		}	1454		}
1455			1455
1456	-	// GetMutexTrylock gets the callback function.	1456	+	// GetMutexTrylock gets the "mutex_trylock" callback function.
1457		// virtual function pointer for g_mutex_trylock()	1457		// virtual function pointer for g_mutex_trylock()
1458		func (x ThreadFunctions) GetMutexTrylock() func(Mutex) bool {	1458		func (x ThreadFunctions) GetMutexTrylock() func(Mutex) bool {
1459		if x.xMutexTrylock == 0 {	1459		if x.xMutexTrylock == 0 {

@@ -1466,7 +1466,7 @@ func (x ThreadFunctions) GetMutexTrylock() func(Mutex) bool {
1466		}	1466		}
1467		}	1467		}
1468			1468
1469	-	// OverrideMutexUnlock sets the callback function.	1469	+	// OverrideMutexUnlock sets the "mutex_unlock" callback function.
1470		// virtual function pointer for g_mutex_unlock()	1470		// virtual function pointer for g_mutex_unlock()
1471		func (x ThreadFunctions) OverrideMutexUnlock(cb func(Mutex)) {	1471		func (x ThreadFunctions) OverrideMutexUnlock(cb func(Mutex)) {
1472		if cb == nil {	1472		if cb == nil {

@@ -1478,7 +1478,7 @@ func (x ThreadFunctions) OverrideMutexUnlock(cb func(Mutex)) {
1478		}	1478		}
1479		}	1479		}
1480			1480
1481	-	// GetMutexUnlock gets the callback function.	1481	+	// GetMutexUnlock gets the "mutex_unlock" callback function.
1482		// virtual function pointer for g_mutex_unlock()	1482		// virtual function pointer for g_mutex_unlock()
1483		func (x ThreadFunctions) GetMutexUnlock() func(Mutex) {	1483		func (x ThreadFunctions) GetMutexUnlock() func(Mutex) {
1484		if x.xMutexUnlock == 0 {	1484		if x.xMutexUnlock == 0 {

@@ -1491,7 +1491,7 @@ func (x ThreadFunctions) GetMutexUnlock() func(Mutex) {
1491		}	1491		}
1492		}	1492		}
1493			1493
1494	-	// OverrideMutexFree sets the callback function.	1494	+	// OverrideMutexFree sets the "mutex_free" callback function.
1495		// virtual function pointer for g_mutex_free()	1495		// virtual function pointer for g_mutex_free()
1496		func (x ThreadFunctions) OverrideMutexFree(cb func(Mutex)) {	1496		func (x ThreadFunctions) OverrideMutexFree(cb func(Mutex)) {
1497		if cb == nil {	1497		if cb == nil {

@@ -1503,7 +1503,7 @@ func (x ThreadFunctions) OverrideMutexFree(cb func(Mutex)) {
1503		}	1503		}
1504		}	1504		}
1505			1505
1506	-	// GetMutexFree gets the callback function.	1506	+	// GetMutexFree gets the "mutex_free" callback function.
1507		// virtual function pointer for g_mutex_free()	1507		// virtual function pointer for g_mutex_free()
1508		func (x ThreadFunctions) GetMutexFree() func(Mutex) {	1508		func (x ThreadFunctions) GetMutexFree() func(Mutex) {
1509		if x.xMutexFree == 0 {	1509		if x.xMutexFree == 0 {

@@ -1516,7 +1516,7 @@ func (x ThreadFunctions) GetMutexFree() func(Mutex) {
1516		}	1516		}
1517		}	1517		}
1518			1518
1519	-	// OverrideCondNew sets the callback function.	1519	+	// OverrideCondNew sets the "cond_new" callback function.
1520		// virtual function pointer for g_cond_new()	1520		// virtual function pointer for g_cond_new()
1521		func (x ThreadFunctions) OverrideCondNew(cb func() Cond) {	1521		func (x ThreadFunctions) OverrideCondNew(cb func() Cond) {
1522		if cb == nil {	1522		if cb == nil {

@@ -1528,7 +1528,7 @@ func (x ThreadFunctions) OverrideCondNew(cb func() Cond) {
1528		}	1528		}
1529		}	1529		}
1530			1530
1531	-	// GetCondNew gets the callback function.	1531	+	// GetCondNew gets the "cond_new" callback function.
1532		// virtual function pointer for g_cond_new()	1532		// virtual function pointer for g_cond_new()
1533		func (x ThreadFunctions) GetCondNew() func() Cond {	1533		func (x ThreadFunctions) GetCondNew() func() Cond {
1534		if x.xCondNew == 0 {	1534		if x.xCondNew == 0 {

@@ -1541,7 +1541,7 @@ func (x ThreadFunctions) GetCondNew() func() Cond {
1541		}	1541		}
1542		}	1542		}
1543			1543
1544	-	// OverrideCondSignal sets the callback function.	1544	+	// OverrideCondSignal sets the "cond_signal" callback function.
1545		// virtual function pointer for g_cond_signal()	1545		// virtual function pointer for g_cond_signal()
1546		func (x ThreadFunctions) OverrideCondSignal(cb func(Cond)) {	1546		func (x ThreadFunctions) OverrideCondSignal(cb func(Cond)) {
1547		if cb == nil {	1547		if cb == nil {

@@ -1553,7 +1553,7 @@ func (x ThreadFunctions) OverrideCondSignal(cb func(Cond)) {
1553		}	1553		}
1554		}	1554		}
1555			1555
1556	-	// GetCondSignal gets the callback function.	1556	+	// GetCondSignal gets the "cond_signal" callback function.
1557		// virtual function pointer for g_cond_signal()	1557		// virtual function pointer for g_cond_signal()
1558		func (x ThreadFunctions) GetCondSignal() func(Cond) {	1558		func (x ThreadFunctions) GetCondSignal() func(Cond) {
1559		if x.xCondSignal == 0 {	1559		if x.xCondSignal == 0 {

@@ -1566,7 +1566,7 @@ func (x ThreadFunctions) GetCondSignal() func(Cond) {
1566		}	1566		}
1567		}	1567		}
1568			1568
1569	-	// OverrideCondBroadcast sets the callback function.	1569	+	// OverrideCondBroadcast sets the "cond_broadcast" callback function.
1570		// virtual function pointer for g_cond_broadcast()	1570		// virtual function pointer for g_cond_broadcast()
1571		func (x ThreadFunctions) OverrideCondBroadcast(cb func(Cond)) {	1571		func (x ThreadFunctions) OverrideCondBroadcast(cb func(Cond)) {
1572		if cb == nil {	1572		if cb == nil {

@@ -1578,7 +1578,7 @@ func (x ThreadFunctions) OverrideCondBroadcast(cb func(Cond)) {
1578		}	1578		}
1579		}	1579		}
1580			1580
1581	-	// GetCondBroadcast gets the callback function.	1581	+	// GetCondBroadcast gets the "cond_broadcast" callback function.
1582		// virtual function pointer for g_cond_broadcast()	1582		// virtual function pointer for g_cond_broadcast()
1583		func (x ThreadFunctions) GetCondBroadcast() func(Cond) {	1583		func (x ThreadFunctions) GetCondBroadcast() func(Cond) {
1584		if x.xCondBroadcast == 0 {	1584		if x.xCondBroadcast == 0 {

@@ -1591,7 +1591,7 @@ func (x ThreadFunctions) GetCondBroadcast() func(Cond) {
1591		}	1591		}
1592		}	1592		}
1593			1593
1594	-	// OverrideCondWait sets the callback function.	1594	+	// OverrideCondWait sets the "cond_wait" callback function.
1595		// virtual function pointer for g_cond_wait()	1595		// virtual function pointer for g_cond_wait()
1596		func (x ThreadFunctions) OverrideCondWait(cb func(Cond, *Mutex)) {	1596		func (x ThreadFunctions) OverrideCondWait(cb func(Cond, *Mutex)) {
1597		if cb == nil {	1597		if cb == nil {

@@ -1603,7 +1603,7 @@ func (x ThreadFunctions) OverrideCondWait(cb func(Cond, *Mutex)) {
1603		}	1603		}
1604		}	1604		}
1605			1605
1606	-	// GetCondWait gets the callback function.	1606	+	// GetCondWait gets the "cond_wait" callback function.
1607		// virtual function pointer for g_cond_wait()	1607		// virtual function pointer for g_cond_wait()
1608		func (x ThreadFunctions) GetCondWait() func(Cond, *Mutex) {	1608		func (x ThreadFunctions) GetCondWait() func(Cond, *Mutex) {
1609		if x.xCondWait == 0 {	1609		if x.xCondWait == 0 {

@@ -1616,7 +1616,7 @@ func (x ThreadFunctions) GetCondWait() func(Cond, *Mutex) {
1616		}	1616		}
1617		}	1617		}
1618			1618
1619	-	// OverrideCondTimedWait sets the callback function.	1619	+	// OverrideCondTimedWait sets the "cond_timed_wait" callback function.
1620		// virtual function pointer for g_cond_timed_wait()	1620		// virtual function pointer for g_cond_timed_wait()
1621		func (x ThreadFunctions) OverrideCondTimedWait(cb func(Cond, Mutex, TimeVal) bool) {	1621		func (x ThreadFunctions) OverrideCondTimedWait(cb func(Cond, Mutex, TimeVal) bool) {
1622		if cb == nil {	1622		if cb == nil {

@@ -1628,7 +1628,7 @@ func (x ThreadFunctions) OverrideCondTimedWait(cb func(Cond, Mutex, TimeVal)
1628		}	1628		}
1629		}	1629		}
1630			1630
1631	-	// GetCondTimedWait gets the callback function.	1631	+	// GetCondTimedWait gets the "cond_timed_wait" callback function.
1632		// virtual function pointer for g_cond_timed_wait()	1632		// virtual function pointer for g_cond_timed_wait()
1633		func (x ThreadFunctions) GetCondTimedWait() func(Cond, Mutex, TimeVal) bool {	1633		func (x ThreadFunctions) GetCondTimedWait() func(Cond, Mutex, TimeVal) bool {
1634		if x.xCondTimedWait == 0 {	1634		if x.xCondTimedWait == 0 {

@@ -1641,7 +1641,7 @@ func (x ThreadFunctions) GetCondTimedWait() func(Cond, Mutex, TimeVal) bool
1641		}	1641		}
1642		}	1642		}
1643			1643
1644	-	// OverrideCondFree sets the callback function.	1644	+	// OverrideCondFree sets the "cond_free" callback function.
1645		// virtual function pointer for g_cond_free()	1645		// virtual function pointer for g_cond_free()
1646		func (x ThreadFunctions) OverrideCondFree(cb func(Cond)) {	1646		func (x ThreadFunctions) OverrideCondFree(cb func(Cond)) {
1647		if cb == nil {	1647		if cb == nil {

@@ -1653,7 +1653,7 @@ func (x ThreadFunctions) OverrideCondFree(cb func(Cond)) {
1653		}	1653		}
1654		}	1654		}
1655			1655
1656	-	// GetCondFree gets the callback function.	1656	+	// GetCondFree gets the "cond_free" callback function.
1657		// virtual function pointer for g_cond_free()	1657		// virtual function pointer for g_cond_free()
1658		func (x ThreadFunctions) GetCondFree() func(Cond) {	1658		func (x ThreadFunctions) GetCondFree() func(Cond) {
1659		if x.xCondFree == 0 {	1659		if x.xCondFree == 0 {

@@ -1666,7 +1666,7 @@ func (x ThreadFunctions) GetCondFree() func(Cond) {
1666		}	1666		}
1667		}	1667		}
1668			1668
1669	-	// OverridePrivateNew sets the callback function.	1669	+	// OverridePrivateNew sets the "private_new" callback function.
1670		// virtual function pointer for g_private_new()	1670		// virtual function pointer for g_private_new()
1671		func (x ThreadFunctions) OverridePrivateNew(cb func(DestroyNotify) *Private) {	1671		func (x ThreadFunctions) OverridePrivateNew(cb func(DestroyNotify) *Private) {
1672		if cb == nil {	1672		if cb == nil {

@@ -1678,7 +1678,7 @@ func (x ThreadFunctions) OverridePrivateNew(cb func(DestroyNotify) *Private) {
1678		}	1678		}
1679		}	1679		}
1680			1680
1681	-	// GetPrivateNew gets the callback function.	1681	+	// GetPrivateNew gets the "private_new" callback function.
1682		// virtual function pointer for g_private_new()	1682		// virtual function pointer for g_private_new()
1683		func (x ThreadFunctions) GetPrivateNew() func(DestroyNotify) *Private {	1683		func (x ThreadFunctions) GetPrivateNew() func(DestroyNotify) *Private {
1684		if x.xPrivateNew == 0 {	1684		if x.xPrivateNew == 0 {

@@ -1691,7 +1691,7 @@ func (x ThreadFunctions) GetPrivateNew() func(DestroyNotify) *Private {
1691		}	1691		}
1692		}	1692		}
1693			1693
1694	-	// OverridePrivateGet sets the callback function.	1694	+	// OverridePrivateGet sets the "private_get" callback function.
1695		// virtual function pointer for g_private_get()	1695		// virtual function pointer for g_private_get()
1696		func (x ThreadFunctions) OverridePrivateGet(cb func(Private) uintptr) {	1696		func (x ThreadFunctions) OverridePrivateGet(cb func(Private) uintptr) {
1697		if cb == nil {	1697		if cb == nil {

@@ -1703,7 +1703,7 @@ func (x ThreadFunctions) OverridePrivateGet(cb func(Private) uintptr) {
1703		}	1703		}
1704		}	1704		}
1705			1705
1706	-	// GetPrivateGet gets the callback function.	1706	+	// GetPrivateGet gets the "private_get" callback function.
1707		// virtual function pointer for g_private_get()	1707		// virtual function pointer for g_private_get()
1708		func (x ThreadFunctions) GetPrivateGet() func(Private) uintptr {	1708		func (x ThreadFunctions) GetPrivateGet() func(Private) uintptr {
1709		if x.xPrivateGet == 0 {	1709		if x.xPrivateGet == 0 {

@@ -1716,7 +1716,7 @@ func (x ThreadFunctions) GetPrivateGet() func(Private) uintptr {
1716		}	1716		}
1717		}	1717		}
1718			1718
1719	-	// OverridePrivateSet sets the callback function.	1719	+	// OverridePrivateSet sets the "private_set" callback function.
1720		// virtual function pointer for g_private_set()	1720		// virtual function pointer for g_private_set()
1721		func (x ThreadFunctions) OverridePrivateSet(cb func(Private, uintptr)) {	1721		func (x ThreadFunctions) OverridePrivateSet(cb func(Private, uintptr)) {
1722		if cb == nil {	1722		if cb == nil {

@@ -1728,7 +1728,7 @@ func (x ThreadFunctions) OverridePrivateSet(cb func(Private, uintptr)) {
1728		}	1728		}
1729		}	1729		}
1730			1730
1731	-	// GetPrivateSet gets the callback function.	1731	+	// GetPrivateSet gets the "private_set" callback function.
1732		// virtual function pointer for g_private_set()	1732		// virtual function pointer for g_private_set()
1733		func (x ThreadFunctions) GetPrivateSet() func(Private, uintptr) {	1733		func (x ThreadFunctions) GetPrivateSet() func(Private, uintptr) {
1734		if x.xPrivateSet == 0 {	1734		if x.xPrivateSet == 0 {

@@ -1741,7 +1741,7 @@ func (x ThreadFunctions) GetPrivateSet() func(Private, uintptr) {
1741		}	1741		}
1742		}	1742		}
1743			1743
1744	-	// OverrideThreadCreate sets the callback function.	1744	+	// OverrideThreadCreate sets the "thread_create" callback function.
1745		// virtual function pointer for g_thread_create()	1745		// virtual function pointer for g_thread_create()
1746		func (x ThreadFunctions) OverrideThreadCreate(cb func(ThreadFunc, uintptr, uint32, bool, bool, ThreadPriority, uintptr)) {	1746		func (x ThreadFunctions) OverrideThreadCreate(cb func(ThreadFunc, uintptr, uint32, bool, bool, ThreadPriority, uintptr)) {
1747		if cb == nil {	1747		if cb == nil {

@@ -1753,7 +1753,7 @@ func (x ThreadFunctions) OverrideThreadCreate(cb func(ThreadFunc, uintptr, uin
1753		}	1753		}
1754		}	1754		}
1755			1755
1756	-	// GetThreadCreate gets the callback function.	1756	+	// GetThreadCreate gets the "thread_create" callback function.
1757		// virtual function pointer for g_thread_create()	1757		// virtual function pointer for g_thread_create()
1758		func (x ThreadFunctions) GetThreadCreate() func(ThreadFunc, uintptr, uint32, bool, bool, ThreadPriority, uintptr) {	1758		func (x ThreadFunctions) GetThreadCreate() func(ThreadFunc, uintptr, uint32, bool, bool, ThreadPriority, uintptr) {
1759		if x.xThreadCreate == 0 {	1759		if x.xThreadCreate == 0 {

@@ -1766,7 +1766,7 @@ func (x ThreadFunctions) GetThreadCreate() func(ThreadFunc, uintptr, uint32, b
1766		}	1766		}
1767		}	1767		}
1768			1768
1769	-	// OverrideThreadYield sets the callback function.	1769	+	// OverrideThreadYield sets the "thread_yield" callback function.
1770		// virtual function pointer for g_thread_yield()	1770		// virtual function pointer for g_thread_yield()
1771		func (x *ThreadFunctions) OverrideThreadYield(cb func()) {	1771		func (x *ThreadFunctions) OverrideThreadYield(cb func()) {
1772		if cb == nil {	1772		if cb == nil {

@@ -1778,7 +1778,7 @@ func (x *ThreadFunctions) OverrideThreadYield(cb func()) {
1778		}	1778		}
1779		}	1779		}
1780			1780
1781	-	// GetThreadYield gets the callback function.	1781	+	// GetThreadYield gets the "thread_yield" callback function.
1782		// virtual function pointer for g_thread_yield()	1782		// virtual function pointer for g_thread_yield()
1783		func (x *ThreadFunctions) GetThreadYield() func() {	1783		func (x *ThreadFunctions) GetThreadYield() func() {
1784		if x.xThreadYield == 0 {	1784		if x.xThreadYield == 0 {

@@ -1791,7 +1791,7 @@ func (x *ThreadFunctions) GetThreadYield() func() {
1791		}	1791		}
1792		}	1792		}
1793			1793
1794	-	// OverrideThreadJoin sets the callback function.	1794	+	// OverrideThreadJoin sets the "thread_join" callback function.
1795		// virtual function pointer for g_thread_join()	1795		// virtual function pointer for g_thread_join()
1796		func (x *ThreadFunctions) OverrideThreadJoin(cb func(uintptr)) {	1796		func (x *ThreadFunctions) OverrideThreadJoin(cb func(uintptr)) {
1797		if cb == nil {	1797		if cb == nil {

@@ -1803,7 +1803,7 @@ func (x *ThreadFunctions) OverrideThreadJoin(cb func(uintptr)) {
1803		}	1803		}
1804		}	1804		}
1805			1805
1806	-	// GetThreadJoin gets the callback function.	1806	+	// GetThreadJoin gets the "thread_join" callback function.
1807		// virtual function pointer for g_thread_join()	1807		// virtual function pointer for g_thread_join()
1808		func (x *ThreadFunctions) GetThreadJoin() func(uintptr) {	1808		func (x *ThreadFunctions) GetThreadJoin() func(uintptr) {
1809		if x.xThreadJoin == 0 {	1809		if x.xThreadJoin == 0 {

@@ -1816,7 +1816,7 @@ func (x *ThreadFunctions) GetThreadJoin() func(uintptr) {
1816		}	1816		}
1817		}	1817		}
1818			1818
1819	-	// OverrideThreadExit sets the callback function.	1819	+	// OverrideThreadExit sets the "thread_exit" callback function.
1820		// virtual function pointer for g_thread_exit()	1820		// virtual function pointer for g_thread_exit()
1821		func (x *ThreadFunctions) OverrideThreadExit(cb func()) {	1821		func (x *ThreadFunctions) OverrideThreadExit(cb func()) {
1822		if cb == nil {	1822		if cb == nil {

@@ -1828,7 +1828,7 @@ func (x *ThreadFunctions) OverrideThreadExit(cb func()) {
1828		}	1828		}
1829		}	1829		}
1830			1830
1831	-	// GetThreadExit gets the callback function.	1831	+	// GetThreadExit gets the "thread_exit" callback function.
1832		// virtual function pointer for g_thread_exit()	1832		// virtual function pointer for g_thread_exit()
1833		func (x *ThreadFunctions) GetThreadExit() func() {	1833		func (x *ThreadFunctions) GetThreadExit() func() {
1834		if x.xThreadExit == 0 {	1834		if x.xThreadExit == 0 {

@@ -1841,7 +1841,7 @@ func (x *ThreadFunctions) GetThreadExit() func() {
1841		}	1841		}
1842		}	1842		}
1843			1843
1844	-	// OverrideThreadSetPriority sets the callback function.	1844	+	// OverrideThreadSetPriority sets the "thread_set_priority" callback function.
1845		// virtual function pointer for	1845		// virtual function pointer for
1846		//	1846		//
1847		// g_thread_set_priority()	1847		// g_thread_set_priority()

@@ -1855,7 +1855,7 @@ func (x *ThreadFunctions) OverrideThreadSetPriority(cb func(uintptr, ThreadPrior
1855		}	1855		}
1856		}	1856		}
1857			1857
1858	-	// GetThreadSetPriority gets the callback function.	1858	+	// GetThreadSetPriority gets the "thread_set_priority" callback function.
1859		// virtual function pointer for	1859		// virtual function pointer for
1860		//	1860		//
1861		// g_thread_set_priority()	1861		// g_thread_set_priority()

@@ -1870,7 +1870,7 @@ func (x *ThreadFunctions) GetThreadSetPriority() func(uintptr, ThreadPriority) {
1870		}	1870		}
1871		}	1871		}
1872			1872
1873	-	// OverrideThreadSelf sets the callback function.	1873	+	// OverrideThreadSelf sets the "thread_self" callback function.
1874		// virtual function pointer for g_thread_self()	1874		// virtual function pointer for g_thread_self()
1875		func (x *ThreadFunctions) OverrideThreadSelf(cb func(uintptr)) {	1875		func (x *ThreadFunctions) OverrideThreadSelf(cb func(uintptr)) {
1876		if cb == nil {	1876		if cb == nil {

@@ -1882,7 +1882,7 @@ func (x *ThreadFunctions) OverrideThreadSelf(cb func(uintptr)) {
1882		}	1882		}
1883		}	1883		}
1884			1884
1885	-	// GetThreadSelf gets the callback function.	1885	+	// GetThreadSelf gets the "thread_self" callback function.
1886		// virtual function pointer for g_thread_self()	1886		// virtual function pointer for g_thread_self()
1887		func (x *ThreadFunctions) GetThreadSelf() func(uintptr) {	1887		func (x *ThreadFunctions) GetThreadSelf() func(uintptr) {
1888		if x.xThreadSelf == 0 {	1888		if x.xThreadSelf == 0 {

@@ -1895,7 +1895,7 @@ func (x *ThreadFunctions) GetThreadSelf() func(uintptr) {
1895		}	1895		}
1896		}	1896		}
1897			1897
1898	-	// OverrideThreadEqual sets the callback function.	1898	+	// OverrideThreadEqual sets the "thread_equal" callback function.
1899		// used internally by recursive mutex locks and by some	1899		// used internally by recursive mutex locks and by some
1900		//	1900		//
1901		// assertion checks	1901		// assertion checks

@@ -1909,7 +1909,7 @@ func (x *ThreadFunctions) OverrideThreadEqual(cb func(uintptr, uintptr) bool) {
1909		}	1909		}
1910		}	1910		}
1911			1911
1912	-	// GetThreadEqual gets the callback function.	1912	+	// GetThreadEqual gets the "thread_equal" callback function.
1913		// used internally by recursive mutex locks and by some	1913		// used internally by recursive mutex locks and by some
1914		//	1914		//
1915		// assertion checks	1915		// assertion checks

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


@@ -172,13 +172,13 @@ func (x *Tree) Lookup(KeyVar uintptr) uintptr {
172		return cret	172		return cret
173		}	173		}
174			174
175	-	var xTreeLookupExtended func(uintptr, uintptr, uintptr, uintptr) bool	175	+	var xTreeLookupExtended func(uintptr, uintptr, uintptr, uintptr) bool
176			176
177		// Looks up a key in the #GTree, returning the original key and the	177		// Looks up a key in the #GTree, returning the original key and the
178		// associated value. This is useful if you need to free the memory	178		// associated value. This is useful if you need to free the memory
179		// allocated for the original key, for example before calling	179		// allocated for the original key, for example before calling
180		// g_tree_remove().	180		// g_tree_remove().
181	-	func (x *Tree) LookupExtended(LookupKeyVar uintptr, OrigKeyVar uintptr, ValueVar uintptr) bool {	181	+	func (x Tree) LookupExtended(LookupKeyVar uintptr, OrigKeyVar uintptr, ValueVar *uintptr) bool {
182			182
183		cret := xTreeLookupExtended(x.GoPointer(), LookupKeyVar, OrigKeyVar, ValueVar)	183		cret := xTreeLookupExtended(x.GoPointer(), LookupKeyVar, OrigKeyVar, ValueVar)
184		return cret	184		return cret

M v4/glib/gunicode.go +28 -28


@@ -613,12 +613,12 @@ const (
613		GUnicodeSpaceSeparatorValue UnicodeType = 29	613		GUnicodeSpaceSeparatorValue UnicodeType = 29
614		)	614		)
615			615
616	-	var xUcs4ToUtf16 func([]uint32, int32, int32, int32, **Error) uint16	616	+	var xUcs4ToUtf16 func([]uint32, int32, int32, int32, **Error) uint16
617			617
618		// Convert a string from UCS-4 to UTF-16.	618		// Convert a string from UCS-4 to UTF-16.
619		//	619		//
620		// A nul character (U+0000) will be added to the result after the converted text.	620		// A nul character (U+0000) will be added to the result after the converted text.
621	-	func Ucs4ToUtf16(StrVar []uint32, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint16, error) {	621	+	func Ucs4ToUtf16(StrVar []uint32, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint16, error) {
622		var cerr *Error	622		var cerr *Error
623			623
624		cret := xUcs4ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	624		cret := xUcs4ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -629,13 +629,13 @@ func Ucs4ToUtf16(StrVar []uint32, LenVar int32, ItemsReadVar int32, ItemsWritten
629			629
630		}	630		}
631			631
632	-	var xUcs4ToUtf8 func([]uint32, int32, int32, int32, **Error) string	632	+	var xUcs4ToUtf8 func([]uint32, int32, int32, int32, **Error) string
633			633
634		// Convert a string from a 32-bit fixed width representation as UCS-4.	634		// Convert a string from a 32-bit fixed width representation as UCS-4.
635		// to UTF-8.	635		// to UTF-8.
636		//	636		//
637		// The result will be terminated with a nul byte.	637		// The result will be terminated with a nul byte.
638	-	func Ucs4ToUtf8(StrVar []uint32, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (string, error) {	638	+	func Ucs4ToUtf8(StrVar []uint32, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (string, error) {
639		var cerr *Error	639		var cerr *Error
640			640
641		cret := xUcs4ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	641		cret := xUcs4ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -669,7 +669,7 @@ func UnicharCombiningClass(UcVar uint32) int {
669		return cret	669		return cret
670		}	670		}
671			671
672	-	var xUnicharCompose func(uint32, uint32, uint32) bool	672	+	var xUnicharCompose func(uint32, uint32, *uint32) bool
673			673
674		// Performs a single composition step of the	674		// Performs a single composition step of the
675		// Unicode canonical composition algorithm.	675		// Unicode canonical composition algorithm.

@@ -687,13 +687,13 @@ var xUnicharCompose func(uint32, uint32, uint32) bool
687		// See	687		// See
688		// [UAX#15](http://unicode.org/reports/tr15/)	688		// [UAX#15](http://unicode.org/reports/tr15/)
689		// for details.	689		// for details.
690	-	func UnicharCompose(AVar uint32, BVar uint32, ChVar uint32) bool {	690	+	func UnicharCompose(AVar uint32, BVar uint32, ChVar *uint32) bool {
691			691
692		cret := xUnicharCompose(AVar, BVar, ChVar)	692		cret := xUnicharCompose(AVar, BVar, ChVar)
693		return cret	693		return cret
694		}	694		}
695			695
696	-	var xUnicharDecompose func(uint32, uint32, uint32) bool	696	+	var xUnicharDecompose func(uint32, uint32, uint32) bool
697			697
698		// Performs a single decomposition step of the	698		// Performs a single decomposition step of the
699		// Unicode canonical decomposition algorithm.	699		// Unicode canonical decomposition algorithm.

@@ -718,7 +718,7 @@ var xUnicharDecompose func(uint32, uint32, uint32) bool
718		// See	718		// See
719		// [UAX#15](http://unicode.org/reports/tr15/)	719		// [UAX#15](http://unicode.org/reports/tr15/)
720		// for details.	720		// for details.
721	-	func UnicharDecompose(ChVar uint32, AVar uint32, BVar uint32) bool {	721	+	func UnicharDecompose(ChVar uint32, AVar uint32, BVar uint32) bool {
722			722
723		cret := xUnicharDecompose(ChVar, AVar, BVar)	723		cret := xUnicharDecompose(ChVar, AVar, BVar)
724		return cret	724		return cret

@@ -734,7 +734,7 @@ func UnicharDigitValue(CVar uint32) int {
734		return cret	734		return cret
735		}	735		}
736			736
737	-	var xUnicharFullyDecompose func(uint32, bool, uint32, uint) uint	737	+	var xUnicharFullyDecompose func(uint32, bool, *uint32, uint) uint
738			738
739		// Computes the canonical or compatibility decomposition of a	739		// Computes the canonical or compatibility decomposition of a
740		// Unicode character. For compatibility decomposition,	740		// Unicode character. For compatibility decomposition,

@@ -755,13 +755,13 @@ var xUnicharFullyDecompose func(uint32, bool, uint32, uint) uint
755		// See	755		// See
756		// [UAX#15](http://unicode.org/reports/tr15/)	756		// [UAX#15](http://unicode.org/reports/tr15/)
757		// for details.	757		// for details.
758	-	func UnicharFullyDecompose(ChVar uint32, CompatVar bool, ResultVar uint32, ResultLenVar uint) uint {	758	+	func UnicharFullyDecompose(ChVar uint32, CompatVar bool, ResultVar *uint32, ResultLenVar uint) uint {
759			759
760		cret := xUnicharFullyDecompose(ChVar, CompatVar, ResultVar, ResultLenVar)	760		cret := xUnicharFullyDecompose(ChVar, CompatVar, ResultVar, ResultLenVar)
761		return cret	761		return cret
762		}	762		}
763			763
764	-	var xUnicharGetMirrorChar func(uint32, uint32) bool	764	+	var xUnicharGetMirrorChar func(uint32, *uint32) bool
765			765
766		// In Unicode, some characters are "mirrored". This means that their	766		// In Unicode, some characters are "mirrored". This means that their
767		// images are mirrored horizontally in text that is laid out from right	767		// images are mirrored horizontally in text that is laid out from right

@@ -772,7 +772,7 @@ var xUnicharGetMirrorChar func(uint32, uint32) bool
772		// character that typically has a glyph that is the mirror image of @ch's	772		// character that typically has a glyph that is the mirror image of @ch's
773		// glyph and @mirrored_ch is set, it puts that character in the address	773		// glyph and @mirrored_ch is set, it puts that character in the address
774		// pointed to by @mirrored_ch. Otherwise the original character is put.	774		// pointed to by @mirrored_ch. Otherwise the original character is put.
775	-	func UnicharGetMirrorChar(ChVar uint32, MirroredChVar uint32) bool {	775	+	func UnicharGetMirrorChar(ChVar uint32, MirroredChVar *uint32) bool {
776			776
777		cret := xUnicharGetMirrorChar(ChVar, MirroredChVar)	777		cret := xUnicharGetMirrorChar(ChVar, MirroredChVar)
778		return cret	778		return cret

@@ -1003,10 +1003,10 @@ func UnicharIszerowidth(CVar uint32) bool {
1003		return cret	1003		return cret
1004		}	1004		}
1005			1005
1006	-	var xUnicharToUtf8 func(uint32, string) int	1006	+	var xUnicharToUtf8 func(uint32, *string) int
1007			1007
1008		// Converts a single character to UTF-8.	1008		// Converts a single character to UTF-8.
1009	-	func UnicharToUtf8(CVar uint32, OutbufVar string) int {	1009	+	func UnicharToUtf8(CVar uint32, OutbufVar *string) int {
1010			1010
1011		cret := xUnicharToUtf8(CVar, OutbufVar)	1011		cret := xUnicharToUtf8(CVar, OutbufVar)
1012		return cret	1012		return cret

@@ -1125,12 +1125,12 @@ func UnicodeScriptToIso15924(ScriptVar UnicodeScript) uint32 {
1125		return cret	1125		return cret
1126		}	1126		}
1127			1127
1128	-	var xUtf16ToUcs4 func([]uint16, int32, int32, int32, **Error) uint32	1128	+	var xUtf16ToUcs4 func([]uint16, int32, int32, int32, **Error) uint32
1129			1129
1130		// Convert a string from UTF-16 to UCS-4.	1130		// Convert a string from UTF-16 to UCS-4.
1131		//	1131		//
1132		// The result will be nul-terminated.	1132		// The result will be nul-terminated.
1133	-	func Utf16ToUcs4(StrVar []uint16, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint32, error) {	1133	+	func Utf16ToUcs4(StrVar []uint16, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint32, error) {
1134		var cerr *Error	1134		var cerr *Error
1135			1135
1136		cret := xUtf16ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1136		cret := xUtf16ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -1141,7 +1141,7 @@ func Utf16ToUcs4(StrVar []uint16, LenVar int32, ItemsReadVar int32, ItemsWritten
1141			1141
1142		}	1142		}
1143			1143
1144	-	var xUtf16ToUtf8 func([]uint16, int32, int32, int32, **Error) string	1144	+	var xUtf16ToUtf8 func([]uint16, int32, int32, int32, **Error) string
1145			1145
1146		// Convert a string from UTF-16 to UTF-8.	1146		// Convert a string from UTF-16 to UTF-8.
1147		//	1147		//

@@ -1157,7 +1157,7 @@ var xUtf16ToUtf8 func([]uint16, int32, int32, int32, **Error) string
1157		// validation done by this function is to ensure that the input can	1157		// validation done by this function is to ensure that the input can
1158		// be correctly interpreted as UTF-16, i.e. it doesn’t contain	1158		// be correctly interpreted as UTF-16, i.e. it doesn’t contain
1159		// unpaired surrogates or partial character sequences.	1159		// unpaired surrogates or partial character sequences.
1160	-	func Utf16ToUtf8(StrVar []uint16, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (string, error) {	1160	+	func Utf16ToUtf8(StrVar []uint16, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (string, error) {
1161		var cerr *Error	1161		var cerr *Error
1162			1162
1163		cret := xUtf16ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1163		cret := xUtf16ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -1524,13 +1524,13 @@ func Utf8Substring(StrVar string, StartPosVar int32, EndPosVar int32) string {
1524		return cret	1524		return cret
1525		}	1525		}
1526			1526
1527	-	var xUtf8ToUcs4 func(string, int32, int32, int32, **Error) uint32	1527	+	var xUtf8ToUcs4 func(string, int32, int32, int32, **Error) uint32
1528			1528
1529		// Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4.	1529		// Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4.
1530		//	1530		//
1531		// A trailing nul character (U+0000) will be added to the string after the	1531		// A trailing nul character (U+0000) will be added to the string after the
1532		// converted text.	1532		// converted text.
1533	-	func Utf8ToUcs4(StrVar string, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint32, error) {	1533	+	func Utf8ToUcs4(StrVar string, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint32, error) {
1534		var cerr *Error	1534		var cerr *Error
1535			1535
1536		cret := xUtf8ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1536		cret := xUtf8ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -1541,7 +1541,7 @@ func Utf8ToUcs4(StrVar string, LenVar int32, ItemsReadVar int32, ItemsWrittenVar
1541			1541
1542		}	1542		}
1543			1543
1544	-	var xUtf8ToUcs4Fast func(string, int32, int32) uint32	1544	+	var xUtf8ToUcs4Fast func(string, int32, *int32) uint32
1545			1545
1546		// Convert a string from UTF-8 to a 32-bit fixed width	1546		// Convert a string from UTF-8 to a 32-bit fixed width
1547		// representation as UCS-4, assuming valid UTF-8 input.	1547		// representation as UCS-4, assuming valid UTF-8 input.

@@ -1549,18 +1549,18 @@ var xUtf8ToUcs4Fast func(string, int32, int32) uint32
1549		// This function is roughly twice as fast as [func@GLib.utf8_to_ucs4]	1549		// This function is roughly twice as fast as [func@GLib.utf8_to_ucs4]
1550		// but does no error checking on the input. A trailing nul character (U+0000)	1550		// but does no error checking on the input. A trailing nul character (U+0000)
1551		// will be added to the string after the converted text.	1551		// will be added to the string after the converted text.
1552	-	func Utf8ToUcs4Fast(StrVar string, LenVar int32, ItemsWrittenVar int32) uint32 {	1552	+	func Utf8ToUcs4Fast(StrVar string, LenVar int32, ItemsWrittenVar *int32) uint32 {
1553			1553
1554		cret := xUtf8ToUcs4Fast(StrVar, LenVar, ItemsWrittenVar)	1554		cret := xUtf8ToUcs4Fast(StrVar, LenVar, ItemsWrittenVar)
1555		return cret	1555		return cret
1556		}	1556		}
1557			1557
1558	-	var xUtf8ToUtf16 func(string, int32, int32, int32, **Error) uint16	1558	+	var xUtf8ToUtf16 func(string, int32, int32, int32, **Error) uint16
1559			1559
1560		// Convert a string from UTF-8 to UTF-16.	1560		// Convert a string from UTF-8 to UTF-16.
1561		//	1561		//
1562		// A nul character (U+0000) will be added to the result after the converted text.	1562		// A nul character (U+0000) will be added to the result after the converted text.
1563	-	func Utf8ToUtf16(StrVar string, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint16, error) {	1563	+	func Utf8ToUtf16(StrVar string, LenVar int32, ItemsReadVar int32, ItemsWrittenVar int32) (uint16, error) {
1564		var cerr *Error	1564		var cerr *Error
1565			1565
1566		cret := xUtf8ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1566		cret := xUtf8ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)

@@ -1584,7 +1584,7 @@ func Utf8TruncateMiddle(StringVar string, TruncateLengthVar uint) string {
1584		return cret	1584		return cret
1585		}	1585		}
1586			1586
1587	-	var xUtf8Validate func([]byte, int, []byte) bool	1587	+	var xUtf8Validate func([]byte, int, *[]byte) bool
1588			1588
1589		// Validates UTF-8 encoded text.	1589		// Validates UTF-8 encoded text.
1590		//	1590		//

@@ -1603,19 +1603,19 @@ var xUtf8Validate func([]byte, int, []byte) bool
1603		// routines require valid UTF-8 as input; so data read from a file	1603		// routines require valid UTF-8 as input; so data read from a file
1604		// or the network should be checked with `g_utf8_validate()` before	1604		// or the network should be checked with `g_utf8_validate()` before
1605		// doing anything else with it.	1605		// doing anything else with it.
1606	-	func Utf8Validate(StrVar []byte, MaxLenVar int, EndVar []byte) bool {	1606	+	func Utf8Validate(StrVar []byte, MaxLenVar int, EndVar *[]byte) bool {
1607			1607
1608		cret := xUtf8Validate(StrVar, MaxLenVar, EndVar)	1608		cret := xUtf8Validate(StrVar, MaxLenVar, EndVar)
1609		return cret	1609		return cret
1610		}	1610		}
1611			1611
1612	-	var xUtf8ValidateLen func([]byte, uint, []byte) bool	1612	+	var xUtf8ValidateLen func([]byte, uint, *[]byte) bool
1613			1613
1614		// Validates UTF-8 encoded text.	1614		// Validates UTF-8 encoded text.
1615		//	1615		//
1616		// As with [func@GLib.utf8_validate], but @max_len must be set, and hence this	1616		// As with [func@GLib.utf8_validate], but @max_len must be set, and hence this
1617		// function will always return `FALSE` if any of the bytes of @str are nul.	1617		// function will always return `FALSE` if any of the bytes of @str are nul.
1618	-	func Utf8ValidateLen(StrVar []byte, MaxLenVar uint, EndVar []byte) bool {	1618	+	func Utf8ValidateLen(StrVar []byte, MaxLenVar uint, EndVar *[]byte) bool {
1619			1619
1620		cret := xUtf8ValidateLen(StrVar, MaxLenVar, EndVar)	1620		cret := xUtf8ValidateLen(StrVar, MaxLenVar, EndVar)
1621		return cret	1621		return cret

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


@@ -449,7 +449,7 @@ func (x *UriParamsIter) Init(ParamsVar string, LengthVar int, SeparatorsVar stri
449			449
450		}	450		}
451			451
452	-	var xUriParamsIterNext func(uintptr, string, string, **Error) bool	452	+	var xUriParamsIterNext func(uintptr, string, string, **Error) bool
453			453
454		// Advances @iter and retrieves the next attribute/value. %FALSE is returned if	454		// Advances @iter and retrieves the next attribute/value. %FALSE is returned if
455		// an error has occurred (in which case @error is set), or if the end of the	455		// an error has occurred (in which case @error is set), or if the end of the

@@ -460,7 +460,7 @@ var xUriParamsIterNext func(uintptr, string, string, **Error) bool
460		//	460		//
461		// Note that the same @attribute may be returned multiple times, since URIs	461		// Note that the same @attribute may be returned multiple times, since URIs
462		// allow repeated attributes.	462		// allow repeated attributes.
463	-	func (x *UriParamsIter) Next(AttributeVar string, ValueVar string) (bool, error) {	463	+	func (x UriParamsIter) Next(AttributeVar string, ValueVar *string) (bool, error) {
464		var cerr *Error	464		var cerr *Error
465			465
466		cret := xUriParamsIterNext(x.GoPointer(), AttributeVar, ValueVar, &cerr)	466		cret := xUriParamsIterNext(x.GoPointer(), AttributeVar, ValueVar, &cerr)

@@ -827,7 +827,7 @@ func UriResolveRelative(BaseUriStringVar string, UriRefVar string, FlagsVar UriF
827			827
828		}	828		}
829			829
830	-	var xUriSplit func(string, UriFlags, string, string, string, int, string, string, string, **Error) bool	830	+	var xUriSplit func(string, UriFlags, string, string, string, int, string, string, string, *Error) bool
831			831
832		// Parses @uri_ref (which can be an	832		// Parses @uri_ref (which can be an
833		// [absolute or relative URI](#relative-and-absolute-uris)) according to @flags, and	833		// [absolute or relative URI](#relative-and-absolute-uris)) according to @flags, and

@@ -845,7 +845,7 @@ var xUriSplit func(string, UriFlags, string, string, string, int, string, string
845		// %G_URI_FLAGS_HAS_AUTH_PARAMS @flags are ignored by g_uri_split(),	845		// %G_URI_FLAGS_HAS_AUTH_PARAMS @flags are ignored by g_uri_split(),
846		// since it always returns only the full userinfo; use	846		// since it always returns only the full userinfo; use
847		// g_uri_split_with_user() if you want it split up.	847		// g_uri_split_with_user() if you want it split up.
848	-	func UriSplit(UriRefVar string, FlagsVar UriFlags, SchemeVar string, UserinfoVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar string) (bool, error) {	848	+	func UriSplit(UriRefVar string, FlagsVar UriFlags, SchemeVar string, UserinfoVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar *string) (bool, error) {
849		var cerr *Error	849		var cerr *Error
850			850
851		cret := xUriSplit(UriRefVar, FlagsVar, SchemeVar, UserinfoVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar, &cerr)	851		cret := xUriSplit(UriRefVar, FlagsVar, SchemeVar, UserinfoVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar, &cerr)

@@ -856,7 +856,7 @@ func UriSplit(UriRefVar string, FlagsVar UriFlags, SchemeVar string, UserinfoVar
856			856
857		}	857		}
858			858
859	-	var xUriSplitNetwork func(string, UriFlags, string, string, int, **Error) bool	859	+	var xUriSplitNetwork func(string, UriFlags, string, string, int, *Error) bool
860			860
861		// Parses @uri_string (which must be an [absolute URI](#relative-and-absolute-uris))	861		// Parses @uri_string (which must be an [absolute URI](#relative-and-absolute-uris))
862		// according to @flags, and returns the pieces relevant to connecting to a host.	862		// according to @flags, and returns the pieces relevant to connecting to a host.

@@ -864,7 +864,7 @@ var xUriSplitNetwork func(string, UriFlags, string, string, int, **Error) bool
864		// mostly a wrapper around that function with simpler arguments.	864		// mostly a wrapper around that function with simpler arguments.
865		// However, it will return an error if @uri_string is a relative URI,	865		// However, it will return an error if @uri_string is a relative URI,
866		// or does not contain a hostname component.	866		// or does not contain a hostname component.
867	-	func UriSplitNetwork(UriStringVar string, FlagsVar UriFlags, SchemeVar string, HostVar string, PortVar int) (bool, error) {	867	+	func UriSplitNetwork(UriStringVar string, FlagsVar UriFlags, SchemeVar string, HostVar string, PortVar *int) (bool, error) {
868		var cerr *Error	868		var cerr *Error
869			869
870		cret := xUriSplitNetwork(UriStringVar, FlagsVar, SchemeVar, HostVar, PortVar, &cerr)	870		cret := xUriSplitNetwork(UriStringVar, FlagsVar, SchemeVar, HostVar, PortVar, &cerr)

@@ -875,7 +875,7 @@ func UriSplitNetwork(UriStringVar string, FlagsVar UriFlags, SchemeVar string, H
875			875
876		}	876		}
877			877
878	-	var xUriSplitWithUser func(string, UriFlags, string, string, string, string, string, int, string, string, string, **Error) bool	878	+	var xUriSplitWithUser func(string, UriFlags, string, string, string, string, string, int, string, string, string, *Error) bool
879			879
880		// Parses @uri_ref (which can be an	880		// Parses @uri_ref (which can be an
881		// [absolute or relative URI](#relative-and-absolute-uris)) according to @flags, and	881		// [absolute or relative URI](#relative-and-absolute-uris)) according to @flags, and

@@ -888,7 +888,7 @@ var xUriSplitWithUser func(string, UriFlags, string, string, string, string, str
888		// be parsed out if @flags contains %G_URI_FLAGS_HAS_PASSWORD, and	888		// be parsed out if @flags contains %G_URI_FLAGS_HAS_PASSWORD, and
889		// @auth_params will only be parsed out if @flags contains	889		// @auth_params will only be parsed out if @flags contains
890		// %G_URI_FLAGS_HAS_AUTH_PARAMS.	890		// %G_URI_FLAGS_HAS_AUTH_PARAMS.
891	-	func UriSplitWithUser(UriRefVar string, FlagsVar UriFlags, SchemeVar string, UserVar string, PasswordVar string, AuthParamsVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar string) (bool, error) {	891	+	func UriSplitWithUser(UriRefVar string, FlagsVar UriFlags, SchemeVar string, UserVar string, PasswordVar string, AuthParamsVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar *string) (bool, error) {
892		var cerr *Error	892		var cerr *Error
893			893
894		cret := xUriSplitWithUser(UriRefVar, FlagsVar, SchemeVar, UserVar, PasswordVar, AuthParamsVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar, &cerr)	894		cret := xUriSplitWithUser(UriRefVar, FlagsVar, SchemeVar, UserVar, PasswordVar, AuthParamsVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar, &cerr)

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


@@ -877,19 +877,19 @@ func (x *Variant) Compare(TwoVar uintptr) int {
877		return cret	877		return cret
878		}	878		}
879			879
880	-	var xVariantDupBytestring func(uintptr, uint) uintptr	880	+	var xVariantDupBytestring func(uintptr, *uint) uintptr
881			881
882		// Similar to g_variant_get_bytestring() except that instead of	882		// Similar to g_variant_get_bytestring() except that instead of
883		// returning a constant string, the string is duplicated.	883		// returning a constant string, the string is duplicated.
884		//	884		//
885		// The return value must be freed using g_free().	885		// The return value must be freed using g_free().
886	-	func (x *Variant) DupBytestring(LengthVar uint) uintptr {	886	+	func (x Variant) DupBytestring(LengthVar uint) uintptr {
887			887
888		cret := xVariantDupBytestring(x.GoPointer(), LengthVar)	888		cret := xVariantDupBytestring(x.GoPointer(), LengthVar)
889		return cret	889		return cret
890		}	890		}
891			891
892	-	var xVariantDupBytestringArray func(uintptr, uint) []string	892	+	var xVariantDupBytestringArray func(uintptr, *uint) []string
893			893
894		// Gets the contents of an array of array of bytes #GVariant. This call	894		// Gets the contents of an array of array of bytes #GVariant. This call
895		// makes a deep copy; the return result should be released with	895		// makes a deep copy; the return result should be released with

@@ -901,13 +901,13 @@ var xVariantDupBytestringArray func(uintptr, uint) []string
901		//	901		//
902		// For an empty array, @length will be set to 0 and a pointer to a	902		// For an empty array, @length will be set to 0 and a pointer to a
903		// %NULL pointer will be returned.	903		// %NULL pointer will be returned.
904	-	func (x *Variant) DupBytestringArray(LengthVar uint) []string {	904	+	func (x Variant) DupBytestringArray(LengthVar uint) []string {
905			905
906		cret := xVariantDupBytestringArray(x.GoPointer(), LengthVar)	906		cret := xVariantDupBytestringArray(x.GoPointer(), LengthVar)
907		return cret	907		return cret
908		}	908		}
909			909
910	-	var xVariantDupObjv func(uintptr, uint) []string	910	+	var xVariantDupObjv func(uintptr, *uint) []string
911			911
912		// Gets the contents of an array of object paths #GVariant. This call	912		// Gets the contents of an array of object paths #GVariant. This call
913		// makes a deep copy; the return result should be released with	913		// makes a deep copy; the return result should be released with

@@ -919,13 +919,13 @@ var xVariantDupObjv func(uintptr, uint) []string
919		//	919		//
920		// For an empty array, @length will be set to 0 and a pointer to a	920		// For an empty array, @length will be set to 0 and a pointer to a
921		// %NULL pointer will be returned.	921		// %NULL pointer will be returned.
922	-	func (x *Variant) DupObjv(LengthVar uint) []string {	922	+	func (x Variant) DupObjv(LengthVar uint) []string {
923			923
924		cret := xVariantDupObjv(x.GoPointer(), LengthVar)	924		cret := xVariantDupObjv(x.GoPointer(), LengthVar)
925		return cret	925		return cret
926		}	926		}
927			927
928	-	var xVariantDupString func(uintptr, uint) string	928	+	var xVariantDupString func(uintptr, *uint) string
929			929
930		// Similar to g_variant_get_string() except that instead of returning	930		// Similar to g_variant_get_string() except that instead of returning
931		// a constant string, the string is duplicated.	931		// a constant string, the string is duplicated.

@@ -933,13 +933,13 @@ var xVariantDupString func(uintptr, uint) string
933		// The string will always be UTF-8 encoded.	933		// The string will always be UTF-8 encoded.
934		//	934		//
935		// The return value must be freed using g_free().	935		// The return value must be freed using g_free().
936	-	func (x *Variant) DupString(LengthVar uint) string {	936	+	func (x Variant) DupString(LengthVar uint) string {
937			937
938		cret := xVariantDupString(x.GoPointer(), LengthVar)	938		cret := xVariantDupString(x.GoPointer(), LengthVar)
939		return cret	939		return cret
940		}	940		}
941			941
942	-	var xVariantDupStrv func(uintptr, uint) []string	942	+	var xVariantDupStrv func(uintptr, *uint) []string
943			943
944		// Gets the contents of an array of strings #GVariant. This call	944		// Gets the contents of an array of strings #GVariant. This call
945		// makes a deep copy; the return result should be released with	945		// makes a deep copy; the return result should be released with

@@ -951,7 +951,7 @@ var xVariantDupStrv func(uintptr, uint) []string
951		//	951		//
952		// For an empty array, @length will be set to 0 and a pointer to a	952		// For an empty array, @length will be set to 0 and a pointer to a
953		// %NULL pointer will be returned.	953		// %NULL pointer will be returned.
954	-	func (x *Variant) DupStrv(LengthVar uint) []string {	954	+	func (x Variant) DupStrv(LengthVar uint) []string {
955			955
956		cret := xVariantDupStrv(x.GoPointer(), LengthVar)	956		cret := xVariantDupStrv(x.GoPointer(), LengthVar)
957		return cret	957		return cret

@@ -1043,7 +1043,7 @@ func (x *Variant) GetBytestring() uintptr {
1043		return cret	1043		return cret
1044		}	1044		}
1045			1045
1046	-	var xVariantGetBytestringArray func(uintptr, uint) []string	1046	+	var xVariantGetBytestringArray func(uintptr, *uint) []string
1047			1047
1048		// Gets the contents of an array of array of bytes #GVariant. This call	1048		// Gets the contents of an array of array of bytes #GVariant. This call
1049		// makes a shallow copy; the return result should be released with	1049		// makes a shallow copy; the return result should be released with

@@ -1055,7 +1055,7 @@ var xVariantGetBytestringArray func(uintptr, uint) []string
1055		//	1055		//
1056		// For an empty array, @length will be set to 0 and a pointer to a	1056		// For an empty array, @length will be set to 0 and a pointer to a
1057		// %NULL pointer will be returned.	1057		// %NULL pointer will be returned.
1058	-	func (x *Variant) GetBytestringArray(LengthVar uint) []string {	1058	+	func (x Variant) GetBytestringArray(LengthVar uint) []string {
1059			1059
1060		cret := xVariantGetBytestringArray(x.GoPointer(), LengthVar)	1060		cret := xVariantGetBytestringArray(x.GoPointer(), LengthVar)
1061		return cret	1061		return cret

@@ -1166,7 +1166,7 @@ func (x *Variant) GetDouble() float64 {
1166		return cret	1166		return cret
1167		}	1167		}
1168			1168
1169	-	var xVariantGetFixedArray func(uintptr, uint, uint) uintptr	1169	+	var xVariantGetFixedArray func(uintptr, *uint, uint) uintptr
1170			1170
1171		// Provides access to the serialized data for an array of fixed-sized	1171		// Provides access to the serialized data for an array of fixed-sized
1172		// items.	1172		// items.

@@ -1194,7 +1194,7 @@ var xVariantGetFixedArray func(uintptr, uint, uint) uintptr
1194		//	1194		//
1195		// @n_elements, which must be non-%NULL, is set equal to the number of	1195		// @n_elements, which must be non-%NULL, is set equal to the number of
1196		// items in the array.	1196		// items in the array.
1197	-	func (x *Variant) GetFixedArray(NElementsVar uint, ElementSizeVar uint) uintptr {	1197	+	func (x Variant) GetFixedArray(NElementsVar uint, ElementSizeVar uint) uintptr {
1198			1198
1199		cret := xVariantGetFixedArray(x.GoPointer(), NElementsVar, ElementSizeVar)	1199		cret := xVariantGetFixedArray(x.GoPointer(), NElementsVar, ElementSizeVar)
1200		return cret	1200		return cret

@@ -1295,7 +1295,7 @@ func (x Variant) GetNormalForm() Variant {
1295		return cret	1295		return cret
1296		}	1296		}
1297			1297
1298	-	var xVariantGetObjv func(uintptr, uint) []string	1298	+	var xVariantGetObjv func(uintptr, *uint) []string
1299			1299
1300		// Gets the contents of an array of object paths #GVariant. This call	1300		// Gets the contents of an array of object paths #GVariant. This call
1301		// makes a shallow copy; the return result should be released with	1301		// makes a shallow copy; the return result should be released with

@@ -1307,7 +1307,7 @@ var xVariantGetObjv func(uintptr, uint) []string
1307		//	1307		//
1308		// For an empty array, @length will be set to 0 and a pointer to a	1308		// For an empty array, @length will be set to 0 and a pointer to a
1309		// %NULL pointer will be returned.	1309		// %NULL pointer will be returned.
1310	-	func (x *Variant) GetObjv(LengthVar uint) []string {	1310	+	func (x Variant) GetObjv(LengthVar uint) []string {
1311			1311
1312		cret := xVariantGetObjv(x.GoPointer(), LengthVar)	1312		cret := xVariantGetObjv(x.GoPointer(), LengthVar)
1313		return cret	1313		return cret

@@ -1332,7 +1332,7 @@ func (x *Variant) GetSize() uint {
1332		return cret	1332		return cret
1333		}	1333		}
1334			1334
1335	-	var xVariantGetString func(uintptr, uint) string	1335	+	var xVariantGetString func(uintptr, *uint) string
1336			1336
1337		// Returns the string value of a #GVariant instance with a string	1337		// Returns the string value of a #GVariant instance with a string
1338		// type. This includes the types %G_VARIANT_TYPE_STRING,	1338		// type. This includes the types %G_VARIANT_TYPE_STRING,

@@ -1352,13 +1352,13 @@ var xVariantGetString func(uintptr, uint) string
1352		// other than those three.	1352		// other than those three.
1353		//	1353		//
1354		// The return value remains valid as long as @value exists.	1354		// The return value remains valid as long as @value exists.
1355	-	func (x *Variant) GetString(LengthVar uint) string {	1355	+	func (x Variant) GetString(LengthVar uint) string {
1356			1356
1357		cret := xVariantGetString(x.GoPointer(), LengthVar)	1357		cret := xVariantGetString(x.GoPointer(), LengthVar)
1358		return cret	1358		return cret
1359		}	1359		}
1360			1360
1361	-	var xVariantGetStrv func(uintptr, uint) []string	1361	+	var xVariantGetStrv func(uintptr, *uint) []string
1362			1362
1363		// Gets the contents of an array of strings #GVariant. This call	1363		// Gets the contents of an array of strings #GVariant. This call
1364		// makes a shallow copy; the return result should be released with	1364		// makes a shallow copy; the return result should be released with

@@ -1370,7 +1370,7 @@ var xVariantGetStrv func(uintptr, uint) []string
1370		//	1370		//
1371		// For an empty array, @length will be set to 0 and a pointer to a	1371		// For an empty array, @length will be set to 0 and a pointer to a
1372		// %NULL pointer will be returned.	1372		// %NULL pointer will be returned.
1373	-	func (x *Variant) GetStrv(LengthVar uint) []string {	1373	+	func (x Variant) GetStrv(LengthVar uint) []string {
1374			1374
1375		cret := xVariantGetStrv(x.GoPointer(), LengthVar)	1375		cret := xVariantGetStrv(x.GoPointer(), LengthVar)
1376		return cret	1376		return cret

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


@@ -625,7 +625,7 @@ func VariantTypeStringIsValid(TypeStringVar string) bool {
625		return cret	625		return cret
626		}	626		}
627			627
628	-	var xVariantTypeStringScan func(string, string, string) bool	628	+	var xVariantTypeStringScan func(string, string, *string) bool
629			629
630		// Scan for a single complete and valid GVariant type string in @string.	630		// Scan for a single complete and valid GVariant type string in @string.
631		//	631		//

@@ -641,7 +641,7 @@ var xVariantTypeStringScan func(string, string, string) bool
641		//	641		//
642		// For the simple case of checking if a string is a valid type string,	642		// For the simple case of checking if a string is a valid type string,
643		// see [func@GLib.VariantType.string_is_valid].	643		// see [func@GLib.VariantType.string_is_valid].
644	-	func VariantTypeStringScan(StringVar string, LimitVar string, EndptrVar string) bool {	644	+	func VariantTypeStringScan(StringVar string, LimitVar string, EndptrVar *string) bool {
645			645
646		cret := xVariantTypeStringScan(StringVar, LimitVar, EndptrVar)	646		cret := xVariantTypeStringScan(StringVar, LimitVar, EndptrVar)
647		return cret	647		return cret

M v4/gmodule/gmodule.go +2 -2


@@ -67,11 +67,11 @@ func (x *Module) Name() string {
67		return cret	67		return cret
68		}	68		}
69			69
70	-	var xModuleSymbol func(uintptr, string, uintptr) bool	70	+	var xModuleSymbol func(uintptr, string, *uintptr) bool
71			71
72		// Gets a symbol pointer from a module, such as one exported	72		// Gets a symbol pointer from a module, such as one exported
73		// by %G_MODULE_EXPORT. Note that a valid symbol can be %NULL.	73		// by %G_MODULE_EXPORT. Note that a valid symbol can be %NULL.
74	-	func (x *Module) Symbol(SymbolNameVar string, SymbolVar uintptr) bool {	74	+	func (x Module) Symbol(SymbolNameVar string, SymbolVar uintptr) bool {
75			75
76		cret := xModuleSymbol(x.GoPointer(), SymbolNameVar, SymbolVar)	76		cret := xModuleSymbol(x.GoPointer(), SymbolNameVar, SymbolVar)
77		return cret	77		return cret

M v4/gobject/gbinding.go +50 -0


@@ -297,6 +297,56 @@ func (c *Binding) SetGoPointer(ptr uintptr) {
297	c.Ptr = ptr	297		c.Ptr = ptr
298	}	298		}
299		299
		300	+	// SetPropertySourceProperty sets the "source-property" property.
		301	+	// The name of the property of #GBinding:source that should be used
		302	+	// as the source of the binding.
		303	+	//
		304	+	// This should be in [canonical form][canonical-parameter-names] to get the
		305	+	// best performance.
		306	+	func (x *Binding) SetPropertySourceProperty(value string) {
		307	+	var v Value
		308	+	v.Init(TypeStringVal)
		309	+	v.SetString(value)
		310	+	x.SetProperty("source-property", &v)
		311	+	}
		312	+
		313	+	// GetPropertySourceProperty gets the "source-property" property.
		314	+	// The name of the property of #GBinding:source that should be used
		315	+	// as the source of the binding.
		316	+	//
		317	+	// This should be in [canonical form][canonical-parameter-names] to get the
		318	+	// best performance.
		319	+	func (x *Binding) GetPropertySourceProperty() string {
		320	+	var v Value
		321	+	x.GetProperty("source-property", &v)
		322	+	return v.GetString()
		323	+	}
		324	+
		325	+	// SetPropertyTargetProperty sets the "target-property" property.
		326	+	// The name of the property of #GBinding:target that should be used
		327	+	// as the target of the binding.
		328	+	//
		329	+	// This should be in [canonical form][canonical-parameter-names] to get the
		330	+	// best performance.
		331	+	func (x *Binding) SetPropertyTargetProperty(value string) {
		332	+	var v Value
		333	+	v.Init(TypeStringVal)
		334	+	v.SetString(value)
		335	+	x.SetProperty("target-property", &v)
		336	+	}
		337	+
		338	+	// GetPropertyTargetProperty gets the "target-property" property.
		339	+	// The name of the property of #GBinding:target that should be used
		340	+	// as the target of the binding.
		341	+	//
		342	+	// This should be in [canonical form][canonical-parameter-names] to get the
		343	+	// best performance.
		344	+	func (x *Binding) GetPropertyTargetProperty() string {
		345	+	var v Value
		346	+	x.GetProperty("target-property", &v)
		347	+	return v.GetString()
		348	+	}
		349	+
300	func init() {	350		func init() {
301	core.SetPackageName("GOBJECT", "gobject-2.0")	351		core.SetPackageName("GOBJECT", "gobject-2.0")
302	core.SetSharedLibraries("GOBJECT", []string{"libgobject-2.0.so.0"})	352		core.SetSharedLibraries("GOBJECT", []string{"libgobject-2.0.so.0"})

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


@@ -411,7 +411,7 @@ func (x *Closure) Unref() {
411			411
412		}	412		}
413			413
414	-	// OverrideMarshal sets the callback function.	414	+	// OverrideMarshal sets the "marshal" callback function.
415		func (x Closure) OverrideMarshal(cb func(Closure, Value, uint, Value, uintptr, uintptr)) {	415		func (x Closure) OverrideMarshal(cb func(Closure, Value, uint, Value, uintptr, uintptr)) {
416		if cb == nil {	416		if cb == nil {
417		x.xMarshal = 0	417		x.xMarshal = 0

@@ -422,7 +422,7 @@ func (x Closure) OverrideMarshal(cb func(Closure, Value, uint, Value, uintpt
422		}	422		}
423		}	423		}
424			424
425	-	// GetMarshal gets the callback function.	425	+	// GetMarshal gets the "marshal" callback function.
426		func (x Closure) GetMarshal() func(Closure, Value, uint, Value, uintptr, uintptr) {	426		func (x Closure) GetMarshal() func(Closure, Value, uint, Value, uintptr, uintptr) {
427		if x.xMarshal == 0 {	427		if x.xMarshal == 0 {
428		return nil	428		return nil

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


@@ -78,7 +78,7 @@ func (x *InitiallyUnownedClass) GoPointer() uintptr {
78		return uintptr(unsafe.Pointer(x))	78		return uintptr(unsafe.Pointer(x))
79		}	79		}
80			80
81	-	// OverrideConstructor sets the callback function.	81	+	// OverrideConstructor sets the "constructor" callback function.
82		// the @constructor function is called by g_object_new () to	82		// the @constructor function is called by g_object_new () to
83		//	83		//
84		// complete the object initialization after all the construction properties are	84		// complete the object initialization after all the construction properties are

@@ -99,7 +99,7 @@ func (x InitiallyUnownedClass) OverrideConstructor(cb func(types.GType, uint,
99		}	99		}
100		}	100		}
101			101
102	-	// GetConstructor gets the callback function.	102	+	// GetConstructor gets the "constructor" callback function.
103		// the @constructor function is called by g_object_new () to	103		// the @constructor function is called by g_object_new () to
104		//	104		//
105		// complete the object initialization after all the construction properties are	105		// complete the object initialization after all the construction properties are

@@ -123,7 +123,7 @@ func (x InitiallyUnownedClass) GetConstructor() func(types.GType, uint, Object
123		}	123		}
124		}	124		}
125			125
126	-	// OverrideSetProperty sets the callback function.	126	+	// OverrideSetProperty sets the "set_property" callback function.
127		// the generic setter for all properties of this type. Should be	127		// the generic setter for all properties of this type. Should be
128		//	128		//
129		// overridden for every type with properties. If implementations of	129		// overridden for every type with properties. If implementations of

@@ -140,7 +140,7 @@ func (x InitiallyUnownedClass) OverrideSetProperty(cb func(Object, uint, *Valu
140		}	140		}
141		}	141		}
142			142
143	-	// GetSetProperty gets the callback function.	143	+	// GetSetProperty gets the "set_property" callback function.
144		// the generic setter for all properties of this type. Should be	144		// the generic setter for all properties of this type. Should be
145		//	145		//
146		// overridden for every type with properties. If implementations of	146		// overridden for every type with properties. If implementations of

@@ -158,7 +158,7 @@ func (x InitiallyUnownedClass) GetSetProperty() func(Object, uint, Value, Pa
158		}	158		}
159		}	159		}
160			160
161	-	// OverrideGetProperty sets the callback function.	161	+	// OverrideGetProperty sets the "get_property" callback function.
162		// the generic getter for all properties of this type. Should be	162		// the generic getter for all properties of this type. Should be
163		//	163		//
164		// overridden for every type with properties.	164		// overridden for every type with properties.

@@ -172,7 +172,7 @@ func (x InitiallyUnownedClass) OverrideGetProperty(cb func(Object, uint, *Valu
172		}	172		}
173		}	173		}
174			174
175	-	// GetGetProperty gets the callback function.	175	+	// GetGetProperty gets the "get_property" callback function.
176		// the generic getter for all properties of this type. Should be	176		// the generic getter for all properties of this type. Should be
177		//	177		//
178		// overridden for every type with properties.	178		// overridden for every type with properties.

@@ -187,7 +187,7 @@ func (x InitiallyUnownedClass) GetGetProperty() func(Object, uint, Value, Pa
187		}	187		}
188		}	188		}
189			189
190	-	// OverrideDispose sets the callback function.	190	+	// OverrideDispose sets the "dispose" callback function.
191		// the @dispose function is supposed to drop all references to other	191		// the @dispose function is supposed to drop all references to other
192		//	192		//
193		// objects, but keep the instance otherwise intact, so that client method	193		// objects, but keep the instance otherwise intact, so that client method

@@ -204,7 +204,7 @@ func (x InitiallyUnownedClass) OverrideDispose(cb func(Object)) {
204		}	204		}
205		}	205		}
206			206
207	-	// GetDispose gets the callback function.	207	+	// GetDispose gets the "dispose" callback function.
208		// the @dispose function is supposed to drop all references to other	208		// the @dispose function is supposed to drop all references to other
209		//	209		//
210		// objects, but keep the instance otherwise intact, so that client method	210		// objects, but keep the instance otherwise intact, so that client method

@@ -222,7 +222,7 @@ func (x InitiallyUnownedClass) GetDispose() func(Object) {
222		}	222		}
223		}	223		}
224			224
225	-	// OverrideFinalize sets the callback function.	225	+	// OverrideFinalize sets the "finalize" callback function.
226		// instance finalization function, should finish the finalization of	226		// instance finalization function, should finish the finalization of
227		//	227		//
228		// the instance begun in @dispose and chain up to the @finalize method of the	228		// the instance begun in @dispose and chain up to the @finalize method of the

@@ -237,7 +237,7 @@ func (x InitiallyUnownedClass) OverrideFinalize(cb func(Object)) {
237		}	237		}
238		}	238		}
239			239
240	-	// GetFinalize gets the callback function.	240	+	// GetFinalize gets the "finalize" callback function.
241		// instance finalization function, should finish the finalization of	241		// instance finalization function, should finish the finalization of
242		//	242		//
243		// the instance begun in @dispose and chain up to the @finalize method of the	243		// the instance begun in @dispose and chain up to the @finalize method of the

@@ -253,7 +253,7 @@ func (x InitiallyUnownedClass) GetFinalize() func(Object) {
253		}	253		}
254		}	254		}
255			255
256	-	// OverrideDispatchPropertiesChanged sets the callback function.	256	+	// OverrideDispatchPropertiesChanged sets the "dispatch_properties_changed" callback function.
257		// emits property change notification for a bunch	257		// emits property change notification for a bunch
258		//	258		//
259		// of properties. Overriding @dispatch_properties_changed should be rarely	259		// of properties. Overriding @dispatch_properties_changed should be rarely

@@ -268,7 +268,7 @@ func (x InitiallyUnownedClass) OverrideDispatchPropertiesChanged(cb func(Objec
268		}	268		}
269		}	269		}
270			270
271	-	// GetDispatchPropertiesChanged gets the callback function.	271	+	// GetDispatchPropertiesChanged gets the "dispatch_properties_changed" callback function.
272		// emits property change notification for a bunch	272		// emits property change notification for a bunch
273		//	273		//
274		// of properties. Overriding @dispatch_properties_changed should be rarely	274		// of properties. Overriding @dispatch_properties_changed should be rarely

@@ -284,7 +284,7 @@ func (x InitiallyUnownedClass) GetDispatchPropertiesChanged() func(Object, uin
284		}	284		}
285		}	285		}
286			286
287	-	// OverrideNotify sets the callback function.	287	+	// OverrideNotify sets the "notify" callback function.
288		// the class closure for the notify signal	288		// the class closure for the notify signal
289		func (x InitiallyUnownedClass) OverrideNotify(cb func(Object, *ParamSpec)) {	289		func (x InitiallyUnownedClass) OverrideNotify(cb func(Object, *ParamSpec)) {
290		if cb == nil {	290		if cb == nil {

@@ -296,7 +296,7 @@ func (x InitiallyUnownedClass) OverrideNotify(cb func(Object, *ParamSpec)) {
296		}	296		}
297		}	297		}
298			298
299	-	// GetNotify gets the callback function.	299	+	// GetNotify gets the "notify" callback function.
300		// the class closure for the notify signal	300		// the class closure for the notify signal
301		func (x InitiallyUnownedClass) GetNotify() func(Object, *ParamSpec) {	301		func (x InitiallyUnownedClass) GetNotify() func(Object, *ParamSpec) {
302		if x.xNotify == 0 {	302		if x.xNotify == 0 {

@@ -309,7 +309,7 @@ func (x InitiallyUnownedClass) GetNotify() func(Object, *ParamSpec) {
309		}	309		}
310		}	310		}
311			311
312	-	// OverrideConstructed sets the callback function.	312	+	// OverrideConstructed sets the "constructed" callback function.
313		// the @constructed function is called by g_object_new() as the	313		// the @constructed function is called by g_object_new() as the
314		//	314		//
315		// final step of the object creation process. At the point of the call, all	315		// final step of the object creation process. At the point of the call, all

@@ -328,7 +328,7 @@ func (x InitiallyUnownedClass) OverrideConstructed(cb func(Object)) {
328		}	328		}
329		}	329		}
330			330
331	-	// GetConstructed gets the callback function.	331	+	// GetConstructed gets the "constructed" callback function.
332		// the @constructed function is called by g_object_new() as the	332		// the @constructed function is called by g_object_new() as the
333		//	333		//
334		// final step of the object creation process. At the point of the call, all	334		// final step of the object creation process. At the point of the call, all

@@ -526,10 +526,10 @@ func (x ObjectClass) InstallProperty(PropertyIdVar uint, PspecVar ParamSpec) {
526			526
527		}	527		}
528			528
529	-	var xObjectClassListProperties func(uintptr, uint) uintptr	529	+	var xObjectClassListProperties func(uintptr, *uint) uintptr
530			530
531		// Get an array of #GParamSpec* for all properties of a class.	531		// Get an array of #GParamSpec* for all properties of a class.
532	-	func (x *ObjectClass) ListProperties(NPropertiesVar uint) uintptr {	532	+	func (x ObjectClass) ListProperties(NPropertiesVar uint) uintptr {
533			533
534		cret := xObjectClassListProperties(x.GoPointer(), NPropertiesVar)	534		cret := xObjectClassListProperties(x.GoPointer(), NPropertiesVar)
535		return cret	535		return cret

@@ -559,7 +559,7 @@ func (x *ObjectClass) OverrideProperty(PropertyIdVar uint, NameVar string) {
559			559
560		}	560		}
561			561
562	-	// OverrideConstructor sets the callback function.	562	+	// OverrideConstructor sets the "constructor" callback function.
563		// the @constructor function is called by g_object_new () to	563		// the @constructor function is called by g_object_new () to
564		//	564		//
565		// complete the object initialization after all the construction properties are	565		// complete the object initialization after all the construction properties are

@@ -580,7 +580,7 @@ func (x ObjectClass) OverrideConstructor(cb func(types.GType, uint, ObjectCons
580		}	580		}
581		}	581		}
582			582
583	-	// GetConstructor gets the callback function.	583	+	// GetConstructor gets the "constructor" callback function.
584		// the @constructor function is called by g_object_new () to	584		// the @constructor function is called by g_object_new () to
585		//	585		//
586		// complete the object initialization after all the construction properties are	586		// complete the object initialization after all the construction properties are

@@ -604,7 +604,7 @@ func (x ObjectClass) GetConstructor() func(types.GType, uint, ObjectConstructP
604		}	604		}
605		}	605		}
606			606
607	-	// OverrideSetProperty sets the callback function.	607	+	// OverrideSetProperty sets the "set_property" callback function.
608		// The type of the @set_property function of #GObjectClass.	608		// The type of the @set_property function of #GObjectClass.
609		func (x ObjectClass) OverrideSetProperty(cb func(Object, uint, Value, ParamSpec)) {	609		func (x ObjectClass) OverrideSetProperty(cb func(Object, uint, Value, ParamSpec)) {
610		if cb == nil {	610		if cb == nil {

@@ -616,7 +616,7 @@ func (x ObjectClass) OverrideSetProperty(cb func(Object, uint, Value, ParamS
616		}	616		}
617		}	617		}
618			618
619	-	// GetSetProperty gets the callback function.	619	+	// GetSetProperty gets the "set_property" callback function.
620		// The type of the @set_property function of #GObjectClass.	620		// The type of the @set_property function of #GObjectClass.
621		func (x ObjectClass) GetSetProperty() func(Object, uint, Value, ParamSpec) {	621		func (x ObjectClass) GetSetProperty() func(Object, uint, Value, ParamSpec) {
622		if x.xSetProperty == 0 {	622		if x.xSetProperty == 0 {

@@ -629,7 +629,7 @@ func (x ObjectClass) GetSetProperty() func(Object, uint, Value, ParamSpec) {
629		}	629		}
630		}	630		}
631			631
632	-	// OverrideGetProperty sets the callback function.	632	+	// OverrideGetProperty sets the "get_property" callback function.
633		// The type of the @get_property function of #GObjectClass.	633		// The type of the @get_property function of #GObjectClass.
634		func (x ObjectClass) OverrideGetProperty(cb func(Object, uint, Value, ParamSpec)) {	634		func (x ObjectClass) OverrideGetProperty(cb func(Object, uint, Value, ParamSpec)) {
635		if cb == nil {	635		if cb == nil {

@@ -641,7 +641,7 @@ func (x ObjectClass) OverrideGetProperty(cb func(Object, uint, Value, ParamS
641		}	641		}
642		}	642		}
643			643
644	-	// GetGetProperty gets the callback function.	644	+	// GetGetProperty gets the "get_property" callback function.
645		// The type of the @get_property function of #GObjectClass.	645		// The type of the @get_property function of #GObjectClass.
646		func (x ObjectClass) GetGetProperty() func(Object, uint, Value, ParamSpec) {	646		func (x ObjectClass) GetGetProperty() func(Object, uint, Value, ParamSpec) {
647		if x.xGetProperty == 0 {	647		if x.xGetProperty == 0 {

@@ -654,7 +654,7 @@ func (x ObjectClass) GetGetProperty() func(Object, uint, Value, ParamSpec) {
654		}	654		}
655		}	655		}
656			656
657	-	// OverrideDispose sets the callback function.	657	+	// OverrideDispose sets the "dispose" callback function.
658		// the @dispose function is supposed to drop all references to other	658		// the @dispose function is supposed to drop all references to other
659		//	659		//
660		// objects, but keep the instance otherwise intact, so that client method	660		// objects, but keep the instance otherwise intact, so that client method

@@ -671,7 +671,7 @@ func (x ObjectClass) OverrideDispose(cb func(Object)) {
671		}	671		}
672		}	672		}
673			673
674	-	// GetDispose gets the callback function.	674	+	// GetDispose gets the "dispose" callback function.
675		// the @dispose function is supposed to drop all references to other	675		// the @dispose function is supposed to drop all references to other
676		//	676		//
677		// objects, but keep the instance otherwise intact, so that client method	677		// objects, but keep the instance otherwise intact, so that client method

@@ -689,7 +689,7 @@ func (x ObjectClass) GetDispose() func(Object) {
689		}	689		}
690		}	690		}
691			691
692	-	// OverrideFinalize sets the callback function.	692	+	// OverrideFinalize sets the "finalize" callback function.
693		// The type of the @finalize function of #GObjectClass.	693		// The type of the @finalize function of #GObjectClass.
694		func (x ObjectClass) OverrideFinalize(cb func(Object)) {	694		func (x ObjectClass) OverrideFinalize(cb func(Object)) {
695		if cb == nil {	695		if cb == nil {

@@ -701,7 +701,7 @@ func (x ObjectClass) OverrideFinalize(cb func(Object)) {
701		}	701		}
702		}	702		}
703			703
704	-	// GetFinalize gets the callback function.	704	+	// GetFinalize gets the "finalize" callback function.
705		// The type of the @finalize function of #GObjectClass.	705		// The type of the @finalize function of #GObjectClass.
706		func (x ObjectClass) GetFinalize() func(Object) {	706		func (x ObjectClass) GetFinalize() func(Object) {
707		if x.xFinalize == 0 {	707		if x.xFinalize == 0 {

@@ -714,7 +714,7 @@ func (x ObjectClass) GetFinalize() func(Object) {
714		}	714		}
715		}	715		}
716			716
717	-	// OverrideDispatchPropertiesChanged sets the callback function.	717	+	// OverrideDispatchPropertiesChanged sets the "dispatch_properties_changed" callback function.
718		// emits property change notification for a bunch	718		// emits property change notification for a bunch
719		//	719		//
720		// of properties. Overriding @dispatch_properties_changed should be rarely	720		// of properties. Overriding @dispatch_properties_changed should be rarely

@@ -729,7 +729,7 @@ func (x ObjectClass) OverrideDispatchPropertiesChanged(cb func(Object, uint, *
729		}	729		}
730		}	730		}
731			731
732	-	// GetDispatchPropertiesChanged gets the callback function.	732	+	// GetDispatchPropertiesChanged gets the "dispatch_properties_changed" callback function.
733		// emits property change notification for a bunch	733		// emits property change notification for a bunch
734		//	734		//
735		// of properties. Overriding @dispatch_properties_changed should be rarely	735		// of properties. Overriding @dispatch_properties_changed should be rarely

@@ -745,7 +745,7 @@ func (x ObjectClass) GetDispatchPropertiesChanged() func(Object, uint, **Param
745		}	745		}
746		}	746		}
747			747
748	-	// OverrideNotify sets the callback function.	748	+	// OverrideNotify sets the "notify" callback function.
749		// the class closure for the notify signal	749		// the class closure for the notify signal
750		func (x ObjectClass) OverrideNotify(cb func(Object, *ParamSpec)) {	750		func (x ObjectClass) OverrideNotify(cb func(Object, *ParamSpec)) {
751		if cb == nil {	751		if cb == nil {

@@ -757,7 +757,7 @@ func (x ObjectClass) OverrideNotify(cb func(Object, *ParamSpec)) {
757		}	757		}
758		}	758		}
759			759
760	-	// GetNotify gets the callback function.	760	+	// GetNotify gets the "notify" callback function.
761		// the class closure for the notify signal	761		// the class closure for the notify signal
762		func (x ObjectClass) GetNotify() func(Object, *ParamSpec) {	762		func (x ObjectClass) GetNotify() func(Object, *ParamSpec) {
763		if x.xNotify == 0 {	763		if x.xNotify == 0 {

@@ -770,7 +770,7 @@ func (x ObjectClass) GetNotify() func(Object, *ParamSpec) {
770		}	770		}
771		}	771		}
772			772
773	-	// OverrideConstructed sets the callback function.	773	+	// OverrideConstructed sets the "constructed" callback function.
774		// the @constructed function is called by g_object_new() as the	774		// the @constructed function is called by g_object_new() as the
775		//	775		//
776		// final step of the object creation process. At the point of the call, all	776		// final step of the object creation process. At the point of the call, all

@@ -789,7 +789,7 @@ func (x ObjectClass) OverrideConstructed(cb func(Object)) {
789		}	789		}
790		}	790		}
791			791
792	-	// GetConstructed gets the callback function.	792	+	// GetConstructed gets the "constructed" callback function.
793		// the @constructed function is called by g_object_new() as the	793		// the @constructed function is called by g_object_new() as the
794		//	794		//
795		// final step of the object creation process. At the point of the call, all	795		// final step of the object creation process. At the point of the call, all

@@ -1718,7 +1718,7 @@ func (x *Object) RemoveWeakPointer(WeakPointerLocationVar uintptr) {
1718			1718
1719		}	1719		}
1720			1720
1721	-	var xObjectReplaceData func(uintptr, string, uintptr, uintptr, uintptr, uintptr) bool	1721	+	var xObjectReplaceData func(uintptr, string, uintptr, uintptr, uintptr, *glib.DestroyNotify) bool
1722			1722
1723		// Compares the user data for the key @key on @object with	1723		// Compares the user data for the key @key on @object with
1724		// @oldval, and if they are the same, replaces @oldval with	1724		// @oldval, and if they are the same, replaces @oldval with

@@ -1738,11 +1738,11 @@ var xObjectReplaceData func(uintptr, string, uintptr, uintptr, uintptr, uintptr)
1738		// for @key.	1738		// for @key.
1739		func (x Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {	1739		func (x Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
1740			1740
1741	-	cret := xObjectReplaceData(x.GoPointer(), KeyVar, OldvalVar, NewvalVar, glib.NewCallbackNullable(DestroyVar), glib.NewCallback(OldDestroyVar))	1741	+	cret := xObjectReplaceData(x.GoPointer(), KeyVar, OldvalVar, NewvalVar, glib.NewCallbackNullable(DestroyVar), OldDestroyVar)
1742		return cret	1742		return cret
1743		}	1743		}
1744			1744
1745	-	var xObjectReplaceQdata func(uintptr, glib.Quark, uintptr, uintptr, uintptr, uintptr) bool	1745	+	var xObjectReplaceQdata func(uintptr, glib.Quark, uintptr, uintptr, uintptr, *glib.DestroyNotify) bool
1746			1746
1747		// Compares the user data for the key @quark on @object with	1747		// Compares the user data for the key @quark on @object with
1748		// @oldval, and if they are the same, replaces @oldval with	1748		// @oldval, and if they are the same, replaces @oldval with

@@ -1759,7 +1759,7 @@ var xObjectReplaceQdata func(uintptr, glib.Quark, uintptr, uintptr, uintptr, uin
1759		// should not destroy the object in the normal way.	1759		// should not destroy the object in the normal way.
1760		func (x Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {	1760		func (x Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
1761			1761
1762	-	cret := xObjectReplaceQdata(x.GoPointer(), QuarkVar, OldvalVar, NewvalVar, glib.NewCallbackNullable(DestroyVar), glib.NewCallback(OldDestroyVar))	1762	+	cret := xObjectReplaceQdata(x.GoPointer(), QuarkVar, OldvalVar, NewvalVar, glib.NewCallbackNullable(DestroyVar), OldDestroyVar)
1763		return cret	1763		return cret
1764		}	1764		}
1765			1765

@@ -2177,13 +2177,13 @@ func ObjectInterfaceInstallProperty(GIfaceVar TypeInterface, PspecVar ParamSpe
2177			2177
2178		}	2178		}
2179			2179
2180	-	var xObjectInterfaceListProperties func(*TypeInterface, uint) uintptr	2180	+	var xObjectInterfaceListProperties func(TypeInterface, uint) uintptr
2181			2181
2182		// Lists the properties of an interface.Generally, the interface	2182		// Lists the properties of an interface.Generally, the interface
2183		// vtable passed in as @g_iface will be the default vtable from	2183		// vtable passed in as @g_iface will be the default vtable from
2184		// g_type_default_interface_ref(), or, if you know the interface has	2184		// g_type_default_interface_ref(), or, if you know the interface has
2185		// already been loaded, g_type_default_interface_peek().	2185		// already been loaded, g_type_default_interface_peek().
2186	-	func ObjectInterfaceListProperties(GIfaceVar *TypeInterface, NPropertiesPVar uint) uintptr {	2186	+	func ObjectInterfaceListProperties(GIfaceVar TypeInterface, NPropertiesPVar uint) uintptr {
2187			2187
2188		cret := xObjectInterfaceListProperties(GIfaceVar, NPropertiesPVar)	2188		cret := xObjectInterfaceListProperties(GIfaceVar, NPropertiesPVar)
2189		return cret	2189		return cret

M v4/gobject/gparam.go +22 -22


@@ -38,7 +38,7 @@ func (x *ParamSpecClass) GoPointer() uintptr {
38		return uintptr(unsafe.Pointer(x))	38		return uintptr(unsafe.Pointer(x))
39		}	39		}
40			40
41	-	// OverrideFinalize sets the callback function.	41	+	// OverrideFinalize sets the "finalize" callback function.
42		// The instance finalization function (optional), should chain	42		// The instance finalization function (optional), should chain
43		//	43		//
44		// up to the finalize method of the parent class.	44		// up to the finalize method of the parent class.

@@ -52,7 +52,7 @@ func (x ParamSpecClass) OverrideFinalize(cb func(ParamSpec)) {
52		}	52		}
53		}	53		}
54			54
55	-	// GetFinalize gets the callback function.	55	+	// GetFinalize gets the "finalize" callback function.
56		// The instance finalization function (optional), should chain	56		// The instance finalization function (optional), should chain
57		//	57		//
58		// up to the finalize method of the parent class.	58		// up to the finalize method of the parent class.

@@ -67,7 +67,7 @@ func (x ParamSpecClass) GetFinalize() func(ParamSpec) {
67		}	67		}
68		}	68		}
69			69
70	-	// OverrideValueSetDefault sets the callback function.	70	+	// OverrideValueSetDefault sets the "value_set_default" callback function.
71		// Resets a @value to the default value for this type	71		// Resets a @value to the default value for this type
72		//	72		//
73		// (recommended, the default is g_value_reset()), see	73		// (recommended, the default is g_value_reset()), see

@@ -82,7 +82,7 @@ func (x ParamSpecClass) OverrideValueSetDefault(cb func(ParamSpec, *Value)) {
82		}	82		}
83		}	83		}
84			84
85	-	// GetValueSetDefault gets the callback function.	85	+	// GetValueSetDefault gets the "value_set_default" callback function.
86		// Resets a @value to the default value for this type	86		// Resets a @value to the default value for this type
87		//	87		//
88		// (recommended, the default is g_value_reset()), see	88		// (recommended, the default is g_value_reset()), see

@@ -98,7 +98,7 @@ func (x ParamSpecClass) GetValueSetDefault() func(ParamSpec, *Value) {
98		}	98		}
99		}	99		}
100			100
101	-	// OverrideValueValidate sets the callback function.	101	+	// OverrideValueValidate sets the "value_validate" callback function.
102		// Ensures that the contents of @value comply with the	102		// Ensures that the contents of @value comply with the
103		//	103		//
104		// specifications set out by this type (optional), see	104		// specifications set out by this type (optional), see

@@ -113,7 +113,7 @@ func (x ParamSpecClass) OverrideValueValidate(cb func(ParamSpec, *Value) bool)
113		}	113		}
114		}	114		}
115			115
116	-	// GetValueValidate gets the callback function.	116	+	// GetValueValidate gets the "value_validate" callback function.
117		// Ensures that the contents of @value comply with the	117		// Ensures that the contents of @value comply with the
118		//	118		//
119		// specifications set out by this type (optional), see	119		// specifications set out by this type (optional), see

@@ -129,7 +129,7 @@ func (x ParamSpecClass) GetValueValidate() func(ParamSpec, *Value) bool {
129		}	129		}
130		}	130		}
131			131
132	-	// OverrideValuesCmp sets the callback function.	132	+	// OverrideValuesCmp sets the "values_cmp" callback function.
133		// Compares @value1 with @value2 according to this type	133		// Compares @value1 with @value2 according to this type
134		//	134		//
135		// (recommended, the default is memcmp()), see g_param_values_cmp().	135		// (recommended, the default is memcmp()), see g_param_values_cmp().

@@ -143,7 +143,7 @@ func (x ParamSpecClass) OverrideValuesCmp(cb func(ParamSpec, Value, Value) i
143		}	143		}
144		}	144		}
145			145
146	-	// GetValuesCmp gets the callback function.	146	+	// GetValuesCmp gets the "values_cmp" callback function.
147		// Compares @value1 with @value2 according to this type	147		// Compares @value1 with @value2 according to this type
148		//	148		//
149		// (recommended, the default is memcmp()), see g_param_values_cmp().	149		// (recommended, the default is memcmp()), see g_param_values_cmp().

@@ -158,7 +158,7 @@ func (x ParamSpecClass) GetValuesCmp() func(ParamSpec, Value, Value) int {
158		}	158		}
159		}	159		}
160			160
161	-	// OverrideValueIsValid sets the callback function.	161	+	// OverrideValueIsValid sets the "value_is_valid" callback function.
162		// Checks if contents of @value comply with the specifications	162		// Checks if contents of @value comply with the specifications
163		//	163		//
164		// set out by this type, without modifying the value. This vfunc is optional.	164		// set out by this type, without modifying the value. This vfunc is optional.

@@ -173,7 +173,7 @@ func (x ParamSpecClass) OverrideValueIsValid(cb func(ParamSpec, *Value) bool)
173		}	173		}
174		}	174		}
175			175
176	-	// GetValueIsValid gets the callback function.	176	+	// GetValueIsValid gets the "value_is_valid" callback function.
177		// Checks if contents of @value comply with the specifications	177		// Checks if contents of @value comply with the specifications
178		//	178		//
179		// set out by this type, without modifying the value. This vfunc is optional.	179		// set out by this type, without modifying the value. This vfunc is optional.

@@ -220,11 +220,11 @@ func (x ParamSpecPool) Insert(PspecVar ParamSpec, OwnerTypeVar types.GType) {
220			220
221		}	221		}
222			222
223	-	var xParamSpecPoolList func(uintptr, types.GType, uint) uintptr	223	+	var xParamSpecPoolList func(uintptr, types.GType, *uint) uintptr
224			224
225		// Gets an array of all #GParamSpecs owned by @owner_type in	225		// Gets an array of all #GParamSpecs owned by @owner_type in
226		// the pool.	226		// the pool.
227	-	func (x *ParamSpecPool) List(OwnerTypeVar types.GType, NPspecsPVar uint) uintptr {	227	+	func (x ParamSpecPool) List(OwnerTypeVar types.GType, NPspecsPVar uint) uintptr {
228			228
229		cret := xParamSpecPoolList(x.GoPointer(), OwnerTypeVar, NPspecsPVar)	229		cret := xParamSpecPoolList(x.GoPointer(), OwnerTypeVar, NPspecsPVar)
230		return cret	230		return cret

@@ -298,7 +298,7 @@ func (x *ParamSpecTypeInfo) GoPointer() uintptr {
298		return uintptr(unsafe.Pointer(x))	298		return uintptr(unsafe.Pointer(x))
299		}	299		}
300			300
301	-	// OverrideInstanceInit sets the callback function.	301	+	// OverrideInstanceInit sets the "instance_init" callback function.
302		// Location of the instance initialization function (optional).	302		// Location of the instance initialization function (optional).
303		func (x ParamSpecTypeInfo) OverrideInstanceInit(cb func(ParamSpec)) {	303		func (x ParamSpecTypeInfo) OverrideInstanceInit(cb func(ParamSpec)) {
304		if cb == nil {	304		if cb == nil {

@@ -310,7 +310,7 @@ func (x ParamSpecTypeInfo) OverrideInstanceInit(cb func(ParamSpec)) {
310		}	310		}
311		}	311		}
312			312
313	-	// GetInstanceInit gets the callback function.	313	+	// GetInstanceInit gets the "instance_init" callback function.
314		// Location of the instance initialization function (optional).	314		// Location of the instance initialization function (optional).
315		func (x ParamSpecTypeInfo) GetInstanceInit() func(ParamSpec) {	315		func (x ParamSpecTypeInfo) GetInstanceInit() func(ParamSpec) {
316		if x.xInstanceInit == 0 {	316		if x.xInstanceInit == 0 {

@@ -323,7 +323,7 @@ func (x ParamSpecTypeInfo) GetInstanceInit() func(ParamSpec) {
323		}	323		}
324		}	324		}
325			325
326	-	// OverrideFinalize sets the callback function.	326	+	// OverrideFinalize sets the "finalize" callback function.
327		// The instance finalization function (optional).	327		// The instance finalization function (optional).
328		func (x ParamSpecTypeInfo) OverrideFinalize(cb func(ParamSpec)) {	328		func (x ParamSpecTypeInfo) OverrideFinalize(cb func(ParamSpec)) {
329		if cb == nil {	329		if cb == nil {

@@ -335,7 +335,7 @@ func (x ParamSpecTypeInfo) OverrideFinalize(cb func(ParamSpec)) {
335		}	335		}
336		}	336		}
337			337
338	-	// GetFinalize gets the callback function.	338	+	// GetFinalize gets the "finalize" callback function.
339		// The instance finalization function (optional).	339		// The instance finalization function (optional).
340		func (x ParamSpecTypeInfo) GetFinalize() func(ParamSpec) {	340		func (x ParamSpecTypeInfo) GetFinalize() func(ParamSpec) {
341		if x.xFinalize == 0 {	341		if x.xFinalize == 0 {

@@ -348,7 +348,7 @@ func (x ParamSpecTypeInfo) GetFinalize() func(ParamSpec) {
348		}	348		}
349		}	349		}
350			350
351	-	// OverrideValueSetDefault sets the callback function.	351	+	// OverrideValueSetDefault sets the "value_set_default" callback function.
352		// Resets a @value to the default value for @pspec	352		// Resets a @value to the default value for @pspec
353		//	353		//
354		// (recommended, the default is g_value_reset()), see	354		// (recommended, the default is g_value_reset()), see

@@ -363,7 +363,7 @@ func (x ParamSpecTypeInfo) OverrideValueSetDefault(cb func(ParamSpec, *Value))
363		}	363		}
364		}	364		}
365			365
366	-	// GetValueSetDefault gets the callback function.	366	+	// GetValueSetDefault gets the "value_set_default" callback function.
367		// Resets a @value to the default value for @pspec	367		// Resets a @value to the default value for @pspec
368		//	368		//
369		// (recommended, the default is g_value_reset()), see	369		// (recommended, the default is g_value_reset()), see

@@ -379,7 +379,7 @@ func (x ParamSpecTypeInfo) GetValueSetDefault() func(ParamSpec, *Value) {
379		}	379		}
380		}	380		}
381			381
382	-	// OverrideValueValidate sets the callback function.	382	+	// OverrideValueValidate sets the "value_validate" callback function.
383		// Ensures that the contents of @value comply with the	383		// Ensures that the contents of @value comply with the
384		//	384		//
385		// specifications set out by @pspec (optional), see	385		// specifications set out by @pspec (optional), see

@@ -394,7 +394,7 @@ func (x ParamSpecTypeInfo) OverrideValueValidate(cb func(ParamSpec, *Value) bo
394		}	394		}
395		}	395		}
396			396
397	-	// GetValueValidate gets the callback function.	397	+	// GetValueValidate gets the "value_validate" callback function.
398		// Ensures that the contents of @value comply with the	398		// Ensures that the contents of @value comply with the
399		//	399		//
400		// specifications set out by @pspec (optional), see	400		// specifications set out by @pspec (optional), see

@@ -410,7 +410,7 @@ func (x ParamSpecTypeInfo) GetValueValidate() func(ParamSpec, *Value) bool {
410		}	410		}
411		}	411		}
412			412
413	-	// OverrideValuesCmp sets the callback function.	413	+	// OverrideValuesCmp sets the "values_cmp" callback function.
414		// Compares @value1 with @value2 according to @pspec	414		// Compares @value1 with @value2 according to @pspec
415		//	415		//
416		// (recommended, the default is memcmp()), see g_param_values_cmp().	416		// (recommended, the default is memcmp()), see g_param_values_cmp().

@@ -424,7 +424,7 @@ func (x ParamSpecTypeInfo) OverrideValuesCmp(cb func(ParamSpec, Value, Value
424		}	424		}
425		}	425		}
426			426
427	-	// GetValuesCmp gets the callback function.	427	+	// GetValuesCmp gets the "values_cmp" callback function.
428		// Compares @value1 with @value2 according to @pspec	428		// Compares @value1 with @value2 according to @pspec
429		//	429		//
430		// (recommended, the default is memcmp()), see g_param_values_cmp().	430		// (recommended, the default is memcmp()), see g_param_values_cmp().

M v4/gobject/gsignal.go +4 -4


@@ -565,12 +565,12 @@ func SignalIsValidName(NameVar string) bool {
565		return cret	565		return cret
566		}	566		}
567			567
568	-	var xSignalListIds func(types.GType, uint) uintptr	568	+	var xSignalListIds func(types.GType, *uint) uintptr
569			569
570		// Lists the signals by id that a certain instance or interface type	570		// Lists the signals by id that a certain instance or interface type
571		// created. Further information about the signals can be acquired through	571		// created. Further information about the signals can be acquired through
572		// g_signal_query().	572		// g_signal_query().
573	-	func SignalListIds(ItypeVar types.GType, NIdsVar uint) uintptr {	573	+	func SignalListIds(ItypeVar types.GType, NIdsVar *uint) uintptr {
574			574
575		cret := xSignalListIds(ItypeVar, NIdsVar)	575		cret := xSignalListIds(ItypeVar, NIdsVar)
576		return cret	576		return cret

@@ -721,11 +721,11 @@ func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar types.GTyp
721			721
722		}	722		}
723			723
724	-	var xSignalParseName func(string, types.GType, uint, *glib.Quark, bool) bool	724	+	var xSignalParseName func(string, types.GType, uint, glib.Quark, bool) bool
725			725
726		// Internal function to parse a signal name into its @signal_id	726		// Internal function to parse a signal name into its @signal_id
727		// and @detail quark.	727		// and @detail quark.
728	-	func SignalParseName(DetailedSignalVar string, ItypeVar types.GType, SignalIdPVar uint, DetailPVar *glib.Quark, ForceDetailQuarkVar bool) bool {	728	+	func SignalParseName(DetailedSignalVar string, ItypeVar types.GType, SignalIdPVar uint, DetailPVar glib.Quark, ForceDetailQuarkVar bool) bool {
729			729
730		cret := xSignalParseName(DetailedSignalVar, ItypeVar, SignalIdPVar, DetailPVar, ForceDetailQuarkVar)	730		cret := xSignalParseName(DetailedSignalVar, ItypeVar, SignalIdPVar, DetailPVar, ForceDetailQuarkVar)
731		return cret	731		return cret

M v4/gobject/gtype.go +6 -6


@@ -953,11 +953,11 @@ func TypeCheckValueHolds(ValueVar *Value, TypeVar types.GType) bool {
953		return cret	953		return cret
954		}	954		}
955			955
956	-	var xTypeChildren func(types.GType, uint) uintptr	956	+	var xTypeChildren func(types.GType, *uint) uintptr
957			957
958		// Return a newly allocated and 0-terminated array of type IDs, listing	958		// Return a newly allocated and 0-terminated array of type IDs, listing
959		// the child types of @type.	959		// the child types of @type.
960	-	func TypeChildren(TypeVar types.GType, NChildrenVar uint) uintptr {	960	+	func TypeChildren(TypeVar types.GType, NChildrenVar *uint) uintptr {
961			961
962		cret := xTypeChildren(TypeVar, NChildrenVar)	962		cret := xTypeChildren(TypeVar, NChildrenVar)
963		return cret	963		return cret

@@ -1313,20 +1313,20 @@ func TypeInterfacePeek(InstanceClassVar TypeClass, IfaceTypeVar types.GType) T
1313		return cret	1313		return cret
1314		}	1314		}
1315			1315
1316	-	var xTypeInterfacePrerequisites func(types.GType, uint) uintptr	1316	+	var xTypeInterfacePrerequisites func(types.GType, *uint) uintptr
1317			1317
1318		// Returns the prerequisites of an interfaces type.	1318		// Returns the prerequisites of an interfaces type.
1319	-	func TypeInterfacePrerequisites(InterfaceTypeVar types.GType, NPrerequisitesVar uint) uintptr {	1319	+	func TypeInterfacePrerequisites(InterfaceTypeVar types.GType, NPrerequisitesVar *uint) uintptr {
1320			1320
1321		cret := xTypeInterfacePrerequisites(InterfaceTypeVar, NPrerequisitesVar)	1321		cret := xTypeInterfacePrerequisites(InterfaceTypeVar, NPrerequisitesVar)
1322		return cret	1322		return cret
1323		}	1323		}
1324			1324
1325	-	var xTypeInterfaces func(types.GType, uint) uintptr	1325	+	var xTypeInterfaces func(types.GType, *uint) uintptr
1326			1326
1327		// Return a newly allocated and 0-terminated array of type IDs, listing	1327		// Return a newly allocated and 0-terminated array of type IDs, listing
1328		// the interface types that @type conforms to.	1328		// the interface types that @type conforms to.
1329	-	func TypeInterfaces(TypeVar types.GType, NInterfacesVar uint) uintptr {	1329	+	func TypeInterfaces(TypeVar types.GType, NInterfacesVar *uint) uintptr {
1330			1330
1331		cret := xTypeInterfaces(TypeVar, NInterfacesVar)	1331		cret := xTypeInterfaces(TypeVar, NInterfacesVar)
1332		return cret	1332		return cret

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


@@ -34,7 +34,7 @@ func (x *TypeModuleClass) GoPointer() uintptr {
34		return uintptr(unsafe.Pointer(x))	34		return uintptr(unsafe.Pointer(x))
35		}	35		}
36			36
37	-	// OverrideLoad sets the callback function.	37	+	// OverrideLoad sets the "load" callback function.
38		// loads the module and registers one or more types using	38		// loads the module and registers one or more types using
39		//	39		//
40		// g_type_module_register_type().	40		// g_type_module_register_type().

@@ -48,7 +48,7 @@ func (x TypeModuleClass) OverrideLoad(cb func(TypeModule) bool) {
48		}	48		}
49		}	49		}
50			50
51	-	// GetLoad gets the callback function.	51	+	// GetLoad gets the "load" callback function.
52		// loads the module and registers one or more types using	52		// loads the module and registers one or more types using
53		//	53		//
54		// g_type_module_register_type().	54		// g_type_module_register_type().

@@ -63,7 +63,7 @@ func (x TypeModuleClass) GetLoad() func(TypeModule) bool {
63		}	63		}
64		}	64		}
65			65
66	-	// OverrideUnload sets the callback function.	66	+	// OverrideUnload sets the "unload" callback function.
67		// unloads the module	67		// unloads the module
68		func (x TypeModuleClass) OverrideUnload(cb func(TypeModule)) {	68		func (x TypeModuleClass) OverrideUnload(cb func(TypeModule)) {
69		if cb == nil {	69		if cb == nil {

@@ -75,7 +75,7 @@ func (x TypeModuleClass) OverrideUnload(cb func(TypeModule)) {
75		}	75		}
76		}	76		}
77			77
78	-	// GetUnload gets the callback function.	78	+	// GetUnload gets the "unload" callback function.
79		// unloads the module	79		// unloads the module
80		func (x TypeModuleClass) GetUnload() func(TypeModule) {	80		func (x TypeModuleClass) GetUnload() func(TypeModule) {
81		if x.xUnload == 0 {	81		if x.xUnload == 0 {

@@ -88,7 +88,7 @@ func (x TypeModuleClass) GetUnload() func(TypeModule) {
88		}	88		}
89		}	89		}
90			90
91	-	// OverrideReserved1 sets the callback function.	91	+	// OverrideReserved1 sets the "reserved1" callback function.
92		func (x *TypeModuleClass) OverrideReserved1(cb func()) {	92		func (x *TypeModuleClass) OverrideReserved1(cb func()) {
93		if cb == nil {	93		if cb == nil {
94		x.xReserved1 = 0	94		x.xReserved1 = 0

@@ -99,7 +99,7 @@ func (x *TypeModuleClass) OverrideReserved1(cb func()) {
99		}	99		}
100		}	100		}
101			101
102	-	// GetReserved1 gets the callback function.	102	+	// GetReserved1 gets the "reserved1" callback function.
103		func (x *TypeModuleClass) GetReserved1() func() {	103		func (x *TypeModuleClass) GetReserved1() func() {
104		if x.xReserved1 == 0 {	104		if x.xReserved1 == 0 {
105		return nil	105		return nil

@@ -111,7 +111,7 @@ func (x *TypeModuleClass) GetReserved1() func() {
111		}	111		}
112		}	112		}
113			113
114	-	// OverrideReserved2 sets the callback function.	114	+	// OverrideReserved2 sets the "reserved2" callback function.
115		func (x *TypeModuleClass) OverrideReserved2(cb func()) {	115		func (x *TypeModuleClass) OverrideReserved2(cb func()) {
116		if cb == nil {	116		if cb == nil {
117		x.xReserved2 = 0	117		x.xReserved2 = 0

@@ -122,7 +122,7 @@ func (x *TypeModuleClass) OverrideReserved2(cb func()) {
122		}	122		}
123		}	123		}
124			124
125	-	// GetReserved2 gets the callback function.	125	+	// GetReserved2 gets the "reserved2" callback function.
126		func (x *TypeModuleClass) GetReserved2() func() {	126		func (x *TypeModuleClass) GetReserved2() func() {
127		if x.xReserved2 == 0 {	127		if x.xReserved2 == 0 {
128		return nil	128		return nil

@@ -134,7 +134,7 @@ func (x *TypeModuleClass) GetReserved2() func() {
134		}	134		}
135		}	135		}
136			136
137	-	// OverrideReserved3 sets the callback function.	137	+	// OverrideReserved3 sets the "reserved3" callback function.
138		func (x *TypeModuleClass) OverrideReserved3(cb func()) {	138		func (x *TypeModuleClass) OverrideReserved3(cb func()) {
139		if cb == nil {	139		if cb == nil {
140		x.xReserved3 = 0	140		x.xReserved3 = 0

@@ -145,7 +145,7 @@ func (x *TypeModuleClass) OverrideReserved3(cb func()) {
145		}	145		}
146		}	146		}
147			147
148	-	// GetReserved3 gets the callback function.	148	+	// GetReserved3 gets the "reserved3" callback function.
149		func (x *TypeModuleClass) GetReserved3() func() {	149		func (x *TypeModuleClass) GetReserved3() func() {
150		if x.xReserved3 == 0 {	150		if x.xReserved3 == 0 {
151		return nil	151		return nil

@@ -157,7 +157,7 @@ func (x *TypeModuleClass) GetReserved3() func() {
157		}	157		}
158		}	158		}
159			159
160	-	// OverrideReserved4 sets the callback function.	160	+	// OverrideReserved4 sets the "reserved4" callback function.
161		func (x *TypeModuleClass) OverrideReserved4(cb func()) {	161		func (x *TypeModuleClass) OverrideReserved4(cb func()) {
162		if cb == nil {	162		if cb == nil {
163		x.xReserved4 = 0	163		x.xReserved4 = 0

@@ -168,7 +168,7 @@ func (x *TypeModuleClass) OverrideReserved4(cb func()) {
168		}	168		}
169		}	169		}
170			170
171	-	// GetReserved4 gets the callback function.	171	+	// GetReserved4 gets the "reserved4" callback function.
172		func (x *TypeModuleClass) GetReserved4() func() {	172		func (x *TypeModuleClass) GetReserved4() func() {
173		if x.xReserved4 == 0 {	173		if x.xReserved4 == 0 {
174		return nil	174		return nil

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


@@ -176,10 +176,10 @@ func (x Box) GetSize(SizeVar Vec3) {
176			176
177		}	177		}
178			178
179	-	var xBoxGetVertices func(uintptr, [8]Vec3)	179	+	var xBoxGetVertices func(uintptr, *[8]Vec3)
180			180
181		// Computes the vertices of the given #graphene_box_t.	181		// Computes the vertices of the given #graphene_box_t.
182	-	func (x *Box) GetVertices(VerticesVar [8]Vec3) {	182	+	func (x Box) GetVertices(VerticesVar [8]Vec3) {
183			183
184		xBoxGetVertices(x.GoPointer(), VerticesVar)	184		xBoxGetVertices(x.GoPointer(), VerticesVar)
185			185

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


@@ -69,10 +69,10 @@ func (x *Frustum) Free() {
69			69
70		}	70		}
71			71
72	-	var xFrustumGetPlanes func(uintptr, [6]Plane)	72	+	var xFrustumGetPlanes func(uintptr, *[6]Plane)
73			73
74		// Retrieves the planes that define the given #graphene_frustum_t.	74		// Retrieves the planes that define the given #graphene_frustum_t.
75	-	func (x *Frustum) GetPlanes(PlanesVar [6]Plane) {	75	+	func (x Frustum) GetPlanes(PlanesVar [6]Plane) {
76			76
77		xFrustumGetPlanes(x.GoPointer(), PlanesVar)	77		xFrustumGetPlanes(x.GoPointer(), PlanesVar)
78			78

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


@@ -597,7 +597,7 @@ func (x *Matrix) SkewYz(FactorVar float32) {
597			597
598		}	598		}
599			599
600	-	var xMatrixTo2d func(uintptr, float64, float64, float64, float64, float64, float64) bool	600	+	var xMatrixTo2d func(uintptr, float64, float64, float64, float64, float64, float64) bool
601			601
602		// Converts a #graphene_matrix_t to an affine transformation	602		// Converts a #graphene_matrix_t to an affine transformation
603		// matrix, if the given matrix is compatible.	603		// matrix, if the given matrix is compatible.

@@ -614,17 +614,17 @@ var xMatrixTo2d func(uintptr, float64, float64, float64, float64, float64, float
614		//	614		//
615		// This function can be used to convert between a #graphene_matrix_t	615		// This function can be used to convert between a #graphene_matrix_t
616		// and an affine matrix type from other libraries.	616		// and an affine matrix type from other libraries.
617	-	func (x *Matrix) To2d(XxVar float64, YxVar float64, XyVar float64, YyVar float64, X0Var float64, Y0Var float64) bool {	617	+	func (x Matrix) To2d(XxVar float64, YxVar float64, XyVar float64, YyVar float64, X0Var float64, Y0Var *float64) bool {
618			618
619		cret := xMatrixTo2d(x.GoPointer(), XxVar, YxVar, XyVar, YyVar, X0Var, Y0Var)	619		cret := xMatrixTo2d(x.GoPointer(), XxVar, YxVar, XyVar, YyVar, X0Var, Y0Var)
620		return cret	620		return cret
621		}	621		}
622			622
623	-	var xMatrixToFloat func(uintptr, [16]float32)	623	+	var xMatrixToFloat func(uintptr, *[16]float32)
624			624
625		// Converts a #graphene_matrix_t to an array of floating point	625		// Converts a #graphene_matrix_t to an array of floating point
626		// values.	626		// values.
627	-	func (x *Matrix) ToFloat(VVar [16]float32) {	627	+	func (x Matrix) ToFloat(VVar [16]float32) {
628			628
629		xMatrixToFloat(x.GoPointer(), VVar)	629		xMatrixToFloat(x.GoPointer(), VVar)
630			630

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


@@ -59,10 +59,10 @@ func PointAlloc() *Point {
59		return cret	59		return cret
60		}	60		}
61			61
62	-	var xPointDistance func(uintptr, *Point, float32, float32) float32	62	+	var xPointDistance func(uintptr, Point, float32, *float32) float32
63			63
64		// Computes the distance between @a and @b.	64		// Computes the distance between @a and @b.
65	-	func (x Point) Distance(BVar Point, DXVar float32, DYVar float32) float32 {	65	+	func (x Point) Distance(BVar Point, DXVar float32, DYVar float32) float32 {
66			66
67		cret := xPointDistance(x.GoPointer(), BVar, DXVar, DYVar)	67		cret := xPointDistance(x.GoPointer(), BVar, DXVar, DYVar)
68		return cret	68		return cret

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


@@ -224,21 +224,21 @@ func (x Quaternion) Slerp(BVar Quaternion, FactorVar float32, ResVar *Quaterni
224			224
225		}	225		}
226			226
227	-	var xQuaternionToAngleVec3 func(uintptr, float32, *Vec3)	227	+	var xQuaternionToAngleVec3 func(uintptr, float32, Vec3)
228			228
229		// Converts a quaternion into an @angle, @axis pair.	229		// Converts a quaternion into an @angle, @axis pair.
230	-	func (x Quaternion) ToAngleVec3(AngleVar float32, AxisVar Vec3) {	230	+	func (x Quaternion) ToAngleVec3(AngleVar float32, AxisVar *Vec3) {
231			231
232		xQuaternionToAngleVec3(x.GoPointer(), AngleVar, AxisVar)	232		xQuaternionToAngleVec3(x.GoPointer(), AngleVar, AxisVar)
233			233
234		}	234		}
235			235
236	-	var xQuaternionToAngles func(uintptr, float32, float32, float32)	236	+	var xQuaternionToAngles func(uintptr, float32, float32, *float32)
237			237
238		// Converts a #graphene_quaternion_t to its corresponding rotations	238		// Converts a #graphene_quaternion_t to its corresponding rotations
239		// on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)	239		// on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
240		// on each axis.	240		// on each axis.
241	-	func (x *Quaternion) ToAngles(DegXVar float32, DegYVar float32, DegZVar float32) {	241	+	func (x Quaternion) ToAngles(DegXVar float32, DegYVar float32, DegZVar float32) {
242			242
243		xQuaternionToAngles(x.GoPointer(), DegXVar, DegYVar, DegZVar)	243		xQuaternionToAngles(x.GoPointer(), DegXVar, DegYVar, DegZVar)
244			244

@@ -254,12 +254,12 @@ func (x Quaternion) ToMatrix(MVar Matrix) {
254			254
255		}	255		}
256			256
257	-	var xQuaternionToRadians func(uintptr, float32, float32, float32)	257	+	var xQuaternionToRadians func(uintptr, float32, float32, *float32)
258			258
259		// Converts a #graphene_quaternion_t to its corresponding rotations	259		// Converts a #graphene_quaternion_t to its corresponding rotations
260		// on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)	260		// on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
261		// on each axis.	261		// on each axis.
262	-	func (x *Quaternion) ToRadians(RadXVar float32, RadYVar float32, RadZVar float32) {	262	+	func (x Quaternion) ToRadians(RadXVar float32, RadYVar float32, RadZVar float32) {
263			263
264		xQuaternionToRadians(x.GoPointer(), RadXVar, RadYVar, RadZVar)	264		xQuaternionToRadians(x.GoPointer(), RadXVar, RadYVar, RadZVar)
265			265

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


@@ -154,31 +154,31 @@ func (x Ray) InitFromVec3(OriginVar Vec3, DirectionVar Vec3) Ray {
154		return cret	154		return cret
155		}	155		}
156			156
157	-	var xRayIntersectBox func(uintptr, *Box, float32) RayIntersectionKind	157	+	var xRayIntersectBox func(uintptr, Box, float32) RayIntersectionKind
158			158
159		// Intersects the given #graphene_ray_t @r with the given	159		// Intersects the given #graphene_ray_t @r with the given
160		// #graphene_box_t @b.	160		// #graphene_box_t @b.
161	-	func (x Ray) IntersectBox(BVar Box, TOutVar float32) RayIntersectionKind {	161	+	func (x Ray) IntersectBox(BVar Box, TOutVar *float32) RayIntersectionKind {
162			162
163		cret := xRayIntersectBox(x.GoPointer(), BVar, TOutVar)	163		cret := xRayIntersectBox(x.GoPointer(), BVar, TOutVar)
164		return cret	164		return cret
165		}	165		}
166			166
167	-	var xRayIntersectSphere func(uintptr, *Sphere, float32) RayIntersectionKind	167	+	var xRayIntersectSphere func(uintptr, Sphere, float32) RayIntersectionKind
168			168
169		// Intersects the given #graphene_ray_t @r with the given	169		// Intersects the given #graphene_ray_t @r with the given
170		// #graphene_sphere_t @s.	170		// #graphene_sphere_t @s.
171	-	func (x Ray) IntersectSphere(SVar Sphere, TOutVar float32) RayIntersectionKind {	171	+	func (x Ray) IntersectSphere(SVar Sphere, TOutVar *float32) RayIntersectionKind {
172			172
173		cret := xRayIntersectSphere(x.GoPointer(), SVar, TOutVar)	173		cret := xRayIntersectSphere(x.GoPointer(), SVar, TOutVar)
174		return cret	174		return cret
175		}	175		}
176			176
177	-	var xRayIntersectTriangle func(uintptr, *Triangle, float32) RayIntersectionKind	177	+	var xRayIntersectTriangle func(uintptr, Triangle, float32) RayIntersectionKind
178			178
179		// Intersects the given #graphene_ray_t @r with the given	179		// Intersects the given #graphene_ray_t @r with the given
180		// #graphene_triangle_t @t.	180		// #graphene_triangle_t @t.
181	-	func (x Ray) IntersectTriangle(TVar Triangle, TOutVar float32) RayIntersectionKind {	181	+	func (x Ray) IntersectTriangle(TVar Triangle, TOutVar *float32) RayIntersectionKind {
182			182
183		cret := xRayIntersectTriangle(x.GoPointer(), TVar, TOutVar)	183		cret := xRayIntersectTriangle(x.GoPointer(), TVar, TOutVar)
184		return cret	184		return cret

M v4/graphene/graphene-rect.go +2 -2


@@ -149,10 +149,10 @@ func (x Rect) GetTopRight(PVar Point) {
149			149
150		}	150		}
151			151
152	-	var xRectGetVertices func(uintptr, [4]Vec2)	152	+	var xRectGetVertices func(uintptr, *[4]Vec2)
153			153
154		// Computes the four vertices of a #graphene_rect_t.	154		// Computes the four vertices of a #graphene_rect_t.
155	-	func (x *Rect) GetVertices(VerticesVar [4]Vec2) {	155	+	func (x Rect) GetVertices(VerticesVar [4]Vec2) {
156			156
157		xRectGetVertices(x.GoPointer(), VerticesVar)	157		xRectGetVertices(x.GoPointer(), VerticesVar)
158			158

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


@@ -234,10 +234,10 @@ func (x Vec2) Subtract(BVar Vec2, ResVar *Vec2) {
234			234
235		}	235		}
236			236
237	-	var xVec2ToFloat func(uintptr, [2]float32)	237	+	var xVec2ToFloat func(uintptr, *[2]float32)
238			238
239		// Stores the components of @v into an array.	239		// Stores the components of @v into an array.
240	-	func (x *Vec2) ToFloat(DestVar [2]float32) {	240	+	func (x Vec2) ToFloat(DestVar [2]float32) {
241			241
242		xVec2ToFloat(x.GoPointer(), DestVar)	242		xVec2ToFloat(x.GoPointer(), DestVar)
243			243

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


@@ -301,10 +301,10 @@ func (x Vec3) Subtract(BVar Vec3, ResVar *Vec3) {
301			301
302		}	302		}
303			303
304	-	var xVec3ToFloat func(uintptr, [3]float32)	304	+	var xVec3ToFloat func(uintptr, *[3]float32)
305			305
306		// Copies the components of a #graphene_vec3_t into the given array.	306		// Copies the components of a #graphene_vec3_t into the given array.
307	-	func (x *Vec3) ToFloat(DestVar [3]float32) {	307	+	func (x Vec3) ToFloat(DestVar [3]float32) {
308			308
309		xVec3ToFloat(x.GoPointer(), DestVar)	309		xVec3ToFloat(x.GoPointer(), DestVar)
310			310

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


@@ -291,11 +291,11 @@ func (x Vec4) Subtract(BVar Vec4, ResVar *Vec4) {
291			291
292		}	292		}
293			293
294	-	var xVec4ToFloat func(uintptr, [4]float32)	294	+	var xVec4ToFloat func(uintptr, *[4]float32)
295			295
296		// Stores the components of the given #graphene_vec4_t into an array	296		// Stores the components of the given #graphene_vec4_t into an array
297		// of floating point values.	297		// of floating point values.
298	-	func (x *Vec4) ToFloat(DestVar [4]float32) {	298	+	func (x Vec4) ToFloat(DestVar [4]float32) {
299			299
300		xVec4ToFloat(x.GoPointer(), DestVar)	300		xVec4ToFloat(x.GoPointer(), DestVar)
301			301

M v4/gsk/gskglshader.go +40 -0


@@ -577,6 +577,46 @@ func (c *GLShader) SetGoPointer(ptr uintptr) {
577	c.Ptr = ptr	577		c.Ptr = ptr
578	}	578		}
579		579
		580	+	// SetPropertyResource sets the "resource" property.
		581	+	// Resource containing the source code for the shader.
		582	+	//
		583	+	// If the shader source is not coming from a resource, this
		584	+	// will be %NULL.
		585	+	func (x *GLShader) SetPropertyResource(value string) {
		586	+	var v gobject.Value
		587	+	v.Init(gobject.TypeStringVal)
		588	+	v.SetString(value)
		589	+	x.SetProperty("resource", &v)
		590	+	}
		591	+
		592	+	// GetPropertyResource gets the "resource" property.
		593	+	// Resource containing the source code for the shader.
		594	+	//
		595	+	// If the shader source is not coming from a resource, this
		596	+	// will be %NULL.
		597	+	func (x *GLShader) GetPropertyResource() string {
		598	+	var v gobject.Value
		599	+	x.GetProperty("resource", &v)
		600	+	return v.GetString()
		601	+	}
		602	+
		603	+	// SetPropertySource sets the "source" property.
		604	+	// The source code for the shader, as a `GBytes`.
		605	+	func (x *GLShader) SetPropertySource(value uintptr) {
		606	+	var v gobject.Value
		607	+	v.Init(gobject.TypePointerVal)
		608	+	v.SetPointer(value)
		609	+	x.SetProperty("source", &v)
		610	+	}
		611	+
		612	+	// GetPropertySource gets the "source" property.
		613	+	// The source code for the shader, as a `GBytes`.
		614	+	func (x *GLShader) GetPropertySource() uintptr {
		615	+	var v gobject.Value
		616	+	x.GetProperty("source", &v)
		617	+	return v.GetPointer()
		618	+	}
		619	+
580	func init() {	620		func init() {
581	core.SetPackageName("GSK", "gtk4")	621		core.SetPackageName("GSK", "gtk4")
582	core.SetSharedLibraries("GSK", []string{"libgtk-4.so.1"})	622		core.SetSharedLibraries("GSK", []string{"libgtk-4.so.1"})

M v4/gsk/gskrenderer.go +8 -0


@@ -201,6 +201,14 @@ func (c *Renderer) SetGoPointer(ptr uintptr) {
201	c.Ptr = ptr	201		c.Ptr = ptr
202	}	202		}
203		203
		204	+	// GetPropertyRealized gets the "realized" property.
		205	+	// Whether the renderer has been associated with a surface or draw context.
		206	+	func (x *Renderer) GetPropertyRealized() bool {
		207	+	var v gobject.Value
		208	+	x.GetProperty("realized", &v)
		209	+	return v.GetBoolean()
		210	+	}
		211	+
204	func init() {	212		func init() {
205	core.SetPackageName("GSK", "gtk4")	213		core.SetPackageName("GSK", "gtk4")
206	core.SetSharedLibraries("GSK", []string{"libgtk-4.so.1"})	214		core.SetSharedLibraries("GSK", []string{"libgtk-4.so.1"})

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


@@ -589,10 +589,10 @@ func (x ConicGradientNode) GetCenter() graphene.Point {
589		return cret	589		return cret
590		}	590		}
591			591
592	-	var xConicGradientNodeGetColorStops func(uintptr, uint) uintptr	592	+	var xConicGradientNodeGetColorStops func(uintptr, *uint) uintptr
593			593
594		// Retrieves the color stops in the gradient.	594		// Retrieves the color stops in the gradient.
595	-	func (x *ConicGradientNode) GetColorStops(NStopsVar uint) uintptr {	595	+	func (x ConicGradientNode) GetColorStops(NStopsVar uint) uintptr {
596			596
597		cret := xConicGradientNodeGetColorStops(x.GoPointer(), NStopsVar)	597		cret := xConicGradientNodeGetColorStops(x.GoPointer(), NStopsVar)
598		return cret	598		return cret

@@ -1191,10 +1191,10 @@ func NewLinearGradientNode(BoundsVar graphene.Rect, StartVar graphene.Point, E
1191		return cls	1191		return cls
1192		}	1192		}
1193			1193
1194	-	var xLinearGradientNodeGetColorStops func(uintptr, uint) uintptr	1194	+	var xLinearGradientNodeGetColorStops func(uintptr, *uint) uintptr
1195			1195
1196		// Retrieves the color stops in the gradient.	1196		// Retrieves the color stops in the gradient.
1197	-	func (x *LinearGradientNode) GetColorStops(NStopsVar uint) uintptr {	1197	+	func (x LinearGradientNode) GetColorStops(NStopsVar uint) uintptr {
1198			1198
1199		cret := xLinearGradientNodeGetColorStops(x.GoPointer(), NStopsVar)	1199		cret := xLinearGradientNodeGetColorStops(x.GoPointer(), NStopsVar)
1200		return cret	1200		return cret

@@ -1548,10 +1548,10 @@ func (x RadialGradientNode) GetCenter() graphene.Point {
1548		return cret	1548		return cret
1549		}	1549		}
1550			1550
1551	-	var xRadialGradientNodeGetColorStops func(uintptr, uint) uintptr	1551	+	var xRadialGradientNodeGetColorStops func(uintptr, *uint) uintptr
1552			1552
1553		// Retrieves the color stops in the gradient.	1553		// Retrieves the color stops in the gradient.
1554	-	func (x *RadialGradientNode) GetColorStops(NStopsVar uint) uintptr {	1554	+	func (x RadialGradientNode) GetColorStops(NStopsVar uint) uintptr {
1555			1555
1556		cret := xRadialGradientNodeGetColorStops(x.GoPointer(), NStopsVar)	1556		cret := xRadialGradientNodeGetColorStops(x.GoPointer(), NStopsVar)
1557		return cret	1557		return cret

@@ -2154,10 +2154,10 @@ func (x TextNode) GetFont() pango.Font {
2154		return cls	2154		return cls
2155		}	2155		}
2156			2156
2157	-	var xTextNodeGetGlyphs func(uintptr, uint) uintptr	2157	+	var xTextNodeGetGlyphs func(uintptr, *uint) uintptr
2158			2158
2159		// Retrieves the glyph information in the @node.	2159		// Retrieves the glyph information in the @node.
2160	-	func (x *TextNode) GetGlyphs(NGlyphsVar uint) uintptr {	2160	+	func (x TextNode) GetGlyphs(NGlyphsVar uint) uintptr {
2161			2161
2162		cret := xTextNodeGetGlyphs(x.GoPointer(), NGlyphsVar)	2162		cret := xTextNodeGetGlyphs(x.GoPointer(), NGlyphsVar)
2163		return cret	2163		return cret

M v4/gsk/gsktypes.go +12 -12


@@ -296,13 +296,13 @@ func (x Path) GetBounds(BoundsVar graphene.Rect) bool {
296		return cret	296		return cret
297		}	297		}
298			298
299	-	var xPathGetClosestPoint func(uintptr, graphene.Point, float32, PathPoint, float32) bool	299	+	var xPathGetClosestPoint func(uintptr, graphene.Point, float32, PathPoint, *float32) bool
300			300
301		// Computes the closest point on the path to the given point.	301		// Computes the closest point on the path to the given point.
302		//	302		//
303		// If there is no point closer than the given threshold,	303		// If there is no point closer than the given threshold,
304		// false is returned.	304		// false is returned.
305	-	func (x Path) GetClosestPoint(PointVar graphene.Point, ThresholdVar float32, ResultVar *PathPoint, DistanceVar float32) bool {	305	+	func (x Path) GetClosestPoint(PointVar graphene.Point, ThresholdVar float32, ResultVar PathPoint, DistanceVar float32) bool {
306			306
307		cret := xPathGetClosestPoint(x.GoPointer(), PointVar, ThresholdVar, ResultVar, DistanceVar)	307		cret := xPathGetClosestPoint(x.GoPointer(), PointVar, ThresholdVar, ResultVar, DistanceVar)
308		return cret	308		return cret

@@ -1081,10 +1081,10 @@ func (x *Stroke) Free() {
1081			1081
1082		}	1082		}
1083			1083
1084	-	var xStrokeGetDash func(uintptr, uint) uintptr	1084	+	var xStrokeGetDash func(uintptr, *uint) uintptr
1085			1085
1086		// Gets the dash array in use.	1086		// Gets the dash array in use.
1087	-	func (x *Stroke) GetDash(NDashVar uint) uintptr {	1087	+	func (x Stroke) GetDash(NDashVar uint) uintptr {
1088			1088
1089		cret := xStrokeGetDash(x.GoPointer(), NDashVar)	1089		cret := xStrokeGetDash(x.GoPointer(), NDashVar)
1090		return cret	1090		return cret

@@ -1447,7 +1447,7 @@ func (x Transform) Skew(SkewXVar float32, SkewYVar float32) Transform {
1447		return cret	1447		return cret
1448		}	1448		}
1449			1449
1450	-	var xTransformTo2d func(uintptr, float32, float32, float32, float32, float32, float32)	1450	+	var xTransformTo2d func(uintptr, float32, float32, float32, float32, float32, float32)
1451			1451
1452		// Converts a transform to a 2D transformation matrix.	1452		// Converts a transform to a 2D transformation matrix.
1453		//	1453		//

@@ -1473,13 +1473,13 @@ var xTransformTo2d func(uintptr, float32, float32, float32, float32, float32, fl
1473		// This function can be used to convert between a `GskTransform`	1473		// This function can be used to convert between a `GskTransform`
1474		// and a matrix type from other 2D drawing libraries, in particular	1474		// and a matrix type from other 2D drawing libraries, in particular
1475		// Cairo.	1475		// Cairo.
1476	-	func (x *Transform) To2d(OutXxVar float32, OutYxVar float32, OutXyVar float32, OutYyVar float32, OutDxVar float32, OutDyVar float32) {	1476	+	func (x Transform) To2d(OutXxVar float32, OutYxVar float32, OutXyVar float32, OutYyVar float32, OutDxVar float32, OutDyVar *float32) {
1477			1477
1478		xTransformTo2d(x.GoPointer(), OutXxVar, OutYxVar, OutXyVar, OutYyVar, OutDxVar, OutDyVar)	1478		xTransformTo2d(x.GoPointer(), OutXxVar, OutYxVar, OutXyVar, OutYyVar, OutDxVar, OutDyVar)
1479			1479
1480		}	1480		}
1481			1481
1482	-	var xTransformTo2dComponents func(uintptr, float32, float32, float32, float32, float32, float32, float32)	1482	+	var xTransformTo2dComponents func(uintptr, float32, float32, float32, float32, float32, float32, *float32)
1483			1483
1484		// Converts a transform to 2D transformation factors.	1484		// Converts a transform to 2D transformation factors.
1485		//	1485		//

@@ -1499,13 +1499,13 @@ var xTransformTo2dComponents func(uintptr, float32, float32, float32, float32, f
1499		// gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D	1499		// gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D
1500		//	1500		//
1501		// to check.	1501		// to check.
1502	-	func (x *Transform) To2dComponents(OutSkewXVar float32, OutSkewYVar float32, OutScaleXVar float32, OutScaleYVar float32, OutAngleVar float32, OutDxVar float32, OutDyVar float32) {	1502	+	func (x Transform) To2dComponents(OutSkewXVar float32, OutSkewYVar float32, OutScaleXVar float32, OutScaleYVar float32, OutAngleVar float32, OutDxVar float32, OutDyVar float32) {
1503			1503
1504		xTransformTo2dComponents(x.GoPointer(), OutSkewXVar, OutSkewYVar, OutScaleXVar, OutScaleYVar, OutAngleVar, OutDxVar, OutDyVar)	1504		xTransformTo2dComponents(x.GoPointer(), OutSkewXVar, OutSkewYVar, OutScaleXVar, OutScaleYVar, OutAngleVar, OutDxVar, OutDyVar)
1505			1505
1506		}	1506		}
1507			1507
1508	-	var xTransformToAffine func(uintptr, float32, float32, float32, float32)	1508	+	var xTransformToAffine func(uintptr, float32, float32, float32, float32)
1509			1509
1510		// Converts a transform to 2D affine transformation factors.	1510		// Converts a transform to 2D affine transformation factors.
1511		//	1511		//

@@ -1524,7 +1524,7 @@ var xTransformToAffine func(uintptr, float32, float32, float32, float32)
1524		// gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D_AFFINE	1524		// gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D_AFFINE
1525		//	1525		//
1526		// to check.	1526		// to check.
1527	-	func (x *Transform) ToAffine(OutScaleXVar float32, OutScaleYVar float32, OutDxVar float32, OutDyVar float32) {	1527	+	func (x Transform) ToAffine(OutScaleXVar float32, OutScaleYVar float32, OutDxVar float32, OutDyVar *float32) {
1528			1528
1529		xTransformToAffine(x.GoPointer(), OutScaleXVar, OutScaleYVar, OutDxVar, OutDyVar)	1529		xTransformToAffine(x.GoPointer(), OutScaleXVar, OutScaleYVar, OutDxVar, OutDyVar)
1530			1530

@@ -1554,7 +1554,7 @@ func (x *Transform) ToString() string {
1554		return cret	1554		return cret
1555		}	1555		}
1556			1556
1557	-	var xTransformToTranslate func(uintptr, float32, float32)	1557	+	var xTransformToTranslate func(uintptr, float32, float32)
1558			1558
1559		// Converts a transform to a translation operation.	1559		// Converts a transform to a translation operation.
1560		//	1560		//

@@ -1564,7 +1564,7 @@ var xTransformToTranslate func(uintptr, float32, float32)
1564		// gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D_TRANSLATE	1564		// gsk_transform_get_category() >= GSK_TRANSFORM_CATEGORY_2D_TRANSLATE
1565		//	1565		//
1566		// to check.	1566		// to check.
1567	-	func (x *Transform) ToTranslate(OutDxVar float32, OutDyVar float32) {	1567	+	func (x Transform) ToTranslate(OutDxVar float32, OutDyVar *float32) {
1568			1568
1569		xTransformToTranslate(x.GoPointer(), OutDxVar, OutDyVar)	1569		xTransformToTranslate(x.GoPointer(), OutDxVar, OutDyVar)
1570			1570

M v4/gtk/gtkaboutdialog.go +332 -2


@@ -535,6 +535,336 @@ func (c *AboutDialog) SetGoPointer(ptr uintptr) {
535		c.Ptr = ptr	535		c.Ptr = ptr
536		}	536		}
537			537
			538	+	// SetPropertyArtists sets the "artists" property.
			539	+	// The people who contributed artwork to the program.
			540	+	//
			541	+	// Each string may contain email addresses and URLs, which will be displayed
			542	+	// as links.
			543	+	func (x *AboutDialog) SetPropertyArtists(value []string) {
			544	+	var v gobject.Value
			545	+	v.Init(glib.StrvGetType())
			546	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			547	+	x.SetProperty("artists", &v)
			548	+	}
			549	+
			550	+	// GetPropertyArtists gets the "artists" property.
			551	+	// The people who contributed artwork to the program.
			552	+	//
			553	+	// Each string may contain email addresses and URLs, which will be displayed
			554	+	// as links.
			555	+	func (x *AboutDialog) GetPropertyArtists() []string {
			556	+	var v gobject.Value
			557	+	x.GetProperty("artists", &v)
			558	+	return core.GoStringSlice(v.GetBoxed())
			559	+	}
			560	+
			561	+	// SetPropertyAuthors sets the "authors" property.
			562	+	// The authors of the program.
			563	+	//
			564	+	// Each string may contain email addresses and URLs, which will be displayed
			565	+	// as links, see the introduction for more details.
			566	+	func (x *AboutDialog) SetPropertyAuthors(value []string) {
			567	+	var v gobject.Value
			568	+	v.Init(glib.StrvGetType())
			569	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			570	+	x.SetProperty("authors", &v)
			571	+	}
			572	+
			573	+	// GetPropertyAuthors gets the "authors" property.
			574	+	// The authors of the program.
			575	+	//
			576	+	// Each string may contain email addresses and URLs, which will be displayed
			577	+	// as links, see the introduction for more details.
			578	+	func (x *AboutDialog) GetPropertyAuthors() []string {
			579	+	var v gobject.Value
			580	+	x.GetProperty("authors", &v)
			581	+	return core.GoStringSlice(v.GetBoxed())
			582	+	}
			583	+
			584	+	// SetPropertyComments sets the "comments" property.
			585	+	// Comments about the program.
			586	+	//
			587	+	// This string is displayed in a label in the main dialog, thus it
			588	+	// should be a short explanation of the main purpose of the program,
			589	+	// not a detailed list of features.
			590	+	func (x *AboutDialog) SetPropertyComments(value string) {
			591	+	var v gobject.Value
			592	+	v.Init(gobject.TypeStringVal)
			593	+	v.SetString(value)
			594	+	x.SetProperty("comments", &v)
			595	+	}
			596	+
			597	+	// GetPropertyComments gets the "comments" property.
			598	+	// Comments about the program.
			599	+	//
			600	+	// This string is displayed in a label in the main dialog, thus it
			601	+	// should be a short explanation of the main purpose of the program,
			602	+	// not a detailed list of features.
			603	+	func (x *AboutDialog) GetPropertyComments() string {
			604	+	var v gobject.Value
			605	+	x.GetProperty("comments", &v)
			606	+	return v.GetString()
			607	+	}
			608	+
			609	+	// SetPropertyCopyright sets the "copyright" property.
			610	+	// Copyright information for the program.
			611	+	func (x *AboutDialog) SetPropertyCopyright(value string) {
			612	+	var v gobject.Value
			613	+	v.Init(gobject.TypeStringVal)
			614	+	v.SetString(value)
			615	+	x.SetProperty("copyright", &v)
			616	+	}
			617	+
			618	+	// GetPropertyCopyright gets the "copyright" property.
			619	+	// Copyright information for the program.
			620	+	func (x *AboutDialog) GetPropertyCopyright() string {
			621	+	var v gobject.Value
			622	+	x.GetProperty("copyright", &v)
			623	+	return v.GetString()
			624	+	}
			625	+
			626	+	// SetPropertyDocumenters sets the "documenters" property.
			627	+	// The people documenting the program.
			628	+	//
			629	+	// Each string may contain email addresses and URLs, which will be displayed
			630	+	// as links, see the introduction for more details.
			631	+	func (x *AboutDialog) SetPropertyDocumenters(value []string) {
			632	+	var v gobject.Value
			633	+	v.Init(glib.StrvGetType())
			634	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
			635	+	x.SetProperty("documenters", &v)
			636	+	}
			637	+
			638	+	// GetPropertyDocumenters gets the "documenters" property.
			639	+	// The people documenting the program.
			640	+	//
			641	+	// Each string may contain email addresses and URLs, which will be displayed
			642	+	// as links, see the introduction for more details.
			643	+	func (x *AboutDialog) GetPropertyDocumenters() []string {
			644	+	var v gobject.Value
			645	+	x.GetProperty("documenters", &v)
			646	+	return core.GoStringSlice(v.GetBoxed())
			647	+	}
			648	+
			649	+	// SetPropertyLicense sets the "license" property.
			650	+	// The license of the program, as free-form text.
			651	+	//
			652	+	// This string is displayed in a text view in a secondary dialog, therefore
			653	+	// it is fine to use a long multi-paragraph text. Note that the text is only
			654	+	// wrapped in the text view if the "wrap-license" property is set to `TRUE`;
			655	+	// otherwise the text itself must contain the intended linebreaks.
			656	+	//
			657	+	// When setting this property to a non-`NULL` value, the
			658	+	// [property@Gtk.AboutDialog:license-type] property is set to
			659	+	// [enum@Gtk.License.custom] as a side effect.
			660	+	//
			661	+	// The text may contain links in this format `<http://www.some.place/>`
			662	+	// and email references in the form `<mail-to@some.body>`, and these will
			663	+	// be converted into clickable links.
			664	+	func (x *AboutDialog) SetPropertyLicense(value string) {
			665	+	var v gobject.Value
			666	+	v.Init(gobject.TypeStringVal)
			667	+	v.SetString(value)
			668	+	x.SetProperty("license", &v)
			669	+	}
			670	+
			671	+	// GetPropertyLicense gets the "license" property.
			672	+	// The license of the program, as free-form text.
			673	+	//
			674	+	// This string is displayed in a text view in a secondary dialog, therefore
			675	+	// it is fine to use a long multi-paragraph text. Note that the text is only
			676	+	// wrapped in the text view if the "wrap-license" property is set to `TRUE`;
			677	+	// otherwise the text itself must contain the intended linebreaks.
			678	+	//
			679	+	// When setting this property to a non-`NULL` value, the
			680	+	// [property@Gtk.AboutDialog:license-type] property is set to
			681	+	// [enum@Gtk.License.custom] as a side effect.
			682	+	//
			683	+	// The text may contain links in this format `<http://www.some.place/>`
			684	+	// and email references in the form `<mail-to@some.body>`, and these will
			685	+	// be converted into clickable links.
			686	+	func (x *AboutDialog) GetPropertyLicense() string {
			687	+	var v gobject.Value
			688	+	x.GetProperty("license", &v)
			689	+	return v.GetString()
			690	+	}
			691	+
			692	+	// SetPropertyLogoIconName sets the "logo-icon-name" property.
			693	+	// A named icon to use as the logo for the about box.
			694	+	//
			695	+	// This property overrides the [property@Gtk.AboutDialog:logo] property.
			696	+	func (x *AboutDialog) SetPropertyLogoIconName(value string) {
			697	+	var v gobject.Value
			698	+	v.Init(gobject.TypeStringVal)
			699	+	v.SetString(value)
			700	+	x.SetProperty("logo-icon-name", &v)
			701	+	}
			702	+
			703	+	// GetPropertyLogoIconName gets the "logo-icon-name" property.
			704	+	// A named icon to use as the logo for the about box.
			705	+	//
			706	+	// This property overrides the [property@Gtk.AboutDialog:logo] property.
			707	+	func (x *AboutDialog) GetPropertyLogoIconName() string {
			708	+	var v gobject.Value
			709	+	x.GetProperty("logo-icon-name", &v)
			710	+	return v.GetString()
			711	+	}
			712	+
			713	+	// SetPropertyProgramName sets the "program-name" property.
			714	+	// The name of the program.
			715	+	//
			716	+	// If this is not set, it defaults to the value returned by
			717	+	// [func@GLib.get_application_name].
			718	+	func (x *AboutDialog) SetPropertyProgramName(value string) {
			719	+	var v gobject.Value
			720	+	v.Init(gobject.TypeStringVal)
			721	+	v.SetString(value)
			722	+	x.SetProperty("program-name", &v)
			723	+	}
			724	+
			725	+	// GetPropertyProgramName gets the "program-name" property.
			726	+	// The name of the program.
			727	+	//
			728	+	// If this is not set, it defaults to the value returned by
			729	+	// [func@GLib.get_application_name].
			730	+	func (x *AboutDialog) GetPropertyProgramName() string {
			731	+	var v gobject.Value
			732	+	x.GetProperty("program-name", &v)
			733	+	return v.GetString()
			734	+	}
			735	+
			736	+	// SetPropertySystemInformation sets the "system-information" property.
			737	+	// Information about the system on which the program is running.
			738	+	//
			739	+	// This information is displayed in a separate page, therefore it is fine
			740	+	// to use a long multi-paragraph text. Note that the text should contain
			741	+	// the intended linebreaks.
			742	+	//
			743	+	// The text may contain links in this format `<http://www.some.place/>`
			744	+	// and email references in the form `<mail-to@some.body>`, and these will
			745	+	// be converted into clickable links.
			746	+	func (x *AboutDialog) SetPropertySystemInformation(value string) {
			747	+	var v gobject.Value
			748	+	v.Init(gobject.TypeStringVal)
			749	+	v.SetString(value)
			750	+	x.SetProperty("system-information", &v)
			751	+	}
			752	+
			753	+	// GetPropertySystemInformation gets the "system-information" property.
			754	+	// Information about the system on which the program is running.
			755	+	//
			756	+	// This information is displayed in a separate page, therefore it is fine
			757	+	// to use a long multi-paragraph text. Note that the text should contain
			758	+	// the intended linebreaks.
			759	+	//
			760	+	// The text may contain links in this format `<http://www.some.place/>`
			761	+	// and email references in the form `<mail-to@some.body>`, and these will
			762	+	// be converted into clickable links.
			763	+	func (x *AboutDialog) GetPropertySystemInformation() string {
			764	+	var v gobject.Value
			765	+	x.GetProperty("system-information", &v)
			766	+	return v.GetString()
			767	+	}
			768	+
			769	+	// SetPropertyTranslatorCredits sets the "translator-credits" property.
			770	+	// Credits to the translators.
			771	+	//
			772	+	// This string should be marked as translatable.
			773	+	//
			774	+	// The string may contain email addresses and URLs, which will be displayed
			775	+	// as links, see the introduction for more details.
			776	+	func (x *AboutDialog) SetPropertyTranslatorCredits(value string) {
			777	+	var v gobject.Value
			778	+	v.Init(gobject.TypeStringVal)
			779	+	v.SetString(value)
			780	+	x.SetProperty("translator-credits", &v)
			781	+	}
			782	+
			783	+	// GetPropertyTranslatorCredits gets the "translator-credits" property.
			784	+	// Credits to the translators.
			785	+	//
			786	+	// This string should be marked as translatable.
			787	+	//
			788	+	// The string may contain email addresses and URLs, which will be displayed
			789	+	// as links, see the introduction for more details.
			790	+	func (x *AboutDialog) GetPropertyTranslatorCredits() string {
			791	+	var v gobject.Value
			792	+	x.GetProperty("translator-credits", &v)
			793	+	return v.GetString()
			794	+	}
			795	+
			796	+	// SetPropertyVersion sets the "version" property.
			797	+	// The version of the program.
			798	+	func (x *AboutDialog) SetPropertyVersion(value string) {
			799	+	var v gobject.Value
			800	+	v.Init(gobject.TypeStringVal)
			801	+	v.SetString(value)
			802	+	x.SetProperty("version", &v)
			803	+	}
			804	+
			805	+	// GetPropertyVersion gets the "version" property.
			806	+	// The version of the program.
			807	+	func (x *AboutDialog) GetPropertyVersion() string {
			808	+	var v gobject.Value
			809	+	x.GetProperty("version", &v)
			810	+	return v.GetString()
			811	+	}
			812	+
			813	+	// SetPropertyWebsite sets the "website" property.
			814	+	// The URL for the link to the website of the program.
			815	+	//
			816	+	// This should be a string starting with `http://` or `https://`.
			817	+	func (x *AboutDialog) SetPropertyWebsite(value string) {
			818	+	var v gobject.Value
			819	+	v.Init(gobject.TypeStringVal)
			820	+	v.SetString(value)
			821	+	x.SetProperty("website", &v)
			822	+	}
			823	+
			824	+	// GetPropertyWebsite gets the "website" property.
			825	+	// The URL for the link to the website of the program.
			826	+	//
			827	+	// This should be a string starting with `http://` or `https://`.
			828	+	func (x *AboutDialog) GetPropertyWebsite() string {
			829	+	var v gobject.Value
			830	+	x.GetProperty("website", &v)
			831	+	return v.GetString()
			832	+	}
			833	+
			834	+	// SetPropertyWebsiteLabel sets the "website-label" property.
			835	+	// The label for the link to the website of the program.
			836	+	func (x *AboutDialog) SetPropertyWebsiteLabel(value string) {
			837	+	var v gobject.Value
			838	+	v.Init(gobject.TypeStringVal)
			839	+	v.SetString(value)
			840	+	x.SetProperty("website-label", &v)
			841	+	}
			842	+
			843	+	// GetPropertyWebsiteLabel gets the "website-label" property.
			844	+	// The label for the link to the website of the program.
			845	+	func (x *AboutDialog) GetPropertyWebsiteLabel() string {
			846	+	var v gobject.Value
			847	+	x.GetProperty("website-label", &v)
			848	+	return v.GetString()
			849	+	}
			850	+
			851	+	// SetPropertyWrapLicense sets the "wrap-license" property.
			852	+	// Whether to wrap the text in the license dialog.
			853	+	func (x *AboutDialog) SetPropertyWrapLicense(value bool) {
			854	+	var v gobject.Value
			855	+	v.Init(gobject.TypeBooleanVal)
			856	+	v.SetBoolean(value)
			857	+	x.SetProperty("wrap-license", &v)
			858	+	}
			859	+
			860	+	// GetPropertyWrapLicense gets the "wrap-license" property.
			861	+	// Whether to wrap the text in the license dialog.
			862	+	func (x *AboutDialog) GetPropertyWrapLicense() bool {
			863	+	var v gobject.Value
			864	+	x.GetProperty("wrap-license", &v)
			865	+	return v.GetBoolean()
			866	+	}
			867	+
538		// Emitted every time a URL is activated.	868		// Emitted every time a URL is activated.
539		//	869		//
540		// Applications may connect to it to override the default behaviour,	870		// Applications may connect to it to override the default behaviour,

@@ -615,7 +945,7 @@ func (x AboutDialog) GetAtContext() ATContext {
615		// This functionality can be overridden by `GtkAccessible`	945		// This functionality can be overridden by `GtkAccessible`
616		// implementations, e.g. to get the bounds from an ignored	946		// implementations, e.g. to get the bounds from an ignored
617		// child widget.	947		// child widget.
618	-	func (x *AboutDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	948	+	func (x AboutDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
619			949
620		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	950		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
621		return cret	951		return cret

@@ -870,7 +1200,7 @@ func (x AboutDialog) GetSurface() gdk.Surface {
870		//	1200		//
871		// This is the translation from @self's surface coordinates into	1201		// This is the translation from @self's surface coordinates into
872		// @self's widget coordinates.	1202		// @self's widget coordinates.
873	-	func (x *AboutDialog) GetSurfaceTransform(XVar float64, YVar float64) {	1203	+	func (x AboutDialog) GetSurfaceTransform(XVar float64, YVar *float64) {
874			1204
875		XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	1205		XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
876			1206

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


@@ -77,7 +77,7 @@ func AcceleratorNameWithKeycode(DisplayVar *gdk.Display, AcceleratorKeyVar uint,
77		return cret	77		return cret
78		}	78		}
79			79
80	-	var xAcceleratorParse func(string, uint, *gdk.ModifierType) bool	80	+	var xAcceleratorParse func(string, uint, gdk.ModifierType) bool
81			81
82		// Parses a string representing an accelerator.	82		// Parses a string representing an accelerator.
83		//	83		//

@@ -102,13 +102,13 @@ var xAcceleratorParse func(string, uint, *gdk.ModifierType) bool
102		//	102		//
103		// If the parse operation fails, @accelerator_key and @accelerator_mods will	103		// If the parse operation fails, @accelerator_key and @accelerator_mods will
104		// be set to 0 (zero).	104		// be set to 0 (zero).
105	-	func AcceleratorParse(AcceleratorVar string, AcceleratorKeyVar uint, AcceleratorModsVar *gdk.ModifierType) bool {	105	+	func AcceleratorParse(AcceleratorVar string, AcceleratorKeyVar uint, AcceleratorModsVar gdk.ModifierType) bool {
106			106
107		cret := xAcceleratorParse(AcceleratorVar, AcceleratorKeyVar, AcceleratorModsVar)	107		cret := xAcceleratorParse(AcceleratorVar, AcceleratorKeyVar, AcceleratorModsVar)
108		return cret	108		return cret
109		}	109		}
110			110
111	-	var xAcceleratorParseWithKeycode func(string, uintptr, uint, []uint, *gdk.ModifierType) bool	111	+	var xAcceleratorParseWithKeycode func(string, uintptr, uint, []uint, *gdk.ModifierType) bool
112			112
113		// Parses a string representing an accelerator.	113		// Parses a string representing an accelerator.
114		//	114		//

@@ -124,7 +124,7 @@ var xAcceleratorParseWithKeycode func(string, uintptr, uint, []uint, *gdk.Modifi
124		//	124		//
125		// If the parse fails, @accelerator_key, @accelerator_mods and	125		// If the parse fails, @accelerator_key, @accelerator_mods and
126		// @accelerator_codes will be set to 0 (zero).	126		// @accelerator_codes will be set to 0 (zero).
127	-	func AcceleratorParseWithKeycode(AcceleratorVar string, DisplayVar gdk.Display, AcceleratorKeyVar uint, AcceleratorCodesVar []uint, AcceleratorModsVar gdk.ModifierType) bool {	127	+	func AcceleratorParseWithKeycode(AcceleratorVar string, DisplayVar gdk.Display, AcceleratorKeyVar uint, AcceleratorCodesVar []uint, AcceleratorModsVar gdk.ModifierType) bool {
128			128
129		cret := xAcceleratorParseWithKeycode(AcceleratorVar, DisplayVar.GoPointer(), AcceleratorKeyVar, AcceleratorCodesVar, AcceleratorModsVar)	129		cret := xAcceleratorParseWithKeycode(AcceleratorVar, DisplayVar.GoPointer(), AcceleratorKeyVar, AcceleratorCodesVar, AcceleratorModsVar)
130		return cret	130		return cret

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


@@ -35,7 +35,7 @@ func (x *AccessibleInterface) GoPointer() uintptr {
35		return uintptr(unsafe.Pointer(x))	35		return uintptr(unsafe.Pointer(x))
36		}	36		}
37			37
38	-	// OverrideGetAtContext sets the callback function.	38	+	// OverrideGetAtContext sets the "get_at_context" callback function.
39		// retrieve the platform-specific accessibility context	39		// retrieve the platform-specific accessibility context
40		//	40		//
41		// for the accessible implementation	41		// for the accessible implementation

@@ -53,7 +53,7 @@ func (x AccessibleInterface) OverrideGetAtContext(cb func(Accessible) ATContex
53		}	53		}
54		}	54		}
55			55
56	-	// GetGetAtContext gets the callback function.	56	+	// GetGetAtContext gets the "get_at_context" callback function.
57		// retrieve the platform-specific accessibility context	57		// retrieve the platform-specific accessibility context
58		//	58		//
59		// for the accessible implementation	59		// for the accessible implementation

@@ -74,7 +74,7 @@ func (x AccessibleInterface) GetGetAtContext() func(Accessible) ATContext {
74		}	74		}
75		}	75		}
76			76
77	-	// OverrideGetPlatformState sets the callback function.	77	+	// OverrideGetPlatformState sets the "get_platform_state" callback function.
78		// retrieve the accessible state	78		// retrieve the accessible state
79		func (x *AccessibleInterface) OverrideGetPlatformState(cb func(Accessible, AccessiblePlatformState) bool) {	79		func (x *AccessibleInterface) OverrideGetPlatformState(cb func(Accessible, AccessiblePlatformState) bool) {
80		if cb == nil {	80		if cb == nil {

@@ -86,7 +86,7 @@ func (x *AccessibleInterface) OverrideGetPlatformState(cb func(Accessible, Acces
86		}	86		}
87		}	87		}
88			88
89	-	// GetGetPlatformState gets the callback function.	89	+	// GetGetPlatformState gets the "get_platform_state" callback function.
90		// retrieve the accessible state	90		// retrieve the accessible state
91		func (x *AccessibleInterface) GetGetPlatformState() func(Accessible, AccessiblePlatformState) bool {	91		func (x *AccessibleInterface) GetGetPlatformState() func(Accessible, AccessiblePlatformState) bool {
92		if x.xGetPlatformState == 0 {	92		if x.xGetPlatformState == 0 {

@@ -99,7 +99,7 @@ func (x *AccessibleInterface) GetGetPlatformState() func(Accessible, AccessibleP
99		}	99		}
100		}	100		}
101			101
102	-	// OverrideGetAccessibleParent sets the callback function.	102	+	// OverrideGetAccessibleParent sets the "get_accessible_parent" callback function.
103		func (x AccessibleInterface) OverrideGetAccessibleParent(cb func(Accessible) AccessibleBase) {	103		func (x AccessibleInterface) OverrideGetAccessibleParent(cb func(Accessible) AccessibleBase) {
104		if cb == nil {	104		if cb == nil {
105		x.xGetAccessibleParent = 0	105		x.xGetAccessibleParent = 0

@@ -114,7 +114,7 @@ func (x AccessibleInterface) OverrideGetAccessibleParent(cb func(Accessible) A
114		}	114		}
115		}	115		}
116			116
117	-	// GetGetAccessibleParent gets the callback function.	117	+	// GetGetAccessibleParent gets the "get_accessible_parent" callback function.
118		func (x AccessibleInterface) GetGetAccessibleParent() func(Accessible) AccessibleBase {	118		func (x AccessibleInterface) GetGetAccessibleParent() func(Accessible) AccessibleBase {
119		if x.xGetAccessibleParent == 0 {	119		if x.xGetAccessibleParent == 0 {
120		return nil	120		return nil

@@ -132,7 +132,7 @@ func (x AccessibleInterface) GetGetAccessibleParent() func(Accessible) Accessi
132		}	132		}
133		}	133		}
134			134
135	-	// OverrideGetFirstAccessibleChild sets the callback function.	135	+	// OverrideGetFirstAccessibleChild sets the "get_first_accessible_child" callback function.
136		func (x AccessibleInterface) OverrideGetFirstAccessibleChild(cb func(Accessible) AccessibleBase) {	136		func (x AccessibleInterface) OverrideGetFirstAccessibleChild(cb func(Accessible) AccessibleBase) {
137		if cb == nil {	137		if cb == nil {
138		x.xGetFirstAccessibleChild = 0	138		x.xGetFirstAccessibleChild = 0

@@ -147,7 +147,7 @@ func (x *AccessibleInterface) OverrideGetFirstAccessibleChild(cb func(Accessible
147		}	147		}
148		}	148		}
149			149
150	-	// GetGetFirstAccessibleChild gets the callback function.	150	+	// GetGetFirstAccessibleChild gets the "get_first_accessible_child" callback function.
151		func (x AccessibleInterface) GetGetFirstAccessibleChild() func(Accessible) AccessibleBase {	151		func (x AccessibleInterface) GetGetFirstAccessibleChild() func(Accessible) AccessibleBase {
152		if x.xGetFirstAccessibleChild == 0 {	152		if x.xGetFirstAccessibleChild == 0 {
153		return nil	153		return nil

@@ -165,7 +165,7 @@ func (x AccessibleInterface) GetGetFirstAccessibleChild() func(Accessible) Acc
165		}	165		}
166		}	166		}
167			167
168	-	// OverrideGetNextAccessibleSibling sets the callback function.	168	+	// OverrideGetNextAccessibleSibling sets the "get_next_accessible_sibling" callback function.
169		func (x AccessibleInterface) OverrideGetNextAccessibleSibling(cb func(Accessible) AccessibleBase) {	169		func (x AccessibleInterface) OverrideGetNextAccessibleSibling(cb func(Accessible) AccessibleBase) {
170		if cb == nil {	170		if cb == nil {
171		x.xGetNextAccessibleSibling = 0	171		x.xGetNextAccessibleSibling = 0

@@ -180,7 +180,7 @@ func (x *AccessibleInterface) OverrideGetNextAccessibleSibling(cb func(Accessibl
180		}	180		}
181		}	181		}
182			182
183	-	// GetGetNextAccessibleSibling gets the callback function.	183	+	// GetGetNextAccessibleSibling gets the "get_next_accessible_sibling" callback function.
184		func (x AccessibleInterface) GetGetNextAccessibleSibling() func(Accessible) AccessibleBase {	184		func (x AccessibleInterface) GetGetNextAccessibleSibling() func(Accessible) AccessibleBase {
185		if x.xGetNextAccessibleSibling == 0 {	185		if x.xGetNextAccessibleSibling == 0 {
186		return nil	186		return nil

@@ -198,25 +198,25 @@ func (x AccessibleInterface) GetGetNextAccessibleSibling() func(Accessible) Ac
198		}	198		}
199		}	199		}
200			200
201	-	// OverrideGetBounds sets the callback function.	201	+	// OverrideGetBounds sets the "get_bounds" callback function.
202	-	func (x *AccessibleInterface) OverrideGetBounds(cb func(Accessible, int, int, int, int) bool) {	202	+	func (x AccessibleInterface) OverrideGetBounds(cb func(Accessible, int, int, int, *int) bool) {
203		if cb == nil {	203		if cb == nil {
204		x.xGetBounds = 0	204		x.xGetBounds = 0
205		} else {	205		} else {
206	-	x.xGetBounds = purego.NewCallback(func(SelfVarp uintptr, XVarp int, YVarp int, WidthVarp int, HeightVarp int) bool {	206	+	x.xGetBounds = purego.NewCallback(func(SelfVarp uintptr, XVarp int, YVarp int, WidthVarp int, HeightVarp int) bool {
207		return cb(&AccessibleBase{Ptr: SelfVarp}, XVarp, YVarp, WidthVarp, HeightVarp)	207		return cb(&AccessibleBase{Ptr: SelfVarp}, XVarp, YVarp, WidthVarp, HeightVarp)
208		})	208		})
209		}	209		}
210		}	210		}
211			211
212	-	// GetGetBounds gets the callback function.	212	+	// GetGetBounds gets the "get_bounds" callback function.
213	-	func (x *AccessibleInterface) GetGetBounds() func(Accessible, int, int, int, int) bool {	213	+	func (x AccessibleInterface) GetGetBounds() func(Accessible, int, int, int, *int) bool {
214		if x.xGetBounds == 0 {	214		if x.xGetBounds == 0 {
215		return nil	215		return nil
216		}	216		}
217	-	var rawCallback func(SelfVarp uintptr, XVarp int, YVarp int, WidthVarp int, HeightVarp int) bool	217	+	var rawCallback func(SelfVarp uintptr, XVarp int, YVarp int, WidthVarp int, HeightVarp int) bool
218		purego.RegisterFunc(&rawCallback, x.xGetBounds)	218		purego.RegisterFunc(&rawCallback, x.xGetBounds)
219	-	return func(SelfVar Accessible, XVar int, YVar int, WidthVar int, HeightVar int) bool {	219	+	return func(SelfVar Accessible, XVar int, YVar int, WidthVar int, HeightVar int) bool {
220		return rawCallback(SelfVar.GoPointer(), XVar, YVar, WidthVar, HeightVar)	220		return rawCallback(SelfVar.GoPointer(), XVar, YVar, WidthVar, HeightVar)
221		}	221		}
222		}	222		}

@@ -301,7 +301,7 @@ type Accessible interface {
301		GetAccessibleParent() *AccessibleBase	301		GetAccessibleParent() *AccessibleBase
302		GetAccessibleRole() AccessibleRole	302		GetAccessibleRole() AccessibleRole
303		GetAtContext() *ATContext	303		GetAtContext() *ATContext
304	-	GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool	304	+	GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool
305		GetFirstAccessibleChild() *AccessibleBase	305		GetFirstAccessibleChild() *AccessibleBase
306		GetNextAccessibleSibling() *AccessibleBase	306		GetNextAccessibleSibling() *AccessibleBase
307		GetPlatformState(StateVar AccessiblePlatformState) bool	307		GetPlatformState(StateVar AccessiblePlatformState) bool

@@ -397,7 +397,7 @@ func (x AccessibleBase) GetAtContext() ATContext {
397		// This functionality can be overridden by `GtkAccessible`	397		// This functionality can be overridden by `GtkAccessible`
398		// implementations, e.g. to get the bounds from an ignored	398		// implementations, e.g. to get the bounds from an ignored
399		// child widget.	399		// child widget.
400	-	func (x *AccessibleBase) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	400	+	func (x AccessibleBase) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
401			401
402		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	402		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
403		return cret	403		return cret

@@ -612,7 +612,7 @@ var XGtkAccessibleAnnounce func(uintptr, string, AccessibleAnnouncementPriority)
612		var XGtkAccessibleGetAccessibleParent func(uintptr) uintptr	612		var XGtkAccessibleGetAccessibleParent func(uintptr) uintptr
613		var XGtkAccessibleGetAccessibleRole func(uintptr) AccessibleRole	613		var XGtkAccessibleGetAccessibleRole func(uintptr) AccessibleRole
614		var XGtkAccessibleGetAtContext func(uintptr) uintptr	614		var XGtkAccessibleGetAtContext func(uintptr) uintptr
615	-	var XGtkAccessibleGetBounds func(uintptr, int, int, int, int) bool	615	+	var XGtkAccessibleGetBounds func(uintptr, int, int, int, int) bool
616		var XGtkAccessibleGetFirstAccessibleChild func(uintptr) uintptr	616		var XGtkAccessibleGetFirstAccessibleChild func(uintptr) uintptr
617		var XGtkAccessibleGetNextAccessibleSibling func(uintptr) uintptr	617		var XGtkAccessibleGetNextAccessibleSibling func(uintptr) uintptr
618		var XGtkAccessibleGetPlatformState func(uintptr, AccessiblePlatformState) bool	618		var XGtkAccessibleGetPlatformState func(uintptr, AccessiblePlatformState) bool

M v4/gtk/gtkaccessiblerange.go +2 -2


@@ -21,7 +21,7 @@ func (x *AccessibleRangeInterface) GoPointer() uintptr {
21		return uintptr(unsafe.Pointer(x))	21		return uintptr(unsafe.Pointer(x))
22		}	22		}
23			23
24	-	// OverrideSetCurrentValue sets the callback function.	24	+	// OverrideSetCurrentValue sets the "set_current_value" callback function.
25		func (x *AccessibleRangeInterface) OverrideSetCurrentValue(cb func(AccessibleRange, float64) bool) {	25		func (x *AccessibleRangeInterface) OverrideSetCurrentValue(cb func(AccessibleRange, float64) bool) {
26		if cb == nil {	26		if cb == nil {
27		x.xSetCurrentValue = 0	27		x.xSetCurrentValue = 0

@@ -32,7 +32,7 @@ func (x *AccessibleRangeInterface) OverrideSetCurrentValue(cb func(AccessibleRan
32		}	32		}
33		}	33		}
34			34
35	-	// GetSetCurrentValue gets the callback function.	35	+	// GetSetCurrentValue gets the "set_current_value" callback function.
36		func (x *AccessibleRangeInterface) GetSetCurrentValue() func(AccessibleRange, float64) bool {	36		func (x *AccessibleRangeInterface) GetSetCurrentValue() func(AccessibleRange, float64) bool {
37		if x.xSetCurrentValue == 0 {	37		if x.xSetCurrentValue == 0 {
38		return nil	38		return nil

M v4/gtk/gtkaccessibletext.go +41 -41


@@ -39,7 +39,7 @@ func (x *AccessibleTextInterface) GoPointer() uintptr {
39		return uintptr(unsafe.Pointer(x))	39		return uintptr(unsafe.Pointer(x))
40		}	40		}
41			41
42	-	// OverrideGetContents sets the callback function.	42	+	// OverrideGetContents sets the "get_contents" callback function.
43		func (x AccessibleTextInterface) OverrideGetContents(cb func(AccessibleText, uint, uint) glib.Bytes) {	43		func (x AccessibleTextInterface) OverrideGetContents(cb func(AccessibleText, uint, uint) glib.Bytes) {
44		if cb == nil {	44		if cb == nil {
45		x.xGetContents = 0	45		x.xGetContents = 0

@@ -50,7 +50,7 @@ func (x *AccessibleTextInterface) OverrideGetContents(cb func(AccessibleText, ui
50		}	50		}
51		}	51		}
52			52
53	-	// GetGetContents gets the callback function.	53	+	// GetGetContents gets the "get_contents" callback function.
54		func (x AccessibleTextInterface) GetGetContents() func(AccessibleText, uint, uint) glib.Bytes {	54		func (x AccessibleTextInterface) GetGetContents() func(AccessibleText, uint, uint) glib.Bytes {
55		if x.xGetContents == 0 {	55		if x.xGetContents == 0 {
56		return nil	56		return nil

@@ -62,30 +62,30 @@ func (x *AccessibleTextInterface) GetGetContents() func(AccessibleText, uint, ui
62		}	62		}
63		}	63		}
64			64
65	-	// OverrideGetContentsAt sets the callback function.	65	+	// OverrideGetContentsAt sets the "get_contents_at" callback function.
66	-	func (x AccessibleTextInterface) OverrideGetContentsAt(cb func(AccessibleText, uint, AccessibleTextGranularity, uint, uint) glib.Bytes) {	66	+	func (x AccessibleTextInterface) OverrideGetContentsAt(cb func(AccessibleText, uint, AccessibleTextGranularity, uint, uint) glib.Bytes) {
67		if cb == nil {	67		if cb == nil {
68		x.xGetContentsAt = 0	68		x.xGetContentsAt = 0
69		} else {	69		} else {
70	-	x.xGetContentsAt = purego.NewCallback(func(SelfVarp uintptr, OffsetVarp uint, GranularityVarp AccessibleTextGranularity, StartVarp uint, EndVarp uint) *glib.Bytes {	70	+	x.xGetContentsAt = purego.NewCallback(func(SelfVarp uintptr, OffsetVarp uint, GranularityVarp AccessibleTextGranularity, StartVarp uint, EndVarp uint) *glib.Bytes {
71		return cb(&AccessibleTextBase{Ptr: SelfVarp}, OffsetVarp, GranularityVarp, StartVarp, EndVarp)	71		return cb(&AccessibleTextBase{Ptr: SelfVarp}, OffsetVarp, GranularityVarp, StartVarp, EndVarp)
72		})	72		})
73		}	73		}
74		}	74		}
75			75
76	-	// GetGetContentsAt gets the callback function.	76	+	// GetGetContentsAt gets the "get_contents_at" callback function.
77	-	func (x AccessibleTextInterface) GetGetContentsAt() func(AccessibleText, uint, AccessibleTextGranularity, uint, uint) glib.Bytes {	77	+	func (x AccessibleTextInterface) GetGetContentsAt() func(AccessibleText, uint, AccessibleTextGranularity, uint, uint) glib.Bytes {
78		if x.xGetContentsAt == 0 {	78		if x.xGetContentsAt == 0 {
79		return nil	79		return nil
80		}	80		}
81	-	var rawCallback func(SelfVarp uintptr, OffsetVarp uint, GranularityVarp AccessibleTextGranularity, StartVarp uint, EndVarp uint) *glib.Bytes	81	+	var rawCallback func(SelfVarp uintptr, OffsetVarp uint, GranularityVarp AccessibleTextGranularity, StartVarp uint, EndVarp uint) *glib.Bytes
82		purego.RegisterFunc(&rawCallback, x.xGetContentsAt)	82		purego.RegisterFunc(&rawCallback, x.xGetContentsAt)
83	-	return func(SelfVar AccessibleText, OffsetVar uint, GranularityVar AccessibleTextGranularity, StartVar uint, EndVar uint) *glib.Bytes {	83	+	return func(SelfVar AccessibleText, OffsetVar uint, GranularityVar AccessibleTextGranularity, StartVar uint, EndVar uint) *glib.Bytes {
84		return rawCallback(SelfVar.GoPointer(), OffsetVar, GranularityVar, StartVar, EndVar)	84		return rawCallback(SelfVar.GoPointer(), OffsetVar, GranularityVar, StartVar, EndVar)
85		}	85		}
86		}	86		}
87			87
88	-	// OverrideGetCaretPosition sets the callback function.	88	+	// OverrideGetCaretPosition sets the "get_caret_position" callback function.
89		func (x *AccessibleTextInterface) OverrideGetCaretPosition(cb func(AccessibleText) uint) {	89		func (x *AccessibleTextInterface) OverrideGetCaretPosition(cb func(AccessibleText) uint) {
90		if cb == nil {	90		if cb == nil {
91		x.xGetCaretPosition = 0	91		x.xGetCaretPosition = 0

@@ -96,7 +96,7 @@ func (x *AccessibleTextInterface) OverrideGetCaretPosition(cb func(AccessibleTex
96		}	96		}
97		}	97		}
98			98
99	-	// GetGetCaretPosition gets the callback function.	99	+	// GetGetCaretPosition gets the "get_caret_position" callback function.
100		func (x *AccessibleTextInterface) GetGetCaretPosition() func(AccessibleText) uint {	100		func (x *AccessibleTextInterface) GetGetCaretPosition() func(AccessibleText) uint {
101		if x.xGetCaretPosition == 0 {	101		if x.xGetCaretPosition == 0 {
102		return nil	102		return nil

@@ -108,76 +108,76 @@ func (x *AccessibleTextInterface) GetGetCaretPosition() func(AccessibleText) uin
108		}	108		}
109		}	109		}
110			110
111	-	// OverrideGetSelection sets the callback function.	111	+	// OverrideGetSelection sets the "get_selection" callback function.
112	-	func (x *AccessibleTextInterface) OverrideGetSelection(cb func(AccessibleText, uint, uintptr) bool) {	112	+	func (x AccessibleTextInterface) OverrideGetSelection(cb func(AccessibleText, uint, *uintptr) bool) {
113		if cb == nil {	113		if cb == nil {
114		x.xGetSelection = 0	114		x.xGetSelection = 0
115		} else {	115		} else {
116	-	x.xGetSelection = purego.NewCallback(func(SelfVarp uintptr, NRangesVarp uint, RangesVarp uintptr) bool {	116	+	x.xGetSelection = purego.NewCallback(func(SelfVarp uintptr, NRangesVarp uint, RangesVarp uintptr) bool {
117		return cb(&AccessibleTextBase{Ptr: SelfVarp}, NRangesVarp, RangesVarp)	117		return cb(&AccessibleTextBase{Ptr: SelfVarp}, NRangesVarp, RangesVarp)
118		})	118		})
119		}	119		}
120		}	120		}
121			121
122	-	// GetGetSelection gets the callback function.	122	+	// GetGetSelection gets the "get_selection" callback function.
123	-	func (x *AccessibleTextInterface) GetGetSelection() func(AccessibleText, uint, uintptr) bool {	123	+	func (x AccessibleTextInterface) GetGetSelection() func(AccessibleText, uint, *uintptr) bool {
124		if x.xGetSelection == 0 {	124		if x.xGetSelection == 0 {
125		return nil	125		return nil
126		}	126		}
127	-	var rawCallback func(SelfVarp uintptr, NRangesVarp uint, RangesVarp uintptr) bool	127	+	var rawCallback func(SelfVarp uintptr, NRangesVarp uint, RangesVarp uintptr) bool
128		purego.RegisterFunc(&rawCallback, x.xGetSelection)	128		purego.RegisterFunc(&rawCallback, x.xGetSelection)
129	-	return func(SelfVar AccessibleText, NRangesVar uint, RangesVar uintptr) bool {	129	+	return func(SelfVar AccessibleText, NRangesVar uint, RangesVar uintptr) bool {
130		return rawCallback(SelfVar.GoPointer(), NRangesVar, RangesVar)	130		return rawCallback(SelfVar.GoPointer(), NRangesVar, RangesVar)
131		}	131		}
132		}	132		}
133			133
134	-	// OverrideGetAttributes sets the callback function.	134	+	// OverrideGetAttributes sets the "get_attributes" callback function.
135	-	func (x *AccessibleTextInterface) OverrideGetAttributes(cb func(AccessibleText, uint, uint, uintptr, []string, []string) bool) {	135	+	func (x AccessibleTextInterface) OverrideGetAttributes(cb func(AccessibleText, uint, uint, uintptr, []string, *[]string) bool) {
136		if cb == nil {	136		if cb == nil {
137		x.xGetAttributes = 0	137		x.xGetAttributes = 0
138		} else {	138		} else {
139	-	x.xGetAttributes = purego.NewCallback(func(SelfVarp uintptr, OffsetVarp uint, NRangesVarp uint, RangesVarp uintptr, AttributeNamesVarp []string, AttributeValuesVarp []string) bool {	139	+	x.xGetAttributes = purego.NewCallback(func(SelfVarp uintptr, OffsetVarp uint, NRangesVarp uint, RangesVarp uintptr, AttributeNamesVarp []string, AttributeValuesVarp []string) bool {
140		return cb(&AccessibleTextBase{Ptr: SelfVarp}, OffsetVarp, NRangesVarp, RangesVarp, AttributeNamesVarp, AttributeValuesVarp)	140		return cb(&AccessibleTextBase{Ptr: SelfVarp}, OffsetVarp, NRangesVarp, RangesVarp, AttributeNamesVarp, AttributeValuesVarp)
141		})	141		})
142		}	142		}
143		}	143		}
144			144
145	-	// GetGetAttributes gets the callback function.	145	+	// GetGetAttributes gets the "get_attributes" callback function.
146	-	func (x *AccessibleTextInterface) GetGetAttributes() func(AccessibleText, uint, uint, uintptr, []string, []string) bool {	146	+	func (x AccessibleTextInterface) GetGetAttributes() func(AccessibleText, uint, uint, uintptr, []string, *[]string) bool {
147		if x.xGetAttributes == 0 {	147		if x.xGetAttributes == 0 {
148		return nil	148		return nil
149		}	149		}
150	-	var rawCallback func(SelfVarp uintptr, OffsetVarp uint, NRangesVarp uint, RangesVarp uintptr, AttributeNamesVarp []string, AttributeValuesVarp []string) bool	150	+	var rawCallback func(SelfVarp uintptr, OffsetVarp uint, NRangesVarp uint, RangesVarp uintptr, AttributeNamesVarp []string, AttributeValuesVarp []string) bool
151		purego.RegisterFunc(&rawCallback, x.xGetAttributes)	151		purego.RegisterFunc(&rawCallback, x.xGetAttributes)
152	-	return func(SelfVar AccessibleText, OffsetVar uint, NRangesVar uint, RangesVar uintptr, AttributeNamesVar []string, AttributeValuesVar []string) bool {	152	+	return func(SelfVar AccessibleText, OffsetVar uint, NRangesVar uint, RangesVar uintptr, AttributeNamesVar []string, AttributeValuesVar []string) bool {
153		return rawCallback(SelfVar.GoPointer(), OffsetVar, NRangesVar, RangesVar, AttributeNamesVar, AttributeValuesVar)	153		return rawCallback(SelfVar.GoPointer(), OffsetVar, NRangesVar, RangesVar, AttributeNamesVar, AttributeValuesVar)
154		}	154		}
155		}	155		}
156			156
157	-	// OverrideGetDefaultAttributes sets the callback function.	157	+	// OverrideGetDefaultAttributes sets the "get_default_attributes" callback function.
158	-	func (x *AccessibleTextInterface) OverrideGetDefaultAttributes(cb func(AccessibleText, []string, []string)) {	158	+	func (x AccessibleTextInterface) OverrideGetDefaultAttributes(cb func(AccessibleText, []string, *[]string)) {
159		if cb == nil {	159		if cb == nil {
160		x.xGetDefaultAttributes = 0	160		x.xGetDefaultAttributes = 0
161		} else {	161		} else {
162	-	x.xGetDefaultAttributes = purego.NewCallback(func(SelfVarp uintptr, AttributeNamesVarp []string, AttributeValuesVarp []string) {	162	+	x.xGetDefaultAttributes = purego.NewCallback(func(SelfVarp uintptr, AttributeNamesVarp []string, AttributeValuesVarp []string) {
163		cb(&AccessibleTextBase{Ptr: SelfVarp}, AttributeNamesVarp, AttributeValuesVarp)	163		cb(&AccessibleTextBase{Ptr: SelfVarp}, AttributeNamesVarp, AttributeValuesVarp)
164		})	164		})
165		}	165		}
166		}	166		}
167			167
168	-	// GetGetDefaultAttributes gets the callback function.	168	+	// GetGetDefaultAttributes gets the "get_default_attributes" callback function.
169	-	func (x *AccessibleTextInterface) GetGetDefaultAttributes() func(AccessibleText, []string, []string) {	169	+	func (x AccessibleTextInterface) GetGetDefaultAttributes() func(AccessibleText, []string, *[]string) {
170		if x.xGetDefaultAttributes == 0 {	170		if x.xGetDefaultAttributes == 0 {
171		return nil	171		return nil
172		}	172		}
173	-	var rawCallback func(SelfVarp uintptr, AttributeNamesVarp []string, AttributeValuesVarp []string)	173	+	var rawCallback func(SelfVarp uintptr, AttributeNamesVarp []string, AttributeValuesVarp []string)
174		purego.RegisterFunc(&rawCallback, x.xGetDefaultAttributes)	174		purego.RegisterFunc(&rawCallback, x.xGetDefaultAttributes)
175	-	return func(SelfVar AccessibleText, AttributeNamesVar []string, AttributeValuesVar []string) {	175	+	return func(SelfVar AccessibleText, AttributeNamesVar []string, AttributeValuesVar []string) {
176		rawCallback(SelfVar.GoPointer(), AttributeNamesVar, AttributeValuesVar)	176		rawCallback(SelfVar.GoPointer(), AttributeNamesVar, AttributeValuesVar)
177		}	177		}
178		}	178		}
179			179
180	-	// OverrideGetExtents sets the callback function.	180	+	// OverrideGetExtents sets the "get_extents" callback function.
181		func (x AccessibleTextInterface) OverrideGetExtents(cb func(AccessibleText, uint, uint, graphene.Rect) bool) {	181		func (x AccessibleTextInterface) OverrideGetExtents(cb func(AccessibleText, uint, uint, graphene.Rect) bool) {
182		if cb == nil {	182		if cb == nil {
183		x.xGetExtents = 0	183		x.xGetExtents = 0

@@ -188,7 +188,7 @@ func (x *AccessibleTextInterface) OverrideGetExtents(cb func(AccessibleText, uin
188		}	188		}
189		}	189		}
190			190
191	-	// GetGetExtents gets the callback function.	191	+	// GetGetExtents gets the "get_extents" callback function.
192		func (x AccessibleTextInterface) GetGetExtents() func(AccessibleText, uint, uint, graphene.Rect) bool {	192		func (x AccessibleTextInterface) GetGetExtents() func(AccessibleText, uint, uint, graphene.Rect) bool {
193		if x.xGetExtents == 0 {	193		if x.xGetExtents == 0 {
194		return nil	194		return nil

@@ -200,25 +200,25 @@ func (x *AccessibleTextInterface) GetGetExtents() func(AccessibleText, uint, uin
200		}	200		}
201		}	201		}
202			202
203	-	// OverrideGetOffset sets the callback function.	203	+	// OverrideGetOffset sets the "get_offset" callback function.
204	-	func (x AccessibleTextInterface) OverrideGetOffset(cb func(AccessibleText, graphene.Point, uint) bool) {	204	+	func (x AccessibleTextInterface) OverrideGetOffset(cb func(AccessibleText, graphene.Point, *uint) bool) {
205		if cb == nil {	205		if cb == nil {
206		x.xGetOffset = 0	206		x.xGetOffset = 0
207		} else {	207		} else {
208	-	x.xGetOffset = purego.NewCallback(func(SelfVarp uintptr, PointVarp *graphene.Point, OffsetVarp uint) bool {	208	+	x.xGetOffset = purego.NewCallback(func(SelfVarp uintptr, PointVarp graphene.Point, OffsetVarp uint) bool {
209		return cb(&AccessibleTextBase{Ptr: SelfVarp}, PointVarp, OffsetVarp)	209		return cb(&AccessibleTextBase{Ptr: SelfVarp}, PointVarp, OffsetVarp)
210		})	210		})
211		}	211		}
212		}	212		}
213			213
214	-	// GetGetOffset gets the callback function.	214	+	// GetGetOffset gets the "get_offset" callback function.
215	-	func (x AccessibleTextInterface) GetGetOffset() func(AccessibleText, graphene.Point, uint) bool {	215	+	func (x AccessibleTextInterface) GetGetOffset() func(AccessibleText, graphene.Point, *uint) bool {
216		if x.xGetOffset == 0 {	216		if x.xGetOffset == 0 {
217		return nil	217		return nil
218		}	218		}
219	-	var rawCallback func(SelfVarp uintptr, PointVarp *graphene.Point, OffsetVarp uint) bool	219	+	var rawCallback func(SelfVarp uintptr, PointVarp graphene.Point, OffsetVarp uint) bool
220		purego.RegisterFunc(&rawCallback, x.xGetOffset)	220		purego.RegisterFunc(&rawCallback, x.xGetOffset)
221	-	return func(SelfVar AccessibleText, PointVar *graphene.Point, OffsetVar uint) bool {	221	+	return func(SelfVar AccessibleText, PointVar graphene.Point, OffsetVar uint) bool {
222		return rawCallback(SelfVar.GoPointer(), PointVar, OffsetVar)	222		return rawCallback(SelfVar.GoPointer(), PointVar, OffsetVar)
223		}	223		}
224		}	224		}

M v4/gtk/gtkactionable.go +51 -8

 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/pkg/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
+	"github.com/jwijenbergh/puregotk/v4/gobject"
 	"github.com/jwijenbergh/puregotk/v4/gobject/types"
 )
 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideGetActionName sets the callback function.
+// OverrideGetActionName sets the "get_action_name" callback function.
 // virtual function for [method@Actionable.get_action_name]
 func (x *ActionableInterface) OverrideGetActionName(cb func(Actionable) string) {
 	if cb == nil {
 	}
 }
-// GetGetActionName gets the callback function.
+// GetGetActionName gets the "get_action_name" callback function.
 // virtual function for [method@Actionable.get_action_name]
 func (x *ActionableInterface) GetGetActionName() func(Actionable) string {
 	if x.xGetActionName == 0 {
 	}
 }
-// OverrideSetActionName sets the callback function.
+// OverrideSetActionName sets the "set_action_name" callback function.
 // virtual function for [method@Actionable.set_action_name]
 func (x *ActionableInterface) OverrideSetActionName(cb func(Actionable, string)) {
 	if cb == nil {
 	}
 }
-// GetSetActionName gets the callback function.
+// GetSetActionName gets the "set_action_name" callback function.
 // virtual function for [method@Actionable.set_action_name]
 func (x *ActionableInterface) GetSetActionName() func(Actionable, string) {
 	if x.xSetActionName == 0 {
 	}
 }
-// OverrideGetActionTargetValue sets the callback function.
+// OverrideGetActionTargetValue sets the "get_action_target_value" callback function.
 // virtual function for [method@Actionable.get_action_target_value]
 func (x *ActionableInterface) OverrideGetActionTargetValue(cb func(Actionable) *glib.Variant) {
 	if cb == nil {
 	}
 }
-// GetGetActionTargetValue gets the callback function.
+// GetGetActionTargetValue gets the "get_action_target_value" callback function.
 // virtual function for [method@Actionable.get_action_target_value]
 func (x *ActionableInterface) GetGetActionTargetValue() func(Actionable) *glib.Variant {
 	if x.xGetActionTargetValue == 0 {
 	}
 }
-// OverrideSetActionTargetValue sets the callback function.
+// OverrideSetActionTargetValue sets the "set_action_target_value" callback function.
 // virtual function for [method@Actionable.set_action_target_value]
 func (x *ActionableInterface) OverrideSetActionTargetValue(cb func(Actionable, *glib.Variant)) {
 	if cb == nil {
 	}
 }
-// GetSetActionTargetValue gets the callback function.
+// GetSetActionTargetValue gets the "set_action_target_value" callback function.
 // virtual function for [method@Actionable.set_action_target_value]
 func (x *ActionableInterface) GetSetActionTargetValue() func(Actionable, *glib.Variant) {
 	if x.xSetActionTargetValue == 0 {
 }
+// SetPropertyActionName sets the "action-name" property.
+// The name of the action with which this widget should be associated.
+func (x *ActionableBase) SetPropertyActionName(value string) {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	v.Init(gobject.TypeStringVal)
+	v.SetString(value)
+	obj.SetProperty("action-name", &v)
+}
+// GetPropertyActionName gets the "action-name" property.
+// The name of the action with which this widget should be associated.
+func (x *ActionableBase) GetPropertyActionName() string {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("action-name", &v)
+	return v.GetString()
+}
+// SetPropertyActionTarget sets the "action-target" property.
+// The target value of the actionable widget's action.
+func (x *ActionableBase) SetPropertyActionTarget(value uintptr) {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	v.Init(gobject.TypePointerVal)
+	v.SetPointer(value)
+	obj.SetProperty("action-target", &v)
+}
+// GetPropertyActionTarget gets the "action-target" property.
+// The target value of the actionable widget's action.
+func (x *ActionableBase) GetPropertyActionTarget() uintptr {
+	obj := gobject.Object{}
+	obj.Ptr = x.GoPointer()
+	var v gobject.Value
+	obj.GetProperty("action-target", &v)
+	return v.GetPointer()
+}
 var XGtkActionableGetActionName func(uintptr) string
 var XGtkActionableGetActionTargetValue func(uintptr) *glib.Variant
 var XGtkActionableSetActionName func(uintptr, string)

M v4/gtk/gtkactionbar.go +18 -1


@@ -174,6 +174,23 @@ func (c *ActionBar) SetGoPointer(ptr uintptr) {
174		c.Ptr = ptr	174		c.Ptr = ptr
175		}	175		}
176			176
			177	+	// SetPropertyRevealed sets the "revealed" property.
			178	+	// Controls whether the action bar shows its contents.
			179	+	func (x *ActionBar) SetPropertyRevealed(value bool) {
			180	+	var v gobject.Value
			181	+	v.Init(gobject.TypeBooleanVal)
			182	+	v.SetBoolean(value)
			183	+	x.SetProperty("revealed", &v)
			184	+	}
			185	+
			186	+	// GetPropertyRevealed gets the "revealed" property.
			187	+	// Controls whether the action bar shows its contents.
			188	+	func (x *ActionBar) GetPropertyRevealed() bool {
			189	+	var v gobject.Value
			190	+	x.GetProperty("revealed", &v)
			191	+	return v.GetBoolean()
			192	+	}
			193	+
177		// Requests the user's screen reader to announce the given message.	194		// Requests the user's screen reader to announce the given message.
178		//	195		//
179		// This kind of notification is useful for messages that	196		// This kind of notification is useful for messages that

@@ -231,7 +248,7 @@ func (x ActionBar) GetAtContext() ATContext {
231		// This functionality can be overridden by `GtkAccessible`	248		// This functionality can be overridden by `GtkAccessible`
232		// implementations, e.g. to get the bounds from an ignored	249		// implementations, e.g. to get the bounds from an ignored
233		// child widget.	250		// child widget.
234	-	func (x *ActionBar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	251	+	func (x ActionBar) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
235			252
236		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	253		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
237		return cret	254		return cret

M v4/gtk/gtkadjustment.go +128 -12


@@ -34,7 +34,7 @@ func (x *AdjustmentClass) GoPointer() uintptr {
34		return uintptr(unsafe.Pointer(x))	34		return uintptr(unsafe.Pointer(x))
35		}	35		}
36			36
37	-	// OverrideChanged sets the callback function.	37	+	// OverrideChanged sets the "changed" callback function.
38		func (x AdjustmentClass) OverrideChanged(cb func(Adjustment)) {	38		func (x AdjustmentClass) OverrideChanged(cb func(Adjustment)) {
39		if cb == nil {	39		if cb == nil {
40		x.xChanged = 0	40		x.xChanged = 0

@@ -45,7 +45,7 @@ func (x AdjustmentClass) OverrideChanged(cb func(Adjustment)) {
45		}	45		}
46		}	46		}
47			47
48	-	// GetChanged gets the callback function.	48	+	// GetChanged gets the "changed" callback function.
49		func (x AdjustmentClass) GetChanged() func(Adjustment) {	49		func (x AdjustmentClass) GetChanged() func(Adjustment) {
50		if x.xChanged == 0 {	50		if x.xChanged == 0 {
51		return nil	51		return nil

@@ -57,7 +57,7 @@ func (x AdjustmentClass) GetChanged() func(Adjustment) {
57		}	57		}
58		}	58		}
59			59
60	-	// OverrideValueChanged sets the callback function.	60	+	// OverrideValueChanged sets the "value_changed" callback function.
61		func (x AdjustmentClass) OverrideValueChanged(cb func(Adjustment)) {	61		func (x AdjustmentClass) OverrideValueChanged(cb func(Adjustment)) {
62		if cb == nil {	62		if cb == nil {
63		x.xValueChanged = 0	63		x.xValueChanged = 0

@@ -68,7 +68,7 @@ func (x AdjustmentClass) OverrideValueChanged(cb func(Adjustment)) {
68		}	68		}
69		}	69		}
70			70
71	-	// GetValueChanged gets the callback function.	71	+	// GetValueChanged gets the "value_changed" callback function.
72		func (x AdjustmentClass) GetValueChanged() func(Adjustment) {	72		func (x AdjustmentClass) GetValueChanged() func(Adjustment) {
73		if x.xValueChanged == 0 {	73		if x.xValueChanged == 0 {
74		return nil	74		return nil

@@ -80,7 +80,7 @@ func (x AdjustmentClass) GetValueChanged() func(Adjustment) {
80		}	80		}
81		}	81		}
82			82
83	-	// OverrideGtkReserved1 sets the callback function.	83	+	// OverrideGtkReserved1 sets the "_gtk_reserved1" callback function.
84		func (x *AdjustmentClass) OverrideGtkReserved1(cb func()) {	84		func (x *AdjustmentClass) OverrideGtkReserved1(cb func()) {
85		if cb == nil {	85		if cb == nil {
86		x.xGtkReserved1 = 0	86		x.xGtkReserved1 = 0

@@ -91,7 +91,7 @@ func (x *AdjustmentClass) OverrideGtkReserved1(cb func()) {
91		}	91		}
92		}	92		}
93			93
94	-	// GetGtkReserved1 gets the callback function.	94	+	// GetGtkReserved1 gets the "_gtk_reserved1" callback function.
95		func (x *AdjustmentClass) GetGtkReserved1() func() {	95		func (x *AdjustmentClass) GetGtkReserved1() func() {
96		if x.xGtkReserved1 == 0 {	96		if x.xGtkReserved1 == 0 {
97		return nil	97		return nil

@@ -103,7 +103,7 @@ func (x *AdjustmentClass) GetGtkReserved1() func() {
103		}	103		}
104		}	104		}
105			105
106	-	// OverrideGtkReserved2 sets the callback function.	106	+	// OverrideGtkReserved2 sets the "_gtk_reserved2" callback function.
107		func (x *AdjustmentClass) OverrideGtkReserved2(cb func()) {	107		func (x *AdjustmentClass) OverrideGtkReserved2(cb func()) {
108		if cb == nil {	108		if cb == nil {
109		x.xGtkReserved2 = 0	109		x.xGtkReserved2 = 0

@@ -114,7 +114,7 @@ func (x *AdjustmentClass) OverrideGtkReserved2(cb func()) {
114		}	114		}
115		}	115		}
116			116
117	-	// GetGtkReserved2 gets the callback function.	117	+	// GetGtkReserved2 gets the "_gtk_reserved2" callback function.
118		func (x *AdjustmentClass) GetGtkReserved2() func() {	118		func (x *AdjustmentClass) GetGtkReserved2() func() {
119		if x.xGtkReserved2 == 0 {	119		if x.xGtkReserved2 == 0 {
120		return nil	120		return nil

@@ -126,7 +126,7 @@ func (x *AdjustmentClass) GetGtkReserved2() func() {
126		}	126		}
127		}	127		}
128			128
129	-	// OverrideGtkReserved3 sets the callback function.	129	+	// OverrideGtkReserved3 sets the "_gtk_reserved3" callback function.
130		func (x *AdjustmentClass) OverrideGtkReserved3(cb func()) {	130		func (x *AdjustmentClass) OverrideGtkReserved3(cb func()) {
131		if cb == nil {	131		if cb == nil {
132		x.xGtkReserved3 = 0	132		x.xGtkReserved3 = 0

@@ -137,7 +137,7 @@ func (x *AdjustmentClass) OverrideGtkReserved3(cb func()) {
137		}	137		}
138		}	138		}
139			139
140	-	// GetGtkReserved3 gets the callback function.	140	+	// GetGtkReserved3 gets the "_gtk_reserved3" callback function.
141		func (x *AdjustmentClass) GetGtkReserved3() func() {	141		func (x *AdjustmentClass) GetGtkReserved3() func() {
142		if x.xGtkReserved3 == 0 {	142		if x.xGtkReserved3 == 0 {
143		return nil	143		return nil

@@ -149,7 +149,7 @@ func (x *AdjustmentClass) GetGtkReserved3() func() {
149		}	149		}
150		}	150		}
151			151
152	-	// OverrideGtkReserved4 sets the callback function.	152	+	// OverrideGtkReserved4 sets the "_gtk_reserved4" callback function.
153		func (x *AdjustmentClass) OverrideGtkReserved4(cb func()) {	153		func (x *AdjustmentClass) OverrideGtkReserved4(cb func()) {
154		if cb == nil {	154		if cb == nil {
155		x.xGtkReserved4 = 0	155		x.xGtkReserved4 = 0

@@ -160,7 +160,7 @@ func (x *AdjustmentClass) OverrideGtkReserved4(cb func()) {
160		}	160		}
161		}	161		}
162			162
163	-	// GetGtkReserved4 gets the callback function.	163	+	// GetGtkReserved4 gets the "_gtk_reserved4" callback function.
164		func (x *AdjustmentClass) GetGtkReserved4() func() {	164		func (x *AdjustmentClass) GetGtkReserved4() func() {
165		if x.xGtkReserved4 == 0 {	165		if x.xGtkReserved4 == 0 {
166		return nil	166		return nil

@@ -415,6 +415,122 @@ func (c *Adjustment) SetGoPointer(ptr uintptr) {
415		c.Ptr = ptr	415		c.Ptr = ptr
416		}	416		}
417			417
			418	+	// SetPropertyLower sets the "lower" property.
			419	+	// The minimum value of the adjustment.
			420	+	func (x *Adjustment) SetPropertyLower(value float64) {
			421	+	var v gobject.Value
			422	+	v.Init(gobject.TypeDoubleVal)
			423	+	v.SetDouble(value)
			424	+	x.SetProperty("lower", &v)
			425	+	}
			426	+
			427	+	// GetPropertyLower gets the "lower" property.
			428	+	// The minimum value of the adjustment.
			429	+	func (x *Adjustment) GetPropertyLower() float64 {
			430	+	var v gobject.Value
			431	+	x.GetProperty("lower", &v)
			432	+	return v.GetDouble()
			433	+	}
			434	+
			435	+	// SetPropertyPageIncrement sets the "page-increment" property.
			436	+	// The page increment of the adjustment.
			437	+	func (x *Adjustment) SetPropertyPageIncrement(value float64) {
			438	+	var v gobject.Value
			439	+	v.Init(gobject.TypeDoubleVal)
			440	+	v.SetDouble(value)
			441	+	x.SetProperty("page-increment", &v)
			442	+	}
			443	+
			444	+	// GetPropertyPageIncrement gets the "page-increment" property.
			445	+	// The page increment of the adjustment.
			446	+	func (x *Adjustment) GetPropertyPageIncrement() float64 {
			447	+	var v gobject.Value
			448	+	x.GetProperty("page-increment", &v)
			449	+	return v.GetDouble()
			450	+	}
			451	+
			452	+	// SetPropertyPageSize sets the "page-size" property.
			453	+	// The page size of the adjustment.
			454	+	//
			455	+	// Note that the page-size is irrelevant and should be set to zero
			456	+	// if the adjustment is used for a simple scalar value, e.g. in a
			457	+	// `GtkSpinButton`.
			458	+	func (x *Adjustment) SetPropertyPageSize(value float64) {
			459	+	var v gobject.Value
			460	+	v.Init(gobject.TypeDoubleVal)
			461	+	v.SetDouble(value)
			462	+	x.SetProperty("page-size", &v)
			463	+	}
			464	+
			465	+	// GetPropertyPageSize gets the "page-size" property.
			466	+	// The page size of the adjustment.
			467	+	//
			468	+	// Note that the page-size is irrelevant and should be set to zero
			469	+	// if the adjustment is used for a simple scalar value, e.g. in a
			470	+	// `GtkSpinButton`.
			471	+	func (x *Adjustment) GetPropertyPageSize() float64 {
			472	+	var v gobject.Value
			473	+	x.GetProperty("page-size", &v)
			474	+	return v.GetDouble()
			475	+	}
			476	+
			477	+	// SetPropertyStepIncrement sets the "step-increment" property.
			478	+	// The step increment of the adjustment.
			479	+	func (x *Adjustment) SetPropertyStepIncrement(value float64) {
			480	+	var v gobject.Value
			481	+	v.Init(gobject.TypeDoubleVal)
			482	+	v.SetDouble(value)
			483	+	x.SetProperty("step-increment", &v)
			484	+	}
			485	+
			486	+	// GetPropertyStepIncrement gets the "step-increment" property.
			487	+	// The step increment of the adjustment.
			488	+	func (x *Adjustment) GetPropertyStepIncrement() float64 {
			489	+	var v gobject.Value
			490	+	x.GetProperty("step-increment", &v)
			491	+	return v.GetDouble()
			492	+	}
			493	+
			494	+	// SetPropertyUpper sets the "upper" property.
			495	+	// The maximum value of the adjustment.
			496	+	//
			497	+	// Note that values will be restricted by `upper - page-size` if the page-size
			498	+	// property is nonzero.
			499	+	func (x *Adjustment) SetPropertyUpper(value float64) {
			500	+	var v gobject.Value
			501	+	v.Init(gobject.TypeDoubleVal)
			502	+	v.SetDouble(value)
			503	+	x.SetProperty("upper", &v)
			504	+	}
			505	+
			506	+	// GetPropertyUpper gets the "upper" property.
			507	+	// The maximum value of the adjustment.
			508	+	//
			509	+	// Note that values will be restricted by `upper - page-size` if the page-size
			510	+	// property is nonzero.
			511	+	func (x *Adjustment) GetPropertyUpper() float64 {
			512	+	var v gobject.Value
			513	+	x.GetProperty("upper", &v)
			514	+	return v.GetDouble()
			515	+	}
			516	+
			517	+	// SetPropertyValue sets the "value" property.
			518	+	// The value of the adjustment.
			519	+	func (x *Adjustment) SetPropertyValue(value float64) {
			520	+	var v gobject.Value
			521	+	v.Init(gobject.TypeDoubleVal)
			522	+	v.SetDouble(value)
			523	+	x.SetProperty("value", &v)
			524	+	}
			525	+
			526	+	// GetPropertyValue gets the "value" property.
			527	+	// The value of the adjustment.
			528	+	func (x *Adjustment) GetPropertyValue() float64 {
			529	+	var v gobject.Value
			530	+	x.GetProperty("value", &v)
			531	+	return v.GetDouble()
			532	+	}
			533	+
418		// Emitted when one or more of the `GtkAdjustment` properties have been	534		// Emitted when one or more of the `GtkAdjustment` properties have been
419		// changed.	535		// changed.
420		//	536		//

M v4/gtk/gtkalertdialog.go +146 -0


@@ -235,6 +235,152 @@ func (c *AlertDialog) SetGoPointer(ptr uintptr) {
235	c.Ptr = ptr	235		c.Ptr = ptr
236	}	236		}
237		237
		238	+	// SetPropertyButtons sets the "buttons" property.
		239	+	// Labels for buttons to show in the alert.
		240	+	//
		241	+	// The labels should be translated and may contain
		242	+	// a `_` character to indicate the mnemonic character.
		243	+	//
		244	+	// If this property is not set, then a 'Close' button is
		245	+	// automatically created.
		246	+	func (x *AlertDialog) SetPropertyButtons(value []string) {
		247	+	var v gobject.Value
		248	+	v.Init(glib.StrvGetType())
		249	+	v.SetBoxed(uintptr(unsafe.Pointer(core.ByteSlice(value))))
		250	+	x.SetProperty("buttons", &v)
		251	+	}
		252	+
		253	+	// GetPropertyButtons gets the "buttons" property.
		254	+	// Labels for buttons to show in the alert.
		255	+	//
		256	+	// The labels should be translated and may contain
		257	+	// a `_` character to indicate the mnemonic character.
		258	+	//
		259	+	// If this property is not set, then a 'Close' button is
		260	+	// automatically created.
		261	+	func (x *AlertDialog) GetPropertyButtons() []string {
		262	+	var v gobject.Value
		263	+	x.GetProperty("buttons", &v)
		264	+	return core.GoStringSlice(v.GetBoxed())
		265	+	}
		266	+
		267	+	// SetPropertyCancelButton sets the "cancel-button" property.
		268	+	// Determines what happens when the <kbd>Escape</kbd> key is pressed
		269	+	// while the alert is shown.
		270	+	//
		271	+	// If this property holds the index of a button in [property@Gtk.AlertDialog:buttons],
		272	+	// then pressing Escape is treated as if that button was pressed. If it is -1
		273	+	// or not a valid index for the `buttons` array, then an error is returned.
		274	+	//
		275	+	// If `buttons` is `NULL`, then the automatically created 'Close' button
		276	+	// is treated as both cancel and default button, so 0 is returned.
		277	+	func (x *AlertDialog) SetPropertyCancelButton(value int) {
		278	+	var v gobject.Value
		279	+	v.Init(gobject.TypeIntVal)
		280	+	v.SetInt(value)
		281	+	x.SetProperty("cancel-button", &v)
		282	+	}
		283	+
		284	+	// GetPropertyCancelButton gets the "cancel-button" property.
		285	+	// Determines what happens when the <kbd>Escape</kbd> key is pressed
		286	+	// while the alert is shown.
		287	+	//
		288	+	// If this property holds the index of a button in [property@Gtk.AlertDialog:buttons],
		289	+	// then pressing Escape is treated as if that button was pressed. If it is -1
		290	+	// or not a valid index for the `buttons` array, then an error is returned.
		291	+	//
		292	+	// If `buttons` is `NULL`, then the automatically created 'Close' button
		293	+	// is treated as both cancel and default button, so 0 is returned.
		294	+	func (x *AlertDialog) GetPropertyCancelButton() int {
		295	+	var v gobject.Value
		296	+	x.GetProperty("cancel-button", &v)
		297	+	return v.GetInt()
		298	+	}
		299	+
		300	+	// SetPropertyDefaultButton sets the "default-button" property.
		301	+	// Determines what happens when the <kbd>Return</kbd> key is pressed
		302	+	// while the alert is shown.
		303	+	//
		304	+	// If this property holds the index of a button in [property@Gtk.AlertDialog:buttons],
		305	+	// then pressing Return is treated as if that button was pressed. If it is -1
		306	+	// or not a valid index for the `buttons` array, then nothing happens.
		307	+	//
		308	+	// If `buttons` is `NULL`, then the automatically created 'Close' button
		309	+	// is treated as both cancel and default button, so 0 is returned.
		310	+	func (x *AlertDialog) SetPropertyDefaultButton(value int) {
		311	+	var v gobject.Value
		312	+	v.Init(gobject.TypeIntVal)
		313	+	v.SetInt(value)
		314	+	x.SetProperty("default-button", &v)
		315	+	}
		316	+
		317	+	// GetPropertyDefaultButton gets the "default-button" property.
		318	+	// Determines what happens when the <kbd>Return</kbd> key is pressed
		319	+	// while the alert is shown.
		320	+	//
		321	+	// If this property holds the index of a button in [property@Gtk.AlertDialog:buttons],
		322	+	// then pressing Return is treated as if that button was pressed. If it is -1
		323	+	// or not a valid index for the `buttons` array, then nothing happens.
		324	+	//
		325	+	// If `buttons` is `NULL`, then the automatically created 'Close' button
		326	+	// is treated as both cancel and default button, so 0 is returned.
		327	+	func (x *AlertDialog) GetPropertyDefaultButton() int {
		328	+	var v gobject.Value
		329	+	x.GetProperty("default-button", &v)
		330	+	return v.GetInt()
		331	+	}
		332	+
		333	+	// SetPropertyDetail sets the "detail" property.
		334	+	// The detail text for the alert.
		335	+	func (x *AlertDialog) SetPropertyDetail(value string) {
		336	+	var v gobject.Value
		337	+	v.Init(gobject.TypeStringVal)
		338	+	v.SetString(value)
		339	+	x.SetProperty("detail", &v)
		340	+	}
		341	+
		342	+	// GetPropertyDetail gets the "detail" property.
		343	+	// The detail text for the alert.
		344	+	func (x *AlertDialog) GetPropertyDetail() string {
		345	+	var v gobject.Value
		346	+	x.GetProperty("detail", &v)
		347	+	return v.GetString()
		348	+	}
		349	+
		350	+	// SetPropertyMessage sets the "message" property.
		351	+	// The message for the alert.
		352	+	func (x *AlertDialog) SetPropertyMessage(value string) {
		353	+	var v gobject.Value
		354	+	v.Init(gobject.TypeStringVal)
		355	+	v.SetString(value)
		356	+	x.SetProperty("message", &v)
		357	+	}
		358	+
		359	+	// GetPropertyMessage gets the "message" property.
		360	+	// The message for the alert.
		361	+	func (x *AlertDialog) GetPropertyMessage() string {
		362	+	var v gobject.Value
		363	+	x.GetProperty("message", &v)
		364	+	return v.GetString()
		365	+	}
		366	+
		367	+	// SetPropertyModal sets the "modal" property.
		368	+	// Whether the alert is modal.
		369	+	func (x *AlertDialog) SetPropertyModal(value bool) {
		370	+	var v gobject.Value
		371	+	v.Init(gobject.TypeBooleanVal)
		372	+	v.SetBoolean(value)
		373	+	x.SetProperty("modal", &v)
		374	+	}
		375	+
		376	+	// GetPropertyModal gets the "modal" property.
		377	+	// Whether the alert is modal.
		378	+	func (x *AlertDialog) GetPropertyModal() bool {
		379	+	var v gobject.Value
		380	+	x.GetProperty("modal", &v)
		381	+	return v.GetBoolean()
		382	+	}
		383	+
238	func init() {	384		func init() {
239	core.SetPackageName("GTK", "gtk4")	385		core.SetPackageName("GTK", "gtk4")
240	core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})	386		core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})

M v4/gtk/gtkappchooser.go +26 -0


@@ -5,6 +5,7 @@ import (
5	"github.com/jwijenbergh/purego"	5		"github.com/jwijenbergh/purego"
6	"github.com/jwijenbergh/puregotk/pkg/core"	6		"github.com/jwijenbergh/puregotk/pkg/core"
7	"github.com/jwijenbergh/puregotk/v4/gio"	7		"github.com/jwijenbergh/puregotk/v4/gio"
		8	+	"github.com/jwijenbergh/puregotk/v4/gobject"
8	"github.com/jwijenbergh/puregotk/v4/gobject/types"	9		"github.com/jwijenbergh/puregotk/v4/gobject/types"
9	)	10		)
10		11

@@ -85,6 +86,31 @@ func (x *AppChooserBase) Refresh() {
85		86
86	}	87		}
87		88
		89	+	// SetPropertyContentType sets the "content-type" property.
		90	+	// The content type of the `GtkAppChooser` object.
		91	+	//
		92	+	// See `GContentType` for more information about content types.
		93	+	func (x *AppChooserBase) SetPropertyContentType(value string) {
		94	+	obj := gobject.Object{}
		95	+	obj.Ptr = x.GoPointer()
		96	+	var v gobject.Value
		97	+	v.Init(gobject.TypeStringVal)
		98	+	v.SetString(value)
		99	+	obj.SetProperty("content-type", &v)
		100	+	}
		101	+
		102	+	// GetPropertyContentType gets the "content-type" property.
		103	+	// The content type of the `GtkAppChooser` object.
		104	+	//
		105	+	// See `GContentType` for more information about content types.
		106	+	func (x *AppChooserBase) GetPropertyContentType() string {
		107	+	obj := gobject.Object{}
		108	+	obj.Ptr = x.GoPointer()
		109	+	var v gobject.Value
		110	+	obj.GetProperty("content-type", &v)
		111	+	return v.GetString()
		112	+	}
		113	+
88	var XGtkAppChooserGetAppInfo func(uintptr) uintptr	114		var XGtkAppChooserGetAppInfo func(uintptr) uintptr
89	var XGtkAppChooserGetContentType func(uintptr) string	115		var XGtkAppChooserGetContentType func(uintptr) string
90	var XGtkAppChooserRefresh func(uintptr)	116		var XGtkAppChooserRefresh func(uintptr)

M v4/gtk/gtkappchooserbutton.go +79 -1


@@ -208,6 +208,84 @@ func (c *AppChooserButton) SetGoPointer(ptr uintptr) {
208		c.Ptr = ptr	208		c.Ptr = ptr
209		}	209		}
210			210
			211	+	// SetPropertyHeading sets the "heading" property.
			212	+	// The text to show at the top of the dialog that can be
			213	+	// opened from the button.
			214	+	//
			215	+	// The string may contain Pango markup.
			216	+	func (x *AppChooserButton) SetPropertyHeading(value string) {
			217	+	var v gobject.Value
			218	+	v.Init(gobject.TypeStringVal)
			219	+	v.SetString(value)
			220	+	x.SetProperty("heading", &v)
			221	+	}
			222	+
			223	+	// GetPropertyHeading gets the "heading" property.
			224	+	// The text to show at the top of the dialog that can be
			225	+	// opened from the button.
			226	+	//
			227	+	// The string may contain Pango markup.
			228	+	func (x *AppChooserButton) GetPropertyHeading() string {
			229	+	var v gobject.Value
			230	+	x.GetProperty("heading", &v)
			231	+	return v.GetString()
			232	+	}
			233	+
			234	+	// SetPropertyModal sets the "modal" property.
			235	+	// Whether the app chooser dialog should be modal.
			236	+	func (x *AppChooserButton) SetPropertyModal(value bool) {
			237	+	var v gobject.Value
			238	+	v.Init(gobject.TypeBooleanVal)
			239	+	v.SetBoolean(value)
			240	+	x.SetProperty("modal", &v)
			241	+	}
			242	+
			243	+	// GetPropertyModal gets the "modal" property.
			244	+	// Whether the app chooser dialog should be modal.
			245	+	func (x *AppChooserButton) GetPropertyModal() bool {
			246	+	var v gobject.Value
			247	+	x.GetProperty("modal", &v)
			248	+	return v.GetBoolean()
			249	+	}
			250	+
			251	+	// SetPropertyShowDefaultItem sets the "show-default-item" property.
			252	+	// Determines whether the dropdown menu shows the default application
			253	+	// on top for the provided content type.
			254	+	func (x *AppChooserButton) SetPropertyShowDefaultItem(value bool) {
			255	+	var v gobject.Value
			256	+	v.Init(gobject.TypeBooleanVal)
			257	+	v.SetBoolean(value)
			258	+	x.SetProperty("show-default-item", &v)
			259	+	}
			260	+
			261	+	// GetPropertyShowDefaultItem gets the "show-default-item" property.
			262	+	// Determines whether the dropdown menu shows the default application
			263	+	// on top for the provided content type.
			264	+	func (x *AppChooserButton) GetPropertyShowDefaultItem() bool {
			265	+	var v gobject.Value
			266	+	x.GetProperty("show-default-item", &v)
			267	+	return v.GetBoolean()
			268	+	}
			269	+
			270	+	// SetPropertyShowDialogItem sets the "show-dialog-item" property.
			271	+	// Determines whether the dropdown menu shows an item to open
			272	+	// a `GtkAppChooserDialog`.
			273	+	func (x *AppChooserButton) SetPropertyShowDialogItem(value bool) {
			274	+	var v gobject.Value
			275	+	v.Init(gobject.TypeBooleanVal)
			276	+	v.SetBoolean(value)
			277	+	x.SetProperty("show-dialog-item", &v)
			278	+	}
			279	+
			280	+	// GetPropertyShowDialogItem gets the "show-dialog-item" property.
			281	+	// Determines whether the dropdown menu shows an item to open
			282	+	// a `GtkAppChooserDialog`.
			283	+	func (x *AppChooserButton) GetPropertyShowDialogItem() bool {
			284	+	var v gobject.Value
			285	+	x.GetProperty("show-dialog-item", &v)
			286	+	return v.GetBoolean()
			287	+	}
			288	+
211		// Emitted to when the button is activated.	289		// Emitted to when the button is activated.
212		//	290		//
213		// The `::activate` signal on `GtkAppChooserButton` is an action signal and	291		// The `::activate` signal on `GtkAppChooserButton` is an action signal and

@@ -331,7 +409,7 @@ func (x AppChooserButton) GetAtContext() ATContext {
331		// This functionality can be overridden by `GtkAccessible`	409		// This functionality can be overridden by `GtkAccessible`
332		// implementations, e.g. to get the bounds from an ignored	410		// implementations, e.g. to get the bounds from an ignored
333		// child widget.	411		// child widget.
334	-	func (x *AppChooserButton) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	412	+	func (x AppChooserButton) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
335			413
336		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	414		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
337		return cret	415		return cret

M v4/gtk/gtkappchooserdialog.go +23 -2


@@ -135,6 +135,27 @@ func (c *AppChooserDialog) SetGoPointer(ptr uintptr) {
135		c.Ptr = ptr	135		c.Ptr = ptr
136		}	136		}
137			137
			138	+	// SetPropertyHeading sets the "heading" property.
			139	+	// The text to show at the top of the dialog.
			140	+	//
			141	+	// The string may contain Pango markup.
			142	+	func (x *AppChooserDialog) SetPropertyHeading(value string) {
			143	+	var v gobject.Value
			144	+	v.Init(gobject.TypeStringVal)
			145	+	v.SetString(value)
			146	+	x.SetProperty("heading", &v)
			147	+	}
			148	+
			149	+	// GetPropertyHeading gets the "heading" property.
			150	+	// The text to show at the top of the dialog.
			151	+	//
			152	+	// The string may contain Pango markup.
			153	+	func (x *AppChooserDialog) GetPropertyHeading() string {
			154	+	var v gobject.Value
			155	+	x.GetProperty("heading", &v)
			156	+	return v.GetString()
			157	+	}
			158	+
138		// Requests the user's screen reader to announce the given message.	159		// Requests the user's screen reader to announce the given message.
139		//	160		//
140		// This kind of notification is useful for messages that	161		// This kind of notification is useful for messages that

@@ -192,7 +213,7 @@ func (x AppChooserDialog) GetAtContext() ATContext {
192		// This functionality can be overridden by `GtkAccessible`	213		// This functionality can be overridden by `GtkAccessible`
193		// implementations, e.g. to get the bounds from an ignored	214		// implementations, e.g. to get the bounds from an ignored
194		// child widget.	215		// child widget.
195	-	func (x *AppChooserDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	216	+	func (x AppChooserDialog) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
196			217
197		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	218		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
198		return cret	219		return cret

@@ -476,7 +497,7 @@ func (x AppChooserDialog) GetSurface() gdk.Surface {
476		//	497		//
477		// This is the translation from @self's surface coordinates into	498		// This is the translation from @self's surface coordinates into
478		// @self's widget coordinates.	499		// @self's widget coordinates.
479	-	func (x *AppChooserDialog) GetSurfaceTransform(XVar float64, YVar float64) {	500	+	func (x AppChooserDialog) GetSurfaceTransform(XVar float64, YVar *float64) {
480			501
481		XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	502		XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
482			503

M v4/gtk/gtkappchooserwidget.go +135 -1


@@ -200,6 +200,140 @@ func (c *AppChooserWidget) SetGoPointer(ptr uintptr) {
200		c.Ptr = ptr	200		c.Ptr = ptr
201		}	201		}
202			202
			203	+	// SetPropertyDefaultText sets the "default-text" property.
			204	+	// The text that appears in the widget when there are no applications
			205	+	// for the given content type.
			206	+	func (x *AppChooserWidget) SetPropertyDefaultText(value string) {
			207	+	var v gobject.Value
			208	+	v.Init(gobject.TypeStringVal)
			209	+	v.SetString(value)
			210	+	x.SetProperty("default-text", &v)
			211	+	}
			212	+
			213	+	// GetPropertyDefaultText gets the "default-text" property.
			214	+	// The text that appears in the widget when there are no applications
			215	+	// for the given content type.
			216	+	func (x *AppChooserWidget) GetPropertyDefaultText() string {
			217	+	var v gobject.Value
			218	+	x.GetProperty("default-text", &v)
			219	+	return v.GetString()
			220	+	}
			221	+
			222	+	// SetPropertyShowAll sets the "show-all" property.
			223	+	// If %TRUE, the app chooser presents all applications
			224	+	// in a single list, without subsections for default,
			225	+	// recommended or related applications.
			226	+	func (x *AppChooserWidget) SetPropertyShowAll(value bool) {
			227	+	var v gobject.Value
			228	+	v.Init(gobject.TypeBooleanVal)
			229	+	v.SetBoolean(value)
			230	+	x.SetProperty("show-all", &v)
			231	+	}
			232	+
			233	+	// GetPropertyShowAll gets the "show-all" property.
			234	+	// If %TRUE, the app chooser presents all applications
			235	+	// in a single list, without subsections for default,
			236	+	// recommended or related applications.
			237	+	func (x *AppChooserWidget) GetPropertyShowAll() bool {
			238	+	var v gobject.Value
			239	+	x.GetProperty("show-all", &v)
			240	+	return v.GetBoolean()
			241	+	}
			242	+
			243	+	// SetPropertyShowDefault sets the "show-default" property.
			244	+	// Determines whether the app chooser should show the default
			245	+	// handler for the content type in a separate section.
			246	+	//
			247	+	// If %FALSE, the default handler is listed among the recommended
			248	+	// applications.
			249	+	func (x *AppChooserWidget) SetPropertyShowDefault(value bool) {
			250	+	var v gobject.Value
			251	+	v.Init(gobject.TypeBooleanVal)
			252	+	v.SetBoolean(value)
			253	+	x.SetProperty("show-default", &v)
			254	+	}
			255	+
			256	+	// GetPropertyShowDefault gets the "show-default" property.
			257	+	// Determines whether the app chooser should show the default
			258	+	// handler for the content type in a separate section.
			259	+	//
			260	+	// If %FALSE, the default handler is listed among the recommended
			261	+	// applications.
			262	+	func (x *AppChooserWidget) GetPropertyShowDefault() bool {
			263	+	var v gobject.Value
			264	+	x.GetProperty("show-default", &v)
			265	+	return v.GetBoolean()
			266	+	}
			267	+
			268	+	// SetPropertyShowFallback sets the "show-fallback" property.
			269	+	// Determines whether the app chooser should show a section
			270	+	// for fallback applications.
			271	+	//
			272	+	// If %FALSE, the fallback applications are listed among the
			273	+	// other applications.
			274	+	func (x *AppChooserWidget) SetPropertyShowFallback(value bool) {
			275	+	var v gobject.Value
			276	+	v.Init(gobject.TypeBooleanVal)
			277	+	v.SetBoolean(value)
			278	+	x.SetProperty("show-fallback", &v)
			279	+	}
			280	+
			281	+	// GetPropertyShowFallback gets the "show-fallback" property.
			282	+	// Determines whether the app chooser should show a section
			283	+	// for fallback applications.
			284	+	//
			285	+	// If %FALSE, the fallback applications are listed among the
			286	+	// other applications.
			287	+	func (x *AppChooserWidget) GetPropertyShowFallback() bool {
			288	+	var v gobject.Value
			289	+	x.GetProperty("show-fallback", &v)
			290	+	return v.GetBoolean()
			291	+	}
			292	+
			293	+	// SetPropertyShowOther sets the "show-other" property.
			294	+	// Determines whether the app chooser should show a section
			295	+	// for other applications.
			296	+	func (x *AppChooserWidget) SetPropertyShowOther(value bool) {
			297	+	var v gobject.Value
			298	+	v.Init(gobject.TypeBooleanVal)
			299	+	v.SetBoolean(value)
			300	+	x.SetProperty("show-other", &v)
			301	+	}
			302	+
			303	+	// GetPropertyShowOther gets the "show-other" property.
			304	+	// Determines whether the app chooser should show a section
			305	+	// for other applications.
			306	+	func (x *AppChooserWidget) GetPropertyShowOther() bool {
			307	+	var v gobject.Value
			308	+	x.GetProperty("show-other", &v)
			309	+	return v.GetBoolean()
			310	+	}
			311	+
			312	+	// SetPropertyShowRecommended sets the "show-recommended" property.
			313	+	// Determines whether the app chooser should show a section
			314	+	// for recommended applications.
			315	+	//
			316	+	// If %FALSE, the recommended applications are listed
			317	+	// among the other applications.
			318	+	func (x *AppChooserWidget) SetPropertyShowRecommended(value bool) {
			319	+	var v gobject.Value
			320	+	v.Init(gobject.TypeBooleanVal)
			321	+	v.SetBoolean(value)
			322	+	x.SetProperty("show-recommended", &v)
			323	+	}
			324	+
			325	+	// GetPropertyShowRecommended gets the "show-recommended" property.
			326	+	// Determines whether the app chooser should show a section
			327	+	// for recommended applications.
			328	+	//
			329	+	// If %FALSE, the recommended applications are listed
			330	+	// among the other applications.
			331	+	func (x *AppChooserWidget) GetPropertyShowRecommended() bool {
			332	+	var v gobject.Value
			333	+	x.GetProperty("show-recommended", &v)
			334	+	return v.GetBoolean()
			335	+	}
			336	+
203		// Emitted when an application item is activated from the widget's list.	337		// Emitted when an application item is activated from the widget's list.
204		//	338		//
205		// This usually happens when the user double clicks an item, or an item	339		// This usually happens when the user double clicks an item, or an item

@@ -301,7 +435,7 @@ func (x AppChooserWidget) GetAtContext() ATContext {
301		// This functionality can be overridden by `GtkAccessible`	435		// This functionality can be overridden by `GtkAccessible`
302		// implementations, e.g. to get the bounds from an ignored	436		// implementations, e.g. to get the bounds from an ignored
303		// child widget.	437		// child widget.
304	-	func (x *AppChooserWidget) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	438	+	func (x AppChooserWidget) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
305			439
306		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	440		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
307		return cret	441		return cret

M v4/gtk/gtkapplication.go +40 -5

 	return uintptr(unsafe.Pointer(x))
 }
-// OverrideWindowAdded sets the callback function.
+// OverrideWindowAdded sets the "window_added" callback function.
 // Signal emitted when a `GtkWindow` is added to
 //
 //	application through gtk_application_add_window().
 	}
 }
-// GetWindowAdded gets the callback function.
+// GetWindowAdded gets the "window_added" callback function.
 // Signal emitted when a `GtkWindow` is added to
 //
 //	application through gtk_application_add_window().
 	}
 }
-// OverrideWindowRemoved sets the callback function.
+// OverrideWindowRemoved sets the "window_removed" callback function.
 // Signal emitted when a `GtkWindow` is removed from
 //
 //	application, either as a side-effect of being destroyed or
 	}
 }
-// GetWindowRemoved gets the callback function.
+// GetWindowRemoved gets the "window_removed" callback function.
 // Signal emitted when a `GtkWindow` is removed from
 //
 //	application, either as a side-effect of being destroyed or
 	c.Ptr = ptr
 }
+// SetPropertyRegisterSession sets the "register-session" property.
+// Set this property to true to register with the session manager.
+//
+// This will make GTK track the session state (such as the
+// [property@Gtk.Application:screensaver-active] property).
+func (x *Application) SetPropertyRegisterSession(value bool) {
+	var v gobject.Value
+	v.Init(gobject.TypeBooleanVal)
+	v.SetBoolean(value)
+	x.SetProperty("register-session", &v)
+}
+// GetPropertyRegisterSession gets the "register-session" property.
+// Set this property to true to register with the session manager.
+//
+// This will make GTK track the session state (such as the
+// [property@Gtk.Application:screensaver-active] property).
+func (x *Application) GetPropertyRegisterSession() bool {
+	var v gobject.Value
+	x.GetProperty("register-session", &v)
+	return v.GetBoolean()
+}
+// GetPropertyScreensaverActive gets the "screensaver-active" property.
+// This property is true if GTK believes that the screensaver
+// is currently active.
+//
+// Tracking the screensaver state is currently only supported on
+// Linux.
+func (x *Application) GetPropertyScreensaverActive() bool {
+	var v gobject.Value
+	x.GetProperty("screensaver-active", &v)
+	return v.GetBoolean()
+}
 // Emitted when the session manager is about to end the session.
 //
 // Applications can connect to this signal and call
 // fields (as indicated by having a non-`NULL` reference passed in) are
 // filled.  If the action doesn’t exist, `FALSE` is returned and the
 // fields may or may not have been modified.
-func (x *Application) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar **glib.VariantType, StateTypeVar **glib.VariantType, StateHintVar **glib.Variant, StateVar **glib.Variant) bool {
+func (x *Application) QueryAction(ActionNameVar string, EnabledVar *bool, ParameterTypeVar **glib.VariantType, StateTypeVar **glib.VariantType, StateHintVar **glib.Variant, StateVar **glib.Variant) bool {
 	cret := gio.XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
 	return cret

M v4/gtk/gtkapplicationwindow.go +32 -3


@@ -205,6 +205,35 @@ func (c *ApplicationWindow) SetGoPointer(ptr uintptr) {
205		c.Ptr = ptr	205		c.Ptr = ptr
206		}	206		}
207			207
			208	+	// SetPropertyShowMenubar sets the "show-menubar" property.
			209	+	// If this property is true, the window will display a menubar
			210	+	// unless it is shown by the desktop shell.
			211	+	//
			212	+	// See [method@Gtk.Application.set_menubar].
			213	+	//
			214	+	// If false, the window will not display a menubar, regardless
			215	+	// of whether the desktop shell is showing it or not.
			216	+	func (x *ApplicationWindow) SetPropertyShowMenubar(value bool) {
			217	+	var v gobject.Value
			218	+	v.Init(gobject.TypeBooleanVal)
			219	+	v.SetBoolean(value)
			220	+	x.SetProperty("show-menubar", &v)
			221	+	}
			222	+
			223	+	// GetPropertyShowMenubar gets the "show-menubar" property.
			224	+	// If this property is true, the window will display a menubar
			225	+	// unless it is shown by the desktop shell.
			226	+	//
			227	+	// See [method@Gtk.Application.set_menubar].
			228	+	//
			229	+	// If false, the window will not display a menubar, regardless
			230	+	// of whether the desktop shell is showing it or not.
			231	+	func (x *ApplicationWindow) GetPropertyShowMenubar() bool {
			232	+	var v gobject.Value
			233	+	x.GetProperty("show-menubar", &v)
			234	+	return v.GetBoolean()
			235	+	}
			236	+
208		// Emits the [signal@Gio.ActionGroup::action-added] signal on @action_group.	237		// Emits the [signal@Gio.ActionGroup::action-added] signal on @action_group.
209		//	238		//
210		// This function should only be called by [type@Gio.ActionGroup] implementations.	239		// This function should only be called by [type@Gio.ActionGroup] implementations.

@@ -430,7 +459,7 @@ func (x *ApplicationWindow) ListActions() []string {
430		// fields (as indicated by having a non-`NULL` reference passed in) are	459		// fields (as indicated by having a non-`NULL` reference passed in) are
431		// filled. If the action doesn’t exist, `FALSE` is returned and the	460		// filled. If the action doesn’t exist, `FALSE` is returned and the
432		// fields may or may not have been modified.	461		// fields may or may not have been modified.
433	-	func (x ApplicationWindow) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar *glib.Variant) bool {	462	+	func (x ApplicationWindow) QueryAction(ActionNameVar string, EnabledVar bool, ParameterTypeVar glib.VariantType, StateTypeVar glib.VariantType, StateHintVar glib.Variant, StateVar glib.Variant) bool {
434			463
435		cret := gio.XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)	464		cret := gio.XGActionGroupQueryAction(x.GoPointer(), ActionNameVar, EnabledVar, ParameterTypeVar, StateTypeVar, StateHintVar, StateVar)
436		return cret	465		return cret

@@ -611,7 +640,7 @@ func (x ApplicationWindow) GetAtContext() ATContext {
611		// This functionality can be overridden by `GtkAccessible`	640		// This functionality can be overridden by `GtkAccessible`
612		// implementations, e.g. to get the bounds from an ignored	641		// implementations, e.g. to get the bounds from an ignored
613		// child widget.	642		// child widget.
614	-	func (x *ApplicationWindow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	643	+	func (x ApplicationWindow) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
615			644
616		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	645		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
617		return cret	646		return cret

@@ -866,7 +895,7 @@ func (x ApplicationWindow) GetSurface() gdk.Surface {
866		//	895		//
867		// This is the translation from @self's surface coordinates into	896		// This is the translation from @self's surface coordinates into
868		// @self's widget coordinates.	897		// @self's widget coordinates.
869	-	func (x *ApplicationWindow) GetSurfaceTransform(XVar float64, YVar float64) {	898	+	func (x ApplicationWindow) GetSurfaceTransform(XVar float64, YVar *float64) {
870			899
871		XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	900		XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
872			901

M v4/gtk/gtkaspectframe.go +75 -1


@@ -171,6 +171,80 @@ func (c *AspectFrame) SetGoPointer(ptr uintptr) {
171		c.Ptr = ptr	171		c.Ptr = ptr
172		}	172		}
173			173
			174	+	// SetPropertyObeyChild sets the "obey-child" property.
			175	+	// Whether the `GtkAspectFrame` should use the aspect ratio of its child.
			176	+	func (x *AspectFrame) SetPropertyObeyChild(value bool) {
			177	+	var v gobject.Value
			178	+	v.Init(gobject.TypeBooleanVal)
			179	+	v.SetBoolean(value)
			180	+	x.SetProperty("obey-child", &v)
			181	+	}
			182	+
			183	+	// GetPropertyObeyChild gets the "obey-child" property.
			184	+	// Whether the `GtkAspectFrame` should use the aspect ratio of its child.
			185	+	func (x *AspectFrame) GetPropertyObeyChild() bool {
			186	+	var v gobject.Value
			187	+	x.GetProperty("obey-child", &v)
			188	+	return v.GetBoolean()
			189	+	}
			190	+
			191	+	// SetPropertyRatio sets the "ratio" property.
			192	+	// The aspect ratio to be used by the `GtkAspectFrame`.
			193	+	//
			194	+	// This property is only used if
			195	+	// [property@Gtk.AspectFrame:obey-child] is set to %FALSE.
			196	+	func (x *AspectFrame) SetPropertyRatio(value float32) {
			197	+	var v gobject.Value
			198	+	v.Init(gobject.TypeFloatVal)
			199	+	v.SetFloat(value)
			200	+	x.SetProperty("ratio", &v)
			201	+	}
			202	+
			203	+	// GetPropertyRatio gets the "ratio" property.
			204	+	// The aspect ratio to be used by the `GtkAspectFrame`.
			205	+	//
			206	+	// This property is only used if
			207	+	// [property@Gtk.AspectFrame:obey-child] is set to %FALSE.
			208	+	func (x *AspectFrame) GetPropertyRatio() float32 {
			209	+	var v gobject.Value
			210	+	x.GetProperty("ratio", &v)
			211	+	return v.GetFloat()
			212	+	}
			213	+
			214	+	// SetPropertyXalign sets the "xalign" property.
			215	+	// The horizontal alignment of the child.
			216	+	func (x *AspectFrame) SetPropertyXalign(value float32) {
			217	+	var v gobject.Value
			218	+	v.Init(gobject.TypeFloatVal)
			219	+	v.SetFloat(value)
			220	+	x.SetProperty("xalign", &v)
			221	+	}
			222	+
			223	+	// GetPropertyXalign gets the "xalign" property.
			224	+	// The horizontal alignment of the child.
			225	+	func (x *AspectFrame) GetPropertyXalign() float32 {
			226	+	var v gobject.Value
			227	+	x.GetProperty("xalign", &v)
			228	+	return v.GetFloat()
			229	+	}
			230	+
			231	+	// SetPropertyYalign sets the "yalign" property.
			232	+	// The vertical alignment of the child.
			233	+	func (x *AspectFrame) SetPropertyYalign(value float32) {
			234	+	var v gobject.Value
			235	+	v.Init(gobject.TypeFloatVal)
			236	+	v.SetFloat(value)
			237	+	x.SetProperty("yalign", &v)
			238	+	}
			239	+
			240	+	// GetPropertyYalign gets the "yalign" property.
			241	+	// The vertical alignment of the child.
			242	+	func (x *AspectFrame) GetPropertyYalign() float32 {
			243	+	var v gobject.Value
			244	+	x.GetProperty("yalign", &v)
			245	+	return v.GetFloat()
			246	+	}
			247	+
174		// Requests the user's screen reader to announce the given message.	248		// Requests the user's screen reader to announce the given message.
175		//	249		//
176		// This kind of notification is useful for messages that	250		// This kind of notification is useful for messages that

@@ -228,7 +302,7 @@ func (x AspectFrame) GetAtContext() ATContext {
228		// This functionality can be overridden by `GtkAccessible`	302		// This functionality can be overridden by `GtkAccessible`
229		// implementations, e.g. to get the bounds from an ignored	303		// implementations, e.g. to get the bounds from an ignored
230		// child widget.	304		// child widget.
231	-	func (x *AspectFrame) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	305	+	func (x AspectFrame) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
232			306
233		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	307		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
234		return cret	308		return cret

M v4/gtk/gtkassistant.go +67 -2


@@ -427,6 +427,31 @@ func (c *Assistant) SetGoPointer(ptr uintptr) {
427		c.Ptr = ptr	427		c.Ptr = ptr
428		}	428		}
429			429
			430	+	// SetPropertyUseHeaderBar sets the "use-header-bar" property.
			431	+	// %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
			432	+	// instead of the action-area.
			433	+	//
			434	+	// For technical reasons, this property is declared as an integer
			435	+	// property, but you should only set it to %TRUE or %FALSE.
			436	+	func (x *Assistant) SetPropertyUseHeaderBar(value int) {
			437	+	var v gobject.Value
			438	+	v.Init(gobject.TypeIntVal)
			439	+	v.SetInt(value)
			440	+	x.SetProperty("use-header-bar", &v)
			441	+	}
			442	+
			443	+	// GetPropertyUseHeaderBar gets the "use-header-bar" property.
			444	+	// %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
			445	+	// instead of the action-area.
			446	+	//
			447	+	// For technical reasons, this property is declared as an integer
			448	+	// property, but you should only set it to %TRUE or %FALSE.
			449	+	func (x *Assistant) GetPropertyUseHeaderBar() int {
			450	+	var v gobject.Value
			451	+	x.GetProperty("use-header-bar", &v)
			452	+	return v.GetInt()
			453	+	}
			454	+
430		// Emitted when the apply button is clicked.	455		// Emitted when the apply button is clicked.
431		//	456		//
432		// The default behavior of the `GtkAssistant` is to switch to the page	457		// The default behavior of the `GtkAssistant` is to switch to the page

@@ -600,7 +625,7 @@ func (x Assistant) GetAtContext() ATContext {
600		// This functionality can be overridden by `GtkAccessible`	625		// This functionality can be overridden by `GtkAccessible`
601		// implementations, e.g. to get the bounds from an ignored	626		// implementations, e.g. to get the bounds from an ignored
602		// child widget.	627		// child widget.
603	-	func (x *Assistant) GetBounds(XVar int, YVar int, WidthVar int, HeightVar int) bool {	628	+	func (x Assistant) GetBounds(XVar int, YVar int, WidthVar int, HeightVar *int) bool {
604			629
605		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)	630		cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
606		return cret	631		return cret

@@ -855,7 +880,7 @@ func (x Assistant) GetSurface() gdk.Surface {
855		//	880		//
856		// This is the translation from @self's surface coordinates into	881		// This is the translation from @self's surface coordinates into
857		// @self's widget coordinates.	882		// @self's widget coordinates.
858	-	func (x *Assistant) GetSurfaceTransform(XVar float64, YVar float64) {	883	+	func (x Assistant) GetSurfaceTransform(XVar float64, YVar *float64) {
859			884
860		XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)	885		XGtkNativeGetSurfaceTransform(x.GoPointer(), XVar, YVar)
861			886

@@ -973,6 +998,46 @@ func (c *AssistantPage) SetGoPointer(ptr uintptr) {
973		c.Ptr = ptr	998		c.Ptr = ptr
974		}	999		}
975			1000
			1001	+	// SetPropertyComplete sets the "complete" property.
			1002	+	// Whether all required fields are filled in.
			1003	+	//
			1004	+	// GTK uses this information to control the sensitivity
			1005	+	// of the navigation buttons.
			1006	+	func (x *AssistantPage) SetPropertyComplete(value bool) {
			1007	+	var v gobject.Value
			1008	+	v.Init(gobject.TypeBooleanVal)
			1009	+	v.SetBoolean(value)
			1010	+	x.SetProperty("complete", &v)
			1011	+	}
			1012	+
			1013	+	// GetPropertyComplete gets the "complete" property.
			1014	+	// Whether all required fields are filled in.
			1015	+	//
			1016	+	// GTK uses this information to control the sensitivity
			1017	+	// of the navigation buttons.
			1018	+	func (x *AssistantPage) GetPropertyComplete() bool {
			1019	+	var v gobject.Value
			1020	+	x.GetProperty("complete", &v)
			1021	+	return v.GetBoolean()
			1022	+	}
			1023	+
			1024	+	// SetPropertyTitle sets the "title" property.
			1025	+	// The title of the page.
			1026	+	func (x *AssistantPage) SetPropertyTitle(value string) {
			1027	+	var v gobject.Value
			1028	+	v.Init(gobject.TypeStringVal)
			1029	+	v.SetString(value)
			1030	+	x.SetProperty("title", &v)
			1031	+	}
			1032	+
			1033	+	// GetPropertyTitle gets the "title" property.
			1034	+	// The title of the page.
			1035	+	func (x *AssistantPage) GetPropertyTitle() string {
			1036	+	var v gobject.Value
			1037	+	x.GetProperty("title", &v)
			1038	+	return v.GetString()
			1039	+	}
			1040	+
976		func init() {	1041		func init() {
977		core.SetPackageName("GTK", "gtk4")	1042		core.SetPackageName("GTK", "gtk4")
978		core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})	1043		core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})

M v4/gtk/gtkbitset.go +10 -10


@@ -54,61 +54,61 @@ func (x *BitsetIter) IsValid() bool {
54		return cret	54		return cret
55		}	55		}
56			56
57	-	var xBitsetIterNext func(uintptr, uint) bool	57	+	var xBitsetIterNext func(uintptr, *uint) bool
58			58
59		// Moves @iter to the next value in the set.	59		// Moves @iter to the next value in the set.
60		//	60		//
61		// If it was already pointing to the last value in the set,	61		// If it was already pointing to the last value in the set,
62		// %FALSE is returned and @iter is invalidated.	62		// %FALSE is returned and @iter is invalidated.
63	-	func (x *BitsetIter) Next(ValueVar uint) bool {	63	+	func (x BitsetIter) Next(ValueVar uint) bool {
64			64
65		cret := xBitsetIterNext(x.GoPointer(), ValueVar)	65		cret := xBitsetIterNext(x.GoPointer(), ValueVar)
66		return cret	66		return cret
67		}	67		}
68			68
69	-	var xBitsetIterPrevious func(uintptr, uint) bool	69	+	var xBitsetIterPrevious func(uintptr, *uint) bool
70			70
71		// Moves @iter to the previous value in the set.	71		// Moves @iter to the previous value in the set.
72		//	72		//
73		// If it was already pointing to the first value in the set,	73		// If it was already pointing to the first value in the set,
74		// %FALSE is returned and @iter is invalidated.	74		// %FALSE is returned and @iter is invalidated.
75	-	func (x *BitsetIter) Previous(ValueVar uint) bool {	75	+	func (x BitsetIter) Previous(ValueVar uint) bool {
76			76
77		cret := xBitsetIterPrevious(x.GoPointer(), ValueVar)	77		cret := xBitsetIterPrevious(x.GoPointer(), ValueVar)
78		return cret	78		return cret
79		}	79		}
80			80
81	-	var xBitsetIterInitAt func(BitsetIter, Bitset, uint, uint) bool	81	+	var xBitsetIterInitAt func(BitsetIter, Bitset, uint, *uint) bool
82			82
83		// Initializes @iter to point to @target.	83		// Initializes @iter to point to @target.
84		//	84		//
85		// If @target is not found, finds the next value after it.	85		// If @target is not found, finds the next value after it.
86		// If no value >= @target exists in @set, this function returns %FALSE.	86		// If no value >= @target exists in @set, this function returns %FALSE.
87	-	func BitsetIterInitAt(IterVar BitsetIter, SetVar Bitset, TargetVar uint, ValueVar uint) bool {	87	+	func BitsetIterInitAt(IterVar BitsetIter, SetVar Bitset, TargetVar uint, ValueVar *uint) bool {
88			88
89		cret := xBitsetIterInitAt(IterVar, SetVar, TargetVar, ValueVar)	89		cret := xBitsetIterInitAt(IterVar, SetVar, TargetVar, ValueVar)
90		return cret	90		return cret
91		}	91		}
92			92
93	-	var xBitsetIterInitFirst func(BitsetIter, Bitset, uint) bool	93	+	var xBitsetIterInitFirst func(BitsetIter, Bitset, *uint) bool
94			94
95		// Initializes an iterator for @set and points it to the first	95		// Initializes an iterator for @set and points it to the first
96		// value in @set.	96		// value in @set.
97		//	97		//
98		// If @set is empty, %FALSE is returned and @value is set to %G_MAXUINT.	98		// If @set is empty, %FALSE is returned and @value is set to %G_MAXUINT.
99	-	func BitsetIterInitFirst(IterVar BitsetIter, SetVar Bitset, ValueVar uint) bool {	99	+	func BitsetIterInitFirst(IterVar BitsetIter, SetVar Bitset, ValueVar *uint) bool {
100			100
101		cret := xBitsetIterInitFirst(IterVar, SetVar, ValueVar)	101		cret := xBitsetIterInitFirst(IterVar, SetVar, ValueVar)
102		return cret	102		return cret
103		}	103		}
104			104
105	-	var xBitsetIterInitLast func(BitsetIter, Bitset, uint) bool	105	+	var xBitsetIterInitLast func(BitsetIter, Bitset, *uint) bool
106			106
107		// Initializes an iterator for @set and points it to the last	107		// Initializes an iterator for @set and points it to the last
108		// value in @set.	108		// value in @set.
109		//	109		//
110		// If @set is empty, %FALSE is returned.	110		// If @set is empty, %FALSE is returned.
111	-	func BitsetIterInitLast(IterVar BitsetIter, SetVar Bitset, ValueVar uint) bool {	111	+	func BitsetIterInitLast(IterVar BitsetIter, SetVar Bitset, ValueVar *uint) bool {
112			112
113		cret := xBitsetIterInitLast(IterVar, SetVar, ValueVar)	113		cret := xBitsetIterInitLast(IterVar, SetVar, ValueVar)
114		return cret	114		return cret

M v4/gtk/gtkbookmarklist.go +67 -0


@@ -137,6 +137,73 @@ func (c *BookmarkList) SetGoPointer(ptr uintptr) {
137	c.Ptr = ptr	137		c.Ptr = ptr
138	}	138		}
139		139
		140	+	// SetPropertyAttributes sets the "attributes" property.
		141	+	// The attributes to query.
		142	+	func (x *BookmarkList) SetPropertyAttributes(value string) {
		143	+	var v gobject.Value
		144	+	v.Init(gobject.TypeStringVal)
		145	+	v.SetString(value)
		146	+	x.SetProperty("attributes", &v)
		147	+	}
		148	+
		149	+	// GetPropertyAttributes gets the "attributes" property.
		150	+	// The attributes to query.
		151	+	func (x *BookmarkList) GetPropertyAttributes() string {
		152	+	var v gobject.Value
		153	+	x.GetProperty("attributes", &v)
		154	+	return v.GetString()
		155	+	}
		156	+
		157	+	// SetPropertyFilename sets the "filename" property.
		158	+	// The bookmark file to load.
		159	+	func (x *BookmarkList) SetPropertyFilename(value string) {
		160	+	var v gobject.Value
		161	+	v.Init(gobject.TypeStringVal)
		162	+	v.SetString(value)
		163	+	x.SetProperty("filename", &v)
		164	+	}
		165	+
		166	+	// GetPropertyFilename gets the "filename" property.
		167	+	// The bookmark file to load.
		168	+	func (x *BookmarkList) GetPropertyFilename() string {
		169	+	var v gobject.Value
		170	+	x.GetProperty("filename", &v)
		171	+	return v.GetString()
		172	+	}
		173	+
		174	+	// SetPropertyIoPriority sets the "io-priority" property.
		175	+	// Priority used when loading.
		176	+	func (x *BookmarkList) SetPropertyIoPriority(value int) {
		177	+	var v gobject.Value
		178	+	v.Init(gobject.TypeIntVal)
		179	+	v.SetInt(value)
		180	+	x.SetProperty("io-priority", &v)
		181	+	}
		182	+
		183	+	// GetPropertyIoPriority gets the "io-priority" property.
		184	+	// Priority used when loading.
		185	+	func (x *BookmarkList) GetPropertyIoPriority() int {
		186	+	var v gobject.Value
		187	+	x.GetProperty("io-priority", &v)
		188	+	return v.GetInt()
		189	+	}
		190	+
		191	+	// GetPropertyLoading gets the "loading" property.
		192	+	// %TRUE if files are being loaded.
		193	+	func (x *BookmarkList) GetPropertyLoading() bool {
		194	+	var v gobject.Value
		195	+	x.GetProperty("loading", &v)
		196	+	return v.GetBoolean()
		197	+	}
		198	+
		199	+	// GetPropertyNItems gets the "n-items" property.
		200	+	// The number of items. See [method@Gio.ListModel.get_n_items].
		201	+	func (x *BookmarkList) GetPropertyNItems() uint {
		202	+	var v gobject.Value
		203	+	x.GetProperty("n-items", &v)
		204	+	return v.GetUint()
		205	+	}
		206	+
140	// Get the item at @position.	207		// Get the item at @position.
141	//	208		//
142	// If @position is greater than the number of items in @list, %NULL is	209		// If @position is greater than the number of items in @list, %NULL is

M v4/gtk/gtkboolfilter.go +17 -0


@@ -113,6 +113,23 @@ func (c *BoolFilter) SetGoPointer(ptr uintptr) {
113	c.Ptr = ptr	113		c.Ptr = ptr
114	}	114		}
115		115
		116	+	// SetPropertyInvert sets the "invert" property.
		117	+	// If the expression result should be inverted.
		118	+	func (x *BoolFilter) SetPropertyInvert(value bool) {
		119	+	var v gobject.Value
		120	+	v.Init(gobject.TypeBooleanVal)
		121	+	v.SetBoolean(value)
		122	+	x.SetProperty("invert", &v)
		123	+	}
		124	+
		125	+	// GetPropertyInvert gets the "invert" property.
		126	+	// If the expression result should be inverted.
		127	+	func (x *BoolFilter) GetPropertyInvert() bool {
		128	+	var v gobject.Value
		129	+	x.GetProperty("invert", &v)
		130	+	return v.GetBoolean()
		131	+	}
		132	+
116	func init() {	133		func init() {
117	core.SetPackageName("GTK", "gtk4")	134		core.SetPackageName("GTK", "gtk4")
118	core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})	135		core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})

M v4/gtk/gtkbox.go +56 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkboxlayout.go +64 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkbuildable.go +35 -35 collapsed to keep the page light

load diff

M v4/gtk/gtkbuilder.go +25 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkbuilderlistitemfactory.go +34 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkbuilderscope.go +6 -6 collapsed to keep the page light

load diff

M v4/gtk/gtkbutton.go +104 -5 collapsed to keep the page light

load diff

M v4/gtk/gtkcalendar.go +132 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkcellarea.go +70 -70 collapsed to keep the page light

load diff

M v4/gtk/gtkcellareabox.go +17 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcellareacontext.go +68 -28 collapsed to keep the page light

load diff

M v4/gtk/gtkcelleditable.go +28 -6 collapsed to keep the page light

load diff

M v4/gtk/gtkcelllayout.go +18 -18 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrenderer.go +253 -56 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrendereraccel.go +38 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrenderercombo.go +52 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrendererpixbuf.go +19 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrendererprogress.go +136 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrendererspin.go +34 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrendererspinner.go +42 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrenderertext.go +602 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkcellrenderertoggle.go +60 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcellview.go +53 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkcenterbox.go +32 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkcenterlayout.go +31 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcheckbutton.go +87 -5 collapsed to keep the page light

load diff

M v4/gtk/gtkcolorbutton.go +60 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkcolorchooser.go +71 -8 collapsed to keep the page light

load diff

M v4/gtk/gtkcolorchooserdialog.go +23 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkcolorchooserwidget.go +22 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkcolordialog.go +57 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcolordialogbutton.go +32 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkcolorutils.go +4 -4 collapsed to keep the page light

load diff

M v4/gtk/gtkcolumnview.go +86 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkcolumnviewcell.go +33 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcolumnviewcolumn.go +116 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcolumnviewrow.go +101 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkcombobox.go +157 -7 collapsed to keep the page light

load diff

M v4/gtk/gtkcomboboxtext.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkconstraint.go +61 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkconstraintguide.go +125 -6 collapsed to keep the page light

load diff

M v4/gtk/gtkcustomlayout.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkdialog.go +57 -6 collapsed to keep the page light

load diff

M v4/gtk/gtkdirectorylist.go +75 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkdragicon.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkdrawingarea.go +37 -3 collapsed to keep the page light

load diff

M v4/gtk/gtkdropcontrollermotion.go +30 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkdropdown.go +64 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkdroptarget.go +86 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkdroptargetasync.go +17 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkeditable.go +176 -26 collapsed to keep the page light

load diff

M v4/gtk/gtkeditablelabel.go +19 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkemojichooser.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkentry.go +648 -4 collapsed to keep the page light

load diff

M v4/gtk/gtkentrybuffer.go +70 -28 collapsed to keep the page light

load diff

M v4/gtk/gtkentrycompletion.go +145 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkeventcontroller.go +17 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkeventcontrollerfocus.go +30 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkeventcontrollermotion.go +29 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkexpander.go +88 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkfilechooser.go +44 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkfilechooserdialog.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkfilechoosernative.go +38 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkfilechooserwidget.go +34 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkfiledialog.go +78 -6 collapsed to keep the page light

load diff

M v4/gtk/gtkfilefilter.go +53 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkfilelauncher.go +36 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkfilter.go +20 -20 collapsed to keep the page light

load diff

M v4/gtk/gtkfilterlistmodel.go +51 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkfixed.go +3 -3 collapsed to keep the page light

load diff

M v4/gtk/gtkfixedlayout.go +18 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkflattenlistmodel.go +9 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkflowbox.go +139 -4 collapsed to keep the page light

load diff

M v4/gtk/gtkfontbutton.go +69 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkfontchooser.go +132 -14 collapsed to keep the page light

load diff

M v4/gtk/gtkfontchooserdialog.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkfontchooserwidget.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkfontdialog.go +55 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkfontdialogbutton.go +124 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkframe.go +37 -3 collapsed to keep the page light

load diff

M v4/gtk/gtkgesture.go +23 -4 collapsed to keep the page light

load diff

M v4/gtk/gtkgesturedrag.go +4 -4 collapsed to keep the page light

load diff

M v4/gtk/gtkgesturelongpress.go +17 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkgesturesingle.go +56 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkgesturestylus.go +23 -6 collapsed to keep the page light

load diff

M v4/gtk/gtkgestureswipe.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkglarea.go +109 -9 collapsed to keep the page light

load diff

M v4/gtk/gtkgraphicsoffload.go +18 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkgrid.go +88 -3 collapsed to keep the page light

load diff

M v4/gtk/gtkgridlayout.go +156 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkgridview.go +75 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkheaderbar.go +82 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkiconpaintable.go +65 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkicontheme.go +93 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkiconview.go +273 -8 collapsed to keep the page light

load diff

M v4/gtk/gtkimage.go +106 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkimcontext.go +67 -67 collapsed to keep the page light

load diff

M v4/gtk/gtkimmulticontext.go +8 -8 collapsed to keep the page light

load diff

M v4/gtk/gtkinfobar.go +35 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkinscription.go +230 -1 collapsed to keep the page light

load diff

M v4/gtk/gtklabel.go +338 -5 collapsed to keep the page light

load diff

M v4/gtk/gtklayoutmanager.go +19 -19 collapsed to keep the page light

load diff

M v4/gtk/gtklevelbar.go +77 -3 collapsed to keep the page light

load diff

M v4/gtk/gtklinkbutton.go +39 -1 collapsed to keep the page light

load diff

M v4/gtk/gtklistbase.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtklistbox.go +93 -4 collapsed to keep the page light

load diff

M v4/gtk/gtklistheader.go +24 -0 collapsed to keep the page light

load diff

M v4/gtk/gtklistitem.go +101 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkliststore.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtklistview.go +52 -1 collapsed to keep the page light

load diff

M v4/gtk/gtklockbutton.go +86 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkmaplistmodel.go +17 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkmediacontrols.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkmediafile.go +13 -13 collapsed to keep the page light

load diff

M v4/gtk/gtkmediastream.go +171 -29 collapsed to keep the page light

load diff

M v4/gtk/gtkmenubutton.go +143 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkmessagedialog.go +82 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkmountoperation.go +16 -8 collapsed to keep the page light

load diff

M v4/gtk/gtkmultifilter.go +10 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkmultiselection.go +9 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkmultisorter.go +8 -0 collapsed to keep the page light

load diff

M v4/gtk/gtknative.go +3 -3 collapsed to keep the page light

load diff

M v4/gtk/gtknativedialog.go +65 -14 collapsed to keep the page light

load diff

M v4/gtk/gtknoselection.go +9 -1 collapsed to keep the page light

load diff

M v4/gtk/gtknotebook.go +222 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkoverlay.go +3 -3 collapsed to keep the page light

load diff

M v4/gtk/gtkoverlaylayout.go +37 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkpagesetupunixdialog.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkpaned.go +158 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkpasswordentry.go +55 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkpicture.go +54 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkpopover.go +97 -8 collapsed to keep the page light

load diff

M v4/gtk/gtkpopovermenu.go +19 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkpopovermenubar.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkprintcontext.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkprintdialog.go +55 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkprinter.go +123 -4 collapsed to keep the page light

load diff

M v4/gtk/gtkprintjob.go +38 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkprintoperation.go +379 -22 collapsed to keep the page light

load diff

M v4/gtk/gtkprintoperationpreview.go +26 -26 collapsed to keep the page light

load diff

M v4/gtk/gtkprintsettings.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkprintunixdialog.go +70 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkprogressbar.go +104 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkrange.go +108 -13 collapsed to keep the page light

load diff

M v4/gtk/gtkrecentmanager.go +43 -16 collapsed to keep the page light

load diff

M v4/gtk/gtkrevealer.go +43 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkscale.go +61 -10 collapsed to keep the page light

load diff

M v4/gtk/gtkscalebutton.go +92 -3 collapsed to keep the page light

load diff

M v4/gtk/gtkscrollable.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkscrollbar.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkscrolledwindow.go +188 -1 collapsed to keep the page light

load diff

M v4/gtk/gtksearchbar.go +35 -1 collapsed to keep the page light

load diff

M v4/gtk/gtksearchentry.go +57 -2 collapsed to keep the page light

load diff

M v4/gtk/gtksectionmodel.go +10 -10 collapsed to keep the page light

load diff

M v4/gtk/gtkselectionfiltermodel.go +8 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkselectionmodel.go +18 -18 collapsed to keep the page light

load diff

M v4/gtk/gtkseparator.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtksettings.go +1209 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcut.go +17 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcutaction.go +34 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcutcontroller.go +8 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcutlabel.go +41 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcutmanager.go +4 -4 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcutsgroup.go +55 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcutssection.go +105 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcutsshortcut.go +179 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcutswindow.go +54 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkshortcuttrigger.go +34 -0 collapsed to keep the page light

load diff

M v4/gtk/gtksingleselection.go +60 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkslicelistmodel.go +43 -1 collapsed to keep the page light

load diff

M v4/gtk/gtksorter.go +20 -20 collapsed to keep the page light

load diff

M v4/gtk/gtksortlistmodel.go +34 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkspinbutton.go +133 -8 collapsed to keep the page light

load diff

M v4/gtk/gtkspinner.go +18 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkstack.go +205 -2 collapsed to keep the page light

load diff

M v4/gtk/gtkstacksidebar.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkstackswitcher.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkstatusbar.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkstringfilter.go +34 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkstringlist.go +26 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkstringsorter.go +17 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkstylecontext.go +10 -10 collapsed to keep the page light

load diff

M v4/gtk/gtkswitch.go +47 -1 collapsed to keep the page light

load diff

M v4/gtk/gtksymbolicpaintable.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtktestutils.go +2 -2 collapsed to keep the page light

load diff

M v4/gtk/gtktext.go +259 -2 collapsed to keep the page light

load diff

M v4/gtk/gtktextbuffer.go +113 -38 collapsed to keep the page light

load diff

M v4/gtk/gtktextchild.go +10 -10 collapsed to keep the page light

load diff

M v4/gtk/gtktextmark.go +42 -0 collapsed to keep the page light

load diff

M v4/gtk/gtktexttag.go +1411 -0 collapsed to keep the page light

load diff

M v4/gtk/gtktextview.go +366 -39 collapsed to keep the page light

load diff

M v4/gtk/gtktogglebutton.go +20 -3 collapsed to keep the page light

load diff

M v4/gtk/gtktreednd.go +13 -13 collapsed to keep the page light

load diff

M v4/gtk/gtktreeexpander.go +62 -1 collapsed to keep the page light

load diff

M v4/gtk/gtktreelistmodel.go +83 -0 collapsed to keep the page light

load diff

M v4/gtk/gtktreemodel.go +42 -42 collapsed to keep the page light

load diff

M v4/gtk/gtktreemodelfilter.go +21 -4 collapsed to keep the page light

load diff

M v4/gtk/gtktreemodelsort.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtktreeselection.go +6 -6 collapsed to keep the page light

load diff

M v4/gtk/gtktreesortable.go +20 -20 collapsed to keep the page light

load diff

M v4/gtk/gtktreestore.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtktreeview.go +308 -54 collapsed to keep the page light

load diff

M v4/gtk/gtktreeviewcolumn.go +217 -4 collapsed to keep the page light

load diff

M v4/gtk/gtkurilauncher.go +17 -0 collapsed to keep the page light

load diff

M v4/gtk/gtkvideo.go +35 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkviewport.go +26 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkvolumebutton.go +24 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkwidget.go +649 -64 collapsed to keep the page light

load diff

M v4/gtk/gtkwidgetpaintable.go +1 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkwindow.go +340 -14 collapsed to keep the page light

load diff

M v4/gtk/gtkwindowcontrols.go +63 -1 collapsed to keep the page light

load diff

M v4/gtk/gtkwindowgroup.go +8 -8 collapsed to keep the page light

load diff

M v4/gtk/gtkwindowhandle.go +1 -1 collapsed to keep the page light

load diff

M v4/pango/pango-attributes.go +8 -8 collapsed to keep the page light

load diff

M v4/pango/pango-bidi-type.go +2 -2 collapsed to keep the page light

load diff

M v4/pango/pango-break.go +10 -10 collapsed to keep the page light

load diff

M v4/pango/pango-color.go +2 -2 collapsed to keep the page light

load diff

M v4/pango/pango-context.go +2 -2 collapsed to keep the page light

load diff

M v4/pango/pango-coverage.go +2 -2 collapsed to keep the page light

load diff

M v4/pango/pango-font.go +95 -63 collapsed to keep the page light

load diff

M v4/pango/pango-fontmap.go +29 -21 collapsed to keep the page light

load diff

M v4/pango/pango-fontset.go +16 -16 collapsed to keep the page light

load diff

M v4/pango/pango-glyph-item.go +2 -2 collapsed to keep the page light

load diff

M v4/pango/pango-glyph.go +8 -8 collapsed to keep the page light

load diff

M v4/pango/pango-layout.go +26 -26 collapsed to keep the page light

load diff

M v4/pango/pango-markup.go +4 -4 collapsed to keep the page light

load diff

M v4/pango/pango-matrix.go +2 -2 collapsed to keep the page light

load diff

M v4/pango/pango-renderer.go +28 -28 collapsed to keep the page light

load diff

M v4/pango/pango-script.go +2 -2 collapsed to keep the page light

load diff

M v4/pango/pango-tabs.go +4 -4 collapsed to keep the page light

load diff

M v4/pango/pango-types.go +2 -2 collapsed to keep the page light

load diff

M v4/pango/pango-utils.go +6 -6 collapsed to keep the page light

load diff