WebSVN – nexmon – Blame – Rev 1 – /utilities/glib/gio/gioenumtypes.c

1

office

1

2

/* Generated data (by glib-mkenums) */

3

4

#include "config.h"

5

#include "gioenumtypes.h"

6

#include <gio.h>

7

8

/* enumerations from "gioenums.h" */

9

GType

10

g_app_info_create_flags_get_type (void)

11

{

12

static volatile gsize g_define_type_id__volatile = 0;

13

14

if (g_once_init_enter (&g_define_type_id__volatile))

15

{

16

static const GFlagsValue values[] = {

17

{ G_APP_INFO_CREATE_NONE, "G_APP_INFO_CREATE_NONE", "none" },

18

{ G_APP_INFO_CREATE_NEEDS_TERMINAL, "G_APP_INFO_CREATE_NEEDS_TERMINAL", "needs-terminal" },

19

{ G_APP_INFO_CREATE_SUPPORTS_URIS, "G_APP_INFO_CREATE_SUPPORTS_URIS", "supports-uris" },

20

        { G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION, "G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION", "supports-startup-notification" },

21

{ 0, NULL, NULL }

22

};

23

GType g_define_type_id =

24

g_flags_register_static (g_intern_static_string ("GAppInfoCreateFlags"), values);

25

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

26

}

27

28

return g_define_type_id__volatile;

}

GType

g_converter_flags_get_type (void)

33

{

34

static volatile gsize g_define_type_id__volatile = 0;

35

36

if (g_once_init_enter (&g_define_type_id__volatile))

37

{

38

static const GFlagsValue values[] = {

39

{ G_CONVERTER_NO_FLAGS, "G_CONVERTER_NO_FLAGS", "none" },

40

{ G_CONVERTER_INPUT_AT_END, "G_CONVERTER_INPUT_AT_END", "input-at-end" },

41

{ G_CONVERTER_FLUSH, "G_CONVERTER_FLUSH", "flush" },

42

{ 0, NULL, NULL }

43

};

44

GType g_define_type_id =

45

g_flags_register_static (g_intern_static_string ("GConverterFlags"), values);

46

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

47

}

48

49

return g_define_type_id__volatile;

}

GType

g_converter_result_get_type (void)

54

{

55

static volatile gsize g_define_type_id__volatile = 0;

56

57

if (g_once_init_enter (&g_define_type_id__volatile))

58

{

59

static const GEnumValue values[] = {

60

{ G_CONVERTER_ERROR, "G_CONVERTER_ERROR", "error" },

61

{ G_CONVERTER_CONVERTED, "G_CONVERTER_CONVERTED", "converted" },

62

{ G_CONVERTER_FINISHED, "G_CONVERTER_FINISHED", "finished" },

63

{ G_CONVERTER_FLUSHED, "G_CONVERTER_FLUSHED", "flushed" },

64

{ 0, NULL, NULL }

65

};

66

GType g_define_type_id =

67

g_enum_register_static (g_intern_static_string ("GConverterResult"), values);

68

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

69

}

70

71

return g_define_type_id__volatile;

}

GType

g_data_stream_byte_order_get_type (void)

76

{

77

static volatile gsize g_define_type_id__volatile = 0;

78

79

if (g_once_init_enter (&g_define_type_id__volatile))

80

{

81

static const GEnumValue values[] = {

82

{ G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN, "G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN", "big-endian" },

83

{ G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN, "G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN", "little-endian" },

84

{ G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN, "G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN", "host-endian" },

85

{ 0, NULL, NULL }

86

};

87

GType g_define_type_id =

88

g_enum_register_static (g_intern_static_string ("GDataStreamByteOrder"), values);

89

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

90

}

91

92

return g_define_type_id__volatile;

}

GType

g_data_stream_newline_type_get_type (void)

97

{

98

static volatile gsize g_define_type_id__volatile = 0;

99

100

if (g_once_init_enter (&g_define_type_id__volatile))

101

{

102

static const GEnumValue values[] = {

103

{ G_DATA_STREAM_NEWLINE_TYPE_LF, "G_DATA_STREAM_NEWLINE_TYPE_LF", "lf" },

104

{ G_DATA_STREAM_NEWLINE_TYPE_CR, "G_DATA_STREAM_NEWLINE_TYPE_CR", "cr" },

105

{ G_DATA_STREAM_NEWLINE_TYPE_CR_LF, "G_DATA_STREAM_NEWLINE_TYPE_CR_LF", "cr-lf" },

106

{ G_DATA_STREAM_NEWLINE_TYPE_ANY, "G_DATA_STREAM_NEWLINE_TYPE_ANY", "any" },

107

{ 0, NULL, NULL }

108

};

109

GType g_define_type_id =

110

g_enum_register_static (g_intern_static_string ("GDataStreamNewlineType"), values);

111

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

112

}

113

114

return g_define_type_id__volatile;

}

GType

g_file_attribute_type_get_type (void)

119

{

120

static volatile gsize g_define_type_id__volatile = 0;

121

122

if (g_once_init_enter (&g_define_type_id__volatile))

123

{

124

static const GEnumValue values[] = {

125

{ G_FILE_ATTRIBUTE_TYPE_INVALID, "G_FILE_ATTRIBUTE_TYPE_INVALID", "invalid" },

126

{ G_FILE_ATTRIBUTE_TYPE_STRING, "G_FILE_ATTRIBUTE_TYPE_STRING", "string" },

127

{ G_FILE_ATTRIBUTE_TYPE_BYTE_STRING, "G_FILE_ATTRIBUTE_TYPE_BYTE_STRING", "byte-string" },

128

{ G_FILE_ATTRIBUTE_TYPE_BOOLEAN, "G_FILE_ATTRIBUTE_TYPE_BOOLEAN", "boolean" },

129

{ G_FILE_ATTRIBUTE_TYPE_UINT32, "G_FILE_ATTRIBUTE_TYPE_UINT32", "uint32" },

130

{ G_FILE_ATTRIBUTE_TYPE_INT32, "G_FILE_ATTRIBUTE_TYPE_INT32", "int32" },

131

{ G_FILE_ATTRIBUTE_TYPE_UINT64, "G_FILE_ATTRIBUTE_TYPE_UINT64", "uint64" },

132

{ G_FILE_ATTRIBUTE_TYPE_INT64, "G_FILE_ATTRIBUTE_TYPE_INT64", "int64" },

133

{ G_FILE_ATTRIBUTE_TYPE_OBJECT, "G_FILE_ATTRIBUTE_TYPE_OBJECT", "object" },

134

{ G_FILE_ATTRIBUTE_TYPE_STRINGV, "G_FILE_ATTRIBUTE_TYPE_STRINGV", "stringv" },

135

{ 0, NULL, NULL }

136

};

137

GType g_define_type_id =

138

g_enum_register_static (g_intern_static_string ("GFileAttributeType"), values);

139

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

140

}

141

142

return g_define_type_id__volatile;

}

GType

g_file_attribute_info_flags_get_type (void)

147

{

148

static volatile gsize g_define_type_id__volatile = 0;

149

150

if (g_once_init_enter (&g_define_type_id__volatile))

151

{

152

static const GFlagsValue values[] = {

153

{ G_FILE_ATTRIBUTE_INFO_NONE, "G_FILE_ATTRIBUTE_INFO_NONE", "none" },

154

{ G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE, "G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE", "copy-with-file" },

155

{ G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED, "G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED", "copy-when-moved" },

156

{ 0, NULL, NULL }

157

};

158

GType g_define_type_id =

159

g_flags_register_static (g_intern_static_string ("GFileAttributeInfoFlags"), values);

160

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

161

}

162

163

return g_define_type_id__volatile;

}

GType

g_file_attribute_status_get_type (void)

168

{

169

static volatile gsize g_define_type_id__volatile = 0;

170

171

if (g_once_init_enter (&g_define_type_id__volatile))

172

{

173

static const GEnumValue values[] = {

174

{ G_FILE_ATTRIBUTE_STATUS_UNSET, "G_FILE_ATTRIBUTE_STATUS_UNSET", "unset" },

175

{ G_FILE_ATTRIBUTE_STATUS_SET, "G_FILE_ATTRIBUTE_STATUS_SET", "set" },

176

{ G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, "G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING", "error-setting" },

177

{ 0, NULL, NULL }

178

};

179

GType g_define_type_id =

180

g_enum_register_static (g_intern_static_string ("GFileAttributeStatus"), values);

181

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

182

}

183

184

return g_define_type_id__volatile;

}

GType

g_file_query_info_flags_get_type (void)

189

{

190

static volatile gsize g_define_type_id__volatile = 0;

191

192

if (g_once_init_enter (&g_define_type_id__volatile))

193

{

194

static const GFlagsValue values[] = {

195

{ G_FILE_QUERY_INFO_NONE, "G_FILE_QUERY_INFO_NONE", "none" },

196

{ G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, "G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS", "nofollow-symlinks" },

197

{ 0, NULL, NULL }

198

};

199

GType g_define_type_id =

200

g_flags_register_static (g_intern_static_string ("GFileQueryInfoFlags"), values);

201

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

202

}

203

204

return g_define_type_id__volatile;

}

GType

g_file_create_flags_get_type (void)

209

{

210

static volatile gsize g_define_type_id__volatile = 0;

211

212

if (g_once_init_enter (&g_define_type_id__volatile))

213

{

214

static const GFlagsValue values[] = {

215

{ G_FILE_CREATE_NONE, "G_FILE_CREATE_NONE", "none" },

216

{ G_FILE_CREATE_PRIVATE, "G_FILE_CREATE_PRIVATE", "private" },

217

{ G_FILE_CREATE_REPLACE_DESTINATION, "G_FILE_CREATE_REPLACE_DESTINATION", "replace-destination" },

218

{ 0, NULL, NULL }

219

};

220

GType g_define_type_id =

221

g_flags_register_static (g_intern_static_string ("GFileCreateFlags"), values);

222

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

223

}

224

225

return g_define_type_id__volatile;

}

GType

g_file_measure_flags_get_type (void)

230

{

231

static volatile gsize g_define_type_id__volatile = 0;

232

233

if (g_once_init_enter (&g_define_type_id__volatile))

234

{

235

static const GFlagsValue values[] = {

236

{ G_FILE_MEASURE_NONE, "G_FILE_MEASURE_NONE", "none" },

237

{ G_FILE_MEASURE_REPORT_ANY_ERROR, "G_FILE_MEASURE_REPORT_ANY_ERROR", "report-any-error" },

238

{ G_FILE_MEASURE_APPARENT_SIZE, "G_FILE_MEASURE_APPARENT_SIZE", "apparent-size" },

239

{ G_FILE_MEASURE_NO_XDEV, "G_FILE_MEASURE_NO_XDEV", "no-xdev" },

240

{ 0, NULL, NULL }

241

};

242

GType g_define_type_id =

243

g_flags_register_static (g_intern_static_string ("GFileMeasureFlags"), values);

244

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

245

}

246

247

return g_define_type_id__volatile;

}

GType

g_mount_mount_flags_get_type (void)

252

{

253

static volatile gsize g_define_type_id__volatile = 0;

254

255

if (g_once_init_enter (&g_define_type_id__volatile))

256

{

257

static const GFlagsValue values[] = {

258

{ G_MOUNT_MOUNT_NONE, "G_MOUNT_MOUNT_NONE", "none" },

259

{ 0, NULL, NULL }

260

};

261

GType g_define_type_id =

262

g_flags_register_static (g_intern_static_string ("GMountMountFlags"), values);

263

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

264

}

265

266

return g_define_type_id__volatile;

}

GType

g_mount_unmount_flags_get_type (void)

271

{

272

static volatile gsize g_define_type_id__volatile = 0;

273

274

if (g_once_init_enter (&g_define_type_id__volatile))

275

{

276

static const GFlagsValue values[] = {

277

{ G_MOUNT_UNMOUNT_NONE, "G_MOUNT_UNMOUNT_NONE", "none" },

278

{ G_MOUNT_UNMOUNT_FORCE, "G_MOUNT_UNMOUNT_FORCE", "force" },

279

{ 0, NULL, NULL }

280

};

281

GType g_define_type_id =

282

g_flags_register_static (g_intern_static_string ("GMountUnmountFlags"), values);

283

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

284

}

285

286

return g_define_type_id__volatile;

}

GType

g_drive_start_flags_get_type (void)

291

{

292

static volatile gsize g_define_type_id__volatile = 0;

293

294

if (g_once_init_enter (&g_define_type_id__volatile))

295

{

296

static const GFlagsValue values[] = {

297

{ G_DRIVE_START_NONE, "G_DRIVE_START_NONE", "none" },

298

{ 0, NULL, NULL }

299

};

300

GType g_define_type_id =

301

g_flags_register_static (g_intern_static_string ("GDriveStartFlags"), values);

302

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

303

}

304

305

return g_define_type_id__volatile;

}

GType

g_drive_start_stop_type_get_type (void)

310

{

311

static volatile gsize g_define_type_id__volatile = 0;

312

313

if (g_once_init_enter (&g_define_type_id__volatile))

314

{

315

static const GEnumValue values[] = {

316

{ G_DRIVE_START_STOP_TYPE_UNKNOWN, "G_DRIVE_START_STOP_TYPE_UNKNOWN", "unknown" },

317

{ G_DRIVE_START_STOP_TYPE_SHUTDOWN, "G_DRIVE_START_STOP_TYPE_SHUTDOWN", "shutdown" },

318

{ G_DRIVE_START_STOP_TYPE_NETWORK, "G_DRIVE_START_STOP_TYPE_NETWORK", "network" },

319

{ G_DRIVE_START_STOP_TYPE_MULTIDISK, "G_DRIVE_START_STOP_TYPE_MULTIDISK", "multidisk" },

320

{ G_DRIVE_START_STOP_TYPE_PASSWORD, "G_DRIVE_START_STOP_TYPE_PASSWORD", "password" },

321

{ 0, NULL, NULL }

322

};

323

GType g_define_type_id =

324

g_enum_register_static (g_intern_static_string ("GDriveStartStopType"), values);

325

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

326

}

327

328

return g_define_type_id__volatile;

}

GType

g_file_copy_flags_get_type (void)

333

{

334

static volatile gsize g_define_type_id__volatile = 0;

335

336

if (g_once_init_enter (&g_define_type_id__volatile))

337

{

338

static const GFlagsValue values[] = {

339

{ G_FILE_COPY_NONE, "G_FILE_COPY_NONE", "none" },

340

{ G_FILE_COPY_OVERWRITE, "G_FILE_COPY_OVERWRITE", "overwrite" },

341

{ G_FILE_COPY_BACKUP, "G_FILE_COPY_BACKUP", "backup" },

342

{ G_FILE_COPY_NOFOLLOW_SYMLINKS, "G_FILE_COPY_NOFOLLOW_SYMLINKS", "nofollow-symlinks" },

343

{ G_FILE_COPY_ALL_METADATA, "G_FILE_COPY_ALL_METADATA", "all-metadata" },

344

{ G_FILE_COPY_NO_FALLBACK_FOR_MOVE, "G_FILE_COPY_NO_FALLBACK_FOR_MOVE", "no-fallback-for-move" },

345

{ G_FILE_COPY_TARGET_DEFAULT_PERMS, "G_FILE_COPY_TARGET_DEFAULT_PERMS", "target-default-perms" },

346

{ 0, NULL, NULL }

347

};

348

GType g_define_type_id =

349

g_flags_register_static (g_intern_static_string ("GFileCopyFlags"), values);

350

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

351

}

352

353

return g_define_type_id__volatile;

}

GType

g_file_monitor_flags_get_type (void)

358

{

359

static volatile gsize g_define_type_id__volatile = 0;

360

361

if (g_once_init_enter (&g_define_type_id__volatile))

362

{

363

static const GFlagsValue values[] = {

364

{ G_FILE_MONITOR_NONE, "G_FILE_MONITOR_NONE", "none" },

365

{ G_FILE_MONITOR_WATCH_MOUNTS, "G_FILE_MONITOR_WATCH_MOUNTS", "watch-mounts" },

366

{ G_FILE_MONITOR_SEND_MOVED, "G_FILE_MONITOR_SEND_MOVED", "send-moved" },

367

{ G_FILE_MONITOR_WATCH_HARD_LINKS, "G_FILE_MONITOR_WATCH_HARD_LINKS", "watch-hard-links" },

368

{ G_FILE_MONITOR_WATCH_MOVES, "G_FILE_MONITOR_WATCH_MOVES", "watch-moves" },

369

{ 0, NULL, NULL }

370

};

371

GType g_define_type_id =

372

g_flags_register_static (g_intern_static_string ("GFileMonitorFlags"), values);

373

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

374

}

375

376

return g_define_type_id__volatile;

}

GType

g_file_type_get_type (void)

381

{

382

static volatile gsize g_define_type_id__volatile = 0;

383

384

if (g_once_init_enter (&g_define_type_id__volatile))

385

{

386

static const GEnumValue values[] = {

387

{ G_FILE_TYPE_UNKNOWN, "G_FILE_TYPE_UNKNOWN", "unknown" },

388

{ G_FILE_TYPE_REGULAR, "G_FILE_TYPE_REGULAR", "regular" },

389

{ G_FILE_TYPE_DIRECTORY, "G_FILE_TYPE_DIRECTORY", "directory" },

390

{ G_FILE_TYPE_SYMBOLIC_LINK, "G_FILE_TYPE_SYMBOLIC_LINK", "symbolic-link" },

391

{ G_FILE_TYPE_SPECIAL, "G_FILE_TYPE_SPECIAL", "special" },

392

{ G_FILE_TYPE_SHORTCUT, "G_FILE_TYPE_SHORTCUT", "shortcut" },

393

{ G_FILE_TYPE_MOUNTABLE, "G_FILE_TYPE_MOUNTABLE", "mountable" },

394

{ 0, NULL, NULL }

395

};

396

GType g_define_type_id =

397

g_enum_register_static (g_intern_static_string ("GFileType"), values);

398

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

399

}

400

401

return g_define_type_id__volatile;

}

GType

g_filesystem_preview_type_get_type (void)

406

{

407

static volatile gsize g_define_type_id__volatile = 0;

408

409

if (g_once_init_enter (&g_define_type_id__volatile))

410

{

411

static const GEnumValue values[] = {

412

{ G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS, "G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS", "if-always" },

413

{ G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL, "G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL", "if-local" },

414

{ G_FILESYSTEM_PREVIEW_TYPE_NEVER, "G_FILESYSTEM_PREVIEW_TYPE_NEVER", "never" },

415

{ 0, NULL, NULL }

416

};

417

GType g_define_type_id =

418

g_enum_register_static (g_intern_static_string ("GFilesystemPreviewType"), values);

419

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

420

}

421

422

return g_define_type_id__volatile;

}

GType

g_file_monitor_event_get_type (void)

427

{

428

static volatile gsize g_define_type_id__volatile = 0;

429

430

if (g_once_init_enter (&g_define_type_id__volatile))

431

{

432

static const GEnumValue values[] = {

433

{ G_FILE_MONITOR_EVENT_CHANGED, "G_FILE_MONITOR_EVENT_CHANGED", "changed" },

434

{ G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT, "G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT", "changes-done-hint" },

435

{ G_FILE_MONITOR_EVENT_DELETED, "G_FILE_MONITOR_EVENT_DELETED", "deleted" },

436

{ G_FILE_MONITOR_EVENT_CREATED, "G_FILE_MONITOR_EVENT_CREATED", "created" },

437

{ G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED, "G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED", "attribute-changed" },

438

{ G_FILE_MONITOR_EVENT_PRE_UNMOUNT, "G_FILE_MONITOR_EVENT_PRE_UNMOUNT", "pre-unmount" },

439

{ G_FILE_MONITOR_EVENT_UNMOUNTED, "G_FILE_MONITOR_EVENT_UNMOUNTED", "unmounted" },

440

{ G_FILE_MONITOR_EVENT_MOVED, "G_FILE_MONITOR_EVENT_MOVED", "moved" },

441

{ G_FILE_MONITOR_EVENT_RENAMED, "G_FILE_MONITOR_EVENT_RENAMED", "renamed" },

442

{ G_FILE_MONITOR_EVENT_MOVED_IN, "G_FILE_MONITOR_EVENT_MOVED_IN", "moved-in" },

443

{ G_FILE_MONITOR_EVENT_MOVED_OUT, "G_FILE_MONITOR_EVENT_MOVED_OUT", "moved-out" },

444

{ 0, NULL, NULL }

445

};

446

GType g_define_type_id =

447

g_enum_register_static (g_intern_static_string ("GFileMonitorEvent"), values);

448

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

449

}

450

451

return g_define_type_id__volatile;

}

GType

g_io_error_enum_get_type (void)

456

{

457

static volatile gsize g_define_type_id__volatile = 0;

458

459

if (g_once_init_enter (&g_define_type_id__volatile))

460

{

461

static const GEnumValue values[] = {

462

{ G_IO_ERROR_FAILED, "G_IO_ERROR_FAILED", "failed" },

463

{ G_IO_ERROR_NOT_FOUND, "G_IO_ERROR_NOT_FOUND", "not-found" },

464

{ G_IO_ERROR_EXISTS, "G_IO_ERROR_EXISTS", "exists" },

465

{ G_IO_ERROR_IS_DIRECTORY, "G_IO_ERROR_IS_DIRECTORY", "is-directory" },

466

{ G_IO_ERROR_NOT_DIRECTORY, "G_IO_ERROR_NOT_DIRECTORY", "not-directory" },

467

{ G_IO_ERROR_NOT_EMPTY, "G_IO_ERROR_NOT_EMPTY", "not-empty" },

468

{ G_IO_ERROR_NOT_REGULAR_FILE, "G_IO_ERROR_NOT_REGULAR_FILE", "not-regular-file" },

469

{ G_IO_ERROR_NOT_SYMBOLIC_LINK, "G_IO_ERROR_NOT_SYMBOLIC_LINK", "not-symbolic-link" },

470

{ G_IO_ERROR_NOT_MOUNTABLE_FILE, "G_IO_ERROR_NOT_MOUNTABLE_FILE", "not-mountable-file" },

471

{ G_IO_ERROR_FILENAME_TOO_LONG, "G_IO_ERROR_FILENAME_TOO_LONG", "filename-too-long" },

472

{ G_IO_ERROR_INVALID_FILENAME, "G_IO_ERROR_INVALID_FILENAME", "invalid-filename" },

473

{ G_IO_ERROR_TOO_MANY_LINKS, "G_IO_ERROR_TOO_MANY_LINKS", "too-many-links" },

474

{ G_IO_ERROR_NO_SPACE, "G_IO_ERROR_NO_SPACE", "no-space" },

475

{ G_IO_ERROR_INVALID_ARGUMENT, "G_IO_ERROR_INVALID_ARGUMENT", "invalid-argument" },

476

{ G_IO_ERROR_PERMISSION_DENIED, "G_IO_ERROR_PERMISSION_DENIED", "permission-denied" },

477

{ G_IO_ERROR_NOT_SUPPORTED, "G_IO_ERROR_NOT_SUPPORTED", "not-supported" },

478

{ G_IO_ERROR_NOT_MOUNTED, "G_IO_ERROR_NOT_MOUNTED", "not-mounted" },

479

{ G_IO_ERROR_ALREADY_MOUNTED, "G_IO_ERROR_ALREADY_MOUNTED", "already-mounted" },

480

{ G_IO_ERROR_CLOSED, "G_IO_ERROR_CLOSED", "closed" },

481

{ G_IO_ERROR_CANCELLED, "G_IO_ERROR_CANCELLED", "cancelled" },

482

{ G_IO_ERROR_PENDING, "G_IO_ERROR_PENDING", "pending" },

483

{ G_IO_ERROR_READ_ONLY, "G_IO_ERROR_READ_ONLY", "read-only" },

484

{ G_IO_ERROR_CANT_CREATE_BACKUP, "G_IO_ERROR_CANT_CREATE_BACKUP", "cant-create-backup" },

485

{ G_IO_ERROR_WRONG_ETAG, "G_IO_ERROR_WRONG_ETAG", "wrong-etag" },

486

{ G_IO_ERROR_TIMED_OUT, "G_IO_ERROR_TIMED_OUT", "timed-out" },

487

{ G_IO_ERROR_WOULD_RECURSE, "G_IO_ERROR_WOULD_RECURSE", "would-recurse" },

488

{ G_IO_ERROR_BUSY, "G_IO_ERROR_BUSY", "busy" },

489

{ G_IO_ERROR_WOULD_BLOCK, "G_IO_ERROR_WOULD_BLOCK", "would-block" },

490

{ G_IO_ERROR_HOST_NOT_FOUND, "G_IO_ERROR_HOST_NOT_FOUND", "host-not-found" },

491

{ G_IO_ERROR_WOULD_MERGE, "G_IO_ERROR_WOULD_MERGE", "would-merge" },

492

{ G_IO_ERROR_FAILED_HANDLED, "G_IO_ERROR_FAILED_HANDLED", "failed-handled" },

493

{ G_IO_ERROR_TOO_MANY_OPEN_FILES, "G_IO_ERROR_TOO_MANY_OPEN_FILES", "too-many-open-files" },

494

{ G_IO_ERROR_NOT_INITIALIZED, "G_IO_ERROR_NOT_INITIALIZED", "not-initialized" },

495

{ G_IO_ERROR_ADDRESS_IN_USE, "G_IO_ERROR_ADDRESS_IN_USE", "address-in-use" },

496

{ G_IO_ERROR_PARTIAL_INPUT, "G_IO_ERROR_PARTIAL_INPUT", "partial-input" },

497

{ G_IO_ERROR_INVALID_DATA, "G_IO_ERROR_INVALID_DATA", "invalid-data" },

498

{ G_IO_ERROR_DBUS_ERROR, "G_IO_ERROR_DBUS_ERROR", "dbus-error" },

499

{ G_IO_ERROR_HOST_UNREACHABLE, "G_IO_ERROR_HOST_UNREACHABLE", "host-unreachable" },

500

{ G_IO_ERROR_NETWORK_UNREACHABLE, "G_IO_ERROR_NETWORK_UNREACHABLE", "network-unreachable" },

501

{ G_IO_ERROR_CONNECTION_REFUSED, "G_IO_ERROR_CONNECTION_REFUSED", "connection-refused" },

502

{ G_IO_ERROR_PROXY_FAILED, "G_IO_ERROR_PROXY_FAILED", "proxy-failed" },

503

{ G_IO_ERROR_PROXY_AUTH_FAILED, "G_IO_ERROR_PROXY_AUTH_FAILED", "proxy-auth-failed" },

504

{ G_IO_ERROR_PROXY_NEED_AUTH, "G_IO_ERROR_PROXY_NEED_AUTH", "proxy-need-auth" },

505

{ G_IO_ERROR_PROXY_NOT_ALLOWED, "G_IO_ERROR_PROXY_NOT_ALLOWED", "proxy-not-allowed" },

506

{ G_IO_ERROR_BROKEN_PIPE, "G_IO_ERROR_BROKEN_PIPE", "broken-pipe" },

507

{ G_IO_ERROR_CONNECTION_CLOSED, "G_IO_ERROR_CONNECTION_CLOSED", "connection-closed" },

508

{ G_IO_ERROR_NOT_CONNECTED, "G_IO_ERROR_NOT_CONNECTED", "not-connected" },

509

{ G_IO_ERROR_MESSAGE_TOO_LARGE, "G_IO_ERROR_MESSAGE_TOO_LARGE", "message-too-large" },

510

{ 0, NULL, NULL }

511

};

512

GType g_define_type_id =

513

g_enum_register_static (g_intern_static_string ("GIOErrorEnum"), values);

514

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

515

}

516

517

return g_define_type_id__volatile;

}

GType

g_ask_password_flags_get_type (void)

522

{

523

static volatile gsize g_define_type_id__volatile = 0;

524

525

if (g_once_init_enter (&g_define_type_id__volatile))

526

{

527

static const GFlagsValue values[] = {

528

{ G_ASK_PASSWORD_NEED_PASSWORD, "G_ASK_PASSWORD_NEED_PASSWORD", "need-password" },

529

{ G_ASK_PASSWORD_NEED_USERNAME, "G_ASK_PASSWORD_NEED_USERNAME", "need-username" },

530

{ G_ASK_PASSWORD_NEED_DOMAIN, "G_ASK_PASSWORD_NEED_DOMAIN", "need-domain" },

531

{ G_ASK_PASSWORD_SAVING_SUPPORTED, "G_ASK_PASSWORD_SAVING_SUPPORTED", "saving-supported" },

532

{ G_ASK_PASSWORD_ANONYMOUS_SUPPORTED, "G_ASK_PASSWORD_ANONYMOUS_SUPPORTED", "anonymous-supported" },

533

{ 0, NULL, NULL }

534

};

535

GType g_define_type_id =

536

g_flags_register_static (g_intern_static_string ("GAskPasswordFlags"), values);

537

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

538

}

539

540

return g_define_type_id__volatile;

}

GType

g_password_save_get_type (void)

545

{

546

static volatile gsize g_define_type_id__volatile = 0;

547

548

if (g_once_init_enter (&g_define_type_id__volatile))

549

{

550

static const GEnumValue values[] = {

551

{ G_PASSWORD_SAVE_NEVER, "G_PASSWORD_SAVE_NEVER", "never" },

552

{ G_PASSWORD_SAVE_FOR_SESSION, "G_PASSWORD_SAVE_FOR_SESSION", "for-session" },

553

{ G_PASSWORD_SAVE_PERMANENTLY, "G_PASSWORD_SAVE_PERMANENTLY", "permanently" },

554

{ 0, NULL, NULL }

555

};

556

GType g_define_type_id =

557

g_enum_register_static (g_intern_static_string ("GPasswordSave"), values);

558

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

559

}

560

561

return g_define_type_id__volatile;

}

GType

g_mount_operation_result_get_type (void)

566

{

567

static volatile gsize g_define_type_id__volatile = 0;

568

569

if (g_once_init_enter (&g_define_type_id__volatile))

570

{

571

static const GEnumValue values[] = {

572

{ G_MOUNT_OPERATION_HANDLED, "G_MOUNT_OPERATION_HANDLED", "handled" },

573

{ G_MOUNT_OPERATION_ABORTED, "G_MOUNT_OPERATION_ABORTED", "aborted" },

574

{ G_MOUNT_OPERATION_UNHANDLED, "G_MOUNT_OPERATION_UNHANDLED", "unhandled" },

575

{ 0, NULL, NULL }

576

};

577

GType g_define_type_id =

578

g_enum_register_static (g_intern_static_string ("GMountOperationResult"), values);

579

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

580

}

581

582

return g_define_type_id__volatile;

}

GType

g_output_stream_splice_flags_get_type (void)

587

{

588

static volatile gsize g_define_type_id__volatile = 0;

589

590

if (g_once_init_enter (&g_define_type_id__volatile))

591

{

592

static const GFlagsValue values[] = {

593

{ G_OUTPUT_STREAM_SPLICE_NONE, "G_OUTPUT_STREAM_SPLICE_NONE", "none" },

594

{ G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE, "G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE", "close-source" },

595

{ G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, "G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET", "close-target" },

596

{ 0, NULL, NULL }

597

};

598

GType g_define_type_id =

599

g_flags_register_static (g_intern_static_string ("GOutputStreamSpliceFlags"), values);

600

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

601

}

602

603

return g_define_type_id__volatile;

}

GType

g_io_stream_splice_flags_get_type (void)

608

{

609

static volatile gsize g_define_type_id__volatile = 0;

610

611

if (g_once_init_enter (&g_define_type_id__volatile))

612

{

613

static const GFlagsValue values[] = {

614

{ G_IO_STREAM_SPLICE_NONE, "G_IO_STREAM_SPLICE_NONE", "none" },

615

{ G_IO_STREAM_SPLICE_CLOSE_STREAM1, "G_IO_STREAM_SPLICE_CLOSE_STREAM1", "close-stream1" },

616

{ G_IO_STREAM_SPLICE_CLOSE_STREAM2, "G_IO_STREAM_SPLICE_CLOSE_STREAM2", "close-stream2" },

617

{ G_IO_STREAM_SPLICE_WAIT_FOR_BOTH, "G_IO_STREAM_SPLICE_WAIT_FOR_BOTH", "wait-for-both" },

618

{ 0, NULL, NULL }

619

};

620

GType g_define_type_id =

621

g_flags_register_static (g_intern_static_string ("GIOStreamSpliceFlags"), values);

622

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

623

}

624

625

return g_define_type_id__volatile;

}

GType

g_emblem_origin_get_type (void)

630

{

631

static volatile gsize g_define_type_id__volatile = 0;

632

633

if (g_once_init_enter (&g_define_type_id__volatile))

634

{

635

static const GEnumValue values[] = {

636

{ G_EMBLEM_ORIGIN_UNKNOWN, "G_EMBLEM_ORIGIN_UNKNOWN", "unknown" },

637

{ G_EMBLEM_ORIGIN_DEVICE, "G_EMBLEM_ORIGIN_DEVICE", "device" },

638

{ G_EMBLEM_ORIGIN_LIVEMETADATA, "G_EMBLEM_ORIGIN_LIVEMETADATA", "livemetadata" },

639

{ G_EMBLEM_ORIGIN_TAG, "G_EMBLEM_ORIGIN_TAG", "tag" },

640

{ 0, NULL, NULL }

641

};

642

GType g_define_type_id =

643

g_enum_register_static (g_intern_static_string ("GEmblemOrigin"), values);

644

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

645

}

646

647

return g_define_type_id__volatile;

}

GType

g_resolver_error_get_type (void)

652

{

653

static volatile gsize g_define_type_id__volatile = 0;

654

655

if (g_once_init_enter (&g_define_type_id__volatile))

656

{

657

static const GEnumValue values[] = {

658

{ G_RESOLVER_ERROR_NOT_FOUND, "G_RESOLVER_ERROR_NOT_FOUND", "not-found" },

659

{ G_RESOLVER_ERROR_TEMPORARY_FAILURE, "G_RESOLVER_ERROR_TEMPORARY_FAILURE", "temporary-failure" },

660

{ G_RESOLVER_ERROR_INTERNAL, "G_RESOLVER_ERROR_INTERNAL", "internal" },

661

{ 0, NULL, NULL }

662

};

663

GType g_define_type_id =

664

g_enum_register_static (g_intern_static_string ("GResolverError"), values);

665

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

666

}

667

668

return g_define_type_id__volatile;

}

GType

g_resolver_record_type_get_type (void)

673

{

674

static volatile gsize g_define_type_id__volatile = 0;

675

676

if (g_once_init_enter (&g_define_type_id__volatile))

677

{

678

static const GEnumValue values[] = {

679

{ G_RESOLVER_RECORD_SRV, "G_RESOLVER_RECORD_SRV", "srv" },

680

{ G_RESOLVER_RECORD_MX, "G_RESOLVER_RECORD_MX", "mx" },

681

{ G_RESOLVER_RECORD_TXT, "G_RESOLVER_RECORD_TXT", "txt" },

682

{ G_RESOLVER_RECORD_SOA, "G_RESOLVER_RECORD_SOA", "soa" },

683

{ G_RESOLVER_RECORD_NS, "G_RESOLVER_RECORD_NS", "ns" },

684

{ 0, NULL, NULL }

685

};

686

GType g_define_type_id =

687

g_enum_register_static (g_intern_static_string ("GResolverRecordType"), values);

688

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

689

}

690

691

return g_define_type_id__volatile;

}

GType

g_resource_error_get_type (void)

696

{

697

static volatile gsize g_define_type_id__volatile = 0;

698

699

if (g_once_init_enter (&g_define_type_id__volatile))

700

{

701

static const GEnumValue values[] = {

702

{ G_RESOURCE_ERROR_NOT_FOUND, "G_RESOURCE_ERROR_NOT_FOUND", "not-found" },

703

{ G_RESOURCE_ERROR_INTERNAL, "G_RESOURCE_ERROR_INTERNAL", "internal" },

704

{ 0, NULL, NULL }

705

};

706

GType g_define_type_id =

707

g_enum_register_static (g_intern_static_string ("GResourceError"), values);

708

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

709

}

710

711

return g_define_type_id__volatile;

}

GType

g_resource_flags_get_type (void)

716

{

717

static volatile gsize g_define_type_id__volatile = 0;

718

719

if (g_once_init_enter (&g_define_type_id__volatile))

720

{

721

static const GFlagsValue values[] = {

722

{ G_RESOURCE_FLAGS_NONE, "G_RESOURCE_FLAGS_NONE", "none" },

723

{ G_RESOURCE_FLAGS_COMPRESSED, "G_RESOURCE_FLAGS_COMPRESSED", "compressed" },

724

{ 0, NULL, NULL }

725

};

726

GType g_define_type_id =

727

g_flags_register_static (g_intern_static_string ("GResourceFlags"), values);

728

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

729

}

730

731

return g_define_type_id__volatile;

}

GType

g_resource_lookup_flags_get_type (void)

736

{

737

static volatile gsize g_define_type_id__volatile = 0;

738

739

if (g_once_init_enter (&g_define_type_id__volatile))

740

{

741

static const GFlagsValue values[] = {

742

{ G_RESOURCE_LOOKUP_FLAGS_NONE, "G_RESOURCE_LOOKUP_FLAGS_NONE", "none" },

743

{ 0, NULL, NULL }

744

};

745

GType g_define_type_id =

746

g_flags_register_static (g_intern_static_string ("GResourceLookupFlags"), values);

747

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

748

}

749

750

return g_define_type_id__volatile;

}

GType

g_socket_family_get_type (void)

755

{

756

static volatile gsize g_define_type_id__volatile = 0;

757

758

if (g_once_init_enter (&g_define_type_id__volatile))

759

{

760

static const GEnumValue values[] = {

761

{ G_SOCKET_FAMILY_INVALID, "G_SOCKET_FAMILY_INVALID", "invalid" },

762

{ G_SOCKET_FAMILY_UNIX, "G_SOCKET_FAMILY_UNIX", "unix" },

763

{ G_SOCKET_FAMILY_IPV4, "G_SOCKET_FAMILY_IPV4", "ipv4" },

764

{ G_SOCKET_FAMILY_IPV6, "G_SOCKET_FAMILY_IPV6", "ipv6" },

765

{ 0, NULL, NULL }

766

};

767

GType g_define_type_id =

768

g_enum_register_static (g_intern_static_string ("GSocketFamily"), values);

769

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

770

}

771

772

return g_define_type_id__volatile;

}

GType

g_socket_type_get_type (void)

777

{

778

static volatile gsize g_define_type_id__volatile = 0;

779

780

if (g_once_init_enter (&g_define_type_id__volatile))

781

{

782

static const GEnumValue values[] = {

783

{ G_SOCKET_TYPE_INVALID, "G_SOCKET_TYPE_INVALID", "invalid" },

784

{ G_SOCKET_TYPE_STREAM, "G_SOCKET_TYPE_STREAM", "stream" },

785

{ G_SOCKET_TYPE_DATAGRAM, "G_SOCKET_TYPE_DATAGRAM", "datagram" },

786

{ G_SOCKET_TYPE_SEQPACKET, "G_SOCKET_TYPE_SEQPACKET", "seqpacket" },

787

{ 0, NULL, NULL }

788

};

789

GType g_define_type_id =

790

g_enum_register_static (g_intern_static_string ("GSocketType"), values);

791

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

792

}

793

794

return g_define_type_id__volatile;

}

GType

g_socket_msg_flags_get_type (void)

799

{

800

static volatile gsize g_define_type_id__volatile = 0;

801

802

if (g_once_init_enter (&g_define_type_id__volatile))

803

{

804

static const GFlagsValue values[] = {

805

{ G_SOCKET_MSG_NONE, "G_SOCKET_MSG_NONE", "none" },

806

{ G_SOCKET_MSG_OOB, "G_SOCKET_MSG_OOB", "oob" },

807

{ G_SOCKET_MSG_PEEK, "G_SOCKET_MSG_PEEK", "peek" },

808

{ G_SOCKET_MSG_DONTROUTE, "G_SOCKET_MSG_DONTROUTE", "dontroute" },

809

{ 0, NULL, NULL }

810

};

811

GType g_define_type_id =

812

g_flags_register_static (g_intern_static_string ("GSocketMsgFlags"), values);

813

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

814

}

815

816

return g_define_type_id__volatile;

}

GType

g_socket_protocol_get_type (void)

821

{

822

static volatile gsize g_define_type_id__volatile = 0;

823

824

if (g_once_init_enter (&g_define_type_id__volatile))

825

{

826

static const GEnumValue values[] = {

827

{ G_SOCKET_PROTOCOL_UNKNOWN, "G_SOCKET_PROTOCOL_UNKNOWN", "unknown" },

828

{ G_SOCKET_PROTOCOL_DEFAULT, "G_SOCKET_PROTOCOL_DEFAULT", "default" },

829

{ G_SOCKET_PROTOCOL_TCP, "G_SOCKET_PROTOCOL_TCP", "tcp" },

830

{ G_SOCKET_PROTOCOL_UDP, "G_SOCKET_PROTOCOL_UDP", "udp" },

831

{ G_SOCKET_PROTOCOL_SCTP, "G_SOCKET_PROTOCOL_SCTP", "sctp" },

832

{ 0, NULL, NULL }

833

};

834

GType g_define_type_id =

835

g_enum_register_static (g_intern_static_string ("GSocketProtocol"), values);

836

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

837

}

838

839

return g_define_type_id__volatile;

}

GType

g_zlib_compressor_format_get_type (void)

844

{

845

static volatile gsize g_define_type_id__volatile = 0;

846

847

if (g_once_init_enter (&g_define_type_id__volatile))

848

{

849

static const GEnumValue values[] = {

850

{ G_ZLIB_COMPRESSOR_FORMAT_ZLIB, "G_ZLIB_COMPRESSOR_FORMAT_ZLIB", "zlib" },

851

{ G_ZLIB_COMPRESSOR_FORMAT_GZIP, "G_ZLIB_COMPRESSOR_FORMAT_GZIP", "gzip" },

852

{ G_ZLIB_COMPRESSOR_FORMAT_RAW, "G_ZLIB_COMPRESSOR_FORMAT_RAW", "raw" },

853

{ 0, NULL, NULL }

854

};

855

GType g_define_type_id =

856

g_enum_register_static (g_intern_static_string ("GZlibCompressorFormat"), values);

857

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

858

}

859

860

return g_define_type_id__volatile;

}

GType

g_unix_socket_address_type_get_type (void)

865

{

866

static volatile gsize g_define_type_id__volatile = 0;

867

868

if (g_once_init_enter (&g_define_type_id__volatile))

869

{

870

static const GEnumValue values[] = {

871

{ G_UNIX_SOCKET_ADDRESS_INVALID, "G_UNIX_SOCKET_ADDRESS_INVALID", "invalid" },

872

{ G_UNIX_SOCKET_ADDRESS_ANONYMOUS, "G_UNIX_SOCKET_ADDRESS_ANONYMOUS", "anonymous" },

873

{ G_UNIX_SOCKET_ADDRESS_PATH, "G_UNIX_SOCKET_ADDRESS_PATH", "path" },

874

{ G_UNIX_SOCKET_ADDRESS_ABSTRACT, "G_UNIX_SOCKET_ADDRESS_ABSTRACT", "abstract" },

875

{ G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, "G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED", "abstract-padded" },

876

{ 0, NULL, NULL }

877

};

878

GType g_define_type_id =

879

g_enum_register_static (g_intern_static_string ("GUnixSocketAddressType"), values);

880

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

881

}

882

883

return g_define_type_id__volatile;

}

GType

g_bus_type_get_type (void)

888

{

889

static volatile gsize g_define_type_id__volatile = 0;

890

891

if (g_once_init_enter (&g_define_type_id__volatile))

892

{

893

static const GEnumValue values[] = {

894

{ G_BUS_TYPE_STARTER, "G_BUS_TYPE_STARTER", "starter" },

895

{ G_BUS_TYPE_NONE, "G_BUS_TYPE_NONE", "none" },

896

{ G_BUS_TYPE_SYSTEM, "G_BUS_TYPE_SYSTEM", "system" },

897

{ G_BUS_TYPE_SESSION, "G_BUS_TYPE_SESSION", "session" },

898

{ 0, NULL, NULL }

899

};

900

GType g_define_type_id =

901

g_enum_register_static (g_intern_static_string ("GBusType"), values);

902

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

903

}

904

905

return g_define_type_id__volatile;

}

GType

g_bus_name_owner_flags_get_type (void)

910

{

911

static volatile gsize g_define_type_id__volatile = 0;

912

913

if (g_once_init_enter (&g_define_type_id__volatile))

914

{

915

static const GFlagsValue values[] = {

916

{ G_BUS_NAME_OWNER_FLAGS_NONE, "G_BUS_NAME_OWNER_FLAGS_NONE", "none" },

917

{ G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, "G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT", "allow-replacement" },

918

{ G_BUS_NAME_OWNER_FLAGS_REPLACE, "G_BUS_NAME_OWNER_FLAGS_REPLACE", "replace" },

919

{ 0, NULL, NULL }

920

};

921

GType g_define_type_id =

922

g_flags_register_static (g_intern_static_string ("GBusNameOwnerFlags"), values);

923

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

924

}

925

926

return g_define_type_id__volatile;

}

GType

g_bus_name_watcher_flags_get_type (void)

931

{

932

static volatile gsize g_define_type_id__volatile = 0;

933

934

if (g_once_init_enter (&g_define_type_id__volatile))

935

{

936

static const GFlagsValue values[] = {

937

{ G_BUS_NAME_WATCHER_FLAGS_NONE, "G_BUS_NAME_WATCHER_FLAGS_NONE", "none" },

938

{ G_BUS_NAME_WATCHER_FLAGS_AUTO_START, "G_BUS_NAME_WATCHER_FLAGS_AUTO_START", "auto-start" },

939

{ 0, NULL, NULL }

940

};

941

GType g_define_type_id =

942

g_flags_register_static (g_intern_static_string ("GBusNameWatcherFlags"), values);

943

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

944

}

945

946

return g_define_type_id__volatile;

}

GType

g_dbus_proxy_flags_get_type (void)

951

{

952

static volatile gsize g_define_type_id__volatile = 0;

953

954

if (g_once_init_enter (&g_define_type_id__volatile))

955

{

956

static const GFlagsValue values[] = {

957

{ G_DBUS_PROXY_FLAGS_NONE, "G_DBUS_PROXY_FLAGS_NONE", "none" },

958

        { G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, "G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES", "do-not-load-properties" },

959

        { G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, "G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS", "do-not-connect-signals" },

960

{ G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, "G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START", "do-not-auto-start" },

961

        { G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES, "G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES", "get-invalidated-properties" },

962

        { G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION, "G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION", "do-not-auto-start-at-construction" },

963

{ 0, NULL, NULL }

964

};

965

GType g_define_type_id =

966

g_flags_register_static (g_intern_static_string ("GDBusProxyFlags"), values);

967

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

968

}

969

970

return g_define_type_id__volatile;

}

GType

g_dbus_error_get_type (void)

975

{

976

static volatile gsize g_define_type_id__volatile = 0;

977

978

if (g_once_init_enter (&g_define_type_id__volatile))

979

{

980

static const GEnumValue values[] = {

981

{ G_DBUS_ERROR_FAILED, "G_DBUS_ERROR_FAILED", "failed" },

982

{ G_DBUS_ERROR_NO_MEMORY, "G_DBUS_ERROR_NO_MEMORY", "no-memory" },

983

{ G_DBUS_ERROR_SERVICE_UNKNOWN, "G_DBUS_ERROR_SERVICE_UNKNOWN", "service-unknown" },

984

{ G_DBUS_ERROR_NAME_HAS_NO_OWNER, "G_DBUS_ERROR_NAME_HAS_NO_OWNER", "name-has-no-owner" },

985

{ G_DBUS_ERROR_NO_REPLY, "G_DBUS_ERROR_NO_REPLY", "no-reply" },

986

{ G_DBUS_ERROR_IO_ERROR, "G_DBUS_ERROR_IO_ERROR", "io-error" },

987

{ G_DBUS_ERROR_BAD_ADDRESS, "G_DBUS_ERROR_BAD_ADDRESS", "bad-address" },

988

{ G_DBUS_ERROR_NOT_SUPPORTED, "G_DBUS_ERROR_NOT_SUPPORTED", "not-supported" },

989

{ G_DBUS_ERROR_LIMITS_EXCEEDED, "G_DBUS_ERROR_LIMITS_EXCEEDED", "limits-exceeded" },

990

{ G_DBUS_ERROR_ACCESS_DENIED, "G_DBUS_ERROR_ACCESS_DENIED", "access-denied" },

991

{ G_DBUS_ERROR_AUTH_FAILED, "G_DBUS_ERROR_AUTH_FAILED", "auth-failed" },

992

{ G_DBUS_ERROR_NO_SERVER, "G_DBUS_ERROR_NO_SERVER", "no-server" },

993

{ G_DBUS_ERROR_TIMEOUT, "G_DBUS_ERROR_TIMEOUT", "timeout" },

994

{ G_DBUS_ERROR_NO_NETWORK, "G_DBUS_ERROR_NO_NETWORK", "no-network" },

995

{ G_DBUS_ERROR_ADDRESS_IN_USE, "G_DBUS_ERROR_ADDRESS_IN_USE", "address-in-use" },

996

{ G_DBUS_ERROR_DISCONNECTED, "G_DBUS_ERROR_DISCONNECTED", "disconnected" },

997

{ G_DBUS_ERROR_INVALID_ARGS, "G_DBUS_ERROR_INVALID_ARGS", "invalid-args" },

998

{ G_DBUS_ERROR_FILE_NOT_FOUND, "G_DBUS_ERROR_FILE_NOT_FOUND", "file-not-found" },

999

{ G_DBUS_ERROR_FILE_EXISTS, "G_DBUS_ERROR_FILE_EXISTS", "file-exists" },

1000

{ G_DBUS_ERROR_UNKNOWN_METHOD, "G_DBUS_ERROR_UNKNOWN_METHOD", "unknown-method" },

1001

{ G_DBUS_ERROR_TIMED_OUT, "G_DBUS_ERROR_TIMED_OUT", "timed-out" },

1002

{ G_DBUS_ERROR_MATCH_RULE_NOT_FOUND, "G_DBUS_ERROR_MATCH_RULE_NOT_FOUND", "match-rule-not-found" },

1003

{ G_DBUS_ERROR_MATCH_RULE_INVALID, "G_DBUS_ERROR_MATCH_RULE_INVALID", "match-rule-invalid" },

1004

{ G_DBUS_ERROR_SPAWN_EXEC_FAILED, "G_DBUS_ERROR_SPAWN_EXEC_FAILED", "spawn-exec-failed" },

1005

{ G_DBUS_ERROR_SPAWN_FORK_FAILED, "G_DBUS_ERROR_SPAWN_FORK_FAILED", "spawn-fork-failed" },

1006

{ G_DBUS_ERROR_SPAWN_CHILD_EXITED, "G_DBUS_ERROR_SPAWN_CHILD_EXITED", "spawn-child-exited" },

1007

{ G_DBUS_ERROR_SPAWN_CHILD_SIGNALED, "G_DBUS_ERROR_SPAWN_CHILD_SIGNALED", "spawn-child-signaled" },

1008

{ G_DBUS_ERROR_SPAWN_FAILED, "G_DBUS_ERROR_SPAWN_FAILED", "spawn-failed" },

1009

{ G_DBUS_ERROR_SPAWN_SETUP_FAILED, "G_DBUS_ERROR_SPAWN_SETUP_FAILED", "spawn-setup-failed" },

1010

{ G_DBUS_ERROR_SPAWN_CONFIG_INVALID, "G_DBUS_ERROR_SPAWN_CONFIG_INVALID", "spawn-config-invalid" },

1011

{ G_DBUS_ERROR_SPAWN_SERVICE_INVALID, "G_DBUS_ERROR_SPAWN_SERVICE_INVALID", "spawn-service-invalid" },

1012

{ G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND, "G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND", "spawn-service-not-found" },

1013

        { G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID, "G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID", "spawn-permissions-invalid" },

1014

{ G_DBUS_ERROR_SPAWN_FILE_INVALID, "G_DBUS_ERROR_SPAWN_FILE_INVALID", "spawn-file-invalid" },

1015

{ G_DBUS_ERROR_SPAWN_NO_MEMORY, "G_DBUS_ERROR_SPAWN_NO_MEMORY", "spawn-no-memory" },

1016

{ G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN, "G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN", "unix-process-id-unknown" },

1017

{ G_DBUS_ERROR_INVALID_SIGNATURE, "G_DBUS_ERROR_INVALID_SIGNATURE", "invalid-signature" },

1018

{ G_DBUS_ERROR_INVALID_FILE_CONTENT, "G_DBUS_ERROR_INVALID_FILE_CONTENT", "invalid-file-content" },

1019

        { G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN, "G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN", "selinux-security-context-unknown" },

1020

{ G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN, "G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN", "adt-audit-data-unknown" },

1021

{ G_DBUS_ERROR_OBJECT_PATH_IN_USE, "G_DBUS_ERROR_OBJECT_PATH_IN_USE", "object-path-in-use" },

1022

{ G_DBUS_ERROR_UNKNOWN_OBJECT, "G_DBUS_ERROR_UNKNOWN_OBJECT", "unknown-object" },

1023

{ G_DBUS_ERROR_UNKNOWN_INTERFACE, "G_DBUS_ERROR_UNKNOWN_INTERFACE", "unknown-interface" },

1024

{ G_DBUS_ERROR_UNKNOWN_PROPERTY, "G_DBUS_ERROR_UNKNOWN_PROPERTY", "unknown-property" },

1025

{ G_DBUS_ERROR_PROPERTY_READ_ONLY, "G_DBUS_ERROR_PROPERTY_READ_ONLY", "property-read-only" },

1026

{ 0, NULL, NULL }

1027

};

1028

GType g_define_type_id =

1029

g_enum_register_static (g_intern_static_string ("GDBusError"), values);

1030

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1031

}

1032

1033

return g_define_type_id__volatile;

}

GType

g_dbus_connection_flags_get_type (void)

1038

{

1039

static volatile gsize g_define_type_id__volatile = 0;

1040

1041

if (g_once_init_enter (&g_define_type_id__volatile))

1042

{

1043

static const GFlagsValue values[] = {

1044

{ G_DBUS_CONNECTION_FLAGS_NONE, "G_DBUS_CONNECTION_FLAGS_NONE", "none" },

1045

        { G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT", "authentication-client" },

1046

        { G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER, "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER", "authentication-server" },

1047

        { G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS, "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS", "authentication-allow-anonymous" },

1048

        { G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, "G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION", "message-bus-connection" },

1049

        { G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, "G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING", "delay-message-processing" },

1050

{ 0, NULL, NULL }

1051

};

1052

GType g_define_type_id =

1053

g_flags_register_static (g_intern_static_string ("GDBusConnectionFlags"), values);

1054

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1055

}

1056

1057

return g_define_type_id__volatile;

}

GType

g_dbus_capability_flags_get_type (void)

1062

{

1063

static volatile gsize g_define_type_id__volatile = 0;

1064

1065

if (g_once_init_enter (&g_define_type_id__volatile))

1066

{

1067

static const GFlagsValue values[] = {

1068

{ G_DBUS_CAPABILITY_FLAGS_NONE, "G_DBUS_CAPABILITY_FLAGS_NONE", "none" },

1069

{ G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING, "G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING", "unix-fd-passing" },

1070

{ 0, NULL, NULL }

1071

};

1072

GType g_define_type_id =

1073

g_flags_register_static (g_intern_static_string ("GDBusCapabilityFlags"), values);

1074

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1075

}

1076

1077

return g_define_type_id__volatile;

}

GType

g_dbus_call_flags_get_type (void)

1082

{

1083

static volatile gsize g_define_type_id__volatile = 0;

1084

1085

if (g_once_init_enter (&g_define_type_id__volatile))

1086

{

1087

static const GFlagsValue values[] = {

1088

{ G_DBUS_CALL_FLAGS_NONE, "G_DBUS_CALL_FLAGS_NONE", "none" },

1089

{ G_DBUS_CALL_FLAGS_NO_AUTO_START, "G_DBUS_CALL_FLAGS_NO_AUTO_START", "no-auto-start" },

1090

        { G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION, "G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION", "allow-interactive-authorization" },

1091

{ 0, NULL, NULL }

1092

};

1093

GType g_define_type_id =

1094

g_flags_register_static (g_intern_static_string ("GDBusCallFlags"), values);

1095

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1096

}

1097

1098

return g_define_type_id__volatile;

}

GType

g_dbus_message_type_get_type (void)

1103

{

1104

static volatile gsize g_define_type_id__volatile = 0;

1105

1106

if (g_once_init_enter (&g_define_type_id__volatile))

1107

{

1108

static const GEnumValue values[] = {

1109

{ G_DBUS_MESSAGE_TYPE_INVALID, "G_DBUS_MESSAGE_TYPE_INVALID", "invalid" },

1110

{ G_DBUS_MESSAGE_TYPE_METHOD_CALL, "G_DBUS_MESSAGE_TYPE_METHOD_CALL", "method-call" },

1111

{ G_DBUS_MESSAGE_TYPE_METHOD_RETURN, "G_DBUS_MESSAGE_TYPE_METHOD_RETURN", "method-return" },

1112

{ G_DBUS_MESSAGE_TYPE_ERROR, "G_DBUS_MESSAGE_TYPE_ERROR", "error" },

1113

{ G_DBUS_MESSAGE_TYPE_SIGNAL, "G_DBUS_MESSAGE_TYPE_SIGNAL", "signal" },

1114

{ 0, NULL, NULL }

1115

};

1116

GType g_define_type_id =

1117

g_enum_register_static (g_intern_static_string ("GDBusMessageType"), values);

1118

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1119

}

1120

1121

return g_define_type_id__volatile;

}

GType

g_dbus_message_flags_get_type (void)

1126

{

1127

static volatile gsize g_define_type_id__volatile = 0;

1128

1129

if (g_once_init_enter (&g_define_type_id__volatile))

1130

{

1131

static const GFlagsValue values[] = {

1132

{ G_DBUS_MESSAGE_FLAGS_NONE, "G_DBUS_MESSAGE_FLAGS_NONE", "none" },

1133

{ G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED, "G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED", "no-reply-expected" },

1134

{ G_DBUS_MESSAGE_FLAGS_NO_AUTO_START, "G_DBUS_MESSAGE_FLAGS_NO_AUTO_START", "no-auto-start" },

1135

        { G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION, "G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION", "allow-interactive-authorization" },

1136

{ 0, NULL, NULL }

1137

};

1138

GType g_define_type_id =

1139

g_flags_register_static (g_intern_static_string ("GDBusMessageFlags"), values);

1140

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1141

}

1142

1143

return g_define_type_id__volatile;

}

GType

g_dbus_message_header_field_get_type (void)

1148

{

1149

static volatile gsize g_define_type_id__volatile = 0;

1150

1151

if (g_once_init_enter (&g_define_type_id__volatile))

1152

{

1153

static const GEnumValue values[] = {

1154

{ G_DBUS_MESSAGE_HEADER_FIELD_INVALID, "G_DBUS_MESSAGE_HEADER_FIELD_INVALID", "invalid" },

1155

{ G_DBUS_MESSAGE_HEADER_FIELD_PATH, "G_DBUS_MESSAGE_HEADER_FIELD_PATH", "path" },

1156

{ G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, "G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE", "interface" },

1157

{ G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, "G_DBUS_MESSAGE_HEADER_FIELD_MEMBER", "member" },

1158

{ G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, "G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME", "error-name" },

1159

{ G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, "G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL", "reply-serial" },

1160

{ G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, "G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION", "destination" },

1161

{ G_DBUS_MESSAGE_HEADER_FIELD_SENDER, "G_DBUS_MESSAGE_HEADER_FIELD_SENDER", "sender" },

1162

{ G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, "G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE", "signature" },

1163

{ G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, "G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS", "num-unix-fds" },

1164

{ 0, NULL, NULL }

1165

};

1166

GType g_define_type_id =

1167

g_enum_register_static (g_intern_static_string ("GDBusMessageHeaderField"), values);

1168

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1169

}

1170

1171

return g_define_type_id__volatile;

}

GType

g_dbus_property_info_flags_get_type (void)

1176

{

1177

static volatile gsize g_define_type_id__volatile = 0;

1178

1179

if (g_once_init_enter (&g_define_type_id__volatile))

1180

{

1181

static const GFlagsValue values[] = {

1182

{ G_DBUS_PROPERTY_INFO_FLAGS_NONE, "G_DBUS_PROPERTY_INFO_FLAGS_NONE", "none" },

1183

{ G_DBUS_PROPERTY_INFO_FLAGS_READABLE, "G_DBUS_PROPERTY_INFO_FLAGS_READABLE", "readable" },

1184

{ G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE, "G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE", "writable" },

1185

{ 0, NULL, NULL }

1186

};

1187

GType g_define_type_id =

1188

g_flags_register_static (g_intern_static_string ("GDBusPropertyInfoFlags"), values);

1189

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1190

}

1191

1192

return g_define_type_id__volatile;

}

GType

g_dbus_subtree_flags_get_type (void)

1197

{

1198

static volatile gsize g_define_type_id__volatile = 0;

1199

1200

if (g_once_init_enter (&g_define_type_id__volatile))

1201

{

1202

static const GFlagsValue values[] = {

1203

{ G_DBUS_SUBTREE_FLAGS_NONE, "G_DBUS_SUBTREE_FLAGS_NONE", "none" },

1204

        { G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES, "G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES", "dispatch-to-unenumerated-nodes" },

1205

{ 0, NULL, NULL }

1206

};

1207

GType g_define_type_id =

1208

g_flags_register_static (g_intern_static_string ("GDBusSubtreeFlags"), values);

1209

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1210

}

1211

1212

return g_define_type_id__volatile;

}

GType

g_dbus_server_flags_get_type (void)

1217

{

1218

static volatile gsize g_define_type_id__volatile = 0;

1219

1220

if (g_once_init_enter (&g_define_type_id__volatile))

1221

{

1222

static const GFlagsValue values[] = {

1223

{ G_DBUS_SERVER_FLAGS_NONE, "G_DBUS_SERVER_FLAGS_NONE", "none" },

1224

{ G_DBUS_SERVER_FLAGS_RUN_IN_THREAD, "G_DBUS_SERVER_FLAGS_RUN_IN_THREAD", "run-in-thread" },

1225

        { G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS, "G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS", "authentication-allow-anonymous" },

1226

{ 0, NULL, NULL }

1227

};

1228

GType g_define_type_id =

1229

g_flags_register_static (g_intern_static_string ("GDBusServerFlags"), values);

1230

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1231

}

1232

1233

return g_define_type_id__volatile;

}

GType

g_dbus_signal_flags_get_type (void)

1238

{

1239

static volatile gsize g_define_type_id__volatile = 0;

1240

1241

if (g_once_init_enter (&g_define_type_id__volatile))

1242

{

1243

static const GFlagsValue values[] = {

1244

{ G_DBUS_SIGNAL_FLAGS_NONE, "G_DBUS_SIGNAL_FLAGS_NONE", "none" },

1245

{ G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE, "G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE", "no-match-rule" },

1246

        { G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE, "G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE", "match-arg0-namespace" },

1247

{ G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH, "G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH", "match-arg0-path" },

1248

{ 0, NULL, NULL }

1249

};

1250

GType g_define_type_id =

1251

g_flags_register_static (g_intern_static_string ("GDBusSignalFlags"), values);

1252

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1253

}

1254

1255

return g_define_type_id__volatile;

}

GType

g_dbus_send_message_flags_get_type (void)

1260

{

1261

static volatile gsize g_define_type_id__volatile = 0;

1262

1263

if (g_once_init_enter (&g_define_type_id__volatile))

1264

{

1265

static const GFlagsValue values[] = {

1266

{ G_DBUS_SEND_MESSAGE_FLAGS_NONE, "G_DBUS_SEND_MESSAGE_FLAGS_NONE", "none" },

1267

{ G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL, "G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL", "preserve-serial" },

1268

{ 0, NULL, NULL }

1269

};

1270

GType g_define_type_id =

1271

g_flags_register_static (g_intern_static_string ("GDBusSendMessageFlags"), values);

1272

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1273

}

1274

1275

return g_define_type_id__volatile;

}

GType

g_credentials_type_get_type (void)

1280

{

1281

static volatile gsize g_define_type_id__volatile = 0;

1282

1283

if (g_once_init_enter (&g_define_type_id__volatile))

1284

{

1285

static const GEnumValue values[] = {

1286

{ G_CREDENTIALS_TYPE_INVALID, "G_CREDENTIALS_TYPE_INVALID", "invalid" },

1287

{ G_CREDENTIALS_TYPE_LINUX_UCRED, "G_CREDENTIALS_TYPE_LINUX_UCRED", "linux-ucred" },

1288

{ G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED, "G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED", "freebsd-cmsgcred" },

1289

{ G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED, "G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED", "openbsd-sockpeercred" },

1290

{ G_CREDENTIALS_TYPE_SOLARIS_UCRED, "G_CREDENTIALS_TYPE_SOLARIS_UCRED", "solaris-ucred" },

1291

{ G_CREDENTIALS_TYPE_NETBSD_UNPCBID, "G_CREDENTIALS_TYPE_NETBSD_UNPCBID", "netbsd-unpcbid" },

1292

{ 0, NULL, NULL }

1293

};

1294

GType g_define_type_id =

1295

g_enum_register_static (g_intern_static_string ("GCredentialsType"), values);

1296

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1297

}

1298

1299

return g_define_type_id__volatile;

}

GType

g_dbus_message_byte_order_get_type (void)

1304

{

1305

static volatile gsize g_define_type_id__volatile = 0;

1306

1307

if (g_once_init_enter (&g_define_type_id__volatile))

1308

{

1309

static const GEnumValue values[] = {

1310

{ G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN, "G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN", "big-endian" },

1311

{ G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN, "G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN", "little-endian" },

1312

{ 0, NULL, NULL }

1313

};

1314

GType g_define_type_id =

1315

g_enum_register_static (g_intern_static_string ("GDBusMessageByteOrder"), values);

1316

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1317

}

1318

1319

return g_define_type_id__volatile;

}

GType

g_application_flags_get_type (void)

1324

{

1325

static volatile gsize g_define_type_id__volatile = 0;

1326

1327

if (g_once_init_enter (&g_define_type_id__volatile))

1328

{

1329

static const GFlagsValue values[] = {

1330

{ G_APPLICATION_FLAGS_NONE, "G_APPLICATION_FLAGS_NONE", "flags-none" },

1331

{ G_APPLICATION_IS_SERVICE, "G_APPLICATION_IS_SERVICE", "is-service" },

1332

{ G_APPLICATION_IS_LAUNCHER, "G_APPLICATION_IS_LAUNCHER", "is-launcher" },

1333

{ G_APPLICATION_HANDLES_OPEN, "G_APPLICATION_HANDLES_OPEN", "handles-open" },

1334

{ G_APPLICATION_HANDLES_COMMAND_LINE, "G_APPLICATION_HANDLES_COMMAND_LINE", "handles-command-line" },

1335

{ G_APPLICATION_SEND_ENVIRONMENT, "G_APPLICATION_SEND_ENVIRONMENT", "send-environment" },

1336

{ G_APPLICATION_NON_UNIQUE, "G_APPLICATION_NON_UNIQUE", "non-unique" },

1337

{ G_APPLICATION_CAN_OVERRIDE_APP_ID, "G_APPLICATION_CAN_OVERRIDE_APP_ID", "can-override-app-id" },

1338

{ 0, NULL, NULL }

1339

};

1340

GType g_define_type_id =

1341

g_flags_register_static (g_intern_static_string ("GApplicationFlags"), values);

1342

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1343

}

1344

1345

return g_define_type_id__volatile;

}

GType

g_tls_error_get_type (void)

1350

{

1351

static volatile gsize g_define_type_id__volatile = 0;

1352

1353

if (g_once_init_enter (&g_define_type_id__volatile))

1354

{

1355

static const GEnumValue values[] = {

1356

{ G_TLS_ERROR_UNAVAILABLE, "G_TLS_ERROR_UNAVAILABLE", "unavailable" },

1357

{ G_TLS_ERROR_MISC, "G_TLS_ERROR_MISC", "misc" },

1358

{ G_TLS_ERROR_BAD_CERTIFICATE, "G_TLS_ERROR_BAD_CERTIFICATE", "bad-certificate" },

1359

{ G_TLS_ERROR_NOT_TLS, "G_TLS_ERROR_NOT_TLS", "not-tls" },

1360

{ G_TLS_ERROR_HANDSHAKE, "G_TLS_ERROR_HANDSHAKE", "handshake" },

1361

{ G_TLS_ERROR_CERTIFICATE_REQUIRED, "G_TLS_ERROR_CERTIFICATE_REQUIRED", "certificate-required" },

1362

{ G_TLS_ERROR_EOF, "G_TLS_ERROR_EOF", "eof" },

1363

{ 0, NULL, NULL }

1364

};

1365

GType g_define_type_id =

1366

g_enum_register_static (g_intern_static_string ("GTlsError"), values);

1367

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1368

}

1369

1370

return g_define_type_id__volatile;

}

GType

g_tls_certificate_flags_get_type (void)

1375

{

1376

static volatile gsize g_define_type_id__volatile = 0;

1377

1378

if (g_once_init_enter (&g_define_type_id__volatile))

1379

{

1380

static const GFlagsValue values[] = {

1381

{ G_TLS_CERTIFICATE_UNKNOWN_CA, "G_TLS_CERTIFICATE_UNKNOWN_CA", "unknown-ca" },

1382

{ G_TLS_CERTIFICATE_BAD_IDENTITY, "G_TLS_CERTIFICATE_BAD_IDENTITY", "bad-identity" },

1383

{ G_TLS_CERTIFICATE_NOT_ACTIVATED, "G_TLS_CERTIFICATE_NOT_ACTIVATED", "not-activated" },

1384

{ G_TLS_CERTIFICATE_EXPIRED, "G_TLS_CERTIFICATE_EXPIRED", "expired" },

1385

{ G_TLS_CERTIFICATE_REVOKED, "G_TLS_CERTIFICATE_REVOKED", "revoked" },

1386

{ G_TLS_CERTIFICATE_INSECURE, "G_TLS_CERTIFICATE_INSECURE", "insecure" },

1387

{ G_TLS_CERTIFICATE_GENERIC_ERROR, "G_TLS_CERTIFICATE_GENERIC_ERROR", "generic-error" },

1388

{ G_TLS_CERTIFICATE_VALIDATE_ALL, "G_TLS_CERTIFICATE_VALIDATE_ALL", "validate-all" },

1389

{ 0, NULL, NULL }

1390

};

1391

GType g_define_type_id =

1392

g_flags_register_static (g_intern_static_string ("GTlsCertificateFlags"), values);

1393

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1394

}

1395

1396

return g_define_type_id__volatile;

}

GType

g_tls_authentication_mode_get_type (void)

1401

{

1402

static volatile gsize g_define_type_id__volatile = 0;

1403

1404

if (g_once_init_enter (&g_define_type_id__volatile))

1405

{

1406

static const GEnumValue values[] = {

1407

{ G_TLS_AUTHENTICATION_NONE, "G_TLS_AUTHENTICATION_NONE", "none" },

1408

{ G_TLS_AUTHENTICATION_REQUESTED, "G_TLS_AUTHENTICATION_REQUESTED", "requested" },

1409

{ G_TLS_AUTHENTICATION_REQUIRED, "G_TLS_AUTHENTICATION_REQUIRED", "required" },

1410

{ 0, NULL, NULL }

1411

};

1412

GType g_define_type_id =

1413

g_enum_register_static (g_intern_static_string ("GTlsAuthenticationMode"), values);

1414

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1415

}

1416

1417

return g_define_type_id__volatile;

}

GType

g_tls_rehandshake_mode_get_type (void)

1422

{

1423

static volatile gsize g_define_type_id__volatile = 0;

1424

1425

if (g_once_init_enter (&g_define_type_id__volatile))

1426

{

1427

static const GEnumValue values[] = {

1428

{ G_TLS_REHANDSHAKE_NEVER, "G_TLS_REHANDSHAKE_NEVER", "never" },

1429

{ G_TLS_REHANDSHAKE_SAFELY, "G_TLS_REHANDSHAKE_SAFELY", "safely" },

1430

{ G_TLS_REHANDSHAKE_UNSAFELY, "G_TLS_REHANDSHAKE_UNSAFELY", "unsafely" },

1431

{ 0, NULL, NULL }

1432

};

1433

GType g_define_type_id =

1434

g_enum_register_static (g_intern_static_string ("GTlsRehandshakeMode"), values);

1435

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1436

}

1437

1438

return g_define_type_id__volatile;

}

GType

g_tls_password_flags_get_type (void)

1443

{

1444

static volatile gsize g_define_type_id__volatile = 0;

1445

1446

if (g_once_init_enter (&g_define_type_id__volatile))

1447

{

1448

static const GFlagsValue values[] = {

1449

{ G_TLS_PASSWORD_NONE, "G_TLS_PASSWORD_NONE", "none" },

1450

{ G_TLS_PASSWORD_RETRY, "G_TLS_PASSWORD_RETRY", "retry" },

1451

{ G_TLS_PASSWORD_MANY_TRIES, "G_TLS_PASSWORD_MANY_TRIES", "many-tries" },

1452

{ G_TLS_PASSWORD_FINAL_TRY, "G_TLS_PASSWORD_FINAL_TRY", "final-try" },

1453

{ 0, NULL, NULL }

1454

};

1455

GType g_define_type_id =

1456

g_flags_register_static (g_intern_static_string ("GTlsPasswordFlags"), values);

1457

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1458

}

1459

1460

return g_define_type_id__volatile;

}

GType

g_tls_interaction_result_get_type (void)

1465

{

1466

static volatile gsize g_define_type_id__volatile = 0;

1467

1468

if (g_once_init_enter (&g_define_type_id__volatile))

1469

{

1470

static const GEnumValue values[] = {

1471

{ G_TLS_INTERACTION_UNHANDLED, "G_TLS_INTERACTION_UNHANDLED", "unhandled" },

1472

{ G_TLS_INTERACTION_HANDLED, "G_TLS_INTERACTION_HANDLED", "handled" },

1473

{ G_TLS_INTERACTION_FAILED, "G_TLS_INTERACTION_FAILED", "failed" },

1474

{ 0, NULL, NULL }

1475

};

1476

GType g_define_type_id =

1477

g_enum_register_static (g_intern_static_string ("GTlsInteractionResult"), values);

1478

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1479

}

1480

1481

return g_define_type_id__volatile;

}

GType

g_dbus_interface_skeleton_flags_get_type (void)

1486

{

1487

static volatile gsize g_define_type_id__volatile = 0;

1488

1489

if (g_once_init_enter (&g_define_type_id__volatile))

1490

{

1491

static const GFlagsValue values[] = {

1492

{ G_DBUS_INTERFACE_SKELETON_FLAGS_NONE, "G_DBUS_INTERFACE_SKELETON_FLAGS_NONE", "none" },

1493

        { G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD, "G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD", "handle-method-invocations-in-thread" },

1494

{ 0, NULL, NULL }

1495

};

1496

GType g_define_type_id =

1497

g_flags_register_static (g_intern_static_string ("GDBusInterfaceSkeletonFlags"), values);

1498

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1499

}

1500

1501

return g_define_type_id__volatile;

}

GType

g_dbus_object_manager_client_flags_get_type (void)

1506

{

1507

static volatile gsize g_define_type_id__volatile = 0;

1508

1509

if (g_once_init_enter (&g_define_type_id__volatile))

1510

{

1511

static const GFlagsValue values[] = {

1512

{ G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE", "none" },

1513

        { G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START, "G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START", "do-not-auto-start" },

1514

{ 0, NULL, NULL }

1515

};

1516

GType g_define_type_id =

1517

g_flags_register_static (g_intern_static_string ("GDBusObjectManagerClientFlags"), values);

1518

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1519

}

1520

1521

return g_define_type_id__volatile;

}

GType

g_tls_database_verify_flags_get_type (void)

1526

{

1527

static volatile gsize g_define_type_id__volatile = 0;

1528

1529

if (g_once_init_enter (&g_define_type_id__volatile))

1530

{

1531

static const GFlagsValue values[] = {

1532

{ G_TLS_DATABASE_VERIFY_NONE, "G_TLS_DATABASE_VERIFY_NONE", "none" },

1533

{ 0, NULL, NULL }

1534

};

1535

GType g_define_type_id =

1536

g_flags_register_static (g_intern_static_string ("GTlsDatabaseVerifyFlags"), values);

1537

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1538

}

1539

1540

return g_define_type_id__volatile;

}

GType

g_tls_database_lookup_flags_get_type (void)

1545

{

1546

static volatile gsize g_define_type_id__volatile = 0;

1547

1548

if (g_once_init_enter (&g_define_type_id__volatile))

1549

{

1550

static const GEnumValue values[] = {

1551

{ G_TLS_DATABASE_LOOKUP_NONE, "G_TLS_DATABASE_LOOKUP_NONE", "none" },

1552

{ G_TLS_DATABASE_LOOKUP_KEYPAIR, "G_TLS_DATABASE_LOOKUP_KEYPAIR", "keypair" },

1553

{ 0, NULL, NULL }

1554

};

1555

GType g_define_type_id =

1556

g_enum_register_static (g_intern_static_string ("GTlsDatabaseLookupFlags"), values);

1557

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1558

}

1559

1560

return g_define_type_id__volatile;

}

GType

g_tls_certificate_request_flags_get_type (void)

1565

{

1566

static volatile gsize g_define_type_id__volatile = 0;

1567

1568

if (g_once_init_enter (&g_define_type_id__volatile))

1569

{

1570

static const GEnumValue values[] = {

1571

{ G_TLS_CERTIFICATE_REQUEST_NONE, "G_TLS_CERTIFICATE_REQUEST_NONE", "none" },

1572

{ 0, NULL, NULL }

1573

};

1574

GType g_define_type_id =

1575

g_enum_register_static (g_intern_static_string ("GTlsCertificateRequestFlags"), values);

1576

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1577

}

1578

1579

return g_define_type_id__volatile;

}

GType

g_io_module_scope_flags_get_type (void)

1584

{

1585

static volatile gsize g_define_type_id__volatile = 0;

1586

1587

if (g_once_init_enter (&g_define_type_id__volatile))

1588

{

1589

static const GEnumValue values[] = {

1590

{ G_IO_MODULE_SCOPE_NONE, "G_IO_MODULE_SCOPE_NONE", "none" },

1591

{ G_IO_MODULE_SCOPE_BLOCK_DUPLICATES, "G_IO_MODULE_SCOPE_BLOCK_DUPLICATES", "block-duplicates" },

1592

{ 0, NULL, NULL }

1593

};

1594

GType g_define_type_id =

1595

g_enum_register_static (g_intern_static_string ("GIOModuleScopeFlags"), values);

1596

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1597

}

1598

1599

return g_define_type_id__volatile;

}

GType

g_socket_client_event_get_type (void)

1604

{

1605

static volatile gsize g_define_type_id__volatile = 0;

1606

1607

if (g_once_init_enter (&g_define_type_id__volatile))

1608

{

1609

static const GEnumValue values[] = {

1610

{ G_SOCKET_CLIENT_RESOLVING, "G_SOCKET_CLIENT_RESOLVING", "resolving" },

1611

{ G_SOCKET_CLIENT_RESOLVED, "G_SOCKET_CLIENT_RESOLVED", "resolved" },

1612

{ G_SOCKET_CLIENT_CONNECTING, "G_SOCKET_CLIENT_CONNECTING", "connecting" },

1613

{ G_SOCKET_CLIENT_CONNECTED, "G_SOCKET_CLIENT_CONNECTED", "connected" },

1614

{ G_SOCKET_CLIENT_PROXY_NEGOTIATING, "G_SOCKET_CLIENT_PROXY_NEGOTIATING", "proxy-negotiating" },

1615

{ G_SOCKET_CLIENT_PROXY_NEGOTIATED, "G_SOCKET_CLIENT_PROXY_NEGOTIATED", "proxy-negotiated" },

1616

{ G_SOCKET_CLIENT_TLS_HANDSHAKING, "G_SOCKET_CLIENT_TLS_HANDSHAKING", "tls-handshaking" },

1617

{ G_SOCKET_CLIENT_TLS_HANDSHAKED, "G_SOCKET_CLIENT_TLS_HANDSHAKED", "tls-handshaked" },

1618

{ G_SOCKET_CLIENT_COMPLETE, "G_SOCKET_CLIENT_COMPLETE", "complete" },

1619

{ 0, NULL, NULL }

1620

};

1621

GType g_define_type_id =

1622

g_enum_register_static (g_intern_static_string ("GSocketClientEvent"), values);

1623

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1624

}

1625

1626

return g_define_type_id__volatile;

}

GType

g_socket_listener_event_get_type (void)

1631

{

1632

static volatile gsize g_define_type_id__volatile = 0;

1633

1634

if (g_once_init_enter (&g_define_type_id__volatile))

1635

{

1636

static const GEnumValue values[] = {

1637

{ G_SOCKET_LISTENER_BINDING, "G_SOCKET_LISTENER_BINDING", "binding" },

1638

{ G_SOCKET_LISTENER_BOUND, "G_SOCKET_LISTENER_BOUND", "bound" },

1639

{ G_SOCKET_LISTENER_LISTENING, "G_SOCKET_LISTENER_LISTENING", "listening" },

1640

{ G_SOCKET_LISTENER_LISTENED, "G_SOCKET_LISTENER_LISTENED", "listened" },

1641

{ 0, NULL, NULL }

1642

};

1643

GType g_define_type_id =

1644

g_enum_register_static (g_intern_static_string ("GSocketListenerEvent"), values);

1645

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1646

}

1647

1648

return g_define_type_id__volatile;

}

GType

g_test_dbus_flags_get_type (void)

1653

{

1654

static volatile gsize g_define_type_id__volatile = 0;

1655

1656

if (g_once_init_enter (&g_define_type_id__volatile))

1657

{

1658

static const GFlagsValue values[] = {

1659

{ G_TEST_DBUS_NONE, "G_TEST_DBUS_NONE", "none" },

1660

{ 0, NULL, NULL }

1661

};

1662

GType g_define_type_id =

1663

g_flags_register_static (g_intern_static_string ("GTestDBusFlags"), values);

1664

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1665

}

1666

1667

return g_define_type_id__volatile;

}

GType

g_subprocess_flags_get_type (void)

1672

{

1673

static volatile gsize g_define_type_id__volatile = 0;

1674

1675

if (g_once_init_enter (&g_define_type_id__volatile))

1676

{

1677

static const GFlagsValue values[] = {

1678

{ G_SUBPROCESS_FLAGS_NONE, "G_SUBPROCESS_FLAGS_NONE", "none" },

1679

{ G_SUBPROCESS_FLAGS_STDIN_PIPE, "G_SUBPROCESS_FLAGS_STDIN_PIPE", "stdin-pipe" },

1680

{ G_SUBPROCESS_FLAGS_STDIN_INHERIT, "G_SUBPROCESS_FLAGS_STDIN_INHERIT", "stdin-inherit" },

1681

{ G_SUBPROCESS_FLAGS_STDOUT_PIPE, "G_SUBPROCESS_FLAGS_STDOUT_PIPE", "stdout-pipe" },

1682

{ G_SUBPROCESS_FLAGS_STDOUT_SILENCE, "G_SUBPROCESS_FLAGS_STDOUT_SILENCE", "stdout-silence" },

1683

{ G_SUBPROCESS_FLAGS_STDERR_PIPE, "G_SUBPROCESS_FLAGS_STDERR_PIPE", "stderr-pipe" },

1684

{ G_SUBPROCESS_FLAGS_STDERR_SILENCE, "G_SUBPROCESS_FLAGS_STDERR_SILENCE", "stderr-silence" },

1685

{ G_SUBPROCESS_FLAGS_STDERR_MERGE, "G_SUBPROCESS_FLAGS_STDERR_MERGE", "stderr-merge" },

1686

{ G_SUBPROCESS_FLAGS_INHERIT_FDS, "G_SUBPROCESS_FLAGS_INHERIT_FDS", "inherit-fds" },

1687

{ 0, NULL, NULL }

1688

};

1689

GType g_define_type_id =

1690

g_flags_register_static (g_intern_static_string ("GSubprocessFlags"), values);

1691

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1692

}

1693

1694

return g_define_type_id__volatile;

}

GType

g_notification_priority_get_type (void)

1699

{

1700

static volatile gsize g_define_type_id__volatile = 0;

1701

1702

if (g_once_init_enter (&g_define_type_id__volatile))

1703

{

1704

static const GEnumValue values[] = {

1705

{ G_NOTIFICATION_PRIORITY_NORMAL, "G_NOTIFICATION_PRIORITY_NORMAL", "normal" },

1706

{ G_NOTIFICATION_PRIORITY_LOW, "G_NOTIFICATION_PRIORITY_LOW", "low" },

1707

{ G_NOTIFICATION_PRIORITY_HIGH, "G_NOTIFICATION_PRIORITY_HIGH", "high" },

1708

{ G_NOTIFICATION_PRIORITY_URGENT, "G_NOTIFICATION_PRIORITY_URGENT", "urgent" },

1709

{ 0, NULL, NULL }

1710

};

1711

GType g_define_type_id =

1712

g_enum_register_static (g_intern_static_string ("GNotificationPriority"), values);

1713

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1714

}

1715

1716

return g_define_type_id__volatile;

}

GType

g_network_connectivity_get_type (void)

1721

{

1722

static volatile gsize g_define_type_id__volatile = 0;

1723

1724

if (g_once_init_enter (&g_define_type_id__volatile))

1725

{

1726

static const GEnumValue values[] = {

1727

{ G_NETWORK_CONNECTIVITY_LOCAL, "G_NETWORK_CONNECTIVITY_LOCAL", "local" },

1728

{ G_NETWORK_CONNECTIVITY_LIMITED, "G_NETWORK_CONNECTIVITY_LIMITED", "limited" },

1729

{ G_NETWORK_CONNECTIVITY_PORTAL, "G_NETWORK_CONNECTIVITY_PORTAL", "portal" },

1730

{ G_NETWORK_CONNECTIVITY_FULL, "G_NETWORK_CONNECTIVITY_FULL", "full" },

1731

{ 0, NULL, NULL }

1732

};

1733

GType g_define_type_id =

1734

g_enum_register_static (g_intern_static_string ("GNetworkConnectivity"), values);

1735

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1736

}

1737

1738

return g_define_type_id__volatile;

1739

}

1740

1741

/* enumerations from "gsettings.h" */

1742

GType

1743

g_settings_bind_flags_get_type (void)

1744

{

1745

static volatile gsize g_define_type_id__volatile = 0;

1746

1747

if (g_once_init_enter (&g_define_type_id__volatile))

1748

{

1749

static const GFlagsValue values[] = {

1750

{ G_SETTINGS_BIND_DEFAULT, "G_SETTINGS_BIND_DEFAULT", "default" },

1751

{ G_SETTINGS_BIND_GET, "G_SETTINGS_BIND_GET", "get" },

1752

{ G_SETTINGS_BIND_SET, "G_SETTINGS_BIND_SET", "set" },

1753

{ G_SETTINGS_BIND_NO_SENSITIVITY, "G_SETTINGS_BIND_NO_SENSITIVITY", "no-sensitivity" },

1754

{ G_SETTINGS_BIND_GET_NO_CHANGES, "G_SETTINGS_BIND_GET_NO_CHANGES", "get-no-changes" },

1755

{ G_SETTINGS_BIND_INVERT_BOOLEAN, "G_SETTINGS_BIND_INVERT_BOOLEAN", "invert-boolean" },

1756

{ 0, NULL, NULL }

1757

};

1758

GType g_define_type_id =

1759

g_flags_register_static (g_intern_static_string ("GSettingsBindFlags"), values);

1760

g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);

1761

}

1762

1763

return g_define_type_id__volatile;

}

/* Generated data ends here */

1768

nexmon – Blame information for rev 1