1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module glib.c.types; 26 27 public alias uint uid_t; 28 public alias int pid_t; 29 30 version( Windows ) 31 { 32 alias int glong; 33 alias uint gulong; 34 } 35 else version( X86_64 ) 36 { 37 alias long glong; 38 alias ulong gulong; 39 } 40 else 41 { 42 alias int glong; 43 alias uint gulong; 44 } 45 46 version (Windows) 47 { 48 private import core.stdc.stdio; 49 50 static if( !is(typeof(fdopen(0, null))) ) 51 { 52 extern (C) FILE* fdopen(int, char*); 53 } 54 } 55 56 static if ( __VERSION__ >= 2063 ) 57 { 58 public import std.typecons : scoped; 59 60 template Scoped(T) 61 { 62 alias typeof(scoped!T(cast(typeof(T.tupleof[0]))null)) Scoped; 63 } 64 } 65 else 66 { 67 // I'm getting the following error on the older dmd versions: 68 // this for Scoped_store needs to be type Scoped not type inout(Scoped!(T)). 69 // Unlike the phobos version this does use GC alocated memory for the object. 70 // Within GtkD this is used to make sure destroy is called on the object 71 // so it releases the resources it holds. 72 struct Scoped(T) 73 { 74 T payload; 75 76 alias payload this; 77 78 @disable this(); 79 @disable this(this); 80 81 ~this() 82 { 83 .destroy(payload); 84 } 85 } 86 87 auto scoped(T, Args...)(auto ref Args args) if (is(T == class)) 88 { 89 Scoped!(T) result = void; 90 result.payload = new T(args); 91 92 return result; 93 } 94 } 95 96 /** 97 * Get the length of a zero terminated array. 98 */ 99 size_t getArrayLength(T)(T* arr) 100 { 101 size_t len; 102 103 for ( ; arr[len]; len++ ){} 104 105 return len; 106 } 107 108 unittest 109 { 110 assert(getArrayLength("aaaaaaaaa\0".ptr) == 9); 111 } 112 113 Type* gMalloc(Type)() 114 { 115 import glib.c.functions; 116 return cast(Type*)g_malloc0(Type.sizeof); 117 } 118 119 alias void* GIConv; 120 121 /** 122 * Integer representing a day of the month; between 1 and 31. 123 * #G_DATE_BAD_DAY represents an invalid day of the month. 124 */ 125 public alias ubyte GDateDay; 126 127 /** 128 * Integer representing a year; #G_DATE_BAD_YEAR is the invalid 129 * value. The year must be 1 or higher; negative (BC) years are not 130 * allowed. The year is represented with four digits. 131 */ 132 public alias ushort GDateYear; 133 134 /** 135 * Opaque type. See g_mutex_locker_new() for details. 136 */ 137 public alias void GMutexLocker; 138 139 /** 140 * A type which is used to hold a process identification. 141 * 142 * On UNIX, processes are identified by a process id (an integer), 143 * while Windows uses process handles (which are pointers). 144 * 145 * GPid is used in GLib only for descendant processes spawned with 146 * the g_spawn functions. 147 */ 148 public alias int GPid; 149 150 /** 151 * A GQuark is a non-zero integer which uniquely identifies a 152 * particular string. A GQuark value of zero is associated to %NULL. 153 */ 154 public alias uint GQuark; 155 156 /** 157 * A typedef alias for gchar**. This is mostly useful when used together with 158 * g_auto(). 159 */ 160 public alias char** GStrv; 161 162 /** 163 * Simply a replacement for time_t. It has been deprecated 164 * since it is not equivalent to time_t on 64-bit platforms 165 * with a 64-bit time_t. Unrelated to #GTimer. 166 * 167 * Note that #GTime is defined to always be a 32-bit integer, 168 * unlike time_t which may be 64-bit on some systems. Therefore, 169 * #GTime will overflow in the year 2038, and you cannot use the 170 * address of a #GTime variable as argument to the UNIX time() 171 * function. 172 * 173 * Instead, do the following: 174 * |[<!-- language="C" --> 175 * time_t ttime; 176 * GTime gtime; 177 * 178 * time (&ttime); 179 * gtime = (GTime)ttime; 180 * ]| 181 */ 182 public alias int GTime; 183 184 /** 185 * A value representing an interval of time, in microseconds. 186 */ 187 public alias long GTimeSpan; 188 189 enum GPriority 190 { 191 HIGH = -100, 192 DEFAULT = 0, 193 HIGH_IDLE = 100, 194 DEFAULT_IDLE = 200, 195 LOW = 300 196 } 197 198 199 public enum GAsciiType 200 { 201 ALNUM = 1, 202 ALPHA = 2, 203 CNTRL = 4, 204 DIGIT = 8, 205 GRAPH = 16, 206 LOWER = 32, 207 PRINT = 64, 208 PUNCT = 128, 209 SPACE = 256, 210 UPPER = 512, 211 XDIGIT = 1024, 212 } 213 alias GAsciiType AsciiType; 214 215 /** 216 * Error codes returned by bookmark file parsing. 217 */ 218 public enum GBookmarkFileError 219 { 220 /** 221 * URI was ill-formed 222 */ 223 INVALID_URI = 0, 224 /** 225 * a requested field was not found 226 */ 227 INVALID_VALUE = 1, 228 /** 229 * a requested application did 230 * not register a bookmark 231 */ 232 APP_NOT_REGISTERED = 2, 233 /** 234 * a requested URI was not found 235 */ 236 URI_NOT_FOUND = 3, 237 /** 238 * document was ill formed 239 */ 240 READ = 4, 241 /** 242 * the text being parsed was 243 * in an unknown encoding 244 */ 245 UNKNOWN_ENCODING = 5, 246 /** 247 * an error occurred while writing 248 */ 249 WRITE = 6, 250 /** 251 * requested file was not found 252 */ 253 FILE_NOT_FOUND = 7, 254 } 255 alias GBookmarkFileError BookmarkFileError; 256 257 /** 258 * The hashing algorithm to be used by #GChecksum when performing the 259 * digest of some data. 260 * 261 * Note that the #GChecksumType enumeration may be extended at a later 262 * date to include new hashing algorithm types. 263 * 264 * Since: 2.16 265 */ 266 public enum GChecksumType 267 { 268 /** 269 * Use the MD5 hashing algorithm 270 */ 271 MD5 = 0, 272 /** 273 * Use the SHA-1 hashing algorithm 274 */ 275 SHA1 = 1, 276 /** 277 * Use the SHA-256 hashing algorithm 278 */ 279 SHA256 = 2, 280 /** 281 * Use the SHA-512 hashing algorithm (Since: 2.36) 282 */ 283 SHA512 = 3, 284 /** 285 * Use the SHA-384 hashing algorithm (Since: 2.51) 286 */ 287 SHA384 = 4, 288 } 289 alias GChecksumType ChecksumType; 290 291 /** 292 * Error codes returned by character set conversion routines. 293 */ 294 public enum GConvertError 295 { 296 /** 297 * Conversion between the requested character 298 * sets is not supported. 299 */ 300 NO_CONVERSION = 0, 301 /** 302 * Invalid byte sequence in conversion input. 303 */ 304 ILLEGAL_SEQUENCE = 1, 305 /** 306 * Conversion failed for some reason. 307 */ 308 FAILED = 2, 309 /** 310 * Partial character sequence at end of input. 311 */ 312 PARTIAL_INPUT = 3, 313 /** 314 * URI is invalid. 315 */ 316 BAD_URI = 4, 317 /** 318 * Pathname is not an absolute path. 319 */ 320 NOT_ABSOLUTE_PATH = 5, 321 /** 322 * No memory available. Since: 2.40 323 */ 324 NO_MEMORY = 6, 325 } 326 alias GConvertError ConvertError; 327 328 /** 329 * This enumeration isn't used in the API, but may be useful if you need 330 * to mark a number as a day, month, or year. 331 */ 332 public enum GDateDMY 333 { 334 /** 335 * a day 336 */ 337 DAY = 0, 338 /** 339 * a month 340 */ 341 MONTH = 1, 342 /** 343 * a year 344 */ 345 YEAR = 2, 346 } 347 alias GDateDMY DateDMY; 348 349 /** 350 * Enumeration representing a month; values are #G_DATE_JANUARY, 351 * #G_DATE_FEBRUARY, etc. #G_DATE_BAD_MONTH is the invalid value. 352 */ 353 public enum GDateMonth 354 { 355 /** 356 * invalid value 357 */ 358 BAD_MONTH = 0, 359 /** 360 * January 361 */ 362 JANUARY = 1, 363 /** 364 * February 365 */ 366 FEBRUARY = 2, 367 /** 368 * March 369 */ 370 MARCH = 3, 371 /** 372 * April 373 */ 374 APRIL = 4, 375 /** 376 * May 377 */ 378 MAY = 5, 379 /** 380 * June 381 */ 382 JUNE = 6, 383 /** 384 * July 385 */ 386 JULY = 7, 387 /** 388 * August 389 */ 390 AUGUST = 8, 391 /** 392 * September 393 */ 394 SEPTEMBER = 9, 395 /** 396 * October 397 */ 398 OCTOBER = 10, 399 /** 400 * November 401 */ 402 NOVEMBER = 11, 403 /** 404 * December 405 */ 406 DECEMBER = 12, 407 } 408 alias GDateMonth DateMonth; 409 410 /** 411 * Enumeration representing a day of the week; #G_DATE_MONDAY, 412 * #G_DATE_TUESDAY, etc. #G_DATE_BAD_WEEKDAY is an invalid weekday. 413 */ 414 public enum GDateWeekday 415 { 416 /** 417 * invalid value 418 */ 419 BAD_WEEKDAY = 0, 420 /** 421 * Monday 422 */ 423 MONDAY = 1, 424 /** 425 * Tuesday 426 */ 427 TUESDAY = 2, 428 /** 429 * Wednesday 430 */ 431 WEDNESDAY = 3, 432 /** 433 * Thursday 434 */ 435 THURSDAY = 4, 436 /** 437 * Friday 438 */ 439 FRIDAY = 5, 440 /** 441 * Saturday 442 */ 443 SATURDAY = 6, 444 /** 445 * Sunday 446 */ 447 SUNDAY = 7, 448 } 449 alias GDateWeekday DateWeekday; 450 451 /** 452 * The possible errors, used in the @v_error field 453 * of #GTokenValue, when the token is a %G_TOKEN_ERROR. 454 */ 455 public enum GErrorType 456 { 457 /** 458 * unknown error 459 */ 460 UNKNOWN = 0, 461 /** 462 * unexpected end of file 463 */ 464 UNEXP_EOF = 1, 465 /** 466 * unterminated string constant 467 */ 468 UNEXP_EOF_IN_STRING = 2, 469 /** 470 * unterminated comment 471 */ 472 UNEXP_EOF_IN_COMMENT = 3, 473 /** 474 * non-digit character in a number 475 */ 476 NON_DIGIT_IN_CONST = 4, 477 /** 478 * digit beyond radix in a number 479 */ 480 DIGIT_RADIX = 5, 481 /** 482 * non-decimal floating point number 483 */ 484 FLOAT_RADIX = 6, 485 /** 486 * malformed floating point number 487 */ 488 FLOAT_MALFORMED = 7, 489 } 490 alias GErrorType ErrorType; 491 492 /** 493 * Values corresponding to @errno codes returned from file operations 494 * on UNIX. Unlike @errno codes, GFileError values are available on 495 * all systems, even Windows. The exact meaning of each code depends 496 * on what sort of file operation you were performing; the UNIX 497 * documentation gives more details. The following error code descriptions 498 * come from the GNU C Library manual, and are under the copyright 499 * of that manual. 500 * 501 * It's not very portable to make detailed assumptions about exactly 502 * which errors will be returned from a given operation. Some errors 503 * don't occur on some systems, etc., sometimes there are subtle 504 * differences in when a system will report a given error, etc. 505 */ 506 public enum GFileError 507 { 508 /** 509 * Operation not permitted; only the owner of 510 * the file (or other resource) or processes with special privileges 511 * can perform the operation. 512 */ 513 EXIST = 0, 514 /** 515 * File is a directory; you cannot open a directory 516 * for writing, or create or remove hard links to it. 517 */ 518 ISDIR = 1, 519 /** 520 * Permission denied; the file permissions do not 521 * allow the attempted operation. 522 */ 523 ACCES = 2, 524 /** 525 * Filename too long. 526 */ 527 NAMETOOLONG = 3, 528 /** 529 * No such file or directory. This is a "file 530 * doesn't exist" error for ordinary files that are referenced in 531 * contexts where they are expected to already exist. 532 */ 533 NOENT = 4, 534 /** 535 * A file that isn't a directory was specified when 536 * a directory is required. 537 */ 538 NOTDIR = 5, 539 /** 540 * No such device or address. The system tried to 541 * use the device represented by a file you specified, and it 542 * couldn't find the device. This can mean that the device file was 543 * installed incorrectly, or that the physical device is missing or 544 * not correctly attached to the computer. 545 */ 546 NXIO = 6, 547 /** 548 * The underlying file system of the specified file 549 * does not support memory mapping. 550 */ 551 NODEV = 7, 552 /** 553 * The directory containing the new link can't be 554 * modified because it's on a read-only file system. 555 */ 556 ROFS = 8, 557 /** 558 * Text file busy. 559 */ 560 TXTBSY = 9, 561 /** 562 * You passed in a pointer to bad memory. 563 * (GLib won't reliably return this, don't pass in pointers to bad 564 * memory.) 565 */ 566 FAULT = 10, 567 /** 568 * Too many levels of symbolic links were encountered 569 * in looking up a file name. This often indicates a cycle of symbolic 570 * links. 571 */ 572 LOOP = 11, 573 /** 574 * No space left on device; write operation on a 575 * file failed because the disk is full. 576 */ 577 NOSPC = 12, 578 /** 579 * No memory available. The system cannot allocate 580 * more virtual memory because its capacity is full. 581 */ 582 NOMEM = 13, 583 /** 584 * The current process has too many files open and 585 * can't open any more. Duplicate descriptors do count toward this 586 * limit. 587 */ 588 MFILE = 14, 589 /** 590 * There are too many distinct file openings in the 591 * entire system. 592 */ 593 NFILE = 15, 594 /** 595 * Bad file descriptor; for example, I/O on a 596 * descriptor that has been closed or reading from a descriptor open 597 * only for writing (or vice versa). 598 */ 599 BADF = 16, 600 /** 601 * Invalid argument. This is used to indicate 602 * various kinds of problems with passing the wrong argument to a 603 * library function. 604 */ 605 INVAL = 17, 606 /** 607 * Broken pipe; there is no process reading from the 608 * other end of a pipe. Every library function that returns this 609 * error code also generates a 'SIGPIPE' signal; this signal 610 * terminates the program if not handled or blocked. Thus, your 611 * program will never actually see this code unless it has handled 612 * or blocked 'SIGPIPE'. 613 */ 614 PIPE = 18, 615 /** 616 * Resource temporarily unavailable; the call might 617 * work if you try again later. 618 */ 619 AGAIN = 19, 620 /** 621 * Interrupted function call; an asynchronous signal 622 * occurred and prevented completion of the call. When this 623 * happens, you should try the call again. 624 */ 625 INTR = 20, 626 /** 627 * Input/output error; usually used for physical read 628 * or write errors. i.e. the disk or other physical device hardware 629 * is returning errors. 630 */ 631 IO = 21, 632 /** 633 * Operation not permitted; only the owner of the 634 * file (or other resource) or processes with special privileges can 635 * perform the operation. 636 */ 637 PERM = 22, 638 /** 639 * Function not implemented; this indicates that 640 * the system is missing some functionality. 641 */ 642 NOSYS = 23, 643 /** 644 * Does not correspond to a UNIX error code; this 645 * is the standard "failed for unspecified reason" error code present 646 * in all #GError error code enumerations. Returned if no specific 647 * code applies. 648 */ 649 FAILED = 24, 650 } 651 alias GFileError FileError; 652 653 /** 654 * A test to perform on a file using g_file_test(). 655 */ 656 public enum GFileTest 657 { 658 /** 659 * %TRUE if the file is a regular file 660 * (not a directory). Note that this test will also return %TRUE 661 * if the tested file is a symlink to a regular file. 662 */ 663 IS_REGULAR = 1, 664 /** 665 * %TRUE if the file is a symlink. 666 */ 667 IS_SYMLINK = 2, 668 /** 669 * %TRUE if the file is a directory. 670 */ 671 IS_DIR = 4, 672 /** 673 * %TRUE if the file is executable. 674 */ 675 IS_EXECUTABLE = 8, 676 /** 677 * %TRUE if the file exists. It may or may not 678 * be a regular file. 679 */ 680 EXISTS = 16, 681 } 682 alias GFileTest FileTest; 683 684 /** 685 * Flags to modify the format of the string returned by g_format_size_full(). 686 */ 687 public enum GFormatSizeFlags 688 { 689 /** 690 * behave the same as g_format_size() 691 */ 692 DEFAULT = 0, 693 /** 694 * include the exact number of bytes as part 695 * of the returned string. For example, "45.6 kB (45,612 bytes)". 696 */ 697 LONG_FORMAT = 1, 698 /** 699 * use IEC (base 1024) units with "KiB"-style 700 * suffixes. IEC units should only be used for reporting things with 701 * a strong "power of 2" basis, like RAM sizes or RAID stripe sizes. 702 * Network and storage sizes should be reported in the normal SI units. 703 */ 704 IEC_UNITS = 2, 705 } 706 alias GFormatSizeFlags FormatSizeFlags; 707 708 /** 709 * Flags used internally in the #GHook implementation. 710 */ 711 public enum GHookFlagMask 712 { 713 /** 714 * set if the hook has not been destroyed 715 */ 716 ACTIVE = 1, 717 /** 718 * set if the hook is currently being run 719 */ 720 IN_CALL = 2, 721 /** 722 * A mask covering all bits reserved for 723 * hook flags; see %G_HOOK_FLAG_USER_SHIFT 724 */ 725 MASK = 15, 726 } 727 alias GHookFlagMask HookFlagMask; 728 729 /** 730 * Error codes returned by #GIOChannel operations. 731 */ 732 public enum GIOChannelError 733 { 734 /** 735 * File too large. 736 */ 737 FBIG = 0, 738 /** 739 * Invalid argument. 740 */ 741 INVAL = 1, 742 /** 743 * IO error. 744 */ 745 IO = 2, 746 /** 747 * File is a directory. 748 */ 749 ISDIR = 3, 750 /** 751 * No space left on device. 752 */ 753 NOSPC = 4, 754 /** 755 * No such device or address. 756 */ 757 NXIO = 5, 758 /** 759 * Value too large for defined datatype. 760 */ 761 OVERFLOW = 6, 762 /** 763 * Broken pipe. 764 */ 765 PIPE = 7, 766 /** 767 * Some other error. 768 */ 769 FAILED = 8, 770 } 771 alias GIOChannelError IOChannelError; 772 773 /** 774 * A bitwise combination representing a condition to watch for on an 775 * event source. 776 */ 777 public enum GIOCondition 778 { 779 /** 780 * There is data to read. 781 */ 782 IN = 1, 783 /** 784 * Data can be written (without blocking). 785 */ 786 OUT = 4, 787 /** 788 * There is urgent data to read. 789 */ 790 PRI = 2, 791 /** 792 * Error condition. 793 */ 794 ERR = 8, 795 /** 796 * Hung up (the connection has been broken, usually for 797 * pipes and sockets). 798 */ 799 HUP = 16, 800 /** 801 * Invalid request. The file descriptor is not open. 802 */ 803 NVAL = 32, 804 } 805 alias GIOCondition IOCondition; 806 807 /** 808 * #GIOError is only used by the deprecated functions 809 * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek(). 810 */ 811 public enum GIOError 812 { 813 /** 814 * no error 815 */ 816 NONE = 0, 817 /** 818 * an EAGAIN error occurred 819 */ 820 AGAIN = 1, 821 /** 822 * an EINVAL error occurred 823 */ 824 INVAL = 2, 825 /** 826 * another error occurred 827 */ 828 UNKNOWN = 3, 829 } 830 alias GIOError IOError; 831 832 /** 833 * Specifies properties of a #GIOChannel. Some of the flags can only be 834 * read with g_io_channel_get_flags(), but not changed with 835 * g_io_channel_set_flags(). 836 */ 837 public enum GIOFlags 838 { 839 /** 840 * turns on append mode, corresponds to %O_APPEND 841 * (see the documentation of the UNIX open() syscall) 842 */ 843 APPEND = 1, 844 /** 845 * turns on nonblocking mode, corresponds to 846 * %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open() 847 * syscall) 848 */ 849 NONBLOCK = 2, 850 /** 851 * indicates that the io channel is readable. 852 * This flag cannot be changed. 853 */ 854 IS_READABLE = 4, 855 /** 856 * indicates that the io channel is writable. 857 * This flag cannot be changed. 858 */ 859 IS_WRITABLE = 8, 860 /** 861 * a misspelled version of @G_IO_FLAG_IS_WRITABLE 862 * that existed before the spelling was fixed in GLib 2.30. It is kept 863 * here for compatibility reasons. Deprecated since 2.30 864 */ 865 IS_WRITEABLE = 8, 866 /** 867 * indicates that the io channel is seekable, 868 * i.e. that g_io_channel_seek_position() can be used on it. 869 * This flag cannot be changed. 870 */ 871 IS_SEEKABLE = 16, 872 /** 873 * the mask that specifies all the valid flags. 874 */ 875 MASK = 31, 876 /** 877 * the mask of the flags that are returned from 878 * g_io_channel_get_flags() 879 */ 880 GET_MASK = 31, 881 /** 882 * the mask of the flags that the user can modify 883 * with g_io_channel_set_flags() 884 */ 885 SET_MASK = 3, 886 } 887 alias GIOFlags IOFlags; 888 889 /** 890 * Stati returned by most of the #GIOFuncs functions. 891 */ 892 public enum GIOStatus 893 { 894 /** 895 * An error occurred. 896 */ 897 ERROR = 0, 898 /** 899 * Success. 900 */ 901 NORMAL = 1, 902 /** 903 * End of file. 904 */ 905 EOF = 2, 906 /** 907 * Resource temporarily unavailable. 908 */ 909 AGAIN = 3, 910 } 911 alias GIOStatus IOStatus; 912 913 /** 914 * Error codes returned by key file parsing. 915 */ 916 public enum GKeyFileError 917 { 918 /** 919 * the text being parsed was in 920 * an unknown encoding 921 */ 922 UNKNOWN_ENCODING = 0, 923 /** 924 * document was ill-formed 925 */ 926 PARSE = 1, 927 /** 928 * the file was not found 929 */ 930 NOT_FOUND = 2, 931 /** 932 * a requested key was not found 933 */ 934 KEY_NOT_FOUND = 3, 935 /** 936 * a requested group was not found 937 */ 938 GROUP_NOT_FOUND = 4, 939 /** 940 * a value could not be parsed 941 */ 942 INVALID_VALUE = 5, 943 } 944 alias GKeyFileError KeyFileError; 945 946 /** 947 * Flags which influence the parsing. 948 */ 949 public enum GKeyFileFlags 950 { 951 /** 952 * No flags, default behaviour 953 */ 954 NONE = 0, 955 /** 956 * Use this flag if you plan to write the 957 * (possibly modified) contents of the key file back to a file; 958 * otherwise all comments will be lost when the key file is 959 * written back. 960 */ 961 KEEP_COMMENTS = 1, 962 /** 963 * Use this flag if you plan to write the 964 * (possibly modified) contents of the key file back to a file; 965 * otherwise only the translations for the current language will be 966 * written back. 967 */ 968 KEEP_TRANSLATIONS = 2, 969 } 970 alias GKeyFileFlags KeyFileFlags; 971 972 /** 973 * Flags specifying the level of log messages. 974 * 975 * It is possible to change how GLib treats messages of the various 976 * levels using g_log_set_handler() and g_log_set_fatal_mask(). 977 */ 978 public enum GLogLevelFlags 979 { 980 /** 981 * internal flag 982 */ 983 FLAG_RECURSION = 1, 984 /** 985 * internal flag 986 */ 987 FLAG_FATAL = 2, 988 /** 989 * log level for errors, see g_error(). 990 * This level is also used for messages produced by g_assert(). 991 */ 992 LEVEL_ERROR = 4, 993 /** 994 * log level for critical warning messages, see 995 * g_critical(). 996 * This level is also used for messages produced by g_return_if_fail() 997 * and g_return_val_if_fail(). 998 */ 999 LEVEL_CRITICAL = 8, 1000 /** 1001 * log level for warnings, see g_warning() 1002 */ 1003 LEVEL_WARNING = 16, 1004 /** 1005 * log level for messages, see g_message() 1006 */ 1007 LEVEL_MESSAGE = 32, 1008 /** 1009 * log level for informational messages, see g_info() 1010 */ 1011 LEVEL_INFO = 64, 1012 /** 1013 * log level for debug messages, see g_debug() 1014 */ 1015 LEVEL_DEBUG = 128, 1016 /** 1017 * a mask including all log levels 1018 */ 1019 LEVEL_MASK = -4, 1020 } 1021 alias GLogLevelFlags LogLevelFlags; 1022 1023 /** 1024 * Return values from #GLogWriterFuncs to indicate whether the given log entry 1025 * was successfully handled by the writer, or whether there was an error in 1026 * handling it (and hence a fallback writer should be used). 1027 * 1028 * If a #GLogWriterFunc ignores a log entry, it should return 1029 * %G_LOG_WRITER_HANDLED. 1030 * 1031 * Since: 2.50 1032 */ 1033 public enum GLogWriterOutput 1034 { 1035 /** 1036 * Log writer has handled the log entry. 1037 */ 1038 HANDLED = 1, 1039 /** 1040 * Log writer could not handle the log entry. 1041 */ 1042 UNHANDLED = 0, 1043 } 1044 alias GLogWriterOutput LogWriterOutput; 1045 1046 /** 1047 * A mixed enumerated type and flags field. You must specify one type 1048 * (string, strdup, boolean, tristate). Additionally, you may optionally 1049 * bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL. 1050 * 1051 * It is likely that this enum will be extended in the future to 1052 * support other types. 1053 */ 1054 public enum GMarkupCollectType 1055 { 1056 /** 1057 * used to terminate the list of attributes 1058 * to collect 1059 */ 1060 INVALID = 0, 1061 /** 1062 * collect the string pointer directly from 1063 * the attribute_values[] array. Expects a parameter of type (const 1064 * char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the 1065 * attribute isn't present then the pointer will be set to %NULL 1066 */ 1067 STRING = 1, 1068 /** 1069 * as with %G_MARKUP_COLLECT_STRING, but 1070 * expects a parameter of type (char **) and g_strdup()s the 1071 * returned pointer. The pointer must be freed with g_free() 1072 */ 1073 STRDUP = 2, 1074 /** 1075 * expects a parameter of type (gboolean *) 1076 * and parses the attribute value as a boolean. Sets %FALSE if the 1077 * attribute isn't present. Valid boolean values consist of 1078 * (case-insensitive) "false", "f", "no", "n", "0" and "true", "t", 1079 * "yes", "y", "1" 1080 */ 1081 BOOLEAN = 3, 1082 /** 1083 * as with %G_MARKUP_COLLECT_BOOLEAN, but 1084 * in the case of a missing attribute a value is set that compares 1085 * equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is 1086 * implied 1087 */ 1088 TRISTATE = 4, 1089 /** 1090 * can be bitwise ORed with the other fields. 1091 * If present, allows the attribute not to appear. A default value 1092 * is set depending on what value type is used 1093 */ 1094 OPTIONAL = 65536, 1095 } 1096 alias GMarkupCollectType MarkupCollectType; 1097 1098 /** 1099 * Error codes returned by markup parsing. 1100 */ 1101 public enum GMarkupError 1102 { 1103 /** 1104 * text being parsed was not valid UTF-8 1105 */ 1106 BAD_UTF8 = 0, 1107 /** 1108 * document contained nothing, or only whitespace 1109 */ 1110 EMPTY = 1, 1111 /** 1112 * document was ill-formed 1113 */ 1114 PARSE = 2, 1115 /** 1116 * error should be set by #GMarkupParser 1117 * functions; element wasn't known 1118 */ 1119 UNKNOWN_ELEMENT = 3, 1120 /** 1121 * error should be set by #GMarkupParser 1122 * functions; attribute wasn't known 1123 */ 1124 UNKNOWN_ATTRIBUTE = 4, 1125 /** 1126 * error should be set by #GMarkupParser 1127 * functions; content was invalid 1128 */ 1129 INVALID_CONTENT = 5, 1130 /** 1131 * error should be set by #GMarkupParser 1132 * functions; a required attribute was missing 1133 */ 1134 MISSING_ATTRIBUTE = 6, 1135 } 1136 alias GMarkupError MarkupError; 1137 1138 /** 1139 * Flags that affect the behaviour of the parser. 1140 */ 1141 public enum GMarkupParseFlags 1142 { 1143 /** 1144 * flag you should not use 1145 */ 1146 DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1, 1147 /** 1148 * When this flag is set, CDATA marked 1149 * sections are not passed literally to the @passthrough function of 1150 * the parser. Instead, the content of the section (without the 1151 * `<![CDATA[` and `]]>`) is 1152 * passed to the @text function. This flag was added in GLib 2.12 1153 */ 1154 TREAT_CDATA_AS_TEXT = 2, 1155 /** 1156 * Normally errors caught by GMarkup 1157 * itself have line/column information prefixed to them to let the 1158 * caller know the location of the error. When this flag is set the 1159 * location information is also prefixed to errors generated by the 1160 * #GMarkupParser implementation functions 1161 */ 1162 PREFIX_ERROR_POSITION = 4, 1163 /** 1164 * Ignore (don't report) qualified 1165 * attributes and tags, along with their contents. A qualified 1166 * attribute or tag is one that contains ':' in its name (ie: is in 1167 * another namespace). Since: 2.40. 1168 */ 1169 IGNORE_QUALIFIED = 8, 1170 } 1171 alias GMarkupParseFlags MarkupParseFlags; 1172 1173 /** 1174 * Defines how a Unicode string is transformed in a canonical 1175 * form, standardizing such issues as whether a character with 1176 * an accent is represented as a base character and combining 1177 * accent or as a single precomposed character. Unicode strings 1178 * should generally be normalized before comparing them. 1179 */ 1180 public enum GNormalizeMode 1181 { 1182 /** 1183 * standardize differences that do not affect the 1184 * text content, such as the above-mentioned accent representation 1185 */ 1186 DEFAULT = 0, 1187 /** 1188 * another name for %G_NORMALIZE_DEFAULT 1189 */ 1190 NFD = 0, 1191 /** 1192 * like %G_NORMALIZE_DEFAULT, but with 1193 * composed forms rather than a maximally decomposed form 1194 */ 1195 DEFAULT_COMPOSE = 1, 1196 /** 1197 * another name for %G_NORMALIZE_DEFAULT_COMPOSE 1198 */ 1199 NFC = 1, 1200 /** 1201 * beyond %G_NORMALIZE_DEFAULT also standardize the 1202 * "compatibility" characters in Unicode, such as SUPERSCRIPT THREE 1203 * to the standard forms (in this case DIGIT THREE). Formatting 1204 * information may be lost but for most text operations such 1205 * characters should be considered the same 1206 */ 1207 ALL = 2, 1208 /** 1209 * another name for %G_NORMALIZE_ALL 1210 */ 1211 NFKD = 2, 1212 /** 1213 * like %G_NORMALIZE_ALL, but with composed 1214 * forms rather than a maximally decomposed form 1215 */ 1216 ALL_COMPOSE = 3, 1217 /** 1218 * another name for %G_NORMALIZE_ALL_COMPOSE 1219 */ 1220 NFKC = 3, 1221 } 1222 alias GNormalizeMode NormalizeMode; 1223 1224 /** 1225 * Error codes returned by functions converting a string to a number. 1226 * 1227 * Since: 2.54 1228 */ 1229 public enum GNumberParserError 1230 { 1231 /** 1232 * String was not a valid number. 1233 */ 1234 INVALID = 0, 1235 /** 1236 * String was a number, but out of bounds. 1237 */ 1238 OUT_OF_BOUNDS = 1, 1239 } 1240 alias GNumberParserError NumberParserError; 1241 1242 /** 1243 * The possible statuses of a one-time initialization function 1244 * controlled by a #GOnce struct. 1245 * 1246 * Since: 2.4 1247 */ 1248 public enum GOnceStatus 1249 { 1250 /** 1251 * the function has not been called yet. 1252 */ 1253 NOTCALLED = 0, 1254 /** 1255 * the function call is currently in progress. 1256 */ 1257 PROGRESS = 1, 1258 /** 1259 * the function has been called. 1260 */ 1261 READY = 2, 1262 } 1263 alias GOnceStatus OnceStatus; 1264 1265 /** 1266 * The #GOptionArg enum values determine which type of extra argument the 1267 * options expect to find. If an option expects an extra argument, it can 1268 * be specified in several ways; with a short option: `-x arg`, with a long 1269 * option: `--name arg` or combined in a single argument: `--name=arg`. 1270 */ 1271 public enum GOptionArg 1272 { 1273 /** 1274 * No extra argument. This is useful for simple flags. 1275 */ 1276 NONE = 0, 1277 /** 1278 * The option takes a string argument. 1279 */ 1280 STRING = 1, 1281 /** 1282 * The option takes an integer argument. 1283 */ 1284 INT = 2, 1285 /** 1286 * The option provides a callback (of type 1287 * #GOptionArgFunc) to parse the extra argument. 1288 */ 1289 CALLBACK = 3, 1290 /** 1291 * The option takes a filename as argument. 1292 */ 1293 FILENAME = 4, 1294 /** 1295 * The option takes a string argument, multiple 1296 * uses of the option are collected into an array of strings. 1297 */ 1298 STRING_ARRAY = 5, 1299 /** 1300 * The option takes a filename as argument, 1301 * multiple uses of the option are collected into an array of strings. 1302 */ 1303 FILENAME_ARRAY = 6, 1304 /** 1305 * The option takes a double argument. The argument 1306 * can be formatted either for the user's locale or for the "C" locale. 1307 * Since 2.12 1308 */ 1309 DOUBLE = 7, 1310 /** 1311 * The option takes a 64-bit integer. Like 1312 * %G_OPTION_ARG_INT but for larger numbers. The number can be in 1313 * decimal base, or in hexadecimal (when prefixed with `0x`, for 1314 * example, `0xffffffff`). Since 2.12 1315 */ 1316 INT64 = 8, 1317 } 1318 alias GOptionArg OptionArg; 1319 1320 /** 1321 * Error codes returned by option parsing. 1322 */ 1323 public enum GOptionError 1324 { 1325 /** 1326 * An option was not known to the parser. 1327 * This error will only be reported, if the parser hasn't been instructed 1328 * to ignore unknown options, see g_option_context_set_ignore_unknown_options(). 1329 */ 1330 UNKNOWN_OPTION = 0, 1331 /** 1332 * A value couldn't be parsed. 1333 */ 1334 BAD_VALUE = 1, 1335 /** 1336 * A #GOptionArgFunc callback failed. 1337 */ 1338 FAILED = 2, 1339 } 1340 alias GOptionError OptionError; 1341 1342 /** 1343 * Flags which modify individual options. 1344 */ 1345 public enum GOptionFlags 1346 { 1347 /** 1348 * No flags. Since: 2.42. 1349 */ 1350 NONE = 0, 1351 /** 1352 * The option doesn't appear in `--help` output. 1353 */ 1354 HIDDEN = 1, 1355 /** 1356 * The option appears in the main section of the 1357 * `--help` output, even if it is defined in a group. 1358 */ 1359 IN_MAIN = 2, 1360 /** 1361 * For options of the %G_OPTION_ARG_NONE kind, this 1362 * flag indicates that the sense of the option is reversed. 1363 */ 1364 REVERSE = 4, 1365 /** 1366 * For options of the %G_OPTION_ARG_CALLBACK kind, 1367 * this flag indicates that the callback does not take any argument 1368 * (like a %G_OPTION_ARG_NONE option). Since 2.8 1369 */ 1370 NO_ARG = 8, 1371 /** 1372 * For options of the %G_OPTION_ARG_CALLBACK 1373 * kind, this flag indicates that the argument should be passed to the 1374 * callback in the GLib filename encoding rather than UTF-8. Since 2.8 1375 */ 1376 FILENAME = 16, 1377 /** 1378 * For options of the %G_OPTION_ARG_CALLBACK 1379 * kind, this flag indicates that the argument supply is optional. 1380 * If no argument is given then data of %GOptionParseFunc will be 1381 * set to NULL. Since 2.8 1382 */ 1383 OPTIONAL_ARG = 32, 1384 /** 1385 * This flag turns off the automatic conflict 1386 * resolution which prefixes long option names with `groupname-` if 1387 * there is a conflict. This option should only be used in situations 1388 * where aliasing is necessary to model some legacy commandline interface. 1389 * It is not safe to use this option, unless all option groups are under 1390 * your direct control. Since 2.8. 1391 */ 1392 NOALIAS = 64, 1393 } 1394 alias GOptionFlags OptionFlags; 1395 1396 /** 1397 * Flags specifying compile-time options. 1398 * 1399 * Since: 2.14 1400 */ 1401 public enum GRegexCompileFlags 1402 { 1403 /** 1404 * Letters in the pattern match both upper- and 1405 * lowercase letters. This option can be changed within a pattern 1406 * by a "(?i)" option setting. 1407 */ 1408 CASELESS = 1, 1409 /** 1410 * By default, GRegex treats the strings as consisting 1411 * of a single line of characters (even if it actually contains 1412 * newlines). The "start of line" metacharacter ("^") matches only 1413 * at the start of the string, while the "end of line" metacharacter 1414 * ("$") matches only at the end of the string, or before a terminating 1415 * newline (unless #G_REGEX_DOLLAR_ENDONLY is set). When 1416 * #G_REGEX_MULTILINE is set, the "start of line" and "end of line" 1417 * constructs match immediately following or immediately before any 1418 * newline in the string, respectively, as well as at the very start 1419 * and end. This can be changed within a pattern by a "(?m)" option 1420 * setting. 1421 */ 1422 MULTILINE = 2, 1423 /** 1424 * A dot metacharater (".") in the pattern matches all 1425 * characters, including newlines. Without it, newlines are excluded. 1426 * This option can be changed within a pattern by a ("?s") option setting. 1427 */ 1428 DOTALL = 4, 1429 /** 1430 * Whitespace data characters in the pattern are 1431 * totally ignored except when escaped or inside a character class. 1432 * Whitespace does not include the VT character (code 11). In addition, 1433 * characters between an unescaped "#" outside a character class and 1434 * the next newline character, inclusive, are also ignored. This can 1435 * be changed within a pattern by a "(?x)" option setting. 1436 */ 1437 EXTENDED = 8, 1438 /** 1439 * The pattern is forced to be "anchored", that is, 1440 * it is constrained to match only at the first matching point in the 1441 * string that is being searched. This effect can also be achieved by 1442 * appropriate constructs in the pattern itself such as the "^" 1443 * metacharater. 1444 */ 1445 ANCHORED = 16, 1446 /** 1447 * A dollar metacharacter ("$") in the pattern 1448 * matches only at the end of the string. Without this option, a 1449 * dollar also matches immediately before the final character if 1450 * it is a newline (but not before any other newlines). This option 1451 * is ignored if #G_REGEX_MULTILINE is set. 1452 */ 1453 DOLLAR_ENDONLY = 32, 1454 /** 1455 * Inverts the "greediness" of the quantifiers so that 1456 * they are not greedy by default, but become greedy if followed by "?". 1457 * It can also be set by a "(?U)" option setting within the pattern. 1458 */ 1459 UNGREEDY = 512, 1460 /** 1461 * Usually strings must be valid UTF-8 strings, using this 1462 * flag they are considered as a raw sequence of bytes. 1463 */ 1464 RAW = 2048, 1465 /** 1466 * Disables the use of numbered capturing 1467 * parentheses in the pattern. Any opening parenthesis that is not 1468 * followed by "?" behaves as if it were followed by "?:" but named 1469 * parentheses can still be used for capturing (and they acquire numbers 1470 * in the usual way). 1471 */ 1472 NO_AUTO_CAPTURE = 4096, 1473 /** 1474 * Optimize the regular expression. If the pattern will 1475 * be used many times, then it may be worth the effort to optimize it 1476 * to improve the speed of matches. 1477 */ 1478 OPTIMIZE = 8192, 1479 /** 1480 * Limits an unanchored pattern to match before (or at) the 1481 * first newline. Since: 2.34 1482 */ 1483 FIRSTLINE = 262144, 1484 /** 1485 * Names used to identify capturing subpatterns need not 1486 * be unique. This can be helpful for certain types of pattern when it 1487 * is known that only one instance of the named subpattern can ever be 1488 * matched. 1489 */ 1490 DUPNAMES = 524288, 1491 /** 1492 * Usually any newline character or character sequence is 1493 * recognized. If this option is set, the only recognized newline character 1494 * is '\r'. 1495 */ 1496 NEWLINE_CR = 1048576, 1497 /** 1498 * Usually any newline character or character sequence is 1499 * recognized. If this option is set, the only recognized newline character 1500 * is '\n'. 1501 */ 1502 NEWLINE_LF = 2097152, 1503 /** 1504 * Usually any newline character or character sequence is 1505 * recognized. If this option is set, the only recognized newline character 1506 * sequence is '\r\n'. 1507 */ 1508 NEWLINE_CRLF = 3145728, 1509 /** 1510 * Usually any newline character or character sequence 1511 * is recognized. If this option is set, the only recognized newline character 1512 * sequences are '\r', '\n', and '\r\n'. Since: 2.34 1513 */ 1514 NEWLINE_ANYCRLF = 5242880, 1515 /** 1516 * Usually any newline character or character sequence 1517 * is recognised. If this option is set, then "\R" only recognizes the newline 1518 * characters '\r', '\n' and '\r\n'. Since: 2.34 1519 */ 1520 BSR_ANYCRLF = 8388608, 1521 /** 1522 * Changes behaviour so that it is compatible with 1523 * JavaScript rather than PCRE. Since: 2.34 1524 */ 1525 JAVASCRIPT_COMPAT = 33554432, 1526 } 1527 alias GRegexCompileFlags RegexCompileFlags; 1528 1529 /** 1530 * Error codes returned by regular expressions functions. 1531 * 1532 * Since: 2.14 1533 */ 1534 public enum GRegexError 1535 { 1536 /** 1537 * Compilation of the regular expression failed. 1538 */ 1539 COMPILE = 0, 1540 /** 1541 * Optimization of the regular expression failed. 1542 */ 1543 OPTIMIZE = 1, 1544 /** 1545 * Replacement failed due to an ill-formed replacement 1546 * string. 1547 */ 1548 REPLACE = 2, 1549 /** 1550 * The match process failed. 1551 */ 1552 MATCH = 3, 1553 /** 1554 * Internal error of the regular expression engine. 1555 * Since 2.16 1556 */ 1557 INTERNAL = 4, 1558 /** 1559 * "\\" at end of pattern. Since 2.16 1560 */ 1561 STRAY_BACKSLASH = 101, 1562 /** 1563 * "\\c" at end of pattern. Since 2.16 1564 */ 1565 MISSING_CONTROL_CHAR = 102, 1566 /** 1567 * Unrecognized character follows "\\". 1568 * Since 2.16 1569 */ 1570 UNRECOGNIZED_ESCAPE = 103, 1571 /** 1572 * Numbers out of order in "{}" 1573 * quantifier. Since 2.16 1574 */ 1575 QUANTIFIERS_OUT_OF_ORDER = 104, 1576 /** 1577 * Number too big in "{}" quantifier. 1578 * Since 2.16 1579 */ 1580 QUANTIFIER_TOO_BIG = 105, 1581 /** 1582 * Missing terminating "]" for 1583 * character class. Since 2.16 1584 */ 1585 UNTERMINATED_CHARACTER_CLASS = 106, 1586 /** 1587 * Invalid escape sequence 1588 * in character class. Since 2.16 1589 */ 1590 INVALID_ESCAPE_IN_CHARACTER_CLASS = 107, 1591 /** 1592 * Range out of order in character class. 1593 * Since 2.16 1594 */ 1595 RANGE_OUT_OF_ORDER = 108, 1596 /** 1597 * Nothing to repeat. Since 2.16 1598 */ 1599 NOTHING_TO_REPEAT = 109, 1600 /** 1601 * Unrecognized character after "(?", 1602 * "(?<" or "(?P". Since 2.16 1603 */ 1604 UNRECOGNIZED_CHARACTER = 112, 1605 /** 1606 * POSIX named classes are 1607 * supported only within a class. Since 2.16 1608 */ 1609 POSIX_NAMED_CLASS_OUTSIDE_CLASS = 113, 1610 /** 1611 * Missing terminating ")" or ")" 1612 * without opening "(". Since 2.16 1613 */ 1614 UNMATCHED_PARENTHESIS = 114, 1615 /** 1616 * Reference to non-existent 1617 * subpattern. Since 2.16 1618 */ 1619 INEXISTENT_SUBPATTERN_REFERENCE = 115, 1620 /** 1621 * Missing terminating ")" after comment. 1622 * Since 2.16 1623 */ 1624 UNTERMINATED_COMMENT = 118, 1625 /** 1626 * Regular expression too large. 1627 * Since 2.16 1628 */ 1629 EXPRESSION_TOO_LARGE = 120, 1630 /** 1631 * Failed to get memory. Since 2.16 1632 */ 1633 MEMORY_ERROR = 121, 1634 /** 1635 * Lookbehind assertion is not 1636 * fixed length. Since 2.16 1637 */ 1638 VARIABLE_LENGTH_LOOKBEHIND = 125, 1639 /** 1640 * Malformed number or name after "(?(". 1641 * Since 2.16 1642 */ 1643 MALFORMED_CONDITION = 126, 1644 /** 1645 * Conditional group contains 1646 * more than two branches. Since 2.16 1647 */ 1648 TOO_MANY_CONDITIONAL_BRANCHES = 127, 1649 /** 1650 * Assertion expected after "(?(". 1651 * Since 2.16 1652 */ 1653 ASSERTION_EXPECTED = 128, 1654 /** 1655 * Unknown POSIX class name. 1656 * Since 2.16 1657 */ 1658 UNKNOWN_POSIX_CLASS_NAME = 130, 1659 /** 1660 * POSIX collating 1661 * elements are not supported. Since 2.16 1662 */ 1663 POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED = 131, 1664 /** 1665 * Character value in "\\x{...}" sequence 1666 * is too large. Since 2.16 1667 */ 1668 HEX_CODE_TOO_LARGE = 134, 1669 /** 1670 * Invalid condition "(?(0)". Since 2.16 1671 */ 1672 INVALID_CONDITION = 135, 1673 /** 1674 * \\C not allowed in 1675 * lookbehind assertion. Since 2.16 1676 */ 1677 SINGLE_BYTE_MATCH_IN_LOOKBEHIND = 136, 1678 /** 1679 * Recursive call could loop indefinitely. 1680 * Since 2.16 1681 */ 1682 INFINITE_LOOP = 140, 1683 /** 1684 * Missing terminator 1685 * in subpattern name. Since 2.16 1686 */ 1687 MISSING_SUBPATTERN_NAME_TERMINATOR = 142, 1688 /** 1689 * Two named subpatterns have 1690 * the same name. Since 2.16 1691 */ 1692 DUPLICATE_SUBPATTERN_NAME = 143, 1693 /** 1694 * Malformed "\\P" or "\\p" sequence. 1695 * Since 2.16 1696 */ 1697 MALFORMED_PROPERTY = 146, 1698 /** 1699 * Unknown property name after "\\P" or 1700 * "\\p". Since 2.16 1701 */ 1702 UNKNOWN_PROPERTY = 147, 1703 /** 1704 * Subpattern name is too long 1705 * (maximum 32 characters). Since 2.16 1706 */ 1707 SUBPATTERN_NAME_TOO_LONG = 148, 1708 /** 1709 * Too many named subpatterns (maximum 1710 * 10,000). Since 2.16 1711 */ 1712 TOO_MANY_SUBPATTERNS = 149, 1713 /** 1714 * Octal value is greater than "\\377". 1715 * Since 2.16 1716 */ 1717 INVALID_OCTAL_VALUE = 151, 1718 /** 1719 * "DEFINE" group contains more 1720 * than one branch. Since 2.16 1721 */ 1722 TOO_MANY_BRANCHES_IN_DEFINE = 154, 1723 /** 1724 * Repeating a "DEFINE" group is not allowed. 1725 * This error is never raised. Since: 2.16 Deprecated: 2.34 1726 */ 1727 DEFINE_REPETION = 155, 1728 /** 1729 * Inconsistent newline options. 1730 * Since 2.16 1731 */ 1732 INCONSISTENT_NEWLINE_OPTIONS = 156, 1733 /** 1734 * "\\g" is not followed by a braced, 1735 * angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16 1736 */ 1737 MISSING_BACK_REFERENCE = 157, 1738 /** 1739 * relative reference must not be zero. Since: 2.34 1740 */ 1741 INVALID_RELATIVE_REFERENCE = 158, 1742 /** 1743 * the backtracing 1744 * control verb used does not allow an argument. Since: 2.34 1745 */ 1746 BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN = 159, 1747 /** 1748 * unknown backtracing 1749 * control verb. Since: 2.34 1750 */ 1751 UNKNOWN_BACKTRACKING_CONTROL_VERB = 160, 1752 /** 1753 * number is too big in escape sequence. Since: 2.34 1754 */ 1755 NUMBER_TOO_BIG = 161, 1756 /** 1757 * Missing subpattern name. Since: 2.34 1758 */ 1759 MISSING_SUBPATTERN_NAME = 162, 1760 /** 1761 * Missing digit. Since 2.34 1762 */ 1763 MISSING_DIGIT = 163, 1764 /** 1765 * In JavaScript compatibility mode, 1766 * "[" is an invalid data character. Since: 2.34 1767 */ 1768 INVALID_DATA_CHARACTER = 164, 1769 /** 1770 * different names for subpatterns of the 1771 * same number are not allowed. Since: 2.34 1772 */ 1773 EXTRA_SUBPATTERN_NAME = 165, 1774 /** 1775 * the backtracing control 1776 * verb requires an argument. Since: 2.34 1777 */ 1778 BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED = 166, 1779 /** 1780 * "\\c" must be followed by an ASCII 1781 * character. Since: 2.34 1782 */ 1783 INVALID_CONTROL_CHAR = 168, 1784 /** 1785 * "\\k" is not followed by a braced, angle-bracketed, or 1786 * quoted name. Since: 2.34 1787 */ 1788 MISSING_NAME = 169, 1789 /** 1790 * "\\N" is not supported in a class. Since: 2.34 1791 */ 1792 NOT_SUPPORTED_IN_CLASS = 171, 1793 /** 1794 * too many forward references. Since: 2.34 1795 */ 1796 TOO_MANY_FORWARD_REFERENCES = 172, 1797 /** 1798 * the name is too long in "(*MARK)", "(*PRUNE)", 1799 * "(*SKIP)", or "(*THEN)". Since: 2.34 1800 */ 1801 NAME_TOO_LONG = 175, 1802 /** 1803 * the character value in the \\u sequence is 1804 * too large. Since: 2.34 1805 */ 1806 CHARACTER_VALUE_TOO_LARGE = 176, 1807 } 1808 alias GRegexError RegexError; 1809 1810 /** 1811 * Flags specifying match-time options. 1812 * 1813 * Since: 2.14 1814 */ 1815 public enum GRegexMatchFlags 1816 { 1817 /** 1818 * The pattern is forced to be "anchored", that is, 1819 * it is constrained to match only at the first matching point in the 1820 * string that is being searched. This effect can also be achieved by 1821 * appropriate constructs in the pattern itself such as the "^" 1822 * metacharater. 1823 */ 1824 ANCHORED = 16, 1825 /** 1826 * Specifies that first character of the string is 1827 * not the beginning of a line, so the circumflex metacharacter should 1828 * not match before it. Setting this without #G_REGEX_MULTILINE (at 1829 * compile time) causes circumflex never to match. This option affects 1830 * only the behaviour of the circumflex metacharacter, it does not 1831 * affect "\A". 1832 */ 1833 NOTBOL = 128, 1834 /** 1835 * Specifies that the end of the subject string is 1836 * not the end of a line, so the dollar metacharacter should not match 1837 * it nor (except in multiline mode) a newline immediately before it. 1838 * Setting this without #G_REGEX_MULTILINE (at compile time) causes 1839 * dollar never to match. This option affects only the behaviour of 1840 * the dollar metacharacter, it does not affect "\Z" or "\z". 1841 */ 1842 NOTEOL = 256, 1843 /** 1844 * An empty string is not considered to be a valid 1845 * match if this option is set. If there are alternatives in the pattern, 1846 * they are tried. If all the alternatives match the empty string, the 1847 * entire match fails. For example, if the pattern "a?b?" is applied to 1848 * a string not beginning with "a" or "b", it matches the empty string 1849 * at the start of the string. With this flag set, this match is not 1850 * valid, so GRegex searches further into the string for occurrences 1851 * of "a" or "b". 1852 */ 1853 NOTEMPTY = 1024, 1854 /** 1855 * Turns on the partial matching feature, for more 1856 * documentation on partial matching see g_match_info_is_partial_match(). 1857 */ 1858 PARTIAL = 32768, 1859 /** 1860 * Overrides the newline definition set when 1861 * creating a new #GRegex, setting the '\r' character as line terminator. 1862 */ 1863 NEWLINE_CR = 1048576, 1864 /** 1865 * Overrides the newline definition set when 1866 * creating a new #GRegex, setting the '\n' character as line terminator. 1867 */ 1868 NEWLINE_LF = 2097152, 1869 /** 1870 * Overrides the newline definition set when 1871 * creating a new #GRegex, setting the '\r\n' characters sequence as line terminator. 1872 */ 1873 NEWLINE_CRLF = 3145728, 1874 /** 1875 * Overrides the newline definition set when 1876 * creating a new #GRegex, any Unicode newline sequence 1877 * is recognised as a newline. These are '\r', '\n' and '\rn', and the 1878 * single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), 1879 * U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and 1880 * U+2029 PARAGRAPH SEPARATOR. 1881 */ 1882 NEWLINE_ANY = 4194304, 1883 /** 1884 * Overrides the newline definition set when 1885 * creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence 1886 * is recognized as a newline. Since: 2.34 1887 */ 1888 NEWLINE_ANYCRLF = 5242880, 1889 /** 1890 * Overrides the newline definition for "\R" set when 1891 * creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences 1892 * are recognized as a newline by "\R". Since: 2.34 1893 */ 1894 BSR_ANYCRLF = 8388608, 1895 /** 1896 * Overrides the newline definition for "\R" set when 1897 * creating a new #GRegex; any Unicode newline character or character sequence 1898 * are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the 1899 * single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), 1900 * U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and 1901 * U+2029 PARAGRAPH SEPARATOR. Since: 2.34 1902 */ 1903 BSR_ANY = 16777216, 1904 /** 1905 * An alias for #G_REGEX_MATCH_PARTIAL. Since: 2.34 1906 */ 1907 PARTIAL_SOFT = 32768, 1908 /** 1909 * Turns on the partial matching feature. In contrast to 1910 * to #G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match 1911 * is found, without continuing to search for a possible complete match. See 1912 * g_match_info_is_partial_match() for more information. Since: 2.34 1913 */ 1914 PARTIAL_HARD = 134217728, 1915 /** 1916 * Like #G_REGEX_MATCH_NOTEMPTY, but only applied to 1917 * the start of the matched string. For anchored 1918 * patterns this can only happen for pattern containing "\K". Since: 2.34 1919 */ 1920 NOTEMPTY_ATSTART = 268435456, 1921 } 1922 alias GRegexMatchFlags RegexMatchFlags; 1923 1924 /** 1925 * An enumeration specifying the base position for a 1926 * g_io_channel_seek_position() operation. 1927 */ 1928 public enum GSeekType 1929 { 1930 /** 1931 * the current position in the file. 1932 */ 1933 CUR = 0, 1934 /** 1935 * the start of the file. 1936 */ 1937 SET = 1, 1938 /** 1939 * the end of the file. 1940 */ 1941 END = 2, 1942 } 1943 alias GSeekType SeekType; 1944 1945 /** 1946 * Error codes returned by shell functions. 1947 */ 1948 public enum GShellError 1949 { 1950 /** 1951 * Mismatched or otherwise mangled quoting. 1952 */ 1953 BAD_QUOTING = 0, 1954 /** 1955 * String to be parsed was empty. 1956 */ 1957 EMPTY_STRING = 1, 1958 /** 1959 * Some other error. 1960 */ 1961 FAILED = 2, 1962 } 1963 alias GShellError ShellError; 1964 1965 public enum GSliceConfig 1966 { 1967 ALWAYS_MALLOC = 1, 1968 BYPASS_MAGAZINES = 2, 1969 WORKING_SET_MSECS = 3, 1970 COLOR_INCREMENT = 4, 1971 CHUNK_SIZES = 5, 1972 CONTENTION_COUNTER = 6, 1973 } 1974 alias GSliceConfig SliceConfig; 1975 1976 /** 1977 * Error codes returned by spawning processes. 1978 */ 1979 public enum GSpawnError 1980 { 1981 /** 1982 * Fork failed due to lack of memory. 1983 */ 1984 FORK = 0, 1985 /** 1986 * Read or select on pipes failed. 1987 */ 1988 READ = 1, 1989 /** 1990 * Changing to working directory failed. 1991 */ 1992 CHDIR = 2, 1993 /** 1994 * execv() returned `EACCES` 1995 */ 1996 ACCES = 3, 1997 /** 1998 * execv() returned `EPERM` 1999 */ 2000 PERM = 4, 2001 /** 2002 * execv() returned `E2BIG` 2003 */ 2004 TOO_BIG = 5, 2005 /** 2006 * execv() returned `ENOEXEC` 2007 */ 2008 NOEXEC = 6, 2009 /** 2010 * execv() returned `ENAMETOOLONG` 2011 */ 2012 NAMETOOLONG = 7, 2013 /** 2014 * execv() returned `ENOENT` 2015 */ 2016 NOENT = 8, 2017 /** 2018 * execv() returned `ENOMEM` 2019 */ 2020 NOMEM = 9, 2021 /** 2022 * execv() returned `ENOTDIR` 2023 */ 2024 NOTDIR = 10, 2025 /** 2026 * execv() returned `ELOOP` 2027 */ 2028 LOOP = 11, 2029 /** 2030 * execv() returned `ETXTBUSY` 2031 */ 2032 TXTBUSY = 12, 2033 /** 2034 * execv() returned `EIO` 2035 */ 2036 IO = 13, 2037 /** 2038 * execv() returned `ENFILE` 2039 */ 2040 NFILE = 14, 2041 /** 2042 * execv() returned `EMFILE` 2043 */ 2044 MFILE = 15, 2045 /** 2046 * execv() returned `EINVAL` 2047 */ 2048 INVAL = 16, 2049 /** 2050 * execv() returned `EISDIR` 2051 */ 2052 ISDIR = 17, 2053 /** 2054 * execv() returned `ELIBBAD` 2055 */ 2056 LIBBAD = 18, 2057 /** 2058 * Some other fatal failure, 2059 * `error->message` should explain. 2060 */ 2061 FAILED = 19, 2062 } 2063 alias GSpawnError SpawnError; 2064 2065 /** 2066 * Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes(). 2067 */ 2068 public enum GSpawnFlags 2069 { 2070 /** 2071 * no flags, default behaviour 2072 */ 2073 DEFAULT = 0, 2074 /** 2075 * the parent's open file descriptors will 2076 * be inherited by the child; otherwise all descriptors except stdin, 2077 * stdout and stderr will be closed before calling exec() in the child. 2078 */ 2079 LEAVE_DESCRIPTORS_OPEN = 1, 2080 /** 2081 * the child will not be automatically reaped; 2082 * you must use g_child_watch_add() yourself (or call waitpid() or handle 2083 * `SIGCHLD` yourself), or the child will become a zombie. 2084 */ 2085 DO_NOT_REAP_CHILD = 2, 2086 /** 2087 * `argv[0]` need not be an absolute path, it will be 2088 * looked for in the user's `PATH`. 2089 */ 2090 SEARCH_PATH = 4, 2091 /** 2092 * the child's standard output will be discarded, 2093 * instead of going to the same location as the parent's standard output. 2094 */ 2095 STDOUT_TO_DEV_NULL = 8, 2096 /** 2097 * the child's standard error will be discarded. 2098 */ 2099 STDERR_TO_DEV_NULL = 16, 2100 /** 2101 * the child will inherit the parent's standard 2102 * input (by default, the child's standard input is attached to `/dev/null`). 2103 */ 2104 CHILD_INHERITS_STDIN = 32, 2105 /** 2106 * the first element of `argv` is the file to 2107 * execute, while the remaining elements are the actual argument vector 2108 * to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]` 2109 * as the file to execute, and passes all of `argv` to the child. 2110 */ 2111 FILE_AND_ARGV_ZERO = 64, 2112 /** 2113 * if `argv[0]` is not an abolute path, 2114 * it will be looked for in the `PATH` from the passed child environment. 2115 * Since: 2.34 2116 */ 2117 SEARCH_PATH_FROM_ENVP = 128, 2118 /** 2119 * create all pipes with the `O_CLOEXEC` flag set. 2120 * Since: 2.40 2121 */ 2122 CLOEXEC_PIPES = 256, 2123 } 2124 alias GSpawnFlags SpawnFlags; 2125 2126 /** 2127 * The type of file to return the filename for, when used with 2128 * g_test_build_filename(). 2129 * 2130 * These two options correspond rather directly to the 'dist' and 2131 * 'built' terminology that automake uses and are explicitly used to 2132 * distinguish between the 'srcdir' and 'builddir' being separate. All 2133 * files in your project should either be dist (in the 2134 * `EXTRA_DIST` or `dist_schema_DATA` 2135 * sense, in which case they will always be in the srcdir) or built (in 2136 * the `BUILT_SOURCES` sense, in which case they will 2137 * always be in the builddir). 2138 * 2139 * Note: as a general rule of automake, files that are generated only as 2140 * part of the build-from-git process (but then are distributed with the 2141 * tarball) always go in srcdir (even if doing a srcdir != builddir 2142 * build from git) and are considered as distributed files. 2143 * 2144 * Since: 2.38 2145 */ 2146 public enum GTestFileType 2147 { 2148 /** 2149 * a file that was included in the distribution tarball 2150 */ 2151 DIST = 0, 2152 /** 2153 * a file that was built on the compiling machine 2154 */ 2155 BUILT = 1, 2156 } 2157 alias GTestFileType TestFileType; 2158 2159 public enum GTestLogType 2160 { 2161 NONE = 0, 2162 ERROR = 1, 2163 START_BINARY = 2, 2164 LIST_CASE = 3, 2165 SKIP_CASE = 4, 2166 START_CASE = 5, 2167 STOP_CASE = 6, 2168 MIN_RESULT = 7, 2169 MAX_RESULT = 8, 2170 MESSAGE = 9, 2171 START_SUITE = 10, 2172 STOP_SUITE = 11, 2173 } 2174 alias GTestLogType TestLogType; 2175 2176 /** 2177 * Flags to pass to g_test_trap_subprocess() to control input and output. 2178 * 2179 * Note that in contrast with g_test_trap_fork(), the default is to 2180 * not show stdout and stderr. 2181 */ 2182 public enum GTestSubprocessFlags 2183 { 2184 /** 2185 * If this flag is given, the child 2186 * process will inherit the parent's stdin. Otherwise, the child's 2187 * stdin is redirected to `/dev/null`. 2188 */ 2189 STDIN = 1, 2190 /** 2191 * If this flag is given, the child 2192 * process will inherit the parent's stdout. Otherwise, the child's 2193 * stdout will not be visible, but it will be captured to allow 2194 * later tests with g_test_trap_assert_stdout(). 2195 */ 2196 STDOUT = 2, 2197 /** 2198 * If this flag is given, the child 2199 * process will inherit the parent's stderr. Otherwise, the child's 2200 * stderr will not be visible, but it will be captured to allow 2201 * later tests with g_test_trap_assert_stderr(). 2202 */ 2203 STDERR = 4, 2204 } 2205 alias GTestSubprocessFlags TestSubprocessFlags; 2206 2207 /** 2208 * Test traps are guards around forked tests. 2209 * These flags determine what traps to set. 2210 * 2211 * Deprecated: #GTestTrapFlags is used only with g_test_trap_fork(), 2212 * which is deprecated. g_test_trap_subprocess() uses 2213 * #GTestTrapSubprocessFlags. 2214 */ 2215 public enum GTestTrapFlags 2216 { 2217 /** 2218 * Redirect stdout of the test child to 2219 * `/dev/null` so it cannot be observed on the console during test 2220 * runs. The actual output is still captured though to allow later 2221 * tests with g_test_trap_assert_stdout(). 2222 */ 2223 SILENCE_STDOUT = 128, 2224 /** 2225 * Redirect stderr of the test child to 2226 * `/dev/null` so it cannot be observed on the console during test 2227 * runs. The actual output is still captured though to allow later 2228 * tests with g_test_trap_assert_stderr(). 2229 */ 2230 SILENCE_STDERR = 256, 2231 /** 2232 * If this flag is given, stdin of the 2233 * child process is shared with stdin of its parent process. 2234 * It is redirected to `/dev/null` otherwise. 2235 */ 2236 INHERIT_STDIN = 512, 2237 } 2238 alias GTestTrapFlags TestTrapFlags; 2239 2240 /** 2241 * Possible errors of thread related functions. 2242 */ 2243 public enum GThreadError 2244 { 2245 /** 2246 * a thread couldn't be created due to resource 2247 * shortage. Try again later. 2248 */ 2249 THREAD_ERROR_AGAIN = 0, 2250 } 2251 alias GThreadError ThreadError; 2252 2253 /** 2254 * Disambiguates a given time in two ways. 2255 * 2256 * First, specifies if the given time is in universal or local time. 2257 * 2258 * Second, if the time is in local time, specifies if it is local 2259 * standard time or local daylight time. This is important for the case 2260 * where the same local time occurs twice (during daylight savings time 2261 * transitions, for example). 2262 */ 2263 public enum GTimeType 2264 { 2265 /** 2266 * the time is in local standard time 2267 */ 2268 STANDARD = 0, 2269 /** 2270 * the time is in local daylight time 2271 */ 2272 DAYLIGHT = 1, 2273 /** 2274 * the time is in UTC 2275 */ 2276 UNIVERSAL = 2, 2277 } 2278 alias GTimeType TimeType; 2279 2280 /** 2281 * The possible types of token returned from each 2282 * g_scanner_get_next_token() call. 2283 */ 2284 public enum GTokenType 2285 { 2286 /** 2287 * the end of the file 2288 */ 2289 EOF = 0, 2290 /** 2291 * a '(' character 2292 */ 2293 LEFT_PAREN = 40, 2294 /** 2295 * a ')' character 2296 */ 2297 RIGHT_PAREN = 41, 2298 /** 2299 * a '{' character 2300 */ 2301 LEFT_CURLY = 123, 2302 /** 2303 * a '}' character 2304 */ 2305 RIGHT_CURLY = 125, 2306 /** 2307 * a '[' character 2308 */ 2309 LEFT_BRACE = 91, 2310 /** 2311 * a ']' character 2312 */ 2313 RIGHT_BRACE = 93, 2314 /** 2315 * a '=' character 2316 */ 2317 EQUAL_SIGN = 61, 2318 /** 2319 * a ',' character 2320 */ 2321 COMMA = 44, 2322 /** 2323 * not a token 2324 */ 2325 NONE = 256, 2326 /** 2327 * an error occurred 2328 */ 2329 ERROR = 257, 2330 /** 2331 * a character 2332 */ 2333 CHAR = 258, 2334 /** 2335 * a binary integer 2336 */ 2337 BINARY = 259, 2338 /** 2339 * an octal integer 2340 */ 2341 OCTAL = 260, 2342 /** 2343 * an integer 2344 */ 2345 INT = 261, 2346 /** 2347 * a hex integer 2348 */ 2349 HEX = 262, 2350 /** 2351 * a floating point number 2352 */ 2353 FLOAT = 263, 2354 /** 2355 * a string 2356 */ 2357 STRING = 264, 2358 /** 2359 * a symbol 2360 */ 2361 SYMBOL = 265, 2362 /** 2363 * an identifier 2364 */ 2365 IDENTIFIER = 266, 2366 /** 2367 * a null identifier 2368 */ 2369 IDENTIFIER_NULL = 267, 2370 /** 2371 * one line comment 2372 */ 2373 COMMENT_SINGLE = 268, 2374 /** 2375 * multi line comment 2376 */ 2377 COMMENT_MULTI = 269, 2378 } 2379 alias GTokenType TokenType; 2380 2381 /** 2382 * Specifies which nodes are visited during several of the tree 2383 * functions, including g_node_traverse() and g_node_find(). 2384 */ 2385 public enum GTraverseFlags 2386 { 2387 /** 2388 * only leaf nodes should be visited. This name has 2389 * been introduced in 2.6, for older version use 2390 * %G_TRAVERSE_LEAFS. 2391 */ 2392 LEAVES = 1, 2393 /** 2394 * only non-leaf nodes should be visited. This 2395 * name has been introduced in 2.6, for older 2396 * version use %G_TRAVERSE_NON_LEAFS. 2397 */ 2398 NON_LEAVES = 2, 2399 /** 2400 * all nodes should be visited. 2401 */ 2402 ALL = 3, 2403 /** 2404 * a mask of all traverse flags. 2405 */ 2406 MASK = 3, 2407 /** 2408 * identical to %G_TRAVERSE_LEAVES. 2409 */ 2410 LEAFS = 1, 2411 /** 2412 * identical to %G_TRAVERSE_NON_LEAVES. 2413 */ 2414 NON_LEAFS = 2, 2415 } 2416 alias GTraverseFlags TraverseFlags; 2417 2418 /** 2419 * Specifies the type of traveral performed by g_tree_traverse(), 2420 * g_node_traverse() and g_node_find(). The different orders are 2421 * illustrated here: 2422 * - In order: A, B, C, D, E, F, G, H, I 2423 * ![](Sorted_binary_tree_inorder.svg) 2424 * - Pre order: F, B, A, D, C, E, G, I, H 2425 * ![](Sorted_binary_tree_preorder.svg) 2426 * - Post order: A, C, E, D, B, H, I, G, F 2427 * ![](Sorted_binary_tree_postorder.svg) 2428 * - Level order: F, B, G, A, D, I, C, E, H 2429 * ![](Sorted_binary_tree_breadth-first_traversal.svg) 2430 */ 2431 public enum GTraverseType 2432 { 2433 /** 2434 * vists a node's left child first, then the node itself, 2435 * then its right child. This is the one to use if you 2436 * want the output sorted according to the compare 2437 * function. 2438 */ 2439 IN_ORDER = 0, 2440 /** 2441 * visits a node, then its children. 2442 */ 2443 PRE_ORDER = 1, 2444 /** 2445 * visits the node's children, then the node itself. 2446 */ 2447 POST_ORDER = 2, 2448 /** 2449 * is not implemented for 2450 * [balanced binary trees][glib-Balanced-Binary-Trees]. 2451 * For [n-ary trees][glib-N-ary-Trees], it 2452 * vists the root node first, then its children, then 2453 * its grandchildren, and so on. Note that this is less 2454 * efficient than the other orders. 2455 */ 2456 LEVEL_ORDER = 3, 2457 } 2458 alias GTraverseType TraverseType; 2459 2460 /** 2461 * These are the possible line break classifications. 2462 * 2463 * Since new unicode versions may add new types here, applications should be ready 2464 * to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN. 2465 * 2466 * See [Unicode Line Breaking Algorithm](http://www.unicode.org/unicode/reports/tr14/). 2467 */ 2468 public enum GUnicodeBreakType 2469 { 2470 /** 2471 * Mandatory Break (BK) 2472 */ 2473 MANDATORY = 0, 2474 /** 2475 * Carriage Return (CR) 2476 */ 2477 CARRIAGE_RETURN = 1, 2478 /** 2479 * Line Feed (LF) 2480 */ 2481 LINE_FEED = 2, 2482 /** 2483 * Attached Characters and Combining Marks (CM) 2484 */ 2485 COMBINING_MARK = 3, 2486 /** 2487 * Surrogates (SG) 2488 */ 2489 SURROGATE = 4, 2490 /** 2491 * Zero Width Space (ZW) 2492 */ 2493 ZERO_WIDTH_SPACE = 5, 2494 /** 2495 * Inseparable (IN) 2496 */ 2497 INSEPARABLE = 6, 2498 /** 2499 * Non-breaking ("Glue") (GL) 2500 */ 2501 NON_BREAKING_GLUE = 7, 2502 /** 2503 * Contingent Break Opportunity (CB) 2504 */ 2505 CONTINGENT = 8, 2506 /** 2507 * Space (SP) 2508 */ 2509 SPACE = 9, 2510 /** 2511 * Break Opportunity After (BA) 2512 */ 2513 AFTER = 10, 2514 /** 2515 * Break Opportunity Before (BB) 2516 */ 2517 BEFORE = 11, 2518 /** 2519 * Break Opportunity Before and After (B2) 2520 */ 2521 BEFORE_AND_AFTER = 12, 2522 /** 2523 * Hyphen (HY) 2524 */ 2525 HYPHEN = 13, 2526 /** 2527 * Nonstarter (NS) 2528 */ 2529 NON_STARTER = 14, 2530 /** 2531 * Opening Punctuation (OP) 2532 */ 2533 OPEN_PUNCTUATION = 15, 2534 /** 2535 * Closing Punctuation (CL) 2536 */ 2537 CLOSE_PUNCTUATION = 16, 2538 /** 2539 * Ambiguous Quotation (QU) 2540 */ 2541 QUOTATION = 17, 2542 /** 2543 * Exclamation/Interrogation (EX) 2544 */ 2545 EXCLAMATION = 18, 2546 /** 2547 * Ideographic (ID) 2548 */ 2549 IDEOGRAPHIC = 19, 2550 /** 2551 * Numeric (NU) 2552 */ 2553 NUMERIC = 20, 2554 /** 2555 * Infix Separator (Numeric) (IS) 2556 */ 2557 INFIX_SEPARATOR = 21, 2558 /** 2559 * Symbols Allowing Break After (SY) 2560 */ 2561 SYMBOL = 22, 2562 /** 2563 * Ordinary Alphabetic and Symbol Characters (AL) 2564 */ 2565 ALPHABETIC = 23, 2566 /** 2567 * Prefix (Numeric) (PR) 2568 */ 2569 PREFIX = 24, 2570 /** 2571 * Postfix (Numeric) (PO) 2572 */ 2573 POSTFIX = 25, 2574 /** 2575 * Complex Content Dependent (South East Asian) (SA) 2576 */ 2577 COMPLEX_CONTEXT = 26, 2578 /** 2579 * Ambiguous (Alphabetic or Ideographic) (AI) 2580 */ 2581 AMBIGUOUS = 27, 2582 /** 2583 * Unknown (XX) 2584 */ 2585 UNKNOWN = 28, 2586 /** 2587 * Next Line (NL) 2588 */ 2589 NEXT_LINE = 29, 2590 /** 2591 * Word Joiner (WJ) 2592 */ 2593 WORD_JOINER = 30, 2594 /** 2595 * Hangul L Jamo (JL) 2596 */ 2597 HANGUL_L_JAMO = 31, 2598 /** 2599 * Hangul V Jamo (JV) 2600 */ 2601 HANGUL_V_JAMO = 32, 2602 /** 2603 * Hangul T Jamo (JT) 2604 */ 2605 HANGUL_T_JAMO = 33, 2606 /** 2607 * Hangul LV Syllable (H2) 2608 */ 2609 HANGUL_LV_SYLLABLE = 34, 2610 /** 2611 * Hangul LVT Syllable (H3) 2612 */ 2613 HANGUL_LVT_SYLLABLE = 35, 2614 /** 2615 * Closing Parenthesis (CP). Since 2.28 2616 */ 2617 CLOSE_PARANTHESIS = 36, 2618 /** 2619 * Conditional Japanese Starter (CJ). Since: 2.32 2620 */ 2621 CONDITIONAL_JAPANESE_STARTER = 37, 2622 /** 2623 * Hebrew Letter (HL). Since: 2.32 2624 */ 2625 HEBREW_LETTER = 38, 2626 /** 2627 * Regional Indicator (RI). Since: 2.36 2628 */ 2629 REGIONAL_INDICATOR = 39, 2630 /** 2631 * Emoji Base (EB). Since: 2.50 2632 */ 2633 EMOJI_BASE = 40, 2634 /** 2635 * Emoji Modifier (EM). Since: 2.50 2636 */ 2637 EMOJI_MODIFIER = 41, 2638 /** 2639 * Zero Width Joiner (ZWJ). Since: 2.50 2640 */ 2641 ZERO_WIDTH_JOINER = 42, 2642 } 2643 alias GUnicodeBreakType UnicodeBreakType; 2644 2645 /** 2646 * The #GUnicodeScript enumeration identifies different writing 2647 * systems. The values correspond to the names as defined in the 2648 * Unicode standard. The enumeration has been added in GLib 2.14, 2649 * and is interchangeable with #PangoScript. 2650 * 2651 * Note that new types may be added in the future. Applications 2652 * should be ready to handle unknown values. 2653 * See [Unicode Standard Annex #24: Script names](http://www.unicode.org/reports/tr24/). 2654 */ 2655 public enum GUnicodeScript 2656 { 2657 /** 2658 * a value never returned from g_unichar_get_script() 2659 */ 2660 INVALID_CODE = -1, 2661 /** 2662 * a character used by multiple different scripts 2663 */ 2664 COMMON = 0, 2665 /** 2666 * a mark glyph that takes its script from the 2667 * base glyph to which it is attached 2668 */ 2669 INHERITED = 1, 2670 /** 2671 * Arabic 2672 */ 2673 ARABIC = 2, 2674 /** 2675 * Armenian 2676 */ 2677 ARMENIAN = 3, 2678 /** 2679 * Bengali 2680 */ 2681 BENGALI = 4, 2682 /** 2683 * Bopomofo 2684 */ 2685 BOPOMOFO = 5, 2686 /** 2687 * Cherokee 2688 */ 2689 CHEROKEE = 6, 2690 /** 2691 * Coptic 2692 */ 2693 COPTIC = 7, 2694 /** 2695 * Cyrillic 2696 */ 2697 CYRILLIC = 8, 2698 /** 2699 * Deseret 2700 */ 2701 DESERET = 9, 2702 /** 2703 * Devanagari 2704 */ 2705 DEVANAGARI = 10, 2706 /** 2707 * Ethiopic 2708 */ 2709 ETHIOPIC = 11, 2710 /** 2711 * Georgian 2712 */ 2713 GEORGIAN = 12, 2714 /** 2715 * Gothic 2716 */ 2717 GOTHIC = 13, 2718 /** 2719 * Greek 2720 */ 2721 GREEK = 14, 2722 /** 2723 * Gujarati 2724 */ 2725 GUJARATI = 15, 2726 /** 2727 * Gurmukhi 2728 */ 2729 GURMUKHI = 16, 2730 /** 2731 * Han 2732 */ 2733 HAN = 17, 2734 /** 2735 * Hangul 2736 */ 2737 HANGUL = 18, 2738 /** 2739 * Hebrew 2740 */ 2741 HEBREW = 19, 2742 /** 2743 * Hiragana 2744 */ 2745 HIRAGANA = 20, 2746 /** 2747 * Kannada 2748 */ 2749 KANNADA = 21, 2750 /** 2751 * Katakana 2752 */ 2753 KATAKANA = 22, 2754 /** 2755 * Khmer 2756 */ 2757 KHMER = 23, 2758 /** 2759 * Lao 2760 */ 2761 LAO = 24, 2762 /** 2763 * Latin 2764 */ 2765 LATIN = 25, 2766 /** 2767 * Malayalam 2768 */ 2769 MALAYALAM = 26, 2770 /** 2771 * Mongolian 2772 */ 2773 MONGOLIAN = 27, 2774 /** 2775 * Myanmar 2776 */ 2777 MYANMAR = 28, 2778 /** 2779 * Ogham 2780 */ 2781 OGHAM = 29, 2782 /** 2783 * Old Italic 2784 */ 2785 OLD_ITALIC = 30, 2786 /** 2787 * Oriya 2788 */ 2789 ORIYA = 31, 2790 /** 2791 * Runic 2792 */ 2793 RUNIC = 32, 2794 /** 2795 * Sinhala 2796 */ 2797 SINHALA = 33, 2798 /** 2799 * Syriac 2800 */ 2801 SYRIAC = 34, 2802 /** 2803 * Tamil 2804 */ 2805 TAMIL = 35, 2806 /** 2807 * Telugu 2808 */ 2809 TELUGU = 36, 2810 /** 2811 * Thaana 2812 */ 2813 THAANA = 37, 2814 /** 2815 * Thai 2816 */ 2817 THAI = 38, 2818 /** 2819 * Tibetan 2820 */ 2821 TIBETAN = 39, 2822 /** 2823 * Canadian Aboriginal 2824 */ 2825 CANADIAN_ABORIGINAL = 40, 2826 /** 2827 * Yi 2828 */ 2829 YI = 41, 2830 /** 2831 * Tagalog 2832 */ 2833 TAGALOG = 42, 2834 /** 2835 * Hanunoo 2836 */ 2837 HANUNOO = 43, 2838 /** 2839 * Buhid 2840 */ 2841 BUHID = 44, 2842 /** 2843 * Tagbanwa 2844 */ 2845 TAGBANWA = 45, 2846 /** 2847 * Braille 2848 */ 2849 BRAILLE = 46, 2850 /** 2851 * Cypriot 2852 */ 2853 CYPRIOT = 47, 2854 /** 2855 * Limbu 2856 */ 2857 LIMBU = 48, 2858 /** 2859 * Osmanya 2860 */ 2861 OSMANYA = 49, 2862 /** 2863 * Shavian 2864 */ 2865 SHAVIAN = 50, 2866 /** 2867 * Linear B 2868 */ 2869 LINEAR_B = 51, 2870 /** 2871 * Tai Le 2872 */ 2873 TAI_LE = 52, 2874 /** 2875 * Ugaritic 2876 */ 2877 UGARITIC = 53, 2878 /** 2879 * New Tai Lue 2880 */ 2881 NEW_TAI_LUE = 54, 2882 /** 2883 * Buginese 2884 */ 2885 BUGINESE = 55, 2886 /** 2887 * Glagolitic 2888 */ 2889 GLAGOLITIC = 56, 2890 /** 2891 * Tifinagh 2892 */ 2893 TIFINAGH = 57, 2894 /** 2895 * Syloti Nagri 2896 */ 2897 SYLOTI_NAGRI = 58, 2898 /** 2899 * Old Persian 2900 */ 2901 OLD_PERSIAN = 59, 2902 /** 2903 * Kharoshthi 2904 */ 2905 KHAROSHTHI = 60, 2906 /** 2907 * an unassigned code point 2908 */ 2909 UNKNOWN = 61, 2910 /** 2911 * Balinese 2912 */ 2913 BALINESE = 62, 2914 /** 2915 * Cuneiform 2916 */ 2917 CUNEIFORM = 63, 2918 /** 2919 * Phoenician 2920 */ 2921 PHOENICIAN = 64, 2922 /** 2923 * Phags-pa 2924 */ 2925 PHAGS_PA = 65, 2926 /** 2927 * N'Ko 2928 */ 2929 NKO = 66, 2930 /** 2931 * Kayah Li. Since 2.16.3 2932 */ 2933 KAYAH_LI = 67, 2934 /** 2935 * Lepcha. Since 2.16.3 2936 */ 2937 LEPCHA = 68, 2938 /** 2939 * Rejang. Since 2.16.3 2940 */ 2941 REJANG = 69, 2942 /** 2943 * Sundanese. Since 2.16.3 2944 */ 2945 SUNDANESE = 70, 2946 /** 2947 * Saurashtra. Since 2.16.3 2948 */ 2949 SAURASHTRA = 71, 2950 /** 2951 * Cham. Since 2.16.3 2952 */ 2953 CHAM = 72, 2954 /** 2955 * Ol Chiki. Since 2.16.3 2956 */ 2957 OL_CHIKI = 73, 2958 /** 2959 * Vai. Since 2.16.3 2960 */ 2961 VAI = 74, 2962 /** 2963 * Carian. Since 2.16.3 2964 */ 2965 CARIAN = 75, 2966 /** 2967 * Lycian. Since 2.16.3 2968 */ 2969 LYCIAN = 76, 2970 /** 2971 * Lydian. Since 2.16.3 2972 */ 2973 LYDIAN = 77, 2974 /** 2975 * Avestan. Since 2.26 2976 */ 2977 AVESTAN = 78, 2978 /** 2979 * Bamum. Since 2.26 2980 */ 2981 BAMUM = 79, 2982 /** 2983 * Egyptian Hieroglpyhs. Since 2.26 2984 */ 2985 EGYPTIAN_HIEROGLYPHS = 80, 2986 /** 2987 * Imperial Aramaic. Since 2.26 2988 */ 2989 IMPERIAL_ARAMAIC = 81, 2990 /** 2991 * Inscriptional Pahlavi. Since 2.26 2992 */ 2993 INSCRIPTIONAL_PAHLAVI = 82, 2994 /** 2995 * Inscriptional Parthian. Since 2.26 2996 */ 2997 INSCRIPTIONAL_PARTHIAN = 83, 2998 /** 2999 * Javanese. Since 2.26 3000 */ 3001 JAVANESE = 84, 3002 /** 3003 * Kaithi. Since 2.26 3004 */ 3005 KAITHI = 85, 3006 /** 3007 * Lisu. Since 2.26 3008 */ 3009 LISU = 86, 3010 /** 3011 * Meetei Mayek. Since 2.26 3012 */ 3013 MEETEI_MAYEK = 87, 3014 /** 3015 * Old South Arabian. Since 2.26 3016 */ 3017 OLD_SOUTH_ARABIAN = 88, 3018 /** 3019 * Old Turkic. Since 2.28 3020 */ 3021 OLD_TURKIC = 89, 3022 /** 3023 * Samaritan. Since 2.26 3024 */ 3025 SAMARITAN = 90, 3026 /** 3027 * Tai Tham. Since 2.26 3028 */ 3029 TAI_THAM = 91, 3030 /** 3031 * Tai Viet. Since 2.26 3032 */ 3033 TAI_VIET = 92, 3034 /** 3035 * Batak. Since 2.28 3036 */ 3037 BATAK = 93, 3038 /** 3039 * Brahmi. Since 2.28 3040 */ 3041 BRAHMI = 94, 3042 /** 3043 * Mandaic. Since 2.28 3044 */ 3045 MANDAIC = 95, 3046 /** 3047 * Chakma. Since: 2.32 3048 */ 3049 CHAKMA = 96, 3050 /** 3051 * Meroitic Cursive. Since: 2.32 3052 */ 3053 MEROITIC_CURSIVE = 97, 3054 /** 3055 * Meroitic Hieroglyphs. Since: 2.32 3056 */ 3057 MEROITIC_HIEROGLYPHS = 98, 3058 /** 3059 * Miao. Since: 2.32 3060 */ 3061 MIAO = 99, 3062 /** 3063 * Sharada. Since: 2.32 3064 */ 3065 SHARADA = 100, 3066 /** 3067 * Sora Sompeng. Since: 2.32 3068 */ 3069 SORA_SOMPENG = 101, 3070 /** 3071 * Takri. Since: 2.32 3072 */ 3073 TAKRI = 102, 3074 /** 3075 * Bassa. Since: 2.42 3076 */ 3077 BASSA_VAH = 103, 3078 /** 3079 * Caucasian Albanian. Since: 2.42 3080 */ 3081 CAUCASIAN_ALBANIAN = 104, 3082 /** 3083 * Duployan. Since: 2.42 3084 */ 3085 DUPLOYAN = 105, 3086 /** 3087 * Elbasan. Since: 2.42 3088 */ 3089 ELBASAN = 106, 3090 /** 3091 * Grantha. Since: 2.42 3092 */ 3093 GRANTHA = 107, 3094 /** 3095 * Kjohki. Since: 2.42 3096 */ 3097 KHOJKI = 108, 3098 /** 3099 * Khudawadi, Sindhi. Since: 2.42 3100 */ 3101 KHUDAWADI = 109, 3102 /** 3103 * Linear A. Since: 2.42 3104 */ 3105 LINEAR_A = 110, 3106 /** 3107 * Mahajani. Since: 2.42 3108 */ 3109 MAHAJANI = 111, 3110 /** 3111 * Manichaean. Since: 2.42 3112 */ 3113 MANICHAEAN = 112, 3114 /** 3115 * Mende Kikakui. Since: 2.42 3116 */ 3117 MENDE_KIKAKUI = 113, 3118 /** 3119 * Modi. Since: 2.42 3120 */ 3121 MODI = 114, 3122 /** 3123 * Mro. Since: 2.42 3124 */ 3125 MRO = 115, 3126 /** 3127 * Nabataean. Since: 2.42 3128 */ 3129 NABATAEAN = 116, 3130 /** 3131 * Old North Arabian. Since: 2.42 3132 */ 3133 OLD_NORTH_ARABIAN = 117, 3134 /** 3135 * Old Permic. Since: 2.42 3136 */ 3137 OLD_PERMIC = 118, 3138 /** 3139 * Pahawh Hmong. Since: 2.42 3140 */ 3141 PAHAWH_HMONG = 119, 3142 /** 3143 * Palmyrene. Since: 2.42 3144 */ 3145 PALMYRENE = 120, 3146 /** 3147 * Pau Cin Hau. Since: 2.42 3148 */ 3149 PAU_CIN_HAU = 121, 3150 /** 3151 * Psalter Pahlavi. Since: 2.42 3152 */ 3153 PSALTER_PAHLAVI = 122, 3154 /** 3155 * Siddham. Since: 2.42 3156 */ 3157 SIDDHAM = 123, 3158 /** 3159 * Tirhuta. Since: 2.42 3160 */ 3161 TIRHUTA = 124, 3162 /** 3163 * Warang Citi. Since: 2.42 3164 */ 3165 WARANG_CITI = 125, 3166 /** 3167 * Ahom. Since: 2.48 3168 */ 3169 AHOM = 126, 3170 /** 3171 * Anatolian Hieroglyphs. Since: 2.48 3172 */ 3173 ANATOLIAN_HIEROGLYPHS = 127, 3174 /** 3175 * Hatran. Since: 2.48 3176 */ 3177 HATRAN = 128, 3178 /** 3179 * Multani. Since: 2.48 3180 */ 3181 MULTANI = 129, 3182 /** 3183 * Old Hungarian. Since: 2.48 3184 */ 3185 OLD_HUNGARIAN = 130, 3186 /** 3187 * Signwriting. Since: 2.48 3188 */ 3189 SIGNWRITING = 131, 3190 /** 3191 * Adlam. Since: 2.50 3192 */ 3193 ADLAM = 132, 3194 /** 3195 * Bhaiksuki. Since: 2.50 3196 */ 3197 BHAIKSUKI = 133, 3198 /** 3199 * Marchen. Since: 2.50 3200 */ 3201 MARCHEN = 134, 3202 /** 3203 * Newa. Since: 2.50 3204 */ 3205 NEWA = 135, 3206 /** 3207 * Osage. Since: 2.50 3208 */ 3209 OSAGE = 136, 3210 /** 3211 * Tangut. Since: 2.50 3212 * @G_UNICODE_SCRIPT_MASARAM_GONDI, Masaram Gondi. Since: 2.54 3213 * @G_UNICODE_SCRIPT_NUSHU, Nushu. Since: 2.54 3214 * @G_UNICODE_SCRIPT_SOYOMBO, Soyombo. Since: 2.54 3215 * @G_UNICODE_SCRIPT_ZANABAZAR_SQUARE Zanabazar Square. Since: 2.54 3216 */ 3217 TANGUT = 137, 3218 MASARAM_GONDI = 138, 3219 NUSHU = 139, 3220 SOYOMBO = 140, 3221 ZANABAZAR_SQUARE = 141, 3222 } 3223 alias GUnicodeScript UnicodeScript; 3224 3225 /** 3226 * These are the possible character classifications from the 3227 * Unicode specification. 3228 * See [Unicode Character Database](http://www.unicode.org/reports/tr44/#General_Category_Values). 3229 */ 3230 public enum GUnicodeType 3231 { 3232 /** 3233 * General category "Other, Control" (Cc) 3234 */ 3235 CONTROL = 0, 3236 /** 3237 * General category "Other, Format" (Cf) 3238 */ 3239 FORMAT = 1, 3240 /** 3241 * General category "Other, Not Assigned" (Cn) 3242 */ 3243 UNASSIGNED = 2, 3244 /** 3245 * General category "Other, Private Use" (Co) 3246 */ 3247 PRIVATE_USE = 3, 3248 /** 3249 * General category "Other, Surrogate" (Cs) 3250 */ 3251 SURROGATE = 4, 3252 /** 3253 * General category "Letter, Lowercase" (Ll) 3254 */ 3255 LOWERCASE_LETTER = 5, 3256 /** 3257 * General category "Letter, Modifier" (Lm) 3258 */ 3259 MODIFIER_LETTER = 6, 3260 /** 3261 * General category "Letter, Other" (Lo) 3262 */ 3263 OTHER_LETTER = 7, 3264 /** 3265 * General category "Letter, Titlecase" (Lt) 3266 */ 3267 TITLECASE_LETTER = 8, 3268 /** 3269 * General category "Letter, Uppercase" (Lu) 3270 */ 3271 UPPERCASE_LETTER = 9, 3272 /** 3273 * General category "Mark, Spacing" (Mc) 3274 */ 3275 SPACING_MARK = 10, 3276 /** 3277 * General category "Mark, Enclosing" (Me) 3278 */ 3279 ENCLOSING_MARK = 11, 3280 /** 3281 * General category "Mark, Nonspacing" (Mn) 3282 */ 3283 NON_SPACING_MARK = 12, 3284 /** 3285 * General category "Number, Decimal Digit" (Nd) 3286 */ 3287 DECIMAL_NUMBER = 13, 3288 /** 3289 * General category "Number, Letter" (Nl) 3290 */ 3291 LETTER_NUMBER = 14, 3292 /** 3293 * General category "Number, Other" (No) 3294 */ 3295 OTHER_NUMBER = 15, 3296 /** 3297 * General category "Punctuation, Connector" (Pc) 3298 */ 3299 CONNECT_PUNCTUATION = 16, 3300 /** 3301 * General category "Punctuation, Dash" (Pd) 3302 */ 3303 DASH_PUNCTUATION = 17, 3304 /** 3305 * General category "Punctuation, Close" (Pe) 3306 */ 3307 CLOSE_PUNCTUATION = 18, 3308 /** 3309 * General category "Punctuation, Final quote" (Pf) 3310 */ 3311 FINAL_PUNCTUATION = 19, 3312 /** 3313 * General category "Punctuation, Initial quote" (Pi) 3314 */ 3315 INITIAL_PUNCTUATION = 20, 3316 /** 3317 * General category "Punctuation, Other" (Po) 3318 */ 3319 OTHER_PUNCTUATION = 21, 3320 /** 3321 * General category "Punctuation, Open" (Ps) 3322 */ 3323 OPEN_PUNCTUATION = 22, 3324 /** 3325 * General category "Symbol, Currency" (Sc) 3326 */ 3327 CURRENCY_SYMBOL = 23, 3328 /** 3329 * General category "Symbol, Modifier" (Sk) 3330 */ 3331 MODIFIER_SYMBOL = 24, 3332 /** 3333 * General category "Symbol, Math" (Sm) 3334 */ 3335 MATH_SYMBOL = 25, 3336 /** 3337 * General category "Symbol, Other" (So) 3338 */ 3339 OTHER_SYMBOL = 26, 3340 /** 3341 * General category "Separator, Line" (Zl) 3342 */ 3343 LINE_SEPARATOR = 27, 3344 /** 3345 * General category "Separator, Paragraph" (Zp) 3346 */ 3347 PARAGRAPH_SEPARATOR = 28, 3348 /** 3349 * General category "Separator, Space" (Zs) 3350 */ 3351 SPACE_SEPARATOR = 29, 3352 } 3353 alias GUnicodeType UnicodeType; 3354 3355 /** 3356 * These are logical ids for special directories which are defined 3357 * depending on the platform used. You should use g_get_user_special_dir() 3358 * to retrieve the full path associated to the logical id. 3359 * 3360 * The #GUserDirectory enumeration can be extended at later date. Not 3361 * every platform has a directory for every logical id in this 3362 * enumeration. 3363 * 3364 * Since: 2.14 3365 */ 3366 public enum GUserDirectory 3367 { 3368 /** 3369 * the user's Desktop directory 3370 */ 3371 DIRECTORY_DESKTOP = 0, 3372 /** 3373 * the user's Documents directory 3374 */ 3375 DIRECTORY_DOCUMENTS = 1, 3376 /** 3377 * the user's Downloads directory 3378 */ 3379 DIRECTORY_DOWNLOAD = 2, 3380 /** 3381 * the user's Music directory 3382 */ 3383 DIRECTORY_MUSIC = 3, 3384 /** 3385 * the user's Pictures directory 3386 */ 3387 DIRECTORY_PICTURES = 4, 3388 /** 3389 * the user's shared directory 3390 */ 3391 DIRECTORY_PUBLIC_SHARE = 5, 3392 /** 3393 * the user's Templates directory 3394 */ 3395 DIRECTORY_TEMPLATES = 6, 3396 /** 3397 * the user's Movies directory 3398 */ 3399 DIRECTORY_VIDEOS = 7, 3400 /** 3401 * the number of enum values 3402 */ 3403 N_DIRECTORIES = 8, 3404 } 3405 alias GUserDirectory UserDirectory; 3406 3407 /** 3408 * The range of possible top-level types of #GVariant instances. 3409 * 3410 * Since: 2.24 3411 */ 3412 public enum GVariantClass 3413 { 3414 /** 3415 * The #GVariant is a boolean. 3416 */ 3417 BOOLEAN = 98, 3418 /** 3419 * The #GVariant is a byte. 3420 */ 3421 BYTE = 121, 3422 /** 3423 * The #GVariant is a signed 16 bit integer. 3424 */ 3425 INT16 = 110, 3426 /** 3427 * The #GVariant is an unsigned 16 bit integer. 3428 */ 3429 UINT16 = 113, 3430 /** 3431 * The #GVariant is a signed 32 bit integer. 3432 */ 3433 INT32 = 105, 3434 /** 3435 * The #GVariant is an unsigned 32 bit integer. 3436 */ 3437 UINT32 = 117, 3438 /** 3439 * The #GVariant is a signed 64 bit integer. 3440 */ 3441 INT64 = 120, 3442 /** 3443 * The #GVariant is an unsigned 64 bit integer. 3444 */ 3445 UINT64 = 116, 3446 /** 3447 * The #GVariant is a file handle index. 3448 */ 3449 HANDLE = 104, 3450 /** 3451 * The #GVariant is a double precision floating 3452 * point value. 3453 */ 3454 DOUBLE = 100, 3455 /** 3456 * The #GVariant is a normal string. 3457 */ 3458 STRING = 115, 3459 /** 3460 * The #GVariant is a D-Bus object path 3461 * string. 3462 */ 3463 OBJECT_PATH = 111, 3464 /** 3465 * The #GVariant is a D-Bus signature string. 3466 */ 3467 SIGNATURE = 103, 3468 /** 3469 * The #GVariant is a variant. 3470 */ 3471 VARIANT = 118, 3472 /** 3473 * The #GVariant is a maybe-typed value. 3474 */ 3475 MAYBE = 109, 3476 /** 3477 * The #GVariant is an array. 3478 */ 3479 ARRAY = 97, 3480 /** 3481 * The #GVariant is a tuple. 3482 */ 3483 TUPLE = 40, 3484 /** 3485 * The #GVariant is a dictionary entry. 3486 */ 3487 DICT_ENTRY = 123, 3488 } 3489 alias GVariantClass VariantClass; 3490 3491 /** 3492 * Error codes returned by parsing text-format GVariants. 3493 */ 3494 public enum GVariantParseError 3495 { 3496 /** 3497 * generic error (unused) 3498 */ 3499 FAILED = 0, 3500 /** 3501 * a non-basic #GVariantType was given where a basic type was expected 3502 */ 3503 BASIC_TYPE_EXPECTED = 1, 3504 /** 3505 * cannot infer the #GVariantType 3506 */ 3507 CANNOT_INFER_TYPE = 2, 3508 /** 3509 * an indefinite #GVariantType was given where a definite type was expected 3510 */ 3511 DEFINITE_TYPE_EXPECTED = 3, 3512 /** 3513 * extra data after parsing finished 3514 */ 3515 INPUT_NOT_AT_END = 4, 3516 /** 3517 * invalid character in number or unicode escape 3518 */ 3519 INVALID_CHARACTER = 5, 3520 /** 3521 * not a valid #GVariant format string 3522 */ 3523 INVALID_FORMAT_STRING = 6, 3524 /** 3525 * not a valid object path 3526 */ 3527 INVALID_OBJECT_PATH = 7, 3528 /** 3529 * not a valid type signature 3530 */ 3531 INVALID_SIGNATURE = 8, 3532 /** 3533 * not a valid #GVariant type string 3534 */ 3535 INVALID_TYPE_STRING = 9, 3536 /** 3537 * could not find a common type for array entries 3538 */ 3539 NO_COMMON_TYPE = 10, 3540 /** 3541 * the numerical value is out of range of the given type 3542 */ 3543 NUMBER_OUT_OF_RANGE = 11, 3544 /** 3545 * the numerical value is out of range for any type 3546 */ 3547 NUMBER_TOO_BIG = 12, 3548 /** 3549 * cannot parse as variant of the specified type 3550 */ 3551 TYPE_ERROR = 13, 3552 /** 3553 * an unexpected token was encountered 3554 */ 3555 UNEXPECTED_TOKEN = 14, 3556 /** 3557 * an unknown keyword was encountered 3558 */ 3559 UNKNOWN_KEYWORD = 15, 3560 /** 3561 * unterminated string constant 3562 */ 3563 UNTERMINATED_STRING_CONSTANT = 16, 3564 /** 3565 * no value given 3566 */ 3567 VALUE_EXPECTED = 17, 3568 } 3569 alias GVariantParseError VariantParseError; 3570 3571 /** 3572 * Flags passed to g_module_open(). 3573 * Note that these flags are not supported on all platforms. 3574 */ 3575 public enum GModuleFlags 3576 { 3577 /** 3578 * specifies that symbols are only resolved when 3579 * needed. The default action is to bind all symbols when the module 3580 * is loaded. 3581 */ 3582 LAZY = 1, 3583 /** 3584 * specifies that symbols in the module should 3585 * not be added to the global name space. The default action on most 3586 * platforms is to place symbols in the module in the global name space, 3587 * which may cause conflicts with existing symbols. 3588 */ 3589 LOCAL = 2, 3590 /** 3591 * mask for all flags. 3592 */ 3593 MASK = 3, 3594 } 3595 alias GModuleFlags ModuleFlags; 3596 3597 /** 3598 * Contains the public fields of a GArray. 3599 */ 3600 struct GArray 3601 { 3602 /** 3603 * a pointer to the element data. The data may be moved as 3604 * elements are added to the #GArray. 3605 */ 3606 char* data; 3607 /** 3608 * the number of elements in the #GArray not including the 3609 * possible terminating zero element. 3610 */ 3611 uint len; 3612 } 3613 3614 struct GAsyncQueue; 3615 3616 struct GBookmarkFile; 3617 3618 /** 3619 * Contains the public fields of a GByteArray. 3620 */ 3621 struct GByteArray 3622 { 3623 /** 3624 * a pointer to the element data. The data may be moved as 3625 * elements are added to the #GByteArray 3626 */ 3627 ubyte* data; 3628 /** 3629 * the number of elements in the #GByteArray 3630 */ 3631 uint len; 3632 } 3633 3634 struct GBytes; 3635 3636 struct GChecksum; 3637 3638 struct GCond 3639 { 3640 void* p; 3641 uint[2] i; 3642 } 3643 3644 /** 3645 * The #GData struct is an opaque data structure to represent a 3646 * [Keyed Data List][glib-Keyed-Data-Lists]. It should only be 3647 * accessed via the following functions. 3648 */ 3649 struct GData; 3650 3651 struct GDate 3652 { 3653 import std.bitmanip: bitfields; 3654 mixin(bitfields!( 3655 uint, "julianDays", 32, 3656 uint, "julian", 1, 3657 uint, "dmy", 1, 3658 uint, "day", 6, 3659 uint, "month", 4, 3660 uint, "year", 16, 3661 uint, "", 4 3662 )); 3663 } 3664 3665 struct GDateTime; 3666 3667 /** 3668 * Associates a string with a bit flag. 3669 * Used in g_parse_debug_string(). 3670 */ 3671 struct GDebugKey 3672 { 3673 /** 3674 * the string 3675 */ 3676 const(char)* key; 3677 /** 3678 * the flag 3679 */ 3680 uint value; 3681 } 3682 3683 struct GDir; 3684 3685 /** 3686 * The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign, 3687 * mantissa and exponent of IEEE floats and doubles. These unions are defined 3688 * as appropriate for a given platform. IEEE floats and doubles are supported 3689 * (used for storage) by at least Intel, PPC and Sparc. 3690 */ 3691 struct GDoubleIEEE754 3692 { 3693 union 3694 { 3695 /** 3696 * the double value 3697 */ 3698 double vDouble; 3699 struct Mpn 3700 { 3701 import std.bitmanip: bitfields; 3702 mixin(bitfields!( 3703 uint, "mantissaLow", 32, 3704 uint, "mantissaHigh", 20, 3705 uint, "biasedExponent", 11, 3706 uint, "sign", 1 3707 )); 3708 } 3709 Mpn mpn; 3710 } 3711 } 3712 3713 struct GError 3714 { 3715 /** 3716 * error domain, e.g. #G_FILE_ERROR 3717 */ 3718 GQuark domain; 3719 /** 3720 * error code, e.g. %G_FILE_ERROR_NOENT 3721 */ 3722 int code; 3723 /** 3724 * human-readable informative error message 3725 */ 3726 char* message; 3727 } 3728 3729 /** 3730 * The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign, 3731 * mantissa and exponent of IEEE floats and doubles. These unions are defined 3732 * as appropriate for a given platform. IEEE floats and doubles are supported 3733 * (used for storage) by at least Intel, PPC and Sparc. 3734 */ 3735 struct GFloatIEEE754 3736 { 3737 union 3738 { 3739 /** 3740 * the double value 3741 */ 3742 float vFloat; 3743 struct Mpn 3744 { 3745 import std.bitmanip: bitfields; 3746 mixin(bitfields!( 3747 uint, "mantissa", 23, 3748 uint, "biasedExponent", 8, 3749 uint, "sign", 1 3750 )); 3751 } 3752 Mpn mpn; 3753 } 3754 } 3755 3756 /** 3757 * The #GHashTable struct is an opaque data structure to represent a 3758 * [Hash Table][glib-Hash-Tables]. It should only be accessed via the 3759 * following functions. 3760 */ 3761 struct GHashTable; 3762 3763 struct GHashTableIter 3764 { 3765 void* dummy1; 3766 void* dummy2; 3767 void* dummy3; 3768 int dummy4; 3769 bool dummy5; 3770 void* dummy6; 3771 } 3772 3773 struct GHmac; 3774 3775 struct GHook 3776 { 3777 /** 3778 * data which is passed to func when this hook is invoked 3779 */ 3780 void* data; 3781 /** 3782 * pointer to the next hook in the list 3783 */ 3784 GHook* next; 3785 /** 3786 * pointer to the previous hook in the list 3787 */ 3788 GHook* prev; 3789 /** 3790 * the reference count of this hook 3791 */ 3792 uint refCount; 3793 /** 3794 * the id of this hook, which is unique within its list 3795 */ 3796 gulong hookId; 3797 /** 3798 * flags which are set for this hook. See #GHookFlagMask for 3799 * predefined flags 3800 */ 3801 uint flags; 3802 /** 3803 * the function to call when this hook is invoked. The possible 3804 * signatures for this function are #GHookFunc and #GHookCheckFunc 3805 */ 3806 void* func; 3807 /** 3808 * the default @finalize_hook function of a #GHookList calls 3809 * this member of the hook that is being finalized 3810 */ 3811 GDestroyNotify destroy; 3812 } 3813 3814 struct GHookList 3815 { 3816 /** 3817 * the next free #GHook id 3818 */ 3819 gulong seqId; 3820 import std.bitmanip: bitfields; 3821 mixin(bitfields!( 3822 uint, "hookSize", 16, 3823 uint, "isSetup", 1, 3824 uint, "", 15 3825 )); 3826 /** 3827 * the first #GHook element in the list 3828 */ 3829 GHook* hooks; 3830 /** 3831 * unused 3832 */ 3833 void* dummy3; 3834 /** 3835 * the function to call to finalize a #GHook element. 3836 * The default behaviour is to call the hooks @destroy function 3837 */ 3838 GHookFinalizeFunc finalizeHook; 3839 /** 3840 * unused 3841 */ 3842 void*[2] dummy; 3843 } 3844 3845 struct GIOChannel 3846 { 3847 int refCount; 3848 GIOFuncs* funcs; 3849 char* encoding; 3850 GIConv readCd; 3851 GIConv writeCd; 3852 char* lineTerm; 3853 uint lineTermLen; 3854 size_t bufSize; 3855 GString* readBuf; 3856 GString* encodedReadBuf; 3857 GString* writeBuf; 3858 char[6] partialWriteBuf; 3859 import std.bitmanip: bitfields; 3860 mixin(bitfields!( 3861 uint, "useBuffer", 1, 3862 uint, "doEncode", 1, 3863 uint, "closeOnUnref", 1, 3864 uint, "isReadable", 1, 3865 uint, "isWriteable", 1, 3866 uint, "isSeekable", 1, 3867 uint, "", 26 3868 )); 3869 void* reserved1; 3870 void* reserved2; 3871 } 3872 3873 /** 3874 * A table of functions used to handle different types of #GIOChannel 3875 * in a generic way. 3876 */ 3877 struct GIOFuncs 3878 { 3879 /** */ 3880 extern(C) GIOStatus function(GIOChannel* channel, char* buf, size_t count, size_t* bytesRead, GError** err) ioRead; 3881 /** */ 3882 extern(C) GIOStatus function(GIOChannel* channel, const(char)* buf, size_t count, size_t* bytesWritten, GError** err) ioWrite; 3883 /** */ 3884 extern(C) GIOStatus function(GIOChannel* channel, long offset, GSeekType type, GError** err) ioSeek; 3885 /** */ 3886 extern(C) GIOStatus function(GIOChannel* channel, GError** err) ioClose; 3887 /** */ 3888 extern(C) GSource* function(GIOChannel* channel, GIOCondition condition) ioCreateWatch; 3889 /** */ 3890 extern(C) void function(GIOChannel* channel) ioFree; 3891 /** */ 3892 extern(C) GIOStatus function(GIOChannel* channel, GIOFlags flags, GError** err) ioSetFlags; 3893 /** */ 3894 extern(C) GIOFlags function(GIOChannel* channel) ioGetFlags; 3895 } 3896 3897 struct GKeyFile; 3898 3899 /** 3900 * The #GList struct is used for each element in a doubly-linked list. 3901 */ 3902 struct GList 3903 { 3904 /** 3905 * holds the element's data, which can be a pointer to any kind 3906 * of data, or any integer value using the 3907 * [Type Conversion Macros][glib-Type-Conversion-Macros] 3908 */ 3909 void* data; 3910 /** 3911 * contains the link to the next element in the list 3912 */ 3913 GList* next; 3914 /** 3915 * contains the link to the previous element in the list 3916 */ 3917 GList* prev; 3918 } 3919 3920 /** 3921 * Structure representing a single field in a structured log entry. See 3922 * g_log_structured() for details. 3923 * 3924 * Log fields may contain arbitrary values, including binary with embedded nul 3925 * bytes. If the field contains a string, the string must be UTF-8 encoded and 3926 * have a trailing nul byte. Otherwise, @length must be set to a non-negative 3927 * value. 3928 * 3929 * Since: 2.50 3930 */ 3931 struct GLogField 3932 { 3933 /** 3934 * field name (UTF-8 string) 3935 */ 3936 const(char)* key; 3937 /** 3938 * field value (arbitrary bytes) 3939 */ 3940 void* value; 3941 /** 3942 * length of @value, in bytes, or -1 if it is nul-terminated 3943 */ 3944 ptrdiff_t length; 3945 } 3946 3947 struct GMainContext; 3948 3949 struct GMainLoop; 3950 3951 struct GMappedFile; 3952 3953 struct GMarkupParseContext; 3954 3955 /** 3956 * Any of the fields in #GMarkupParser can be %NULL, in which case they 3957 * will be ignored. Except for the @error function, any of these callbacks 3958 * can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT, 3959 * %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT 3960 * errors are intended to be set from these callbacks. If you set an error 3961 * from a callback, g_markup_parse_context_parse() will report that error 3962 * back to its caller. 3963 */ 3964 struct GMarkupParser 3965 { 3966 /** */ 3967 extern(C) void function(GMarkupParseContext* context, const(char)* elementName, char** attributeNames, char** attributeValues, void* userData, GError** err) startElement; 3968 /** */ 3969 extern(C) void function(GMarkupParseContext* context, const(char)* elementName, void* userData, GError** err) endElement; 3970 /** */ 3971 extern(C) void function(GMarkupParseContext* context, const(char)* text, size_t textLen, void* userData, GError** err) text; 3972 /** */ 3973 extern(C) void function(GMarkupParseContext* context, const(char)* passthroughText, size_t textLen, void* userData, GError** err) passthrough; 3974 /** */ 3975 extern(C) void function(GMarkupParseContext* context, GError* error, void* userData) error; 3976 } 3977 3978 struct GMatchInfo; 3979 3980 /** 3981 * A set of functions used to perform memory allocation. The same #GMemVTable must 3982 * be used for all allocations in the same program; a call to g_mem_set_vtable(), 3983 * if it exists, should be prior to any use of GLib. 3984 * 3985 * This functions related to this has been deprecated in 2.46, and no longer work. 3986 */ 3987 struct GMemVTable 3988 { 3989 /** */ 3990 extern(C) void* function(size_t nBytes) malloc; 3991 /** */ 3992 extern(C) void* function(void* mem, size_t nBytes) realloc; 3993 /** */ 3994 extern(C) void function(void* mem) free; 3995 /** */ 3996 extern(C) void* function(size_t nBlocks, size_t nBlockBytes) calloc; 3997 /** */ 3998 extern(C) void* function(size_t nBytes) tryMalloc; 3999 /** */ 4000 extern(C) void* function(void* mem, size_t nBytes) tryRealloc; 4001 } 4002 4003 struct GMutex 4004 { 4005 union 4006 { 4007 void* p; 4008 uint[2] i; 4009 } 4010 } 4011 4012 struct GNode 4013 { 4014 /** 4015 * contains the actual data of the node. 4016 */ 4017 void* data; 4018 /** 4019 * points to the node's next sibling (a sibling is another 4020 * #GNode with the same parent). 4021 */ 4022 GNode* next; 4023 /** 4024 * points to the node's previous sibling. 4025 */ 4026 GNode* prev; 4027 /** 4028 * points to the parent of the #GNode, or is %NULL if the 4029 * #GNode is the root of the tree. 4030 */ 4031 GNode* parent; 4032 /** 4033 * points to the first child of the #GNode. The other 4034 * children are accessed by using the @next pointer of each 4035 * child. 4036 */ 4037 GNode* children; 4038 } 4039 4040 struct GOnce 4041 { 4042 /** 4043 * the status of the #GOnce 4044 */ 4045 GOnceStatus status; 4046 /** 4047 * the value returned by the call to the function, if @status 4048 * is %G_ONCE_STATUS_READY 4049 */ 4050 void* retval; 4051 } 4052 4053 struct GOptionContext; 4054 4055 /** 4056 * A GOptionEntry struct defines a single option. To have an effect, they 4057 * must be added to a #GOptionGroup with g_option_context_add_main_entries() 4058 * or g_option_group_add_entries(). 4059 */ 4060 struct GOptionEntry 4061 { 4062 /** 4063 * The long name of an option can be used to specify it 4064 * in a commandline as `--long_name`. Every option must have a 4065 * long name. To resolve conflicts if multiple option groups contain 4066 * the same long name, it is also possible to specify the option as 4067 * `--groupname-long_name`. 4068 */ 4069 const(char)* longName; 4070 /** 4071 * If an option has a short name, it can be specified 4072 * `-short_name` in a commandline. @short_name must be a printable 4073 * ASCII character different from '-', or zero if the option has no 4074 * short name. 4075 */ 4076 char shortName; 4077 /** 4078 * Flags from #GOptionFlags 4079 */ 4080 int flags; 4081 /** 4082 * The type of the option, as a #GOptionArg 4083 */ 4084 GOptionArg arg; 4085 /** 4086 * If the @arg type is %G_OPTION_ARG_CALLBACK, then @arg_data 4087 * must point to a #GOptionArgFunc callback function, which will be 4088 * called to handle the extra argument. Otherwise, @arg_data is a 4089 * pointer to a location to store the value, the required type of 4090 * the location depends on the @arg type: 4091 * - %G_OPTION_ARG_NONE: %gboolean 4092 * - %G_OPTION_ARG_STRING: %gchar* 4093 * - %G_OPTION_ARG_INT: %gint 4094 * - %G_OPTION_ARG_FILENAME: %gchar* 4095 * - %G_OPTION_ARG_STRING_ARRAY: %gchar** 4096 * - %G_OPTION_ARG_FILENAME_ARRAY: %gchar** 4097 * - %G_OPTION_ARG_DOUBLE: %gdouble 4098 * If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME, 4099 * the location will contain a newly allocated string if the option 4100 * was given. That string needs to be freed by the callee using g_free(). 4101 * Likewise if @arg type is %G_OPTION_ARG_STRING_ARRAY or 4102 * %G_OPTION_ARG_FILENAME_ARRAY, the data should be freed using g_strfreev(). 4103 */ 4104 void* argData; 4105 /** 4106 * the description for the option in `--help` 4107 * output. The @description is translated using the @translate_func 4108 * of the group, see g_option_group_set_translation_domain(). 4109 */ 4110 const(char)* description; 4111 /** 4112 * The placeholder to use for the extra argument parsed 4113 * by the option in `--help` output. The @arg_description is translated 4114 * using the @translate_func of the group, see 4115 * g_option_group_set_translation_domain(). 4116 */ 4117 const(char)* argDescription; 4118 } 4119 4120 struct GOptionGroup; 4121 4122 struct GPatternSpec; 4123 4124 /** 4125 * Represents a file descriptor, which events to poll for, and which events 4126 * occurred. 4127 */ 4128 struct GPollFD 4129 { 4130 /** 4131 * the file descriptor to poll (or a HANDLE on Win32) 4132 */ 4133 int fd; 4134 /** 4135 * a bitwise combination from #GIOCondition, specifying which 4136 * events should be polled for. Typically for reading from a file 4137 * descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and 4138 * for writing you would use %G_IO_OUT | %G_IO_ERR. 4139 */ 4140 ushort events; 4141 /** 4142 * a bitwise combination of flags from #GIOCondition, returned 4143 * from the poll() function to indicate which events occurred. 4144 */ 4145 ushort revents; 4146 } 4147 4148 struct GPrivate 4149 { 4150 void* p; 4151 GDestroyNotify notify; 4152 void*[2] future; 4153 } 4154 4155 /** 4156 * Contains the public fields of a pointer array. 4157 */ 4158 struct GPtrArray 4159 { 4160 /** 4161 * points to the array of pointers, which may be moved when the 4162 * array grows 4163 */ 4164 void** pdata; 4165 /** 4166 * number of pointers in the array 4167 */ 4168 uint len; 4169 } 4170 4171 struct GQueue 4172 { 4173 /** 4174 * a pointer to the first element of the queue 4175 */ 4176 GList* head; 4177 /** 4178 * a pointer to the last element of the queue 4179 */ 4180 GList* tail; 4181 /** 4182 * the number of elements in the queue 4183 */ 4184 uint length; 4185 } 4186 4187 struct GRWLock 4188 { 4189 void* p; 4190 uint[2] i; 4191 } 4192 4193 struct GRand; 4194 4195 struct GRecMutex 4196 { 4197 void* p; 4198 uint[2] i; 4199 } 4200 4201 struct GRegex; 4202 4203 /** 4204 * The #GSList struct is used for each element in the singly-linked 4205 * list. 4206 */ 4207 struct GSList 4208 { 4209 /** 4210 * holds the element's data, which can be a pointer to any kind 4211 * of data, or any integer value using the 4212 * [Type Conversion Macros][glib-Type-Conversion-Macros] 4213 */ 4214 void* data; 4215 /** 4216 * contains the link to the next element in the list. 4217 */ 4218 GSList* next; 4219 } 4220 4221 struct GScanner 4222 { 4223 /** 4224 * unused 4225 */ 4226 void* userData; 4227 /** 4228 * unused 4229 */ 4230 uint maxParseErrors; 4231 /** 4232 * g_scanner_error() increments this field 4233 */ 4234 uint parseErrors; 4235 /** 4236 * name of input stream, featured by the default message handler 4237 */ 4238 const(char)* inputName; 4239 /** 4240 * quarked data 4241 */ 4242 GData* qdata; 4243 /** 4244 * link into the scanner configuration 4245 */ 4246 GScannerConfig* config; 4247 /** 4248 * token parsed by the last g_scanner_get_next_token() 4249 */ 4250 GTokenType token; 4251 /** 4252 * value of the last token from g_scanner_get_next_token() 4253 */ 4254 GTokenValue value; 4255 /** 4256 * line number of the last token from g_scanner_get_next_token() 4257 */ 4258 uint line; 4259 /** 4260 * char number of the last token from g_scanner_get_next_token() 4261 */ 4262 uint position; 4263 /** 4264 * token parsed by the last g_scanner_peek_next_token() 4265 */ 4266 GTokenType nextToken; 4267 /** 4268 * value of the last token from g_scanner_peek_next_token() 4269 */ 4270 GTokenValue nextValue; 4271 /** 4272 * line number of the last token from g_scanner_peek_next_token() 4273 */ 4274 uint nextLine; 4275 /** 4276 * char number of the last token from g_scanner_peek_next_token() 4277 */ 4278 uint nextPosition; 4279 GHashTable* symbolTable; 4280 int inputFd; 4281 const(char)* text; 4282 const(char)* textEnd; 4283 char* buffer; 4284 uint scopeId; 4285 /** 4286 * handler function for _warn and _error 4287 */ 4288 GScannerMsgFunc msgHandler; 4289 } 4290 4291 /** 4292 * Specifies the #GScanner parser configuration. Most settings can 4293 * be changed during the parsing phase and will affect the lexical 4294 * parsing of the next unpeeked token. 4295 */ 4296 struct GScannerConfig 4297 { 4298 /** 4299 * specifies which characters should be skipped 4300 * by the scanner (the default is the whitespace characters: space, 4301 * tab, carriage-return and line-feed). 4302 */ 4303 char* csetSkipCharacters; 4304 /** 4305 * specifies the characters which can start 4306 * identifiers (the default is #G_CSET_a_2_z, "_", and #G_CSET_A_2_Z). 4307 */ 4308 char* csetIdentifierFirst; 4309 /** 4310 * specifies the characters which can be used 4311 * in identifiers, after the first character (the default is 4312 * #G_CSET_a_2_z, "_0123456789", #G_CSET_A_2_Z, #G_CSET_LATINS, 4313 * #G_CSET_LATINC). 4314 */ 4315 char* csetIdentifierNth; 4316 /** 4317 * specifies the characters at the start and 4318 * end of single-line comments. The default is "#\n" which means 4319 * that single-line comments start with a '#' and continue until 4320 * a '\n' (end of line). 4321 */ 4322 char* cpairCommentSingle; 4323 import std.bitmanip: bitfields; 4324 mixin(bitfields!( 4325 uint, "caseSensitive", 1, 4326 uint, "skipCommentMulti", 1, 4327 uint, "skipCommentSingle", 1, 4328 uint, "scanCommentMulti", 1, 4329 uint, "scanIdentifier", 1, 4330 uint, "scanIdentifier1char", 1, 4331 uint, "scanIdentifierNULL", 1, 4332 uint, "scanSymbols", 1, 4333 uint, "scanBinary", 1, 4334 uint, "scanOctal", 1, 4335 uint, "scanFloat", 1, 4336 uint, "scanHex", 1, 4337 uint, "scanHexDollar", 1, 4338 uint, "scanStringSq", 1, 4339 uint, "scanStringDq", 1, 4340 uint, "numbers2Int", 1, 4341 uint, "int2Float", 1, 4342 uint, "identifier2String", 1, 4343 uint, "char2Token", 1, 4344 uint, "symbol2Token", 1, 4345 uint, "scope0Fallback", 1, 4346 uint, "storeInt64", 1, 4347 uint, "", 10 4348 )); 4349 uint paddingDummy; 4350 } 4351 4352 struct GSequence; 4353 4354 struct GSequenceIter; 4355 4356 struct GSource 4357 { 4358 void* callbackData; 4359 GSourceCallbackFuncs* callbackFuncs; 4360 GSourceFuncs* sourceFuncs; 4361 uint refCount; 4362 GMainContext* context; 4363 int priority; 4364 uint flags; 4365 uint sourceId; 4366 GSList* pollFds; 4367 GSource* prev; 4368 GSource* next; 4369 char* name; 4370 GSourcePrivate* priv; 4371 } 4372 4373 /** 4374 * The `GSourceCallbackFuncs` struct contains 4375 * functions for managing callback objects. 4376 */ 4377 struct GSourceCallbackFuncs 4378 { 4379 /** */ 4380 extern(C) void function(void* cbData) doref; 4381 /** */ 4382 extern(C) void function(void* cbData) unref; 4383 /** */ 4384 extern(C) void function(void* cbData, GSource* source, GSourceFunc* func, void** data) get; 4385 } 4386 4387 /** 4388 * The `GSourceFuncs` struct contains a table of 4389 * functions used to handle event sources in a generic manner. 4390 * 4391 * For idle sources, the prepare and check functions always return %TRUE 4392 * to indicate that the source is always ready to be processed. The prepare 4393 * function also returns a timeout value of 0 to ensure that the poll() call 4394 * doesn't block (since that would be time wasted which could have been spent 4395 * running the idle function). 4396 * 4397 * For timeout sources, the prepare and check functions both return %TRUE 4398 * if the timeout interval has expired. The prepare function also returns 4399 * a timeout value to ensure that the poll() call doesn't block too long 4400 * and miss the next timeout. 4401 * 4402 * For file descriptor sources, the prepare function typically returns %FALSE, 4403 * since it must wait until poll() has been called before it knows whether 4404 * any events need to be processed. It sets the returned timeout to -1 to 4405 * indicate that it doesn't mind how long the poll() call blocks. In the 4406 * check function, it tests the results of the poll() call to see if the 4407 * required condition has been met, and returns %TRUE if so. 4408 */ 4409 struct GSourceFuncs 4410 { 4411 /** */ 4412 extern(C) int function(GSource* source, int* timeout) prepare; 4413 /** */ 4414 extern(C) int function(GSource* source) check; 4415 /** */ 4416 extern(C) int function(GSource* source, GSourceFunc callback, void* userData) dispatch; 4417 /** */ 4418 extern(C) void function(GSource* source) finalize; 4419 GSourceFunc closureCallback; 4420 GSourceDummyMarshal closureMarshal; 4421 } 4422 4423 struct GSourcePrivate; 4424 4425 /** 4426 * A type corresponding to the appropriate struct type for the stat() 4427 * system call, depending on the platform and/or compiler being used. 4428 * 4429 * See g_stat() for more information. 4430 */ 4431 struct GStatBuf; 4432 4433 struct GString 4434 { 4435 /** 4436 * points to the character data. It may move as text is added. 4437 * The @str field is null-terminated and so 4438 * can be used as an ordinary C string. 4439 */ 4440 char* str; 4441 /** 4442 * contains the length of the string, not including the 4443 * terminating nul byte. 4444 */ 4445 size_t len; 4446 /** 4447 * the number of bytes that can be stored in the 4448 * string before it needs to be reallocated. May be larger than @len. 4449 */ 4450 size_t allocatedLen; 4451 } 4452 4453 struct GStringChunk; 4454 4455 /** 4456 * An opaque structure representing a test case. 4457 */ 4458 struct GTestCase; 4459 4460 struct GTestConfig 4461 { 4462 bool testInitialized; 4463 bool testQuick; 4464 bool testPerf; 4465 bool testVerbose; 4466 bool testQuiet; 4467 bool testUndefined; 4468 } 4469 4470 struct GTestLogBuffer 4471 { 4472 GString* data; 4473 GSList* msgs; 4474 } 4475 4476 struct GTestLogMsg 4477 { 4478 GTestLogType logType; 4479 uint nStrings; 4480 char** strings; 4481 uint nNums; 4482 long* nums; 4483 } 4484 4485 struct GTestSuite; 4486 4487 struct GThread; 4488 4489 struct GThreadPool 4490 { 4491 /** 4492 * the function to execute in the threads of this pool 4493 */ 4494 GFunc func; 4495 /** 4496 * the user data for the threads of this pool 4497 */ 4498 void* userData; 4499 /** 4500 * are all threads exclusive to this pool 4501 */ 4502 bool exclusive; 4503 } 4504 4505 struct GTimeVal 4506 { 4507 /** 4508 * seconds 4509 */ 4510 glong tvSec; 4511 /** 4512 * microseconds 4513 */ 4514 glong tvUsec; 4515 } 4516 4517 struct GTimeZone; 4518 4519 struct GTimer; 4520 4521 /** 4522 * A union holding the value of the token. 4523 */ 4524 struct GTokenValue 4525 { 4526 union 4527 { 4528 /** 4529 * token symbol value 4530 */ 4531 void* vSymbol; 4532 /** 4533 * token identifier value 4534 */ 4535 char* vIdentifier; 4536 /** 4537 * token binary integer value 4538 */ 4539 gulong vBinary; 4540 /** 4541 * octal integer value 4542 */ 4543 gulong vOctal; 4544 /** 4545 * integer value 4546 */ 4547 gulong vInt; 4548 /** 4549 * 64-bit integer value 4550 */ 4551 ulong vInt64; 4552 /** 4553 * floating point value 4554 */ 4555 double vFloat; 4556 /** 4557 * hex integer value 4558 */ 4559 gulong vHex; 4560 /** 4561 * string value 4562 */ 4563 char* vString; 4564 /** 4565 * comment value 4566 */ 4567 char* vComment; 4568 /** 4569 * character value 4570 */ 4571 char vChar; 4572 /** 4573 * error value 4574 */ 4575 uint vError; 4576 } 4577 } 4578 4579 /** 4580 * Each piece of memory that is pushed onto the stack 4581 * is cast to a GTrashStack*. 4582 * 4583 * Deprecated: #GTrashStack is deprecated without replacement 4584 */ 4585 struct GTrashStack 4586 { 4587 /** 4588 * pointer to the previous element of the stack, 4589 * gets stored in the first `sizeof (gpointer)` 4590 * bytes of the element 4591 */ 4592 GTrashStack* next; 4593 } 4594 4595 struct GTree; 4596 4597 struct GVariant; 4598 4599 struct GVariantBuilder 4600 { 4601 union U 4602 { 4603 struct S 4604 { 4605 size_t partialMagic; 4606 GVariantType* type; 4607 size_t[14] y; 4608 } 4609 S s; 4610 size_t[16] x; 4611 } 4612 U u; 4613 } 4614 4615 struct GVariantDict 4616 { 4617 union U 4618 { 4619 struct S 4620 { 4621 GVariant* asv; 4622 size_t partialMagic; 4623 size_t[14] y; 4624 } 4625 S s; 4626 size_t[16] x; 4627 } 4628 U u; 4629 } 4630 4631 struct GVariantIter 4632 { 4633 size_t[16] x; 4634 } 4635 4636 struct GVariantType; 4637 4638 struct GModule; 4639 4640 /** 4641 * Prototype of a #GChildWatchSource callback, called when a child 4642 * process has exited. To interpret @status, see the documentation 4643 * for g_spawn_check_exit_status(). 4644 * 4645 * Params: 4646 * pid = the process id of the child process 4647 * status = Status information about the child process, encoded 4648 * in a platform-specific manner 4649 * userData = user data passed to g_child_watch_add() 4650 */ 4651 public alias extern(C) void function(GPid pid, int status, void* userData) GChildWatchFunc; 4652 4653 /** 4654 * Specifies the type of a comparison function used to compare two 4655 * values. The function should return a negative integer if the first 4656 * value comes before the second, 0 if they are equal, or a positive 4657 * integer if the first value comes after the second. 4658 * 4659 * Params: 4660 * a = a value 4661 * b = a value to compare with 4662 * userData = user data 4663 * 4664 * Returns: negative value if @a < @b; zero if @a = @b; positive 4665 * value if @a > @b 4666 */ 4667 public alias extern(C) int function(void* a, void* b, void* userData) GCompareDataFunc; 4668 4669 /** 4670 * Specifies the type of a comparison function used to compare two 4671 * values. The function should return a negative integer if the first 4672 * value comes before the second, 0 if they are equal, or a positive 4673 * integer if the first value comes after the second. 4674 * 4675 * Params: 4676 * a = a value 4677 * b = a value to compare with 4678 * 4679 * Returns: negative value if @a < @b; zero if @a = @b; positive 4680 * value if @a > @b 4681 */ 4682 public alias extern(C) int function(void* a, void* b) GCompareFunc; 4683 4684 /** 4685 * A function of this signature is used to copy the node data 4686 * when doing a deep-copy of a tree. 4687 * 4688 * Params: 4689 * src = A pointer to the data which should be copied 4690 * data = Additional data 4691 * 4692 * Returns: A pointer to the copy 4693 * 4694 * Since: 2.4 4695 */ 4696 public alias extern(C) void* function(void* src, void* data) GCopyFunc; 4697 4698 /** 4699 * Specifies the type of function passed to g_dataset_foreach(). It is 4700 * called with each #GQuark id and associated data element, together 4701 * with the @user_data parameter supplied to g_dataset_foreach(). 4702 * 4703 * Params: 4704 * keyId = the #GQuark id to identifying the data element. 4705 * data = the data element. 4706 * userData = user data passed to g_dataset_foreach(). 4707 */ 4708 public alias extern(C) void function(GQuark keyId, void* data, void* userData) GDataForeachFunc; 4709 4710 /** 4711 * Specifies the type of function which is called when a data element 4712 * is destroyed. It is passed the pointer to the data element and 4713 * should free any memory and resources allocated for it. 4714 * 4715 * Params: 4716 * data = the data element. 4717 */ 4718 public alias extern(C) void function(void* data) GDestroyNotify; 4719 4720 /** 4721 * The type of functions that are used to 'duplicate' an object. 4722 * What this means depends on the context, it could just be 4723 * incrementing the reference count, if @data is a ref-counted 4724 * object. 4725 * 4726 * Params: 4727 * data = the data to duplicate 4728 * userData = user data that was specified in g_datalist_id_dup_data() 4729 * 4730 * Returns: a duplicate of data 4731 */ 4732 public alias extern(C) void* function(void* data, void* userData) GDuplicateFunc; 4733 4734 /** 4735 * Specifies the type of a function used to test two values for 4736 * equality. The function should return %TRUE if both values are equal 4737 * and %FALSE otherwise. 4738 * 4739 * Params: 4740 * a = a value 4741 * b = a value to compare with 4742 * 4743 * Returns: %TRUE if @a = @b; %FALSE otherwise 4744 */ 4745 public alias extern(C) int function(void* a, void* b) GEqualFunc; 4746 4747 /** 4748 * Declares a type of function which takes an arbitrary 4749 * data pointer argument and has no return value. It is 4750 * not currently used in GLib or GTK+. 4751 * 4752 * Params: 4753 * data = a data pointer 4754 */ 4755 public alias extern(C) void function(void* data) GFreeFunc; 4756 4757 /** 4758 * Specifies the type of functions passed to g_list_foreach() and 4759 * g_slist_foreach(). 4760 * 4761 * Params: 4762 * data = the element's data 4763 * userData = user data passed to g_list_foreach() or g_slist_foreach() 4764 */ 4765 public alias extern(C) void function(void* data, void* userData) GFunc; 4766 4767 /** 4768 * Specifies the type of the function passed to g_hash_table_foreach(). 4769 * It is called with each key/value pair, together with the @user_data 4770 * parameter which is passed to g_hash_table_foreach(). 4771 * 4772 * Params: 4773 * key = a key 4774 * value = the value corresponding to the key 4775 * userData = user data passed to g_hash_table_foreach() 4776 */ 4777 public alias extern(C) void function(void* key, void* value, void* userData) GHFunc; 4778 4779 /** 4780 * Specifies the type of the function passed to 4781 * g_hash_table_foreach_remove(). It is called with each key/value 4782 * pair, together with the @user_data parameter passed to 4783 * g_hash_table_foreach_remove(). It should return %TRUE if the 4784 * key/value pair should be removed from the #GHashTable. 4785 * 4786 * Params: 4787 * key = a key 4788 * value = the value associated with the key 4789 * userData = user data passed to g_hash_table_remove() 4790 * 4791 * Returns: %TRUE if the key/value pair should be removed from the 4792 * #GHashTable 4793 */ 4794 public alias extern(C) int function(void* key, void* value, void* userData) GHRFunc; 4795 4796 /** 4797 * Specifies the type of the hash function which is passed to 4798 * g_hash_table_new() when a #GHashTable is created. 4799 * 4800 * The function is passed a key and should return a #guint hash value. 4801 * The functions g_direct_hash(), g_int_hash() and g_str_hash() provide 4802 * hash functions which can be used when the key is a #gpointer, #gint*, 4803 * and #gchar* respectively. 4804 * 4805 * g_direct_hash() is also the appropriate hash function for keys 4806 * of the form `GINT_TO_POINTER (n)` (or similar macros). 4807 * 4808 * <!-- FIXME: Need more here. --> A good hash functions should produce 4809 * hash values that are evenly distributed over a fairly large range. 4810 * The modulus is taken with the hash table size (a prime number) to 4811 * find the 'bucket' to place each key into. The function should also 4812 * be very fast, since it is called for each key lookup. 4813 * 4814 * Note that the hash functions provided by GLib have these qualities, 4815 * but are not particularly robust against manufactured keys that 4816 * cause hash collisions. Therefore, you should consider choosing 4817 * a more secure hash function when using a GHashTable with keys 4818 * that originate in untrusted data (such as HTTP requests). 4819 * Using g_str_hash() in that situation might make your application 4820 * vulerable to 4821 * [Algorithmic Complexity Attacks](https://lwn.net/Articles/474912/). 4822 * 4823 * The key to choosing a good hash is unpredictability. Even 4824 * cryptographic hashes are very easy to find collisions for when the 4825 * remainder is taken modulo a somewhat predictable prime number. There 4826 * must be an element of randomness that an attacker is unable to guess. 4827 * 4828 * Params: 4829 * key = a key 4830 * 4831 * Returns: the hash value corresponding to the key 4832 */ 4833 public alias extern(C) uint function(void* key) GHashFunc; 4834 4835 /** 4836 * Defines the type of a hook function that can be invoked 4837 * by g_hook_list_invoke_check(). 4838 * 4839 * Params: 4840 * data = the data field of the #GHook is passed to the hook function here 4841 * 4842 * Returns: %FALSE if the #GHook should be destroyed 4843 */ 4844 public alias extern(C) int function(void* data) GHookCheckFunc; 4845 4846 /** 4847 * Defines the type of function used by g_hook_list_marshal_check(). 4848 * 4849 * Params: 4850 * hook = a #GHook 4851 * marshalData = user data 4852 * 4853 * Returns: %FALSE if @hook should be destroyed 4854 */ 4855 public alias extern(C) int function(GHook* hook, void* marshalData) GHookCheckMarshaller; 4856 4857 /** 4858 * Defines the type of function used to compare #GHook elements in 4859 * g_hook_insert_sorted(). 4860 * 4861 * Params: 4862 * newHook = the #GHook being inserted 4863 * sibling = the #GHook to compare with @new_hook 4864 * 4865 * Returns: a value <= 0 if @new_hook should be before @sibling 4866 */ 4867 public alias extern(C) int function(GHook* newHook, GHook* sibling) GHookCompareFunc; 4868 4869 /** 4870 * Defines the type of function to be called when a hook in a 4871 * list of hooks gets finalized. 4872 * 4873 * Params: 4874 * hookList = a #GHookList 4875 * hook = the hook in @hook_list that gets finalized 4876 */ 4877 public alias extern(C) void function(GHookList* hookList, GHook* hook) GHookFinalizeFunc; 4878 4879 /** 4880 * Defines the type of the function passed to g_hook_find(). 4881 * 4882 * Params: 4883 * hook = a #GHook 4884 * data = user data passed to g_hook_find_func() 4885 * 4886 * Returns: %TRUE if the required #GHook has been found 4887 */ 4888 public alias extern(C) int function(GHook* hook, void* data) GHookFindFunc; 4889 4890 /** 4891 * Defines the type of a hook function that can be invoked 4892 * by g_hook_list_invoke(). 4893 * 4894 * Params: 4895 * data = the data field of the #GHook is passed to the hook function here 4896 */ 4897 public alias extern(C) void function(void* data) GHookFunc; 4898 4899 /** 4900 * Defines the type of function used by g_hook_list_marshal(). 4901 * 4902 * Params: 4903 * hook = a #GHook 4904 * marshalData = user data 4905 */ 4906 public alias extern(C) void function(GHook* hook, void* marshalData) GHookMarshaller; 4907 4908 /** 4909 * Specifies the type of function passed to g_io_add_watch() or 4910 * g_io_add_watch_full(), which is called when the requested condition 4911 * on a #GIOChannel is satisfied. 4912 * 4913 * Params: 4914 * source = the #GIOChannel event source 4915 * condition = the condition which has been satisfied 4916 * data = user data set in g_io_add_watch() or g_io_add_watch_full() 4917 * 4918 * Returns: the function should return %FALSE if the event source 4919 * should be removed 4920 */ 4921 public alias extern(C) int function(GIOChannel* source, GIOCondition condition, void* data) GIOFunc; 4922 4923 /** 4924 * Specifies the prototype of log handler functions. 4925 * 4926 * The default log handler, g_log_default_handler(), automatically appends a 4927 * new-line character to @message when printing it. It is advised that any 4928 * custom log handler functions behave similarly, so that logging calls in user 4929 * code do not need modifying to add a new-line character to the message if the 4930 * log handler is changed. 4931 * 4932 * This is not used if structured logging is enabled; see 4933 * [Using Structured Logging][using-structured-logging]. 4934 * 4935 * Params: 4936 * logDomain = the log domain of the message 4937 * logLevel = the log level of the message (including the 4938 * fatal and recursion flags) 4939 * message = the message to process 4940 * userData = user data, set in g_log_set_handler() 4941 */ 4942 public alias extern(C) void function(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* message, void* userData) GLogFunc; 4943 4944 /** 4945 * Writer function for log entries. A log entry is a collection of one or more 4946 * #GLogFields, using the standard [field names from journal 4947 * specification](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html). 4948 * See g_log_structured() for more information. 4949 * 4950 * Writer functions must ignore fields which they do not recognise, unless they 4951 * can write arbitrary binary output, as field values may be arbitrary binary. 4952 * 4953 * @log_level is guaranteed to be included in @fields as the `PRIORITY` field, 4954 * but is provided separately for convenience of deciding whether or where to 4955 * output the log entry. 4956 * 4957 * Writer functions should return %G_LOG_WRITER_HANDLED if they handled the log 4958 * message successfully or if they deliberately ignored it. If there was an 4959 * error handling the message (for example, if the writer function is meant to 4960 * send messages to a remote logging server and there is a network error), it 4961 * should return %G_LOG_WRITER_UNHANDLED. This allows writer functions to be 4962 * chained and fall back to simpler handlers in case of failure. 4963 * 4964 * Params: 4965 * logLevel = log level of the message 4966 * fields = fields forming the message 4967 * nFields = number of @fields 4968 * userData = user data passed to g_log_set_writer_func() 4969 * 4970 * Returns: %G_LOG_WRITER_HANDLED if the log entry was handled successfully; 4971 * %G_LOG_WRITER_UNHANDLED otherwise 4972 * 4973 * Since: 2.50 4974 */ 4975 public alias extern(C) GLogWriterOutput function(GLogLevelFlags logLevel, GLogField* fields, size_t nFields, void* userData) GLogWriterFunc; 4976 4977 /** 4978 * Specifies the type of function passed to g_node_children_foreach(). 4979 * The function is called with each child node, together with the user 4980 * data passed to g_node_children_foreach(). 4981 * 4982 * Params: 4983 * node = a #GNode. 4984 * data = user data passed to g_node_children_foreach(). 4985 */ 4986 public alias extern(C) void function(GNode* node, void* data) GNodeForeachFunc; 4987 4988 /** 4989 * Specifies the type of function passed to g_node_traverse(). The 4990 * function is called with each of the nodes visited, together with the 4991 * user data passed to g_node_traverse(). If the function returns 4992 * %TRUE, then the traversal is stopped. 4993 * 4994 * Params: 4995 * node = a #GNode. 4996 * data = user data passed to g_node_traverse(). 4997 * 4998 * Returns: %TRUE to stop the traversal. 4999 */ 5000 public alias extern(C) int function(GNode* node, void* data) GNodeTraverseFunc; 5001 5002 /** 5003 * The type of function to be passed as callback for %G_OPTION_ARG_CALLBACK 5004 * options. 5005 * 5006 * Params: 5007 * optionName = The name of the option being parsed. This will be either a 5008 * single dash followed by a single letter (for a short name) or two dashes 5009 * followed by a long option name. 5010 * value = The value to be parsed. 5011 * data = User data added to the #GOptionGroup containing the option when it 5012 * was created with g_option_group_new() 5013 * 5014 * Returns: %TRUE if the option was successfully parsed, %FALSE if an error 5015 * occurred, in which case @error should be set with g_set_error() 5016 * 5017 * Throws: GException on failure. 5018 */ 5019 public alias extern(C) int function(const(char)* optionName, const(char)* value, void* data, GError** err) GOptionArgFunc; 5020 5021 /** 5022 * The type of function to be used as callback when a parse error occurs. 5023 * 5024 * Params: 5025 * context = The active #GOptionContext 5026 * group = The group to which the function belongs 5027 * data = User data added to the #GOptionGroup containing the option when it 5028 * was created with g_option_group_new() 5029 * 5030 * Throws: GException on failure. 5031 */ 5032 public alias extern(C) void function(GOptionContext* context, GOptionGroup* group, void* data, GError** err) GOptionErrorFunc; 5033 5034 /** 5035 * The type of function that can be called before and after parsing. 5036 * 5037 * Params: 5038 * context = The active #GOptionContext 5039 * group = The group to which the function belongs 5040 * data = User data added to the #GOptionGroup containing the option when it 5041 * was created with g_option_group_new() 5042 * 5043 * Returns: %TRUE if the function completed successfully, %FALSE if an error 5044 * occurred, in which case @error should be set with g_set_error() 5045 * 5046 * Throws: GException on failure. 5047 */ 5048 public alias extern(C) int function(GOptionContext* context, GOptionGroup* group, void* data, GError** err) GOptionParseFunc; 5049 5050 /** 5051 * Specifies the type of function passed to g_main_context_set_poll_func(). 5052 * The semantics of the function should match those of the poll() system call. 5053 * 5054 * Params: 5055 * ufds = an array of #GPollFD elements 5056 * nfsd = the number of elements in @ufds 5057 * timeout = the maximum time to wait for an event of the file descriptors. 5058 * A negative value indicates an infinite timeout. 5059 * 5060 * Returns: the number of #GPollFD elements which have events or errors 5061 * reported, or -1 if an error occurred. 5062 */ 5063 public alias extern(C) int function(GPollFD* ufds, uint nfsd, int timeout) GPollFunc; 5064 5065 /** 5066 * Specifies the type of the print handler functions. 5067 * These are called with the complete formatted string to output. 5068 * 5069 * Params: 5070 * str = the message to output 5071 */ 5072 public alias extern(C) void function(const(char)* str) GPrintFunc; 5073 5074 /** 5075 * Specifies the type of the function passed to g_regex_replace_eval(). 5076 * It is called for each occurrence of the pattern in the string passed 5077 * to g_regex_replace_eval(), and it should append the replacement to 5078 * @result. 5079 * 5080 * Params: 5081 * matchInfo = the #GMatchInfo generated by the match. 5082 * Use g_match_info_get_regex() and g_match_info_get_string() if you 5083 * need the #GRegex or the matched string. 5084 * result = a #GString containing the new string 5085 * userData = user data passed to g_regex_replace_eval() 5086 * 5087 * Returns: %FALSE to continue the replacement process, %TRUE to stop it 5088 * 5089 * Since: 2.14 5090 */ 5091 public alias extern(C) int function(GMatchInfo* matchInfo, GString* result, void* userData) GRegexEvalCallback; 5092 5093 /** 5094 * Specifies the type of the message handler function. 5095 * 5096 * Params: 5097 * scanner = a #GScanner 5098 * message = the message 5099 * error = %TRUE if the message signals an error, 5100 * %FALSE if it signals a warning. 5101 */ 5102 public alias extern(C) void function(GScanner* scanner, char* message, int error) GScannerMsgFunc; 5103 5104 /** 5105 * A #GSequenceIterCompareFunc is a function used to compare iterators. 5106 * It must return zero if the iterators compare equal, a negative value 5107 * if @a comes before @b, and a positive value if @b comes before @a. 5108 * 5109 * Params: 5110 * a = a #GSequenceIter 5111 * b = a #GSequenceIter 5112 * data = user data 5113 * 5114 * Returns: zero if the iterators are equal, a negative value if @a 5115 * comes before @b, and a positive value if @b comes before @a. 5116 */ 5117 public alias extern(C) int function(GSequenceIter* a, GSequenceIter* b, void* data) GSequenceIterCompareFunc; 5118 5119 /** 5120 * This is just a placeholder for #GClosureMarshal, 5121 * which cannot be used here for dependency reasons. 5122 */ 5123 public alias extern(C) void function() GSourceDummyMarshal; 5124 5125 /** 5126 * Specifies the type of function passed to g_timeout_add(), 5127 * g_timeout_add_full(), g_idle_add(), and g_idle_add_full(). 5128 * 5129 * Params: 5130 * userData = data passed to the function, set when the source was 5131 * created with one of the above functions 5132 * 5133 * Returns: %FALSE if the source should be removed. #G_SOURCE_CONTINUE and 5134 * #G_SOURCE_REMOVE are more memorable names for the return value. 5135 */ 5136 public alias extern(C) int function(void* userData) GSourceFunc; 5137 5138 /** 5139 * Specifies the type of the setup function passed to g_spawn_async(), 5140 * g_spawn_sync() and g_spawn_async_with_pipes(), which can, in very 5141 * limited ways, be used to affect the child's execution. 5142 * 5143 * On POSIX platforms, the function is called in the child after GLib 5144 * has performed all the setup it plans to perform, but before calling 5145 * exec(). Actions taken in this function will only affect the child, 5146 * not the parent. 5147 * 5148 * On Windows, the function is called in the parent. Its usefulness on 5149 * Windows is thus questionable. In many cases executing the child setup 5150 * function in the parent can have ill effects, and you should be very 5151 * careful when porting software to Windows that uses child setup 5152 * functions. 5153 * 5154 * However, even on POSIX, you are extremely limited in what you can 5155 * safely do from a #GSpawnChildSetupFunc, because any mutexes that were 5156 * held by other threads in the parent process at the time of the fork() 5157 * will still be locked in the child process, and they will never be 5158 * unlocked (since the threads that held them don't exist in the child). 5159 * POSIX allows only async-signal-safe functions (see signal(7)) to be 5160 * called in the child between fork() and exec(), which drastically limits 5161 * the usefulness of child setup functions. 5162 * 5163 * In particular, it is not safe to call any function which may 5164 * call malloc(), which includes POSIX functions such as setenv(). 5165 * If you need to set up the child environment differently from 5166 * the parent, you should use g_get_environ(), g_environ_setenv(), 5167 * and g_environ_unsetenv(), and then pass the complete environment 5168 * list to the `g_spawn...` function. 5169 * 5170 * Params: 5171 * userData = user data to pass to the function. 5172 */ 5173 public alias extern(C) void function(void* userData) GSpawnChildSetupFunc; 5174 5175 /** 5176 * The type used for test case functions that take an extra pointer 5177 * argument. 5178 * 5179 * Params: 5180 * userData = the data provided when registering the test 5181 * 5182 * Since: 2.28 5183 */ 5184 public alias extern(C) void function(void* userData) GTestDataFunc; 5185 5186 /** 5187 * The type used for functions that operate on test fixtures. This is 5188 * used for the fixture setup and teardown functions as well as for the 5189 * testcases themselves. 5190 * 5191 * @user_data is a pointer to the data that was given when registering 5192 * the test case. 5193 * 5194 * @fixture will be a pointer to the area of memory allocated by the 5195 * test framework, of the size requested. If the requested size was 5196 * zero then @fixture will be equal to @user_data. 5197 * 5198 * Params: 5199 * fixture = the test fixture 5200 * userData = the data provided when registering the test 5201 * 5202 * Since: 2.28 5203 */ 5204 public alias extern(C) void function(void* fixture, void* userData) GTestFixtureFunc; 5205 5206 /** 5207 * The type used for test case functions. 5208 * 5209 * Since: 2.28 5210 */ 5211 public alias extern(C) void function() GTestFunc; 5212 5213 /** 5214 * Specifies the prototype of fatal log handler functions. 5215 * 5216 * Params: 5217 * logDomain = the log domain of the message 5218 * logLevel = the log level of the message (including the fatal and recursion flags) 5219 * message = the message to process 5220 * userData = user data, set in g_test_log_set_fatal_handler() 5221 * 5222 * Returns: %TRUE if the program should abort, %FALSE otherwise 5223 * 5224 * Since: 2.22 5225 */ 5226 public alias extern(C) int function(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* message, void* userData) GTestLogFatalFunc; 5227 5228 /** 5229 * Specifies the type of the @func functions passed to g_thread_new() 5230 * or g_thread_try_new(). 5231 * 5232 * Params: 5233 * data = data passed to the thread 5234 * 5235 * Returns: the return value of the thread 5236 */ 5237 public alias extern(C) void* function(void* data) GThreadFunc; 5238 5239 /** 5240 * The type of functions which are used to translate user-visible 5241 * strings, for <option>--help</option> output. 5242 * 5243 * Params: 5244 * str = the untranslated string 5245 * data = user data specified when installing the function, e.g. 5246 * in g_option_group_set_translate_func() 5247 * 5248 * Returns: a translation of the string for the current locale. 5249 * The returned string is owned by GLib and must not be freed. 5250 */ 5251 public alias extern(C) const(char)* function(const(char)* str, void* data) GTranslateFunc; 5252 5253 /** 5254 * Specifies the type of function passed to g_tree_traverse(). It is 5255 * passed the key and value of each node, together with the @user_data 5256 * parameter passed to g_tree_traverse(). If the function returns 5257 * %TRUE, the traversal is stopped. 5258 * 5259 * Params: 5260 * key = a key of a #GTree node 5261 * value = the value corresponding to the key 5262 * data = user data passed to g_tree_traverse() 5263 * 5264 * Returns: %TRUE to stop the traversal 5265 */ 5266 public alias extern(C) int function(void* key, void* value, void* data) GTraverseFunc; 5267 5268 /** 5269 * The type of functions to be called when a UNIX fd watch source 5270 * triggers. 5271 * 5272 * Params: 5273 * fd = the fd that triggered the event 5274 * condition = the IO conditions reported on @fd 5275 * userData = user data passed to g_unix_fd_add() 5276 * 5277 * Returns: %FALSE if the source should be removed 5278 */ 5279 public alias extern(C) int function(int fd, GIOCondition condition, void* userData) GUnixFDSourceFunc; 5280 5281 /** 5282 * Declares a type of function which takes no arguments 5283 * and has no return value. It is used to specify the type 5284 * function passed to g_atexit(). 5285 */ 5286 public alias extern(C) void function() GVoidFunc; 5287 5288 /** 5289 * Specifies the type of the module initialization function. 5290 * If a module contains a function named g_module_check_init() it is called 5291 * automatically when the module is loaded. It is passed the #GModule structure 5292 * and should return %NULL on success or a string describing the initialization 5293 * error. 5294 * 5295 * Params: 5296 * modul = the #GModule corresponding to the module which has just been loaded 5297 * 5298 * Returns: %NULL on success, or a string describing the initialization error 5299 */ 5300 public alias extern(C) const(char)* function(GModule* modul) GModuleCheckInit; 5301 5302 /** 5303 * Specifies the type of the module function called when it is unloaded. 5304 * If a module contains a function named g_module_unload() it is called 5305 * automatically when the module is unloaded. 5306 * It is passed the #GModule structure. 5307 * 5308 * Params: 5309 * modul = the #GModule about to be unloaded 5310 */ 5311 public alias extern(C) void function(GModule* modul) GModuleUnload; 5312 5313 enum ANALYZER_ANALYZING = 1; 5314 alias G_ANALYZER_ANALYZING = ANALYZER_ANALYZING; 5315 5316 /** 5317 * A good size for a buffer to be passed into g_ascii_dtostr(). 5318 * It is guaranteed to be enough for all output of that function 5319 * on systems with 64bit IEEE-compatible doubles. 5320 * 5321 * The typical usage would be something like: 5322 * |[<!-- language="C" --> 5323 * char buf[G_ASCII_DTOSTR_BUF_SIZE]; 5324 * 5325 * fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value)); 5326 * ]| 5327 */ 5328 enum ASCII_DTOSTR_BUF_SIZE = 39; 5329 alias G_ASCII_DTOSTR_BUF_SIZE = ASCII_DTOSTR_BUF_SIZE; 5330 5331 /** 5332 * Specifies one of the possible types of byte order. 5333 * See #G_BYTE_ORDER. 5334 */ 5335 enum BIG_ENDIAN = 4321; 5336 alias G_BIG_ENDIAN = BIG_ENDIAN; 5337 5338 /** 5339 * The set of uppercase ASCII alphabet characters. 5340 * Used for specifying valid identifier characters 5341 * in #GScannerConfig. 5342 */ 5343 enum CSET_A_2_Z = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 5344 alias G_CSET_A_2_Z = CSET_A_2_Z; 5345 5346 /** 5347 * The set of ASCII digits. 5348 * Used for specifying valid identifier characters 5349 * in #GScannerConfig. 5350 */ 5351 enum CSET_DIGITS = "0123456789"; 5352 alias G_CSET_DIGITS = CSET_DIGITS; 5353 5354 /** 5355 * The set of lowercase ASCII alphabet characters. 5356 * Used for specifying valid identifier characters 5357 * in #GScannerConfig. 5358 */ 5359 enum CSET_a_2_z = "abcdefghijklmnopqrstuvwxyz"; 5360 alias G_CSET_a_2_z = CSET_a_2_z; 5361 5362 /** 5363 * A bitmask that restricts the possible flags passed to 5364 * g_datalist_set_flags(). Passing a flags value where 5365 * flags & ~G_DATALIST_FLAGS_MASK != 0 is an error. 5366 */ 5367 enum DATALIST_FLAGS_MASK = 3; 5368 alias G_DATALIST_FLAGS_MASK = DATALIST_FLAGS_MASK; 5369 5370 /** 5371 * Represents an invalid #GDateDay. 5372 */ 5373 enum DATE_BAD_DAY = 0; 5374 alias G_DATE_BAD_DAY = DATE_BAD_DAY; 5375 5376 /** 5377 * Represents an invalid Julian day number. 5378 */ 5379 enum DATE_BAD_JULIAN = 0; 5380 alias G_DATE_BAD_JULIAN = DATE_BAD_JULIAN; 5381 5382 /** 5383 * Represents an invalid year. 5384 */ 5385 enum DATE_BAD_YEAR = 0; 5386 alias G_DATE_BAD_YEAR = DATE_BAD_YEAR; 5387 5388 /** 5389 * This is the platform dependent conversion specifier for scanning and 5390 * printing values of type #gint16. It is a string literal, but doesn't 5391 * include the percent-sign, such that you can add precision and length 5392 * modifiers between percent-sign and conversion specifier. 5393 * 5394 * |[<!-- language="C" --> 5395 * gint16 in; 5396 * gint32 out; 5397 * sscanf ("42", "%" G_GINT16_FORMAT, &in) 5398 * out = in * 1000; 5399 * g_print ("%" G_GINT32_FORMAT, out); 5400 * ]| 5401 */ 5402 enum GINT16_FORMAT = "hi"; 5403 alias G_GINT16_FORMAT = GINT16_FORMAT; 5404 5405 /** 5406 * The platform dependent length modifier for conversion specifiers 5407 * for scanning and printing values of type #gint16 or #guint16. It 5408 * is a string literal, but doesn't include the percent-sign, such 5409 * that you can add precision and length modifiers between percent-sign 5410 * and conversion specifier and append a conversion specifier. 5411 * 5412 * The following example prints "0x7b"; 5413 * |[<!-- language="C" --> 5414 * gint16 value = 123; 5415 * g_print ("%#" G_GINT16_MODIFIER "x", value); 5416 * ]| 5417 */ 5418 enum GINT16_MODIFIER = "h"; 5419 alias G_GINT16_MODIFIER = GINT16_MODIFIER; 5420 5421 /** 5422 * This is the platform dependent conversion specifier for scanning 5423 * and printing values of type #gint32. See also #G_GINT16_FORMAT. 5424 */ 5425 enum GINT32_FORMAT = "i"; 5426 alias G_GINT32_FORMAT = GINT32_FORMAT; 5427 5428 /** 5429 * The platform dependent length modifier for conversion specifiers 5430 * for scanning and printing values of type #gint32 or #guint32. It 5431 * is a string literal. See also #G_GINT16_MODIFIER. 5432 */ 5433 enum GINT32_MODIFIER = ""; 5434 alias G_GINT32_MODIFIER = GINT32_MODIFIER; 5435 5436 /** 5437 * This is the platform dependent conversion specifier for scanning 5438 * and printing values of type #gint64. See also #G_GINT16_FORMAT. 5439 * 5440 * Some platforms do not support scanning and printing 64-bit integers, 5441 * even though the types are supported. On such platforms %G_GINT64_FORMAT 5442 * is not defined. Note that scanf() may not support 64-bit integers, even 5443 * if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf() 5444 * is not recommended for parsing anyway; consider using g_ascii_strtoull() 5445 * instead. 5446 */ 5447 enum GINT64_FORMAT = "li"; 5448 alias G_GINT64_FORMAT = GINT64_FORMAT; 5449 5450 /** 5451 * The platform dependent length modifier for conversion specifiers 5452 * for scanning and printing values of type #gint64 or #guint64. 5453 * It is a string literal. 5454 * 5455 * Some platforms do not support printing 64-bit integers, even 5456 * though the types are supported. On such platforms %G_GINT64_MODIFIER 5457 * is not defined. 5458 */ 5459 enum GINT64_MODIFIER = "l"; 5460 alias G_GINT64_MODIFIER = GINT64_MODIFIER; 5461 5462 /** 5463 * This is the platform dependent conversion specifier for scanning 5464 * and printing values of type #gintptr. 5465 */ 5466 enum GINTPTR_FORMAT = "li"; 5467 alias G_GINTPTR_FORMAT = GINTPTR_FORMAT; 5468 5469 /** 5470 * The platform dependent length modifier for conversion specifiers 5471 * for scanning and printing values of type #gintptr or #guintptr. 5472 * It is a string literal. 5473 */ 5474 enum GINTPTR_MODIFIER = "l"; 5475 alias G_GINTPTR_MODIFIER = GINTPTR_MODIFIER; 5476 5477 /** 5478 * Expands to "" on all modern compilers, and to __FUNCTION__ on gcc 5479 * version 2.x. Don't use it. 5480 * 5481 * Deprecated: Use G_STRFUNC() instead 5482 */ 5483 enum GNUC_FUNCTION = ""; 5484 alias G_GNUC_FUNCTION = GNUC_FUNCTION; 5485 5486 /** 5487 * Expands to "" on all modern compilers, and to __PRETTY_FUNCTION__ 5488 * on gcc version 2.x. Don't use it. 5489 * 5490 * Deprecated: Use G_STRFUNC() instead 5491 */ 5492 enum GNUC_PRETTY_FUNCTION = ""; 5493 alias G_GNUC_PRETTY_FUNCTION = GNUC_PRETTY_FUNCTION; 5494 5495 /** 5496 * This is the platform dependent conversion specifier for scanning 5497 * and printing values of type #gsize. See also #G_GINT16_FORMAT. 5498 */ 5499 enum GSIZE_FORMAT = "lu"; 5500 alias G_GSIZE_FORMAT = GSIZE_FORMAT; 5501 5502 /** 5503 * The platform dependent length modifier for conversion specifiers 5504 * for scanning and printing values of type #gsize. It 5505 * is a string literal. 5506 */ 5507 enum GSIZE_MODIFIER = "l"; 5508 alias G_GSIZE_MODIFIER = GSIZE_MODIFIER; 5509 5510 /** 5511 * This is the platform dependent conversion specifier for scanning 5512 * and printing values of type #gssize. See also #G_GINT16_FORMAT. 5513 */ 5514 enum GSSIZE_FORMAT = "li"; 5515 alias G_GSSIZE_FORMAT = GSSIZE_FORMAT; 5516 5517 /** 5518 * The platform dependent length modifier for conversion specifiers 5519 * for scanning and printing values of type #gssize. It 5520 * is a string literal. 5521 */ 5522 enum GSSIZE_MODIFIER = "l"; 5523 alias G_GSSIZE_MODIFIER = GSSIZE_MODIFIER; 5524 5525 /** 5526 * This is the platform dependent conversion specifier for scanning 5527 * and printing values of type #guint16. See also #G_GINT16_FORMAT 5528 */ 5529 enum GUINT16_FORMAT = "hu"; 5530 alias G_GUINT16_FORMAT = GUINT16_FORMAT; 5531 5532 /** 5533 * This is the platform dependent conversion specifier for scanning 5534 * and printing values of type #guint32. See also #G_GINT16_FORMAT. 5535 */ 5536 enum GUINT32_FORMAT = "u"; 5537 alias G_GUINT32_FORMAT = GUINT32_FORMAT; 5538 5539 /** 5540 * This is the platform dependent conversion specifier for scanning 5541 * and printing values of type #guint64. See also #G_GINT16_FORMAT. 5542 * 5543 * Some platforms do not support scanning and printing 64-bit integers, 5544 * even though the types are supported. On such platforms %G_GUINT64_FORMAT 5545 * is not defined. Note that scanf() may not support 64-bit integers, even 5546 * if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf() 5547 * is not recommended for parsing anyway; consider using g_ascii_strtoull() 5548 * instead. 5549 */ 5550 enum GUINT64_FORMAT = "lu"; 5551 alias G_GUINT64_FORMAT = GUINT64_FORMAT; 5552 5553 /** 5554 * This is the platform dependent conversion specifier 5555 * for scanning and printing values of type #guintptr. 5556 */ 5557 enum GUINTPTR_FORMAT = "lu"; 5558 alias G_GUINTPTR_FORMAT = GUINTPTR_FORMAT; 5559 5560 enum HAVE_GINT64 = 1; 5561 alias G_HAVE_GINT64 = HAVE_GINT64; 5562 5563 enum HAVE_GNUC_VARARGS = 1; 5564 alias G_HAVE_GNUC_VARARGS = HAVE_GNUC_VARARGS; 5565 5566 /** 5567 * Defined to 1 if gcc-style visibility handling is supported. 5568 */ 5569 enum HAVE_GNUC_VISIBILITY = 1; 5570 alias G_HAVE_GNUC_VISIBILITY = HAVE_GNUC_VISIBILITY; 5571 5572 enum HAVE_GROWING_STACK = 0; 5573 alias G_HAVE_GROWING_STACK = HAVE_GROWING_STACK; 5574 5575 enum HAVE_ISO_VARARGS = 1; 5576 alias G_HAVE_ISO_VARARGS = HAVE_ISO_VARARGS; 5577 5578 /** 5579 * The position of the first bit which is not reserved for internal 5580 * use be the #GHook implementation, i.e. 5581 * `1 << G_HOOK_FLAG_USER_SHIFT` is the first 5582 * bit which can be used for application-defined flags. 5583 */ 5584 enum HOOK_FLAG_USER_SHIFT = 4; 5585 alias G_HOOK_FLAG_USER_SHIFT = HOOK_FLAG_USER_SHIFT; 5586 5587 /** 5588 * The bias by which exponents in double-precision floats are offset. 5589 */ 5590 enum IEEE754_DOUBLE_BIAS = 1023; 5591 alias G_IEEE754_DOUBLE_BIAS = IEEE754_DOUBLE_BIAS; 5592 5593 /** 5594 * The bias by which exponents in single-precision floats are offset. 5595 */ 5596 enum IEEE754_FLOAT_BIAS = 127; 5597 alias G_IEEE754_FLOAT_BIAS = IEEE754_FLOAT_BIAS; 5598 5599 /** 5600 * The name of the main group of a desktop entry file, as defined in the 5601 * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec). 5602 * Consult the specification for more 5603 * details about the meanings of the keys below. 5604 */ 5605 enum KEY_FILE_DESKTOP_GROUP = "Desktop Entry"; 5606 alias G_KEY_FILE_DESKTOP_GROUP = KEY_FILE_DESKTOP_GROUP; 5607 5608 /** 5609 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string list 5610 * giving the available application actions. 5611 */ 5612 enum KEY_FILE_DESKTOP_KEY_ACTIONS = "Actions"; 5613 alias G_KEY_FILE_DESKTOP_KEY_ACTIONS = KEY_FILE_DESKTOP_KEY_ACTIONS; 5614 5615 /** 5616 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list 5617 * of strings giving the categories in which the desktop entry 5618 * should be shown in a menu. 5619 */ 5620 enum KEY_FILE_DESKTOP_KEY_CATEGORIES = "Categories"; 5621 alias G_KEY_FILE_DESKTOP_KEY_CATEGORIES = KEY_FILE_DESKTOP_KEY_CATEGORIES; 5622 5623 /** 5624 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized 5625 * string giving the tooltip for the desktop entry. 5626 */ 5627 enum KEY_FILE_DESKTOP_KEY_COMMENT = "Comment"; 5628 alias G_KEY_FILE_DESKTOP_KEY_COMMENT = KEY_FILE_DESKTOP_KEY_COMMENT; 5629 5630 /** 5631 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean set to true 5632 * if the application is D-Bus activatable. 5633 */ 5634 enum KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE = "DBusActivatable"; 5635 alias G_KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE = KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE; 5636 5637 /** 5638 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string 5639 * giving the command line to execute. It is only valid for desktop 5640 * entries with the `Application` type. 5641 */ 5642 enum KEY_FILE_DESKTOP_KEY_EXEC = "Exec"; 5643 alias G_KEY_FILE_DESKTOP_KEY_EXEC = KEY_FILE_DESKTOP_KEY_EXEC; 5644 5645 /** 5646 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized 5647 * string giving the generic name of the desktop entry. 5648 */ 5649 enum KEY_FILE_DESKTOP_KEY_GENERIC_NAME = "GenericName"; 5650 alias G_KEY_FILE_DESKTOP_KEY_GENERIC_NAME = KEY_FILE_DESKTOP_KEY_GENERIC_NAME; 5651 5652 /** 5653 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean 5654 * stating whether the desktop entry has been deleted by the user. 5655 */ 5656 enum KEY_FILE_DESKTOP_KEY_HIDDEN = "Hidden"; 5657 alias G_KEY_FILE_DESKTOP_KEY_HIDDEN = KEY_FILE_DESKTOP_KEY_HIDDEN; 5658 5659 /** 5660 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized 5661 * string giving the name of the icon to be displayed for the desktop 5662 * entry. 5663 */ 5664 enum KEY_FILE_DESKTOP_KEY_ICON = "Icon"; 5665 alias G_KEY_FILE_DESKTOP_KEY_ICON = KEY_FILE_DESKTOP_KEY_ICON; 5666 5667 /** 5668 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list 5669 * of strings giving the MIME types supported by this desktop entry. 5670 */ 5671 enum KEY_FILE_DESKTOP_KEY_MIME_TYPE = "MimeType"; 5672 alias G_KEY_FILE_DESKTOP_KEY_MIME_TYPE = KEY_FILE_DESKTOP_KEY_MIME_TYPE; 5673 5674 /** 5675 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized 5676 * string giving the specific name of the desktop entry. 5677 */ 5678 enum KEY_FILE_DESKTOP_KEY_NAME = "Name"; 5679 alias G_KEY_FILE_DESKTOP_KEY_NAME = KEY_FILE_DESKTOP_KEY_NAME; 5680 5681 /** 5682 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list of 5683 * strings identifying the environments that should not display the 5684 * desktop entry. 5685 */ 5686 enum KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN = "NotShowIn"; 5687 alias G_KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN = KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN; 5688 5689 /** 5690 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean 5691 * stating whether the desktop entry should be shown in menus. 5692 */ 5693 enum KEY_FILE_DESKTOP_KEY_NO_DISPLAY = "NoDisplay"; 5694 alias G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY = KEY_FILE_DESKTOP_KEY_NO_DISPLAY; 5695 5696 /** 5697 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list of 5698 * strings identifying the environments that should display the 5699 * desktop entry. 5700 */ 5701 enum KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN = "OnlyShowIn"; 5702 alias G_KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN = KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN; 5703 5704 /** 5705 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string 5706 * containing the working directory to run the program in. It is only 5707 * valid for desktop entries with the `Application` type. 5708 */ 5709 enum KEY_FILE_DESKTOP_KEY_PATH = "Path"; 5710 alias G_KEY_FILE_DESKTOP_KEY_PATH = KEY_FILE_DESKTOP_KEY_PATH; 5711 5712 /** 5713 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean 5714 * stating whether the application supports the 5715 * [Startup Notification Protocol Specification](http://www.freedesktop.org/Standards/startup-notification-spec). 5716 */ 5717 enum KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY = "StartupNotify"; 5718 alias G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY = KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY; 5719 5720 /** 5721 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is string 5722 * identifying the WM class or name hint of a window that the application 5723 * will create, which can be used to emulate Startup Notification with 5724 * older applications. 5725 */ 5726 enum KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS = "StartupWMClass"; 5727 alias G_KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS = KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS; 5728 5729 /** 5730 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean 5731 * stating whether the program should be run in a terminal window. 5732 * It is only valid for desktop entries with the 5733 * `Application` type. 5734 */ 5735 enum KEY_FILE_DESKTOP_KEY_TERMINAL = "Terminal"; 5736 alias G_KEY_FILE_DESKTOP_KEY_TERMINAL = KEY_FILE_DESKTOP_KEY_TERMINAL; 5737 5738 /** 5739 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string 5740 * giving the file name of a binary on disk used to determine if the 5741 * program is actually installed. It is only valid for desktop entries 5742 * with the `Application` type. 5743 */ 5744 enum KEY_FILE_DESKTOP_KEY_TRY_EXEC = "TryExec"; 5745 alias G_KEY_FILE_DESKTOP_KEY_TRY_EXEC = KEY_FILE_DESKTOP_KEY_TRY_EXEC; 5746 5747 /** 5748 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string 5749 * giving the type of the desktop entry. Usually 5750 * #G_KEY_FILE_DESKTOP_TYPE_APPLICATION, 5751 * #G_KEY_FILE_DESKTOP_TYPE_LINK, or 5752 * #G_KEY_FILE_DESKTOP_TYPE_DIRECTORY. 5753 */ 5754 enum KEY_FILE_DESKTOP_KEY_TYPE = "Type"; 5755 alias G_KEY_FILE_DESKTOP_KEY_TYPE = KEY_FILE_DESKTOP_KEY_TYPE; 5756 5757 /** 5758 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string 5759 * giving the URL to access. It is only valid for desktop entries 5760 * with the `Link` type. 5761 */ 5762 enum KEY_FILE_DESKTOP_KEY_URL = "URL"; 5763 alias G_KEY_FILE_DESKTOP_KEY_URL = KEY_FILE_DESKTOP_KEY_URL; 5764 5765 /** 5766 * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string 5767 * giving the version of the Desktop Entry Specification used for 5768 * the desktop entry file. 5769 */ 5770 enum KEY_FILE_DESKTOP_KEY_VERSION = "Version"; 5771 alias G_KEY_FILE_DESKTOP_KEY_VERSION = KEY_FILE_DESKTOP_KEY_VERSION; 5772 5773 /** 5774 * The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop 5775 * entries representing applications. 5776 */ 5777 enum KEY_FILE_DESKTOP_TYPE_APPLICATION = "Application"; 5778 alias G_KEY_FILE_DESKTOP_TYPE_APPLICATION = KEY_FILE_DESKTOP_TYPE_APPLICATION; 5779 5780 /** 5781 * The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop 5782 * entries representing directories. 5783 */ 5784 enum KEY_FILE_DESKTOP_TYPE_DIRECTORY = "Directory"; 5785 alias G_KEY_FILE_DESKTOP_TYPE_DIRECTORY = KEY_FILE_DESKTOP_TYPE_DIRECTORY; 5786 5787 /** 5788 * The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop 5789 * entries representing links to documents. 5790 */ 5791 enum KEY_FILE_DESKTOP_TYPE_LINK = "Link"; 5792 alias G_KEY_FILE_DESKTOP_TYPE_LINK = KEY_FILE_DESKTOP_TYPE_LINK; 5793 5794 /** 5795 * Specifies one of the possible types of byte order. 5796 * See #G_BYTE_ORDER. 5797 */ 5798 enum LITTLE_ENDIAN = 1234; 5799 alias G_LITTLE_ENDIAN = LITTLE_ENDIAN; 5800 5801 /** 5802 * Defines the log domain. 5803 * 5804 * Libraries should define this so that any messages 5805 * which they log can be differentiated from messages from other 5806 * libraries and application code. But be careful not to define 5807 * it in any public header files. 5808 * 5809 * For example, GTK+ uses this in its Makefile.am: 5810 * |[ 5811 * AM_CPPFLAGS = -DG_LOG_DOMAIN=\"Gtk\" 5812 * ]| 5813 * 5814 * Applications can choose to leave it as the default %NULL (or "") 5815 * domain. However, defining the domain offers the same advantages as 5816 * above. 5817 */ 5818 enum LOG_DOMAIN = 0; 5819 alias G_LOG_DOMAIN = LOG_DOMAIN; 5820 5821 /** 5822 * GLib log levels that are considered fatal by default. 5823 * 5824 * This is not used if structured logging is enabled; see 5825 * [Using Structured Logging][using-structured-logging]. 5826 */ 5827 enum LOG_FATAL_MASK = 0; 5828 alias G_LOG_FATAL_MASK = LOG_FATAL_MASK; 5829 5830 /** 5831 * Log levels below 1<<G_LOG_LEVEL_USER_SHIFT are used by GLib. 5832 * Higher bits can be used for user-defined log levels. 5833 */ 5834 enum LOG_LEVEL_USER_SHIFT = 8; 5835 alias G_LOG_LEVEL_USER_SHIFT = LOG_LEVEL_USER_SHIFT; 5836 5837 /** 5838 * The major version number of the GLib library. 5839 * 5840 * Like #glib_major_version, but from the headers used at 5841 * application compile time, rather than from the library 5842 * linked against at application run time. 5843 */ 5844 enum MAJOR_VERSION = 2; 5845 alias GLIB_MAJOR_VERSION = MAJOR_VERSION; 5846 5847 /** 5848 * The maximum value which can be held in a #gint16. 5849 */ 5850 enum MAXINT16 = 32767; 5851 alias G_MAXINT16 = MAXINT16; 5852 5853 /** 5854 * The maximum value which can be held in a #gint32. 5855 */ 5856 enum MAXINT32 = 2147483647; 5857 alias G_MAXINT32 = MAXINT32; 5858 5859 /** 5860 * The maximum value which can be held in a #gint64. 5861 */ 5862 enum MAXINT64 = 9223372036854775807UL; 5863 alias G_MAXINT64 = MAXINT64; 5864 5865 /** 5866 * The maximum value which can be held in a #gint8. 5867 */ 5868 enum MAXINT8 = 127; 5869 alias G_MAXINT8 = MAXINT8; 5870 5871 /** 5872 * The maximum value which can be held in a #guint16. 5873 */ 5874 enum MAXUINT16 = 65535; 5875 alias G_MAXUINT16 = MAXUINT16; 5876 5877 /** 5878 * The maximum value which can be held in a #guint32. 5879 */ 5880 enum MAXUINT32 = 4294967295; 5881 alias G_MAXUINT32 = MAXUINT32; 5882 5883 /** 5884 * The maximum value which can be held in a #guint64. 5885 */ 5886 enum MAXUINT64 = 18446744073709551615UL; 5887 alias G_MAXUINT64 = MAXUINT64; 5888 5889 /** 5890 * The maximum value which can be held in a #guint8. 5891 */ 5892 enum MAXUINT8 = 255; 5893 alias G_MAXUINT8 = MAXUINT8; 5894 5895 /** 5896 * The micro version number of the GLib library. 5897 * 5898 * Like #gtk_micro_version, but from the headers used at 5899 * application compile time, rather than from the library 5900 * linked against at application run time. 5901 */ 5902 enum MICRO_VERSION = 0; 5903 alias GLIB_MICRO_VERSION = MICRO_VERSION; 5904 5905 /** 5906 * The minimum value which can be held in a #gint16. 5907 */ 5908 enum MININT16 = -32768; 5909 alias G_MININT16 = MININT16; 5910 5911 /** 5912 * The minimum value which can be held in a #gint32. 5913 */ 5914 enum MININT32 = -2147483648; 5915 alias G_MININT32 = MININT32; 5916 5917 /** 5918 * The minimum value which can be held in a #gint64. 5919 */ 5920 enum MININT64 = -9223372036854775808UL; 5921 alias G_MININT64 = MININT64; 5922 5923 /** 5924 * The minimum value which can be held in a #gint8. 5925 */ 5926 enum MININT8 = -128; 5927 alias G_MININT8 = MININT8; 5928 5929 /** 5930 * The minor version number of the GLib library. 5931 * 5932 * Like #gtk_minor_version, but from the headers used at 5933 * application compile time, rather than from the library 5934 * linked against at application run time. 5935 */ 5936 enum MINOR_VERSION = 54; 5937 alias GLIB_MINOR_VERSION = MINOR_VERSION; 5938 5939 enum MODULE_SUFFIX = "so"; 5940 alias G_MODULE_SUFFIX = MODULE_SUFFIX; 5941 5942 /** 5943 * If a long option in the main group has this name, it is not treated as a 5944 * regular option. Instead it collects all non-option arguments which would 5945 * otherwise be left in `argv`. The option must be of type 5946 * %G_OPTION_ARG_CALLBACK, %G_OPTION_ARG_STRING_ARRAY 5947 * or %G_OPTION_ARG_FILENAME_ARRAY. 5948 * 5949 * 5950 * Using #G_OPTION_REMAINING instead of simply scanning `argv` 5951 * for leftover arguments has the advantage that GOption takes care of 5952 * necessary encoding conversions for strings or filenames. 5953 */ 5954 enum OPTION_REMAINING = ""; 5955 alias G_OPTION_REMAINING = OPTION_REMAINING; 5956 5957 /** 5958 * Specifies one of the possible types of byte order 5959 * (currently unused). See #G_BYTE_ORDER. 5960 */ 5961 enum PDP_ENDIAN = 3412; 5962 alias G_PDP_ENDIAN = PDP_ENDIAN; 5963 5964 /** 5965 * A format specifier that can be used in printf()-style format strings 5966 * when printing a #GPid. 5967 */ 5968 enum PID_FORMAT = "i"; 5969 alias G_PID_FORMAT = PID_FORMAT; 5970 5971 /** 5972 * A format specifier that can be used in printf()-style format strings 5973 * when printing the @fd member of a #GPollFD. 5974 */ 5975 enum POLLFD_FORMAT = "%d"; 5976 alias G_POLLFD_FORMAT = POLLFD_FORMAT; 5977 5978 /** 5979 * Use this for default priority event sources. 5980 * 5981 * In GLib this priority is used when adding timeout functions 5982 * with g_timeout_add(). In GDK this priority is used for events 5983 * from the X server. 5984 */ 5985 enum PRIORITY_DEFAULT = 0; 5986 alias G_PRIORITY_DEFAULT = PRIORITY_DEFAULT; 5987 5988 /** 5989 * Use this for default priority idle functions. 5990 * 5991 * In GLib this priority is used when adding idle functions with 5992 * g_idle_add(). 5993 */ 5994 enum PRIORITY_DEFAULT_IDLE = 200; 5995 alias G_PRIORITY_DEFAULT_IDLE = PRIORITY_DEFAULT_IDLE; 5996 5997 /** 5998 * Use this for high priority event sources. 5999 * 6000 * It is not used within GLib or GTK+. 6001 */ 6002 enum PRIORITY_HIGH = -100; 6003 alias G_PRIORITY_HIGH = PRIORITY_HIGH; 6004 6005 /** 6006 * Use this for high priority idle functions. 6007 * 6008 * GTK+ uses #G_PRIORITY_HIGH_IDLE + 10 for resizing operations, 6009 * and #G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is 6010 * done to ensure that any pending resizes are processed before any 6011 * pending redraws, so that widgets are not redrawn twice unnecessarily.) 6012 */ 6013 enum PRIORITY_HIGH_IDLE = 100; 6014 alias G_PRIORITY_HIGH_IDLE = PRIORITY_HIGH_IDLE; 6015 6016 /** 6017 * Use this for very low priority background tasks. 6018 * 6019 * It is not used within GLib or GTK+. 6020 */ 6021 enum PRIORITY_LOW = 300; 6022 alias G_PRIORITY_LOW = PRIORITY_LOW; 6023 6024 enum SIZEOF_LONG = 8; 6025 alias GLIB_SIZEOF_LONG = SIZEOF_LONG; 6026 6027 enum SIZEOF_SIZE_T = 8; 6028 alias GLIB_SIZEOF_SIZE_T = SIZEOF_SIZE_T; 6029 6030 enum SIZEOF_SSIZE_T = 8; 6031 alias GLIB_SIZEOF_SSIZE_T = SIZEOF_SSIZE_T; 6032 6033 enum SIZEOF_VOID_P = 8; 6034 alias GLIB_SIZEOF_VOID_P = SIZEOF_VOID_P; 6035 6036 /** 6037 * Use this macro as the return value of a #GSourceFunc to leave 6038 * the #GSource in the main loop. 6039 */ 6040 enum SOURCE_CONTINUE = true; 6041 alias G_SOURCE_CONTINUE = SOURCE_CONTINUE; 6042 6043 /** 6044 * Use this macro as the return value of a #GSourceFunc to remove 6045 * the #GSource from the main loop. 6046 */ 6047 enum SOURCE_REMOVE = false; 6048 alias G_SOURCE_REMOVE = SOURCE_REMOVE; 6049 6050 /** 6051 * The standard delimiters, used in g_strdelimit(). 6052 */ 6053 enum STR_DELIMITERS = "_-|> <."; 6054 alias G_STR_DELIMITERS = STR_DELIMITERS; 6055 6056 enum SYSDEF_AF_INET = 2; 6057 alias GLIB_SYSDEF_AF_INET = SYSDEF_AF_INET; 6058 6059 enum SYSDEF_AF_INET6 = 10; 6060 alias GLIB_SYSDEF_AF_INET6 = SYSDEF_AF_INET6; 6061 6062 enum SYSDEF_AF_UNIX = 1; 6063 alias GLIB_SYSDEF_AF_UNIX = SYSDEF_AF_UNIX; 6064 6065 enum SYSDEF_MSG_DONTROUTE = 4; 6066 alias GLIB_SYSDEF_MSG_DONTROUTE = SYSDEF_MSG_DONTROUTE; 6067 6068 enum SYSDEF_MSG_OOB = 1; 6069 alias GLIB_SYSDEF_MSG_OOB = SYSDEF_MSG_OOB; 6070 6071 enum SYSDEF_MSG_PEEK = 2; 6072 alias GLIB_SYSDEF_MSG_PEEK = SYSDEF_MSG_PEEK; 6073 6074 /** 6075 * Evaluates to a time span of one day. 6076 */ 6077 enum TIME_SPAN_DAY = 86400000000UL; 6078 alias G_TIME_SPAN_DAY = TIME_SPAN_DAY; 6079 6080 /** 6081 * Evaluates to a time span of one hour. 6082 */ 6083 enum TIME_SPAN_HOUR = 3600000000UL; 6084 alias G_TIME_SPAN_HOUR = TIME_SPAN_HOUR; 6085 6086 /** 6087 * Evaluates to a time span of one millisecond. 6088 */ 6089 enum TIME_SPAN_MILLISECOND = 1000UL; 6090 alias G_TIME_SPAN_MILLISECOND = TIME_SPAN_MILLISECOND; 6091 6092 /** 6093 * Evaluates to a time span of one minute. 6094 */ 6095 enum TIME_SPAN_MINUTE = 60000000UL; 6096 alias G_TIME_SPAN_MINUTE = TIME_SPAN_MINUTE; 6097 6098 /** 6099 * Evaluates to a time span of one second. 6100 */ 6101 enum TIME_SPAN_SECOND = 1000000UL; 6102 alias G_TIME_SPAN_SECOND = TIME_SPAN_SECOND; 6103 6104 /** 6105 * The maximum length (in codepoints) of a compatibility or canonical 6106 * decomposition of a single Unicode character. 6107 * 6108 * This is as defined by Unicode 6.1. 6109 */ 6110 enum UNICHAR_MAX_DECOMPOSITION_LENGTH = 18; 6111 alias G_UNICHAR_MAX_DECOMPOSITION_LENGTH = UNICHAR_MAX_DECOMPOSITION_LENGTH; 6112 6113 /** 6114 * Generic delimiters characters as defined in RFC 3986. Includes ":/?#[]@". 6115 */ 6116 enum URI_RESERVED_CHARS_GENERIC_DELIMITERS = ":/?#[]@"; 6117 alias G_URI_RESERVED_CHARS_GENERIC_DELIMITERS = URI_RESERVED_CHARS_GENERIC_DELIMITERS; 6118 6119 /** 6120 * Subcomponent delimiter characters as defined in RFC 3986. Includes "!$&'()*+,;=". 6121 */ 6122 enum URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS = "!$&'()*+,;="; 6123 alias G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS = URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS; 6124 6125 /** 6126 * Number of microseconds in one second (1 million). 6127 * This macro is provided for code readability. 6128 */ 6129 enum USEC_PER_SEC = 1000000; 6130 alias G_USEC_PER_SEC = USEC_PER_SEC; 6131 6132 enum VA_COPY_AS_ARRAY = 1; 6133 alias G_VA_COPY_AS_ARRAY = VA_COPY_AS_ARRAY; 6134 6135 enum WIN32_MSG_HANDLE = 19981206; 6136 alias G_WIN32_MSG_HANDLE = WIN32_MSG_HANDLE;