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 gtkc.giotypes; 26 27 public import gtkc.glibtypes; 28 public import gtkc.gobjecttypes; 29 30 public alias void* GActionMapAutoptr; 31 32 public alias void* GActionAutoptr; 33 34 public alias void* GAppInfoMonitorAutoptr; 35 36 public alias void* GAppInfoAutoptr; 37 38 public alias void* GAppLaunchContextAutoptr; 39 40 public alias void* GApplicationCommandLineAutoptr; 41 42 public alias void* GApplicationAutoptr; 43 44 public alias void* GAsyncInitableAutoptr; 45 46 public alias void* GAsyncResultAutoptr; 47 48 public alias void* GBufferedInputStreamAutoptr; 49 50 public alias void* GBufferedOutputStreamAutoptr; 51 52 public alias void* GBytesIconAutoptr; 53 54 public alias void* GCancellableAutoptr; 55 56 public alias void* GCharsetConverterAutoptr; 57 58 public alias void* GConverterInputStreamAutoptr; 59 60 public alias void* GConverterOutputStreamAutoptr; 61 62 public alias void* GConverterAutoptr; 63 64 public alias void* GCredentialsAutoptr; 65 66 public alias void* GDBusActionGroupAutoptr; 67 68 public alias void* GDBusAuthObserverAutoptr; 69 70 public alias void* GDBusConnectionAutoptr; 71 72 public alias void* GDBusInterfaceSkeletonAutoptr; 73 74 public alias void* GDBusInterfaceAutoptr; 75 76 public alias void* GDBusMenuModelAutoptr; 77 78 public alias void* GDBusMessageAutoptr; 79 80 public alias void* GDBusMethodInvocationAutoptr; 81 82 public alias void* GDBusNodeInfoAutoptr; 83 84 public alias void* GDBusObjectManagerClientAutoptr; 85 86 public alias void* GDBusObjectManagerServerAutoptr; 87 88 public alias void* GDBusObjectManagerAutoptr; 89 90 public alias void* GDBusObjectProxyAutoptr; 91 92 public alias void* GDBusObjectSkeletonAutoptr; 93 94 public alias void* GDBusObjectAutoptr; 95 96 public alias void* GDBusProxyAutoptr; 97 98 public alias void* GDBusServerAutoptr; 99 100 public alias void* GDataInputStreamAutoptr; 101 102 public alias void* GDataOutputStreamAutoptr; 103 104 public alias void* GDesktopAppInfoAutoptr; 105 106 public alias void* GDriveAutoptr; 107 108 public alias void* GEmblemAutoptr; 109 110 public alias void* GEmblemedIconAutoptr; 111 112 public alias void* GFileDescriptorBasedAutoptr; 113 114 public alias void* GFileEnumeratorAutoptr; 115 116 public alias void* GFileIOStreamAutoptr; 117 118 public alias void* GFileIconAutoptr; 119 120 public alias void* GFileInfoAutoptr; 121 122 public alias void* GFileInputStreamAutoptr; 123 124 public alias void* GFileMonitorAutoptr; 125 126 public alias void* GFileOutputStreamAutoptr; 127 128 public alias void* GFileAutoptr; 129 130 public alias void* GFilenameCompleterAutoptr; 131 132 public alias void* GFilterInputStreamAutoptr; 133 134 public alias void* GFilterOutputStreamAutoptr; 135 136 public alias void* GIOModuleAutoptr; 137 138 public alias void* GIOStreamAutoptr; 139 140 public alias void* GIconAutoptr; 141 142 public alias void* GInetAddressMaskAutoptr; 143 144 public alias void* GInetAddressAutoptr; 145 146 public alias void* GInetSocketAddressAutoptr; 147 148 public alias void* GInitableAutoptr; 149 150 public alias void* GInputStreamAutoptr; 151 152 public alias void* GListModelAutoptr; 153 154 public alias void* GListStoreAutoptr; 155 156 public alias void* GLoadableIconAutoptr; 157 158 public alias void* GMemoryInputStreamAutoptr; 159 160 public alias void* GMemoryOutputStreamAutoptr; 161 162 public alias void* GMenuAttributeIterAutoptr; 163 164 public alias void* GMenuItemAutoptr; 165 166 public alias void* GMenuLinkIterAutoptr; 167 168 public alias void* GMenuModelAutoptr; 169 170 public alias void* GMenuAutoptr; 171 172 public alias void* GMountOperationAutoptr; 173 174 public alias void* GMountAutoptr; 175 176 public alias void* GNativeVolumeMonitorAutoptr; 177 178 public alias void* GNetworkAddressAutoptr; 179 180 public alias void* GNetworkMonitorAutoptr; 181 182 public alias void* GNetworkServiceAutoptr; 183 184 public alias void* GNotificationAutoptr; 185 186 public alias void* GOutputStreamAutoptr; 187 188 public alias void* GPermissionAutoptr; 189 190 public alias void* GPollableInputStreamAutoptr; 191 192 public alias void* GPollableOutputStreamAutoptr; 193 194 public alias void* GPropertyActionAutoptr; 195 196 public alias void* GProxyAddressEnumeratorAutoptr; 197 198 public alias void* GProxyAddressAutoptr; 199 200 public alias void* GProxyResolverAutoptr; 201 202 public alias void* GProxyAutoptr; 203 204 public alias void* GRemoteActionGroupAutoptr; 205 206 public alias void* GResolverAutoptr; 207 208 public alias void* GSeekableAutoptr; 209 210 public alias void* GSettingsBackendAutoptr; 211 212 public alias void* GSettingsSchemaAutoptr; 213 214 public alias void* GSettingsAutoptr; 215 216 public alias void* GSimpleActionGroupAutoptr; 217 218 public alias void* GSimpleActionAutoptr; 219 220 public alias void* GSimpleAsyncResultAutoptr; 221 222 public alias void* GSimplePermissionAutoptr; 223 224 public alias void* GSimpleProxyResolverAutoptr; 225 226 public alias void* GSocketAddressEnumeratorAutoptr; 227 228 public alias void* GSocketAddressAutoptr; 229 230 public alias void* GSocketClientAutoptr; 231 232 public alias void* GSocketConnectableAutoptr; 233 234 public alias void* GSocketConnectionAutoptr; 235 236 public alias void* GSocketControlMessageAutoptr; 237 238 public alias void* GSocketListenerAutoptr; 239 240 public alias void* GSocketServiceAutoptr; 241 242 public alias void* GSocketAutoptr; 243 244 public alias void* GSubprocessLauncherAutoptr; 245 246 public alias void* GSubprocessAutoptr; 247 248 public alias void* GTaskAutoptr; 249 250 public alias void* GTcpConnectionAutoptr; 251 252 public alias void* GTcpWrapperConnectionAutoptr; 253 254 public alias void* GTestDBusAutoptr; 255 256 public alias void* GThemedIconAutoptr; 257 258 public alias void* GThreadedSocketServiceAutoptr; 259 260 public alias void* GTlsBackendAutoptr; 261 262 public alias void* GTlsCertificateAutoptr; 263 264 public alias void* GTlsClientConnectionAutoptr; 265 266 public alias void* GTlsConnectionAutoptr; 267 268 public alias void* GTlsDatabaseAutoptr; 269 270 public alias void* GTlsFileDatabaseAutoptr; 271 272 public alias void* GTlsInteractionAutoptr; 273 274 public alias void* GTlsPasswordAutoptr; 275 276 public alias void* GTlsServerConnectionAutoptr; 277 278 public alias void* GUnixConnectionAutoptr; 279 280 public alias void* GUnixCredentialsMessageAutoptr; 281 282 public alias void* GUnixFDListAutoptr; 283 284 public alias void* GUnixFDMessageAutoptr; 285 286 public alias void* GUnixInputStreamAutoptr; 287 288 public alias void* GUnixMountMonitorAutoptr; 289 290 public alias void* GUnixOutputStreamAutoptr; 291 292 public alias void* GUnixSocketAddressAutoptr; 293 294 public alias void* GVfsAutoptr; 295 296 public alias void* GVolumeMonitorAutoptr; 297 298 public alias void* GVolumeAutoptr; 299 300 public alias void* GZlibCompressorAutoptr; 301 302 public alias void* GZlibDecompressorAutoptr; 303 304 /** 305 * Flags used when creating a #GAppInfo. 306 */ 307 public enum GAppInfoCreateFlags 308 { 309 /** 310 * No flags. 311 */ 312 NONE = 0, 313 /** 314 * Application opens in a terminal window. 315 */ 316 NEEDS_TERMINAL = 1, 317 /** 318 * Application supports URI arguments. 319 */ 320 SUPPORTS_URIS = 2, 321 /** 322 * Application supports startup notification. Since 2.26 323 */ 324 SUPPORTS_STARTUP_NOTIFICATION = 4, 325 } 326 alias GAppInfoCreateFlags AppInfoCreateFlags; 327 328 /** 329 * Flags used to define the behaviour of a #GApplication. 330 * 331 * Since: 2.28 332 */ 333 public enum GApplicationFlags 334 { 335 /** 336 * Default 337 */ 338 FLAGS_NONE = 0, 339 /** 340 * Run as a service. In this mode, registration 341 * fails if the service is already running, and the application 342 * will initially wait up to 10 seconds for an initial activation 343 * message to arrive. 344 */ 345 IS_SERVICE = 1, 346 /** 347 * Don't try to become the primary instance. 348 */ 349 IS_LAUNCHER = 2, 350 /** 351 * This application handles opening files (in 352 * the primary instance). Note that this flag only affects the default 353 * implementation of local_command_line(), and has no effect if 354 * %G_APPLICATION_HANDLES_COMMAND_LINE is given. 355 * See g_application_run() for details. 356 */ 357 HANDLES_OPEN = 4, 358 /** 359 * This application handles command line 360 * arguments (in the primary instance). Note that this flag only affect 361 * the default implementation of local_command_line(). 362 * See g_application_run() for details. 363 */ 364 HANDLES_COMMAND_LINE = 8, 365 /** 366 * Send the environment of the 367 * launching process to the primary instance. Set this flag if your 368 * application is expected to behave differently depending on certain 369 * environment variables. For instance, an editor might be expected 370 * to use the <envar>GIT_COMMITTER_NAME</envar> environment variable 371 * when editing a git commit message. The environment is available 372 * to the #GApplication::command-line signal handler, via 373 * g_application_command_line_getenv(). 374 */ 375 SEND_ENVIRONMENT = 16, 376 /** 377 * Make no attempts to do any of the typical 378 * single-instance application negotiation, even if the application 379 * ID is given. The application neither attempts to become the 380 * owner of the application ID nor does it check if an existing 381 * owner already exists. Everything occurs in the local process. 382 * Since: 2.30. 383 */ 384 NON_UNIQUE = 32, 385 } 386 alias GApplicationFlags ApplicationFlags; 387 388 /** 389 * #GAskPasswordFlags are used to request specific information from the 390 * user, or to notify the user of their choices in an authentication 391 * situation. 392 */ 393 public enum GAskPasswordFlags 394 { 395 /** 396 * operation requires a password. 397 */ 398 NEED_PASSWORD = 1, 399 /** 400 * operation requires a username. 401 */ 402 NEED_USERNAME = 2, 403 /** 404 * operation requires a domain. 405 */ 406 NEED_DOMAIN = 4, 407 /** 408 * operation supports saving settings. 409 */ 410 SAVING_SUPPORTED = 8, 411 /** 412 * operation supports anonymous users. 413 */ 414 ANONYMOUS_SUPPORTED = 16, 415 } 416 alias GAskPasswordFlags AskPasswordFlags; 417 418 /** 419 * Flags used in g_bus_own_name(). 420 * 421 * Since: 2.26 422 */ 423 public enum GBusNameOwnerFlags 424 { 425 /** 426 * No flags set. 427 */ 428 NONE = 0, 429 /** 430 * Allow another message bus connection to claim the name. 431 */ 432 ALLOW_REPLACEMENT = 1, 433 /** 434 * If another message bus connection owns the name and have 435 * specified #G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, then take the name from the other connection. 436 */ 437 REPLACE = 2, 438 } 439 alias GBusNameOwnerFlags BusNameOwnerFlags; 440 441 /** 442 * Flags used in g_bus_watch_name(). 443 * 444 * Since: 2.26 445 */ 446 public enum GBusNameWatcherFlags 447 { 448 /** 449 * No flags set. 450 */ 451 NONE = 0, 452 /** 453 * If no-one owns the name when 454 * beginning to watch the name, ask the bus to launch an owner for the 455 * name. 456 */ 457 AUTO_START = 1, 458 } 459 alias GBusNameWatcherFlags BusNameWatcherFlags; 460 461 /** 462 * An enumeration for well-known message buses. 463 * 464 * Since: 2.26 465 */ 466 public enum GBusType 467 { 468 /** 469 * An alias for the message bus that activated the process, if any. 470 */ 471 STARTER = -1, 472 /** 473 * Not a message bus. 474 */ 475 NONE = 0, 476 /** 477 * The system-wide message bus. 478 */ 479 SYSTEM = 1, 480 /** 481 * The login session message bus. 482 */ 483 SESSION = 2, 484 } 485 alias GBusType BusType; 486 487 /** 488 * Flags used when calling a g_converter_convert(). 489 * 490 * Since: 2.24 491 */ 492 public enum GConverterFlags 493 { 494 /** 495 * No flags. 496 */ 497 NONE = 0, 498 /** 499 * At end of input data 500 */ 501 INPUT_AT_END = 1, 502 /** 503 * Flush data 504 */ 505 FLUSH = 2, 506 } 507 alias GConverterFlags ConverterFlags; 508 509 /** 510 * Results returned from g_converter_convert(). 511 * 512 * Since: 2.24 513 */ 514 public enum GConverterResult 515 { 516 /** 517 * There was an error during conversion. 518 */ 519 ERROR = 0, 520 /** 521 * Some data was consumed or produced 522 */ 523 CONVERTED = 1, 524 /** 525 * The conversion is finished 526 */ 527 FINISHED = 2, 528 /** 529 * Flushing is finished 530 */ 531 FLUSHED = 3, 532 } 533 alias GConverterResult ConverterResult; 534 535 /** 536 * Enumeration describing different kinds of native credential types. 537 * 538 * Since: 2.26 539 */ 540 public enum GCredentialsType 541 { 542 /** 543 * Indicates an invalid native credential type. 544 */ 545 INVALID = 0, 546 /** 547 * The native credentials type is a <type>struct ucred</type>. 548 */ 549 LINUX_UCRED = 1, 550 /** 551 * The native credentials type is a <type>struct cmsgcred</type>. 552 */ 553 FREEBSD_CMSGCRED = 2, 554 /** 555 * The native credentials type is a <type>struct sockpeercred</type>. Added in 2.30. 556 */ 557 OPENBSD_SOCKPEERCRED = 3, 558 /** 559 * The native credentials type is a <type>ucred_t</type>. Added in 2.40. 560 */ 561 SOLARIS_UCRED = 4, 562 /** 563 * The native credentials type is a <type>struct unpcbid</type>. 564 */ 565 NETBSD_UNPCBID = 5, 566 } 567 alias GCredentialsType CredentialsType; 568 569 /** 570 * Flags used in g_dbus_connection_call() and similar APIs. 571 * 572 * Since: 2.26 573 */ 574 public enum GDBusCallFlags 575 { 576 /** 577 * No flags set. 578 */ 579 NONE = 0, 580 /** 581 * The bus must not launch 582 * an owner for the destination name in response to this method 583 * invocation. 584 */ 585 NO_AUTO_START = 1, 586 } 587 alias GDBusCallFlags DBusCallFlags; 588 589 /** 590 * Capabilities negotiated with the remote peer. 591 * 592 * Since: 2.26 593 */ 594 public enum GDBusCapabilityFlags 595 { 596 /** 597 * No flags set. 598 */ 599 NONE = 0, 600 /** 601 * The connection 602 * supports exchanging UNIX file descriptors with the remote peer. 603 */ 604 UNIX_FD_PASSING = 1, 605 } 606 alias GDBusCapabilityFlags DBusCapabilityFlags; 607 608 /** 609 * Flags used when creating a new #GDBusConnection. 610 * 611 * Since: 2.26 612 */ 613 public enum GDBusConnectionFlags 614 { 615 /** 616 * No flags set. 617 */ 618 NONE = 0, 619 /** 620 * Perform authentication against server. 621 */ 622 AUTHENTICATION_CLIENT = 1, 623 /** 624 * Perform authentication against client. 625 */ 626 AUTHENTICATION_SERVER = 2, 627 /** 628 * When 629 * authenticating as a server, allow the anonymous authentication 630 * method. 631 */ 632 AUTHENTICATION_ALLOW_ANONYMOUS = 4, 633 /** 634 * Pass this flag if connecting to a peer that is a 635 * message bus. This means that the Hello() method will be invoked as part of the connection setup. 636 */ 637 MESSAGE_BUS_CONNECTION = 8, 638 /** 639 * If set, processing of D-Bus messages is 640 * delayed until g_dbus_connection_start_message_processing() is called. 641 */ 642 DELAY_MESSAGE_PROCESSING = 16, 643 } 644 alias GDBusConnectionFlags DBusConnectionFlags; 645 646 /** 647 * Error codes for the %G_DBUS_ERROR error domain. 648 * 649 * Since: 2.26 650 */ 651 public enum GDBusError 652 { 653 /** 654 * A generic error; "something went wrong" - see the error message for 655 * more. 656 */ 657 FAILED = 0, 658 /** 659 * There was not enough memory to complete an operation. 660 */ 661 NO_MEMORY = 1, 662 /** 663 * The bus doesn't know how to launch a service to supply the bus name 664 * you wanted. 665 */ 666 SERVICE_UNKNOWN = 2, 667 /** 668 * The bus name you referenced doesn't exist (i.e. no application owns 669 * it). 670 */ 671 NAME_HAS_NO_OWNER = 3, 672 /** 673 * No reply to a message expecting one, usually means a timeout occurred. 674 */ 675 NO_REPLY = 4, 676 /** 677 * Something went wrong reading or writing to a socket, for example. 678 */ 679 IO_ERROR = 5, 680 /** 681 * A D-Bus bus address was malformed. 682 */ 683 BAD_ADDRESS = 6, 684 /** 685 * Requested operation isn't supported (like ENOSYS on UNIX). 686 */ 687 NOT_SUPPORTED = 7, 688 /** 689 * Some limited resource is exhausted. 690 */ 691 LIMITS_EXCEEDED = 8, 692 /** 693 * Security restrictions don't allow doing what you're trying to do. 694 */ 695 ACCESS_DENIED = 9, 696 /** 697 * Authentication didn't work. 698 */ 699 AUTH_FAILED = 10, 700 /** 701 * Unable to connect to server (probably caused by ECONNREFUSED on a 702 * socket). 703 */ 704 NO_SERVER = 11, 705 /** 706 * Certain timeout errors, possibly ETIMEDOUT on a socket. Note that 707 * %G_DBUS_ERROR_NO_REPLY is used for message reply timeouts. Warning: 708 * this is confusingly-named given that %G_DBUS_ERROR_TIMED_OUT also 709 * exists. We can't fix it for compatibility reasons so just be 710 * careful. 711 */ 712 TIMEOUT = 12, 713 /** 714 * No network access (probably ENETUNREACH on a socket). 715 */ 716 NO_NETWORK = 13, 717 /** 718 * Can't bind a socket since its address is in use (i.e. EADDRINUSE). 719 */ 720 ADDRESS_IN_USE = 14, 721 /** 722 * The connection is disconnected and you're trying to use it. 723 */ 724 DISCONNECTED = 15, 725 /** 726 * Invalid arguments passed to a method call. 727 */ 728 INVALID_ARGS = 16, 729 /** 730 * Missing file. 731 */ 732 FILE_NOT_FOUND = 17, 733 /** 734 * Existing file and the operation you're using does not silently overwrite. 735 */ 736 FILE_EXISTS = 18, 737 /** 738 * Method name you invoked isn't known by the object you invoked it on. 739 */ 740 UNKNOWN_METHOD = 19, 741 /** 742 * Certain timeout errors, e.g. while starting a service. Warning: this is 743 * confusingly-named given that %G_DBUS_ERROR_TIMEOUT also exists. We 744 * can't fix it for compatibility reasons so just be careful. 745 */ 746 TIMED_OUT = 20, 747 /** 748 * Tried to remove or modify a match rule that didn't exist. 749 */ 750 MATCH_RULE_NOT_FOUND = 21, 751 /** 752 * The match rule isn't syntactically valid. 753 */ 754 MATCH_RULE_INVALID = 22, 755 /** 756 * While starting a new process, the exec() call failed. 757 */ 758 SPAWN_EXEC_FAILED = 23, 759 /** 760 * While starting a new process, the fork() call failed. 761 */ 762 SPAWN_FORK_FAILED = 24, 763 /** 764 * While starting a new process, the child exited with a status code. 765 */ 766 SPAWN_CHILD_EXITED = 25, 767 /** 768 * While starting a new process, the child exited on a signal. 769 */ 770 SPAWN_CHILD_SIGNALED = 26, 771 /** 772 * While starting a new process, something went wrong. 773 */ 774 SPAWN_FAILED = 27, 775 /** 776 * We failed to setup the environment correctly. 777 */ 778 SPAWN_SETUP_FAILED = 28, 779 /** 780 * We failed to setup the config parser correctly. 781 */ 782 SPAWN_CONFIG_INVALID = 29, 783 /** 784 * Bus name was not valid. 785 */ 786 SPAWN_SERVICE_INVALID = 30, 787 /** 788 * Service file not found in system-services directory. 789 */ 790 SPAWN_SERVICE_NOT_FOUND = 31, 791 /** 792 * Permissions are incorrect on the setuid helper. 793 */ 794 SPAWN_PERMISSIONS_INVALID = 32, 795 /** 796 * Service file invalid (Name, User or Exec missing). 797 */ 798 SPAWN_FILE_INVALID = 33, 799 /** 800 * Tried to get a UNIX process ID and it wasn't available. 801 */ 802 SPAWN_NO_MEMORY = 34, 803 /** 804 * Tried to get a UNIX process ID and it wasn't available. 805 */ 806 UNIX_PROCESS_ID_UNKNOWN = 35, 807 /** 808 * A type signature is not valid. 809 */ 810 INVALID_SIGNATURE = 36, 811 /** 812 * A file contains invalid syntax or is otherwise broken. 813 */ 814 INVALID_FILE_CONTENT = 37, 815 /** 816 * Asked for SELinux security context and it wasn't available. 817 */ 818 SELINUX_SECURITY_CONTEXT_UNKNOWN = 38, 819 /** 820 * Asked for ADT audit data and it wasn't available. 821 */ 822 ADT_AUDIT_DATA_UNKNOWN = 39, 823 /** 824 * There's already an object with the requested object path. 825 */ 826 OBJECT_PATH_IN_USE = 40, 827 /** 828 * Object you invoked a method on isn't known. Since 2.42 829 */ 830 UNKNOWN_OBJECT = 41, 831 /** 832 * Interface you invoked a method on isn't known by the object. Since 2.42 833 */ 834 UNKNOWN_INTERFACE = 42, 835 /** 836 * Property you tried to access isn't known by the object. Since 2.42 837 */ 838 UNKNOWN_PROPERTY = 43, 839 /** 840 * Property you tried to set is read-only. Since 2.42 841 */ 842 PROPERTY_READ_ONLY = 44, 843 } 844 alias GDBusError DBusError; 845 846 /** 847 * Flags describing the behavior of a #GDBusInterfaceSkeleton instance. 848 * 849 * Since: 2.30 850 */ 851 public enum GDBusInterfaceSkeletonFlags 852 { 853 /** 854 * No flags set. 855 */ 856 NONE = 0, 857 /** 858 * Each method invocation is handled in 859 * a thread dedicated to the invocation. This means that the method implementation can use blocking IO 860 * without blocking any other part of the process. It also means that the method implementation must 861 * use locking to access data structures used by other threads. 862 */ 863 HANDLE_METHOD_INVOCATIONS_IN_THREAD = 1, 864 } 865 alias GDBusInterfaceSkeletonFlags DBusInterfaceSkeletonFlags; 866 867 /** 868 * Enumeration used to describe the byte order of a D-Bus message. 869 * 870 * Since: 2.26 871 */ 872 public enum GDBusMessageByteOrder 873 { 874 /** 875 * The byte order is big endian. 876 */ 877 BIG_ENDIAN = 66, 878 /** 879 * The byte order is little endian. 880 */ 881 LITTLE_ENDIAN = 108, 882 } 883 alias GDBusMessageByteOrder DBusMessageByteOrder; 884 885 /** 886 * Message flags used in #GDBusMessage. 887 * 888 * Since: 2.26 889 */ 890 public enum GDBusMessageFlags 891 { 892 /** 893 * No flags set. 894 */ 895 NONE = 0, 896 /** 897 * A reply is not expected. 898 */ 899 NO_REPLY_EXPECTED = 1, 900 /** 901 * The bus must not launch an 902 * owner for the destination name in response to this message. 903 */ 904 NO_AUTO_START = 2, 905 } 906 alias GDBusMessageFlags DBusMessageFlags; 907 908 /** 909 * Header fields used in #GDBusMessage. 910 * 911 * Since: 2.26 912 */ 913 public enum GDBusMessageHeaderField 914 { 915 /** 916 * Not a valid header field. 917 */ 918 INVALID = 0, 919 /** 920 * The object path. 921 */ 922 PATH = 1, 923 /** 924 * The interface name. 925 */ 926 INTERFACE = 2, 927 /** 928 * The method or signal name. 929 */ 930 MEMBER = 3, 931 /** 932 * The name of the error that occurred. 933 */ 934 ERROR_NAME = 4, 935 /** 936 * The serial number the message is a reply to. 937 */ 938 REPLY_SERIAL = 5, 939 /** 940 * The name the message is intended for. 941 */ 942 DESTINATION = 6, 943 /** 944 * Unique name of the sender of the message (filled in by the bus). 945 */ 946 SENDER = 7, 947 /** 948 * The signature of the message body. 949 */ 950 SIGNATURE = 8, 951 /** 952 * The number of UNIX file descriptors that accompany the message. 953 */ 954 NUM_UNIX_FDS = 9, 955 } 956 alias GDBusMessageHeaderField DBusMessageHeaderField; 957 958 /** 959 * Message types used in #GDBusMessage. 960 * 961 * Since: 2.26 962 */ 963 public enum GDBusMessageType 964 { 965 /** 966 * Message is of invalid type. 967 */ 968 INVALID = 0, 969 /** 970 * Method call. 971 */ 972 METHOD_CALL = 1, 973 /** 974 * Method reply. 975 */ 976 METHOD_RETURN = 2, 977 /** 978 * Error reply. 979 */ 980 ERROR = 3, 981 /** 982 * Signal emission. 983 */ 984 SIGNAL = 4, 985 } 986 alias GDBusMessageType DBusMessageType; 987 988 /** 989 * Flags used when constructing a #GDBusObjectManagerClient. 990 * 991 * Since: 2.30 992 */ 993 public enum GDBusObjectManagerClientFlags 994 { 995 /** 996 * No flags set. 997 */ 998 NONE = 0, 999 /** 1000 * If not set and the 1001 * manager is for a well-known name, then request the bus to launch 1002 * an owner for the name if no-one owns the name. This flag can only 1003 * be used in managers for well-known names. 1004 */ 1005 DO_NOT_AUTO_START = 1, 1006 } 1007 alias GDBusObjectManagerClientFlags DBusObjectManagerClientFlags; 1008 1009 /** 1010 * Flags describing the access control of a D-Bus property. 1011 * 1012 * Since: 2.26 1013 */ 1014 public enum GDBusPropertyInfoFlags 1015 { 1016 /** 1017 * No flags set. 1018 */ 1019 NONE = 0, 1020 /** 1021 * Property is readable. 1022 */ 1023 READABLE = 1, 1024 /** 1025 * Property is writable. 1026 */ 1027 WRITABLE = 2, 1028 } 1029 alias GDBusPropertyInfoFlags DBusPropertyInfoFlags; 1030 1031 /** 1032 * Flags used when constructing an instance of a #GDBusProxy derived class. 1033 * 1034 * Since: 2.26 1035 */ 1036 public enum GDBusProxyFlags 1037 { 1038 /** 1039 * No flags set. 1040 */ 1041 NONE = 0, 1042 /** 1043 * Don't load properties. 1044 */ 1045 DO_NOT_LOAD_PROPERTIES = 1, 1046 /** 1047 * Don't connect to signals on the remote object. 1048 */ 1049 DO_NOT_CONNECT_SIGNALS = 2, 1050 /** 1051 * If not set and the proxy if for a well-known name, 1052 * then request the bus to launch an owner for the name if no-one owns the name. This flag can 1053 * only be used in proxies for well-known names. 1054 */ 1055 DO_NOT_AUTO_START = 4, 1056 /** 1057 * If set, the property value for any <emphasis>invalidated property</emphasis> will be (asynchronously) retrieved upon receiving the <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties">PropertiesChanged</ulink> D-Bus signal and the property will not cause emission of the #GDBusProxy::g-properties-changed signal. When the value is received the #GDBusProxy::g-properties-changed signal is emitted for the property along with the retrieved value. Since 2.32. 1058 */ 1059 GET_INVALIDATED_PROPERTIES = 8, 1060 /** 1061 * If the proxy is for a well-known name, 1062 * do not ask the bus to launch an owner during proxy initialization, but allow it to be 1063 * autostarted by a method call. This flag is only meaningful in proxies for well-known names, 1064 * and only if %G_DBUS_PROXY_FLAGS_DO_NOT_AUTOSTART is not also specified. 1065 */ 1066 DO_NOT_AUTO_START_AT_CONSTRUCTION = 16, 1067 } 1068 alias GDBusProxyFlags DBusProxyFlags; 1069 1070 /** 1071 * Flags used when sending #GDBusMessages on a #GDBusConnection. 1072 * 1073 * Since: 2.26 1074 */ 1075 public enum GDBusSendMessageFlags 1076 { 1077 /** 1078 * No flags set. 1079 */ 1080 NONE = 0, 1081 /** 1082 * Do not automatically 1083 * assign a serial number from the #GDBusConnection object when 1084 * sending a message. 1085 */ 1086 PRESERVE_SERIAL = 1, 1087 } 1088 alias GDBusSendMessageFlags DBusSendMessageFlags; 1089 1090 /** 1091 * Flags used when creating a #GDBusServer. 1092 * 1093 * Since: 2.26 1094 */ 1095 public enum GDBusServerFlags 1096 { 1097 /** 1098 * No flags set. 1099 */ 1100 NONE = 0, 1101 /** 1102 * All #GDBusServer::new-connection 1103 * signals will run in separated dedicated threads (see signal for 1104 * details). 1105 */ 1106 RUN_IN_THREAD = 1, 1107 /** 1108 * Allow the anonymous 1109 * authentication method. 1110 */ 1111 AUTHENTICATION_ALLOW_ANONYMOUS = 2, 1112 } 1113 alias GDBusServerFlags DBusServerFlags; 1114 1115 /** 1116 * Flags used when subscribing to signals via g_dbus_connection_signal_subscribe(). 1117 * 1118 * Since: 2.26 1119 */ 1120 public enum GDBusSignalFlags 1121 { 1122 /** 1123 * No flags set. 1124 */ 1125 NONE = 0, 1126 /** 1127 * Don't actually send the AddMatch 1128 * D-Bus call for this signal subscription. This gives you more control 1129 * over which match rules you add (but you must add them manually). 1130 */ 1131 NO_MATCH_RULE = 1, 1132 /** 1133 * Match first arguments that 1134 * contain a bus or interface name with the given namespace. 1135 */ 1136 MATCH_ARG0_NAMESPACE = 2, 1137 /** 1138 * Match first arguments that 1139 * contain an object path that is either equivalent to the given path, 1140 * or one of the paths is a subpath of the other. 1141 */ 1142 MATCH_ARG0_PATH = 4, 1143 } 1144 alias GDBusSignalFlags DBusSignalFlags; 1145 1146 /** 1147 * Flags passed to g_dbus_connection_register_subtree(). 1148 * 1149 * Since: 2.26 1150 */ 1151 public enum GDBusSubtreeFlags 1152 { 1153 /** 1154 * No flags set. 1155 */ 1156 NONE = 0, 1157 /** 1158 * Method calls to objects not in the enumerated range 1159 * will still be dispatched. This is useful if you want 1160 * to dynamically spawn objects in the subtree. 1161 */ 1162 DISPATCH_TO_UNENUMERATED_NODES = 1, 1163 } 1164 alias GDBusSubtreeFlags DBusSubtreeFlags; 1165 1166 /** 1167 * #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources 1168 * across various machine architectures. 1169 */ 1170 public enum GDataStreamByteOrder 1171 { 1172 /** 1173 * Selects Big Endian byte order. 1174 */ 1175 BIG_ENDIAN = 0, 1176 /** 1177 * Selects Little Endian byte order. 1178 */ 1179 LITTLE_ENDIAN = 1, 1180 /** 1181 * Selects endianness based on host machine's architecture. 1182 */ 1183 HOST_ENDIAN = 2, 1184 } 1185 alias GDataStreamByteOrder DataStreamByteOrder; 1186 1187 /** 1188 * #GDataStreamNewlineType is used when checking for or setting the line endings for a given file. 1189 */ 1190 public enum GDataStreamNewlineType 1191 { 1192 /** 1193 * Selects "LF" line endings, common on most modern UNIX platforms. 1194 */ 1195 LF = 0, 1196 /** 1197 * Selects "CR" line endings. 1198 */ 1199 CR = 1, 1200 /** 1201 * Selects "CR, LF" line ending, common on Microsoft Windows. 1202 */ 1203 CR_LF = 2, 1204 /** 1205 * Automatically try to handle any line ending type. 1206 */ 1207 ANY = 3, 1208 } 1209 alias GDataStreamNewlineType DataStreamNewlineType; 1210 1211 /** 1212 * Flags used when starting a drive. 1213 * 1214 * Since: 2.22 1215 */ 1216 public enum GDriveStartFlags 1217 { 1218 /** 1219 * No flags set. 1220 */ 1221 NONE = 0, 1222 } 1223 alias GDriveStartFlags DriveStartFlags; 1224 1225 /** 1226 * Enumeration describing how a drive can be started/stopped. 1227 * 1228 * Since: 2.22 1229 */ 1230 public enum GDriveStartStopType 1231 { 1232 /** 1233 * Unknown or drive doesn't support 1234 * start/stop. 1235 */ 1236 UNKNOWN = 0, 1237 /** 1238 * The stop method will physically 1239 * shut down the drive and e.g. power down the port the drive is 1240 * attached to. 1241 */ 1242 SHUTDOWN = 1, 1243 /** 1244 * The start/stop methods are used 1245 * for connecting/disconnect to the drive over the network. 1246 */ 1247 NETWORK = 2, 1248 /** 1249 * The start/stop methods will 1250 * assemble/disassemble a virtual drive from several physical 1251 * drives. 1252 */ 1253 MULTIDISK = 3, 1254 /** 1255 * The start/stop methods will 1256 * unlock/lock the disk (for example using the ATA <quote>SECURITY 1257 * UNLOCK DEVICE</quote> command) 1258 */ 1259 PASSWORD = 4, 1260 } 1261 alias GDriveStartStopType DriveStartStopType; 1262 1263 /** 1264 * GEmblemOrigin is used to add information about the origin of the emblem 1265 * to #GEmblem. 1266 * 1267 * Since: 2.18 1268 */ 1269 public enum GEmblemOrigin 1270 { 1271 /** 1272 * Emblem of unknown origin 1273 */ 1274 UNKNOWN = 0, 1275 /** 1276 * Emblem adds device-specific information 1277 */ 1278 DEVICE = 1, 1279 /** 1280 * Emblem depicts live metadata, such as "readonly" 1281 */ 1282 LIVEMETADATA = 2, 1283 /** 1284 * Emblem comes from a user-defined tag, e.g. set by nautilus (in the future) 1285 */ 1286 TAG = 3, 1287 } 1288 alias GEmblemOrigin EmblemOrigin; 1289 1290 /** 1291 * Flags specifying the behaviour of an attribute. 1292 */ 1293 public enum GFileAttributeInfoFlags 1294 { 1295 /** 1296 * no flags set. 1297 */ 1298 NONE = 0, 1299 /** 1300 * copy the attribute values when the file is copied. 1301 */ 1302 COPY_WITH_FILE = 1, 1303 /** 1304 * copy the attribute values when the file is moved. 1305 */ 1306 COPY_WHEN_MOVED = 2, 1307 } 1308 alias GFileAttributeInfoFlags FileAttributeInfoFlags; 1309 1310 /** 1311 * Used by g_file_set_attributes_from_info() when setting file attributes. 1312 */ 1313 public enum GFileAttributeStatus 1314 { 1315 /** 1316 * Attribute value is unset (empty). 1317 */ 1318 UNSET = 0, 1319 /** 1320 * Attribute value is set. 1321 */ 1322 SET = 1, 1323 /** 1324 * Indicates an error in setting the value. 1325 */ 1326 ERROR_SETTING = 2, 1327 } 1328 alias GFileAttributeStatus FileAttributeStatus; 1329 1330 /** 1331 * The data types for file attributes. 1332 */ 1333 public enum GFileAttributeType 1334 { 1335 /** 1336 * indicates an invalid or uninitalized type. 1337 */ 1338 INVALID = 0, 1339 /** 1340 * a null terminated UTF8 string. 1341 */ 1342 STRING = 1, 1343 /** 1344 * a zero terminated string of non-zero bytes. 1345 */ 1346 BYTE_STRING = 2, 1347 /** 1348 * a boolean value. 1349 */ 1350 BOOLEAN = 3, 1351 /** 1352 * an unsigned 4-byte/32-bit integer. 1353 */ 1354 UINT32 = 4, 1355 /** 1356 * a signed 4-byte/32-bit integer. 1357 */ 1358 INT32 = 5, 1359 /** 1360 * an unsigned 8-byte/64-bit integer. 1361 */ 1362 UINT64 = 6, 1363 /** 1364 * a signed 8-byte/64-bit integer. 1365 */ 1366 INT64 = 7, 1367 /** 1368 * a #GObject. 1369 */ 1370 OBJECT = 8, 1371 /** 1372 * a %NULL terminated char **. Since 2.22 1373 */ 1374 STRINGV = 9, 1375 } 1376 alias GFileAttributeType FileAttributeType; 1377 1378 /** 1379 * Flags used when copying or moving files. 1380 */ 1381 public enum GFileCopyFlags 1382 { 1383 /** 1384 * No flags set. 1385 */ 1386 NONE = 0, 1387 /** 1388 * Overwrite any existing files 1389 */ 1390 OVERWRITE = 1, 1391 /** 1392 * Make a backup of any existing files. 1393 */ 1394 BACKUP = 2, 1395 /** 1396 * Don't follow symlinks. 1397 */ 1398 NOFOLLOW_SYMLINKS = 4, 1399 /** 1400 * Copy all file metadata instead of just default set used for copy (see #GFileInfo). 1401 */ 1402 ALL_METADATA = 8, 1403 /** 1404 * Don't use copy and delete fallback if native move not supported. 1405 */ 1406 NO_FALLBACK_FOR_MOVE = 16, 1407 /** 1408 * Leaves target file with default perms, instead of setting the source file perms. 1409 */ 1410 TARGET_DEFAULT_PERMS = 32, 1411 } 1412 alias GFileCopyFlags FileCopyFlags; 1413 1414 /** 1415 * Flags used when an operation may create a file. 1416 */ 1417 public enum GFileCreateFlags 1418 { 1419 /** 1420 * No flags set. 1421 */ 1422 NONE = 0, 1423 /** 1424 * Create a file that can only be 1425 * accessed by the current user. 1426 */ 1427 PRIVATE = 1, 1428 /** 1429 * Replace the destination 1430 * as if it didn't exist before. Don't try to keep any old 1431 * permissions, replace instead of following links. This 1432 * is generally useful if you're doing a "copy over" 1433 * rather than a "save new version of" replace operation. 1434 * You can think of it as "unlink destination" before 1435 * writing to it, although the implementation may not 1436 * be exactly like that. Since 2.20 1437 */ 1438 REPLACE_DESTINATION = 2, 1439 } 1440 alias GFileCreateFlags FileCreateFlags; 1441 1442 /** 1443 * Flags that can be used with g_file_measure_disk_usage(). 1444 * 1445 * Since: 2.38 1446 */ 1447 public enum GFileMeasureFlags 1448 { 1449 /** 1450 * No flags set. 1451 */ 1452 NONE = 0, 1453 /** 1454 * Report any error encountered 1455 * while traversing the directory tree. Normally errors are only 1456 * reported for the toplevel file. 1457 */ 1458 REPORT_ANY_ERROR = 2, 1459 /** 1460 * Tally usage based on apparent file 1461 * sizes. Normally, the block-size is used, if available, as this is a 1462 * more accurate representation of disk space used. 1463 * Compare with `du --apparent-size`. 1464 */ 1465 APPARENT_SIZE = 4, 1466 /** 1467 * Do not cross mount point boundaries. 1468 * Compare with `du -x`. 1469 */ 1470 NO_XDEV = 8, 1471 } 1472 alias GFileMeasureFlags FileMeasureFlags; 1473 1474 /** 1475 * Specifies what type of event a monitor event is. 1476 */ 1477 public enum GFileMonitorEvent 1478 { 1479 /** 1480 * a file changed. 1481 */ 1482 CHANGED = 0, 1483 /** 1484 * a hint that this was probably the last change in a set of changes. 1485 */ 1486 CHANGES_DONE_HINT = 1, 1487 /** 1488 * a file was deleted. 1489 */ 1490 DELETED = 2, 1491 /** 1492 * a file was created. 1493 */ 1494 CREATED = 3, 1495 /** 1496 * a file attribute was changed. 1497 */ 1498 ATTRIBUTE_CHANGED = 4, 1499 /** 1500 * the file location will soon be unmounted. 1501 */ 1502 PRE_UNMOUNT = 5, 1503 /** 1504 * the file location was unmounted. 1505 */ 1506 UNMOUNTED = 6, 1507 /** 1508 * the file was moved. 1509 */ 1510 MOVED = 7, 1511 } 1512 alias GFileMonitorEvent FileMonitorEvent; 1513 1514 /** 1515 * Flags used to set what a #GFileMonitor will watch for. 1516 */ 1517 public enum GFileMonitorFlags 1518 { 1519 /** 1520 * No flags set. 1521 */ 1522 NONE = 0, 1523 /** 1524 * Watch for mount events. 1525 */ 1526 WATCH_MOUNTS = 1, 1527 /** 1528 * Pair DELETED and CREATED events caused 1529 * by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED 1530 * event instead (NB: not supported on all backends; the default 1531 * behaviour -without specifying this flag- is to send single DELETED 1532 * and CREATED events). 1533 */ 1534 SEND_MOVED = 2, 1535 /** 1536 * Watch for changes to the file made 1537 * via another hard link. Since 2.36. 1538 */ 1539 WATCH_HARD_LINKS = 4, 1540 } 1541 alias GFileMonitorFlags FileMonitorFlags; 1542 1543 /** 1544 * Flags used when querying a #GFileInfo. 1545 */ 1546 public enum GFileQueryInfoFlags 1547 { 1548 /** 1549 * No flags set. 1550 */ 1551 NONE = 0, 1552 /** 1553 * Don't follow symlinks. 1554 */ 1555 NOFOLLOW_SYMLINKS = 1, 1556 } 1557 alias GFileQueryInfoFlags FileQueryInfoFlags; 1558 1559 /** 1560 * Indicates the file's on-disk type. 1561 */ 1562 public enum GFileType 1563 { 1564 /** 1565 * File's type is unknown. 1566 */ 1567 UNKNOWN = 0, 1568 /** 1569 * File handle represents a regular file. 1570 */ 1571 REGULAR = 1, 1572 /** 1573 * File handle represents a directory. 1574 */ 1575 DIRECTORY = 2, 1576 /** 1577 * File handle represents a symbolic link 1578 * (Unix systems). 1579 */ 1580 SYMBOLIC_LINK = 3, 1581 /** 1582 * File is a "special" file, such as a socket, fifo, 1583 * block device, or character device. 1584 */ 1585 SPECIAL = 4, 1586 /** 1587 * File is a shortcut (Windows systems). 1588 */ 1589 SHORTCUT = 5, 1590 /** 1591 * File is a mountable location. 1592 */ 1593 MOUNTABLE = 6, 1594 } 1595 alias GFileType FileType; 1596 1597 /** 1598 * Indicates a hint from the file system whether files should be 1599 * previewed in a file manager. Returned as the value of the key 1600 * #G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW. 1601 */ 1602 public enum GFilesystemPreviewType 1603 { 1604 /** 1605 * Only preview files if user has explicitly requested it. 1606 */ 1607 IF_ALWAYS = 0, 1608 /** 1609 * Preview files if user has requested preview of "local" files. 1610 */ 1611 IF_LOCAL = 1, 1612 /** 1613 * Never preview files. 1614 */ 1615 NEVER = 2, 1616 } 1617 alias GFilesystemPreviewType FilesystemPreviewType; 1618 1619 /** 1620 * Error codes returned by GIO functions. 1621 * 1622 * Note that this domain may be extended in future GLib releases. In 1623 * general, new error codes either only apply to new APIs, or else 1624 * replace %G_IO_ERROR_FAILED in cases that were not explicitly 1625 * distinguished before. You should therefore avoid writing code like 1626 * |[<!-- language="C" --> 1627 * if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED)) 1628 * { 1629 * // Assume that this is EPRINTERONFIRE 1630 * ... 1631 * } 1632 * ]| 1633 * but should instead treat all unrecognized error codes the same as 1634 * #G_IO_ERROR_FAILED. 1635 */ 1636 public enum GIOErrorEnum 1637 { 1638 /** 1639 * Generic error condition for when an operation fails 1640 * and no more specific #GIOErrorEnum value is defined. 1641 */ 1642 FAILED = 0, 1643 /** 1644 * File not found. 1645 */ 1646 NOT_FOUND = 1, 1647 /** 1648 * File already exists. 1649 */ 1650 EXISTS = 2, 1651 /** 1652 * File is a directory. 1653 */ 1654 IS_DIRECTORY = 3, 1655 /** 1656 * File is not a directory. 1657 */ 1658 NOT_DIRECTORY = 4, 1659 /** 1660 * File is a directory that isn't empty. 1661 */ 1662 NOT_EMPTY = 5, 1663 /** 1664 * File is not a regular file. 1665 */ 1666 NOT_REGULAR_FILE = 6, 1667 /** 1668 * File is not a symbolic link. 1669 */ 1670 NOT_SYMBOLIC_LINK = 7, 1671 /** 1672 * File cannot be mounted. 1673 */ 1674 NOT_MOUNTABLE_FILE = 8, 1675 /** 1676 * Filename is too many characters. 1677 */ 1678 FILENAME_TOO_LONG = 9, 1679 /** 1680 * Filename is invalid or contains invalid characters. 1681 */ 1682 INVALID_FILENAME = 10, 1683 /** 1684 * File contains too many symbolic links. 1685 */ 1686 TOO_MANY_LINKS = 11, 1687 /** 1688 * No space left on drive. 1689 */ 1690 NO_SPACE = 12, 1691 /** 1692 * Invalid argument. 1693 */ 1694 INVALID_ARGUMENT = 13, 1695 /** 1696 * Permission denied. 1697 */ 1698 PERMISSION_DENIED = 14, 1699 /** 1700 * Operation (or one of its parameters) not supported 1701 */ 1702 NOT_SUPPORTED = 15, 1703 /** 1704 * File isn't mounted. 1705 */ 1706 NOT_MOUNTED = 16, 1707 /** 1708 * File is already mounted. 1709 */ 1710 ALREADY_MOUNTED = 17, 1711 /** 1712 * File was closed. 1713 */ 1714 CLOSED = 18, 1715 /** 1716 * Operation was cancelled. See #GCancellable. 1717 */ 1718 CANCELLED = 19, 1719 /** 1720 * Operations are still pending. 1721 */ 1722 PENDING = 20, 1723 /** 1724 * File is read only. 1725 */ 1726 READ_ONLY = 21, 1727 /** 1728 * Backup couldn't be created. 1729 */ 1730 CANT_CREATE_BACKUP = 22, 1731 /** 1732 * File's Entity Tag was incorrect. 1733 */ 1734 WRONG_ETAG = 23, 1735 /** 1736 * Operation timed out. 1737 */ 1738 TIMED_OUT = 24, 1739 /** 1740 * Operation would be recursive. 1741 */ 1742 WOULD_RECURSE = 25, 1743 /** 1744 * File is busy. 1745 */ 1746 BUSY = 26, 1747 /** 1748 * Operation would block. 1749 */ 1750 WOULD_BLOCK = 27, 1751 /** 1752 * Host couldn't be found (remote operations). 1753 */ 1754 HOST_NOT_FOUND = 28, 1755 /** 1756 * Operation would merge files. 1757 */ 1758 WOULD_MERGE = 29, 1759 /** 1760 * Operation failed and a helper program has 1761 * already interacted with the user. Do not display any error dialog. 1762 */ 1763 FAILED_HANDLED = 30, 1764 /** 1765 * The current process has too many files 1766 * open and can't open any more. Duplicate descriptors do count toward 1767 * this limit. Since 2.20 1768 */ 1769 TOO_MANY_OPEN_FILES = 31, 1770 /** 1771 * The object has not been initialized. Since 2.22 1772 */ 1773 NOT_INITIALIZED = 32, 1774 /** 1775 * The requested address is already in use. Since 2.22 1776 */ 1777 ADDRESS_IN_USE = 33, 1778 /** 1779 * Need more input to finish operation. Since 2.24 1780 */ 1781 PARTIAL_INPUT = 34, 1782 /** 1783 * The input data was invalid. Since 2.24 1784 */ 1785 INVALID_DATA = 35, 1786 /** 1787 * A remote object generated an error that 1788 * doesn't correspond to a locally registered #GError error 1789 * domain. Use g_dbus_error_get_remote_error() to extract the D-Bus 1790 * error name and g_dbus_error_strip_remote_error() to fix up the 1791 * message so it matches what was received on the wire. Since 2.26. 1792 */ 1793 DBUS_ERROR = 36, 1794 /** 1795 * Host unreachable. Since 2.26 1796 */ 1797 HOST_UNREACHABLE = 37, 1798 /** 1799 * Network unreachable. Since 2.26 1800 */ 1801 NETWORK_UNREACHABLE = 38, 1802 /** 1803 * Connection refused. Since 2.26 1804 */ 1805 CONNECTION_REFUSED = 39, 1806 /** 1807 * Connection to proxy server failed. Since 2.26 1808 */ 1809 PROXY_FAILED = 40, 1810 /** 1811 * Proxy authentication failed. Since 2.26 1812 */ 1813 PROXY_AUTH_FAILED = 41, 1814 /** 1815 * Proxy server needs authentication. Since 2.26 1816 */ 1817 PROXY_NEED_AUTH = 42, 1818 /** 1819 * Proxy connection is not allowed by ruleset. 1820 * Since 2.26 1821 */ 1822 PROXY_NOT_ALLOWED = 43, 1823 /** 1824 * Broken pipe. Since 2.36 1825 */ 1826 BROKEN_PIPE = 44, 1827 /** 1828 * Connection closed by peer. Note that this 1829 * is the same code as %G_IO_ERROR_BROKEN_PIPE; before 2.44 some 1830 * "connection closed" errors returned %G_IO_ERROR_BROKEN_PIPE, but others 1831 * returned %G_IO_ERROR_FAILED. Now they should all return the same 1832 * value, which has this more logical name. Since 2.44. 1833 */ 1834 CONNECTION_CLOSED = 44, 1835 /** 1836 * Transport endpoint is not connected. Since 2.44 1837 */ 1838 NOT_CONNECTED = 45, 1839 } 1840 alias GIOErrorEnum IOErrorEnum; 1841 1842 /** 1843 * Flags for use with g_io_module_scope_new(). 1844 * 1845 * Since: 2.30 1846 */ 1847 public enum GIOModuleScopeFlags 1848 { 1849 /** 1850 * No module scan flags 1851 */ 1852 NONE = 0, 1853 /** 1854 * When using this scope to load or 1855 * scan modules, automatically block a modules which has the same base 1856 * basename as previously loaded module. 1857 */ 1858 BLOCK_DUPLICATES = 1, 1859 } 1860 alias GIOModuleScopeFlags IOModuleScopeFlags; 1861 1862 /** 1863 * GIOStreamSpliceFlags determine how streams should be spliced. 1864 * 1865 * Since: 2.28 1866 */ 1867 public enum GIOStreamSpliceFlags 1868 { 1869 /** 1870 * Do not close either stream. 1871 */ 1872 NONE = 0, 1873 /** 1874 * Close the first stream after 1875 * the splice. 1876 */ 1877 CLOSE_STREAM1 = 1, 1878 /** 1879 * Close the second stream after 1880 * the splice. 1881 */ 1882 CLOSE_STREAM2 = 2, 1883 /** 1884 * Wait for both splice operations to finish 1885 * before calling the callback. 1886 */ 1887 WAIT_FOR_BOTH = 4, 1888 } 1889 alias GIOStreamSpliceFlags IOStreamSpliceFlags; 1890 1891 /** 1892 * Flags used when mounting a mount. 1893 */ 1894 public enum GMountMountFlags 1895 { 1896 /** 1897 * No flags set. 1898 */ 1899 NONE = 0, 1900 } 1901 alias GMountMountFlags MountMountFlags; 1902 1903 /** 1904 * #GMountOperationResult is returned as a result when a request for 1905 * information is send by the mounting operation. 1906 */ 1907 public enum GMountOperationResult 1908 { 1909 /** 1910 * The request was fulfilled and the 1911 * user specified data is now available 1912 */ 1913 HANDLED = 0, 1914 /** 1915 * The user requested the mount operation 1916 * to be aborted 1917 */ 1918 ABORTED = 1, 1919 /** 1920 * The request was unhandled (i.e. not 1921 * implemented) 1922 */ 1923 UNHANDLED = 2, 1924 } 1925 alias GMountOperationResult MountOperationResult; 1926 1927 /** 1928 * Flags used when an unmounting a mount. 1929 */ 1930 public enum GMountUnmountFlags 1931 { 1932 /** 1933 * No flags set. 1934 */ 1935 NONE = 0, 1936 /** 1937 * Unmount even if there are outstanding 1938 * file operations on the mount. 1939 */ 1940 FORCE = 1, 1941 } 1942 alias GMountUnmountFlags MountUnmountFlags; 1943 1944 /** 1945 * The host's network connectivity state, as reported by #GNetworkMonitor. 1946 * 1947 * Since: 2.44 1948 */ 1949 public enum GNetworkConnectivity 1950 { 1951 /** 1952 * The host is not configured with a 1953 * route to the Internet; it may or may not be connected to a local 1954 * network. 1955 */ 1956 LOCAL = 1, 1957 /** 1958 * The host is connected to a network, but 1959 * does not appear to be able to reach the full Internet, perhaps 1960 * due to upstream network problems. 1961 */ 1962 LIMITED = 2, 1963 /** 1964 * The host is behind a captive portal and 1965 * cannot reach the full Internet. 1966 */ 1967 PORTAL = 3, 1968 /** 1969 * The host is connected to a network, and 1970 * appears to be able to reach the full Internet. 1971 */ 1972 FULL = 4, 1973 } 1974 alias GNetworkConnectivity NetworkConnectivity; 1975 1976 /** 1977 * Priority levels for #GNotifications. 1978 * 1979 * Since: 2.42 1980 */ 1981 public enum GNotificationPriority 1982 { 1983 /** 1984 * the default priority, to be used for the 1985 * majority of notifications (for example email messages, software updates, 1986 * completed download/sync operations) 1987 */ 1988 NORMAL = 0, 1989 /** 1990 * for notifications that do not require 1991 * immediate attention - typically used for contextual background 1992 * information, such as contact birthdays or local weather 1993 */ 1994 LOW = 1, 1995 /** 1996 * for events that require more attention, 1997 * usually because responses are time-sensitive (for example chat and SMS 1998 * messages or alarms) 1999 */ 2000 HIGH = 2, 2001 /** 2002 * for urgent notifications, or notifications 2003 * that require a response in a short space of time (for example phone calls 2004 * or emergency warnings) 2005 */ 2006 URGENT = 3, 2007 } 2008 alias GNotificationPriority NotificationPriority; 2009 2010 /** 2011 * GOutputStreamSpliceFlags determine how streams should be spliced. 2012 */ 2013 public enum GOutputStreamSpliceFlags 2014 { 2015 /** 2016 * Do not close either stream. 2017 */ 2018 NONE = 0, 2019 /** 2020 * Close the source stream after 2021 * the splice. 2022 */ 2023 CLOSE_SOURCE = 1, 2024 /** 2025 * Close the target stream after 2026 * the splice. 2027 */ 2028 CLOSE_TARGET = 2, 2029 } 2030 alias GOutputStreamSpliceFlags OutputStreamSpliceFlags; 2031 2032 /** 2033 * #GPasswordSave is used to indicate the lifespan of a saved password. 2034 * 2035 * #Gvfs stores passwords in the Gnome keyring when this flag allows it 2036 * to, and later retrieves it again from there. 2037 */ 2038 public enum GPasswordSave 2039 { 2040 /** 2041 * never save a password. 2042 */ 2043 NEVER = 0, 2044 /** 2045 * save a password for the session. 2046 */ 2047 FOR_SESSION = 1, 2048 /** 2049 * save a password permanently. 2050 */ 2051 PERMANENTLY = 2, 2052 } 2053 alias GPasswordSave PasswordSave; 2054 2055 /** 2056 * An error code used with %G_RESOLVER_ERROR in a #GError returned 2057 * from a #GResolver routine. 2058 * 2059 * Since: 2.22 2060 */ 2061 public enum GResolverError 2062 { 2063 /** 2064 * the requested name/address/service was not 2065 * found 2066 */ 2067 NOT_FOUND = 0, 2068 /** 2069 * the requested information could not 2070 * be looked up due to a network error or similar problem 2071 */ 2072 TEMPORARY_FAILURE = 1, 2073 /** 2074 * unknown error 2075 */ 2076 INTERNAL = 2, 2077 } 2078 alias GResolverError ResolverError; 2079 2080 /** 2081 * The type of record that g_resolver_lookup_records() or 2082 * g_resolver_lookup_records_async() should retrieve. The records are returned 2083 * as lists of #GVariant tuples. Each record type has different values in 2084 * the variant tuples returned. 2085 * 2086 * %G_RESOLVER_RECORD_SRV records are returned as variants with the signature 2087 * '(qqqs)', containing a guint16 with the priority, a guint16 with the 2088 * weight, a guint16 with the port, and a string of the hostname. 2089 * 2090 * %G_RESOLVER_RECORD_MX records are returned as variants with the signature 2091 * '(qs)', representing a guint16 with the preference, and a string containing 2092 * the mail exchanger hostname. 2093 * 2094 * %G_RESOLVER_RECORD_TXT records are returned as variants with the signature 2095 * '(as)', representing an array of the strings in the text record. 2096 * 2097 * %G_RESOLVER_RECORD_SOA records are returned as variants with the signature 2098 * '(ssuuuuu)', representing a string containing the primary name server, a 2099 * string containing the administrator, the serial as a guint32, the refresh 2100 * interval as guint32, the retry interval as a guint32, the expire timeout 2101 * as a guint32, and the ttl as a guint32. 2102 * 2103 * %G_RESOLVER_RECORD_NS records are returned as variants with the signature 2104 * '(s)', representing a string of the hostname of the name server. 2105 * 2106 * Since: 2.34 2107 */ 2108 public enum GResolverRecordType 2109 { 2110 /** 2111 * lookup DNS SRV records for a domain 2112 */ 2113 SRV = 1, 2114 /** 2115 * lookup DNS MX records for a domain 2116 */ 2117 MX = 2, 2118 /** 2119 * lookup DNS TXT records for a name 2120 */ 2121 TXT = 3, 2122 /** 2123 * lookup DNS SOA records for a zone 2124 */ 2125 SOA = 4, 2126 /** 2127 * lookup DNS NS records for a domain 2128 */ 2129 NS = 5, 2130 } 2131 alias GResolverRecordType ResolverRecordType; 2132 2133 /** 2134 * An error code used with %G_RESOURCE_ERROR in a #GError returned 2135 * from a #GResource routine. 2136 * 2137 * Since: 2.32 2138 */ 2139 public enum GResourceError 2140 { 2141 /** 2142 * no file was found at the requested path 2143 */ 2144 NOT_FOUND = 0, 2145 /** 2146 * unknown error 2147 */ 2148 INTERNAL = 1, 2149 } 2150 alias GResourceError ResourceError; 2151 2152 /** 2153 * GResourceFlags give information about a particular file inside a resource 2154 * bundle. 2155 * 2156 * Since: 2.32 2157 */ 2158 public enum GResourceFlags 2159 { 2160 /** 2161 * No flags set. 2162 */ 2163 NONE = 0, 2164 /** 2165 * The file is compressed. 2166 */ 2167 COMPRESSED = 1, 2168 } 2169 alias GResourceFlags ResourceFlags; 2170 2171 /** 2172 * GResourceLookupFlags determine how resource path lookups are handled. 2173 * 2174 * Since: 2.32 2175 */ 2176 public enum GResourceLookupFlags 2177 { 2178 /** 2179 * No flags set. 2180 */ 2181 NONE = 0, 2182 } 2183 alias GResourceLookupFlags ResourceLookupFlags; 2184 2185 /** 2186 * Flags used when creating a binding. These flags determine in which 2187 * direction the binding works. The default is to synchronize in both 2188 * directions. 2189 */ 2190 public enum GSettingsBindFlags 2191 { 2192 /** 2193 * Equivalent to `G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET` 2194 */ 2195 DEFAULT = 0, 2196 /** 2197 * Update the #GObject property when the setting changes. 2198 * It is an error to use this flag if the property is not writable. 2199 */ 2200 GET = 1, 2201 /** 2202 * Update the setting when the #GObject property changes. 2203 * It is an error to use this flag if the property is not readable. 2204 */ 2205 SET = 2, 2206 /** 2207 * Do not try to bind a "sensitivity" property to the writability of the setting 2208 */ 2209 NO_SENSITIVITY = 4, 2210 /** 2211 * When set in addition to #G_SETTINGS_BIND_GET, set the #GObject property 2212 * value initially from the setting, but do not listen for changes of the setting 2213 */ 2214 GET_NO_CHANGES = 8, 2215 /** 2216 * When passed to g_settings_bind(), uses a pair of mapping functions that invert 2217 * the boolean value when mapping between the setting and the property. The setting and property must both 2218 * be booleans. You cannot pass this flag to g_settings_bind_with_mapping(). 2219 */ 2220 INVERT_BOOLEAN = 16, 2221 } 2222 alias GSettingsBindFlags SettingsBindFlags; 2223 2224 /** 2225 * Describes an event occurring on a #GSocketClient. See the 2226 * #GSocketClient::event signal for more details. 2227 * 2228 * Additional values may be added to this type in the future. 2229 * 2230 * Since: 2.32 2231 */ 2232 public enum GSocketClientEvent 2233 { 2234 /** 2235 * The client is doing a DNS lookup. 2236 */ 2237 RESOLVING = 0, 2238 /** 2239 * The client has completed a DNS lookup. 2240 */ 2241 RESOLVED = 1, 2242 /** 2243 * The client is connecting to a remote 2244 * host (either a proxy or the destination server). 2245 */ 2246 CONNECTING = 2, 2247 /** 2248 * The client has connected to a remote 2249 * host. 2250 */ 2251 CONNECTED = 3, 2252 /** 2253 * The client is negotiating 2254 * with a proxy to connect to the destination server. 2255 */ 2256 PROXY_NEGOTIATING = 4, 2257 /** 2258 * The client has negotiated 2259 * with the proxy server. 2260 */ 2261 PROXY_NEGOTIATED = 5, 2262 /** 2263 * The client is performing a 2264 * TLS handshake. 2265 */ 2266 TLS_HANDSHAKING = 6, 2267 /** 2268 * The client has performed a 2269 * TLS handshake. 2270 */ 2271 TLS_HANDSHAKED = 7, 2272 /** 2273 * The client is done with a particular 2274 * #GSocketConnectable. 2275 */ 2276 COMPLETE = 8, 2277 } 2278 alias GSocketClientEvent SocketClientEvent; 2279 2280 /** 2281 * The protocol family of a #GSocketAddress. (These values are 2282 * identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX, 2283 * if available.) 2284 * 2285 * Since: 2.22 2286 */ 2287 public enum GSocketFamily 2288 { 2289 /** 2290 * no address family 2291 */ 2292 INVALID = 0, 2293 /** 2294 * the UNIX domain family 2295 */ 2296 UNIX = 1, 2297 /** 2298 * the IPv4 family 2299 */ 2300 IPV4 = 2, 2301 /** 2302 * the IPv6 family 2303 */ 2304 IPV6 = 10, 2305 } 2306 alias GSocketFamily SocketFamily; 2307 2308 /** 2309 * Flags used in g_socket_receive_message() and g_socket_send_message(). 2310 * The flags listed in the enum are some commonly available flags, but the 2311 * values used for them are the same as on the platform, and any other flags 2312 * are passed in/out as is. So to use a platform specific flag, just include 2313 * the right system header and pass in the flag. 2314 * 2315 * Since: 2.22 2316 */ 2317 public enum GSocketMsgFlags 2318 { 2319 /** 2320 * No flags. 2321 */ 2322 NONE = 0, 2323 /** 2324 * Request to send/receive out of band data. 2325 */ 2326 OOB = 1, 2327 /** 2328 * Read data from the socket without removing it from 2329 * the queue. 2330 */ 2331 PEEK = 2, 2332 /** 2333 * Don't use a gateway to send out the packet, 2334 * only send to hosts on directly connected networks. 2335 */ 2336 DONTROUTE = 4, 2337 } 2338 alias GSocketMsgFlags SocketMsgFlags; 2339 2340 /** 2341 * A protocol identifier is specified when creating a #GSocket, which is a 2342 * family/type specific identifier, where 0 means the default protocol for 2343 * the particular family/type. 2344 * 2345 * This enum contains a set of commonly available and used protocols. You 2346 * can also pass any other identifiers handled by the platform in order to 2347 * use protocols not listed here. 2348 * 2349 * Since: 2.22 2350 */ 2351 public enum GSocketProtocol 2352 { 2353 /** 2354 * The protocol type is unknown 2355 */ 2356 UNKNOWN = -1, 2357 /** 2358 * The default protocol for the family/type 2359 */ 2360 DEFAULT = 0, 2361 /** 2362 * TCP over IP 2363 */ 2364 TCP = 6, 2365 /** 2366 * UDP over IP 2367 */ 2368 UDP = 17, 2369 /** 2370 * SCTP over IP 2371 */ 2372 SCTP = 132, 2373 } 2374 alias GSocketProtocol SocketProtocol; 2375 2376 /** 2377 * Flags used when creating a #GSocket. Some protocols may not implement 2378 * all the socket types. 2379 * 2380 * Since: 2.22 2381 */ 2382 public enum GSocketType 2383 { 2384 /** 2385 * Type unknown or wrong 2386 */ 2387 INVALID = 0, 2388 /** 2389 * Reliable connection-based byte streams (e.g. TCP). 2390 */ 2391 STREAM = 1, 2392 /** 2393 * Connectionless, unreliable datagram passing. 2394 * (e.g. UDP) 2395 */ 2396 DATAGRAM = 2, 2397 /** 2398 * Reliable connection-based passing of datagrams 2399 * of fixed maximum length (e.g. SCTP). 2400 */ 2401 SEQPACKET = 3, 2402 } 2403 alias GSocketType SocketType; 2404 2405 /** 2406 * Flags to define the behaviour of a #GSubprocess. 2407 * 2408 * Note that the default for stdin is to redirect from /dev/null. For 2409 * stdout and stderr the default are for them to inherit the 2410 * corresponding descriptor from the calling process. 2411 * 2412 * Note that it is a programmer error to mix 'incompatible' flags. For 2413 * example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and 2414 * %G_SUBPROCESS_FLAGS_STDOUT_SILENCE. 2415 * 2416 * Since: 2.40 2417 */ 2418 public enum GSubprocessFlags 2419 { 2420 /** 2421 * No flags. 2422 */ 2423 NONE = 0, 2424 /** 2425 * create a pipe for the stdin of the 2426 * spawned process that can be accessed with 2427 * g_subprocess_get_stdin_pipe(). 2428 */ 2429 STDIN_PIPE = 1, 2430 /** 2431 * stdin is inherited from the 2432 * calling process. 2433 */ 2434 STDIN_INHERIT = 2, 2435 /** 2436 * create a pipe for the stdout of the 2437 * spawned process that can be accessed with 2438 * g_subprocess_get_stdout_pipe(). 2439 */ 2440 STDOUT_PIPE = 4, 2441 /** 2442 * silence the stdout of the spawned 2443 * process (ie: redirect to /dev/null). 2444 */ 2445 STDOUT_SILENCE = 8, 2446 /** 2447 * create a pipe for the stderr of the 2448 * spawned process that can be accessed with 2449 * g_subprocess_get_stderr_pipe(). 2450 */ 2451 STDERR_PIPE = 16, 2452 /** 2453 * silence the stderr of the spawned 2454 * process (ie: redirect to /dev/null). 2455 */ 2456 STDERR_SILENCE = 32, 2457 /** 2458 * merge the stderr of the spawned 2459 * process with whatever the stdout happens to be. This is a good way 2460 * of directing both streams to a common log file, for example. 2461 */ 2462 STDERR_MERGE = 64, 2463 /** 2464 * spawned processes will inherit the 2465 * file descriptors of their parent, unless those descriptors have 2466 * been explicitly marked as close-on-exec. This flag has no effect 2467 * over the "standard" file descriptors (stdin, stdout, stderr). 2468 */ 2469 INHERIT_FDS = 128, 2470 } 2471 alias GSubprocessFlags SubprocessFlags; 2472 2473 /** 2474 * Flags to define future #GTestDBus behaviour. 2475 * 2476 * Since: 2.34 2477 */ 2478 public enum GTestDBusFlags 2479 { 2480 /** 2481 * No flags. 2482 */ 2483 NONE = 0, 2484 } 2485 alias GTestDBusFlags TestDBusFlags; 2486 2487 /** 2488 * The client authentication mode for a #GTlsServerConnection. 2489 * 2490 * Since: 2.28 2491 */ 2492 public enum GTlsAuthenticationMode 2493 { 2494 /** 2495 * client authentication not required 2496 */ 2497 NONE = 0, 2498 /** 2499 * client authentication is requested 2500 */ 2501 REQUESTED = 1, 2502 /** 2503 * client authentication is required 2504 */ 2505 REQUIRED = 2, 2506 } 2507 alias GTlsAuthenticationMode TlsAuthenticationMode; 2508 2509 /** 2510 * A set of flags describing TLS certification validation. This can be 2511 * used to set which validation steps to perform (eg, with 2512 * g_tls_client_connection_set_validation_flags()), or to describe why 2513 * a particular certificate was rejected (eg, in 2514 * #GTlsConnection::accept-certificate). 2515 * 2516 * Since: 2.28 2517 */ 2518 public enum GTlsCertificateFlags 2519 { 2520 /** 2521 * The signing certificate authority is 2522 * not known. 2523 */ 2524 UNKNOWN_CA = 1, 2525 /** 2526 * The certificate does not match the 2527 * expected identity of the site that it was retrieved from. 2528 */ 2529 BAD_IDENTITY = 2, 2530 /** 2531 * The certificate's activation time 2532 * is still in the future 2533 */ 2534 NOT_ACTIVATED = 4, 2535 /** 2536 * The certificate has expired 2537 */ 2538 EXPIRED = 8, 2539 /** 2540 * The certificate has been revoked 2541 * according to the #GTlsConnection's certificate revocation list. 2542 */ 2543 REVOKED = 16, 2544 /** 2545 * The certificate's algorithm is 2546 * considered insecure. 2547 */ 2548 INSECURE = 32, 2549 /** 2550 * Some other error occurred validating 2551 * the certificate 2552 */ 2553 GENERIC_ERROR = 64, 2554 /** 2555 * the combination of all of the above 2556 * flags 2557 */ 2558 VALIDATE_ALL = 127, 2559 } 2560 alias GTlsCertificateFlags TlsCertificateFlags; 2561 2562 /** 2563 * Flags for g_tls_interaction_request_certificate(), 2564 * g_tls_interaction_request_certificate_async(), and 2565 * g_tls_interaction_invoke_request_certificate(). 2566 * 2567 * Since: 2.40 2568 */ 2569 public enum GTlsCertificateRequestFlags 2570 { 2571 /** 2572 * No flags 2573 */ 2574 NONE = 0, 2575 } 2576 alias GTlsCertificateRequestFlags TlsCertificateRequestFlags; 2577 2578 /** 2579 * Flags for g_tls_database_lookup_certificate_handle(), 2580 * g_tls_database_lookup_certificate_issuer(), 2581 * and g_tls_database_lookup_certificates_issued_by(). 2582 * 2583 * Since: 2.30 2584 */ 2585 public enum GTlsDatabaseLookupFlags 2586 { 2587 /** 2588 * No lookup flags 2589 */ 2590 NONE = 0, 2591 /** 2592 * Restrict lookup to certificates that have 2593 * a private key. 2594 */ 2595 KEYPAIR = 1, 2596 } 2597 alias GTlsDatabaseLookupFlags TlsDatabaseLookupFlags; 2598 2599 /** 2600 * Flags for g_tls_database_verify_chain(). 2601 * 2602 * Since: 2.30 2603 */ 2604 public enum GTlsDatabaseVerifyFlags 2605 { 2606 /** 2607 * No verification flags 2608 */ 2609 NONE = 0, 2610 } 2611 alias GTlsDatabaseVerifyFlags TlsDatabaseVerifyFlags; 2612 2613 /** 2614 * An error code used with %G_TLS_ERROR in a #GError returned from a 2615 * TLS-related routine. 2616 * 2617 * Since: 2.28 2618 */ 2619 public enum GTlsError 2620 { 2621 /** 2622 * No TLS provider is available 2623 */ 2624 UNAVAILABLE = 0, 2625 /** 2626 * Miscellaneous TLS error 2627 */ 2628 MISC = 1, 2629 /** 2630 * A certificate could not be parsed 2631 */ 2632 BAD_CERTIFICATE = 2, 2633 /** 2634 * The TLS handshake failed because the 2635 * peer does not seem to be a TLS server. 2636 */ 2637 NOT_TLS = 3, 2638 /** 2639 * The TLS handshake failed because the 2640 * peer's certificate was not acceptable. 2641 */ 2642 HANDSHAKE = 4, 2643 /** 2644 * The TLS handshake failed because 2645 * the server requested a client-side certificate, but none was 2646 * provided. See g_tls_connection_set_certificate(). 2647 */ 2648 CERTIFICATE_REQUIRED = 5, 2649 /** 2650 * The TLS connection was closed without proper 2651 * notice, which may indicate an attack. See 2652 * g_tls_connection_set_require_close_notify(). 2653 */ 2654 EOF = 6, 2655 } 2656 alias GTlsError TlsError; 2657 2658 /** 2659 * #GTlsInteractionResult is returned by various functions in #GTlsInteraction 2660 * when finishing an interaction request. 2661 * 2662 * Since: 2.30 2663 */ 2664 public enum GTlsInteractionResult 2665 { 2666 /** 2667 * The interaction was unhandled (i.e. not 2668 * implemented). 2669 */ 2670 UNHANDLED = 0, 2671 /** 2672 * The interaction completed, and resulting data 2673 * is available. 2674 */ 2675 HANDLED = 1, 2676 /** 2677 * The interaction has failed, or was cancelled. 2678 * and the operation should be aborted. 2679 */ 2680 FAILED = 2, 2681 } 2682 alias GTlsInteractionResult TlsInteractionResult; 2683 2684 /** 2685 * Various flags for the password. 2686 * 2687 * Since: 2.30 2688 */ 2689 public enum GTlsPasswordFlags 2690 { 2691 /** 2692 * No flags 2693 */ 2694 NONE = 0, 2695 /** 2696 * The password was wrong, and the user should retry. 2697 */ 2698 RETRY = 2, 2699 /** 2700 * Hint to the user that the password has been 2701 * wrong many times, and the user may not have many chances left. 2702 */ 2703 MANY_TRIES = 4, 2704 /** 2705 * Hint to the user that this is the last try to get 2706 * this password right. 2707 */ 2708 FINAL_TRY = 8, 2709 } 2710 alias GTlsPasswordFlags TlsPasswordFlags; 2711 2712 /** 2713 * When to allow rehandshaking. See 2714 * g_tls_connection_set_rehandshake_mode(). 2715 * 2716 * Since: 2.28 2717 */ 2718 public enum GTlsRehandshakeMode 2719 { 2720 /** 2721 * Never allow rehandshaking 2722 */ 2723 NEVER = 0, 2724 /** 2725 * Allow safe rehandshaking only 2726 */ 2727 SAFELY = 1, 2728 /** 2729 * Allow unsafe rehandshaking 2730 */ 2731 UNSAFELY = 2, 2732 } 2733 alias GTlsRehandshakeMode TlsRehandshakeMode; 2734 2735 /** 2736 * The type of name used by a #GUnixSocketAddress. 2737 * %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain 2738 * socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS 2739 * indicates a socket not bound to any name (eg, a client-side socket, 2740 * or a socket created with socketpair()). 2741 * 2742 * For abstract sockets, there are two incompatible ways of naming 2743 * them; the man pages suggest using the entire `struct sockaddr_un` 2744 * as the name, padding the unused parts of the %sun_path field with 2745 * zeroes; this corresponds to %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED. 2746 * However, many programs instead just use a portion of %sun_path, and 2747 * pass an appropriate smaller length to bind() or connect(). This is 2748 * %G_UNIX_SOCKET_ADDRESS_ABSTRACT. 2749 * 2750 * Since: 2.26 2751 */ 2752 public enum GUnixSocketAddressType 2753 { 2754 /** 2755 * invalid 2756 */ 2757 INVALID = 0, 2758 /** 2759 * anonymous 2760 */ 2761 ANONYMOUS = 1, 2762 /** 2763 * a filesystem path 2764 */ 2765 PATH = 2, 2766 /** 2767 * an abstract name 2768 */ 2769 ABSTRACT = 3, 2770 /** 2771 * an abstract name, 0-padded 2772 * to the full length of a unix socket name 2773 */ 2774 ABSTRACT_PADDED = 4, 2775 } 2776 alias GUnixSocketAddressType UnixSocketAddressType; 2777 2778 /** 2779 * Used to select the type of data format to use for #GZlibDecompressor 2780 * and #GZlibCompressor. 2781 * 2782 * Since: 2.24 2783 */ 2784 public enum GZlibCompressorFormat 2785 { 2786 /** 2787 * deflate compression with zlib header 2788 */ 2789 ZLIB = 0, 2790 /** 2791 * gzip file format 2792 */ 2793 GZIP = 1, 2794 /** 2795 * deflate compression with no header 2796 */ 2797 RAW = 2, 2798 } 2799 alias GZlibCompressorFormat ZlibCompressorFormat; 2800 2801 struct GAction; 2802 2803 /** 2804 * This struct defines a single action. It is for use with 2805 * g_action_map_add_action_entries(). 2806 * 2807 * The order of the items in the structure are intended to reflect 2808 * frequency of use. It is permissible to use an incomplete initialiser 2809 * in order to leave some of the later values as %NULL. All values 2810 * after @name are optional. Additional optional fields may be added in 2811 * the future. 2812 * 2813 * See g_action_map_add_action_entries() for an example. 2814 */ 2815 struct GActionEntry 2816 { 2817 /** 2818 * the name of the action 2819 */ 2820 const(char)* name; 2821 extern(C) void function(GSimpleAction* action, GVariant* parameter, void* userData) activate; 2822 /** 2823 * the type of the parameter that must be passed to the 2824 * activate function for this action, given as a single 2825 * GVariant type string (or %NULL for no parameter) 2826 */ 2827 const(char)* parameterType; 2828 /** 2829 * the initial state for this action, given in 2830 * [GVariant text format][gvariant-text]. The state is parsed 2831 * with no extra type information, so type tags must be added to 2832 * the string if they are necessary. Stateless actions should 2833 * give %NULL here. 2834 */ 2835 const(char)* state; 2836 extern(C) void function(GSimpleAction* action, GVariant* value, void* userData) changeState; 2837 size_t[3] padding; 2838 } 2839 2840 struct GActionGroup; 2841 2842 /** 2843 * The virtual function table for #GActionGroup. 2844 * 2845 * Since: 2.28 2846 */ 2847 struct GActionGroupInterface 2848 { 2849 GTypeInterface gIface; 2850 /** 2851 * 2852 * Params: 2853 * actionGroup = a #GActionGroup 2854 * actionName = the name of the action to check for 2855 * Return: whether the named action exists 2856 */ 2857 extern(C) int function(GActionGroup* actionGroup, const(char)* actionName) hasAction; 2858 /** 2859 * 2860 * Params: 2861 * actionGroup = a #GActionGroup 2862 * Return: a %NULL-terminated array of the names of the 2863 * actions in the groupb 2864 */ 2865 extern(C) char** function(GActionGroup* actionGroup) listActions; 2866 /** 2867 * 2868 * Params: 2869 * actionGroup = a #GActionGroup 2870 * actionName = the name of the action to query 2871 * Return: whether or not the action is currently enabled 2872 */ 2873 extern(C) int function(GActionGroup* actionGroup, const(char)* actionName) getActionEnabled; 2874 /** 2875 * 2876 * Params: 2877 * actionGroup = a #GActionGroup 2878 * actionName = the name of the action to query 2879 * Return: the parameter type 2880 */ 2881 extern(C) GVariantType* function(GActionGroup* actionGroup, const(char)* actionName) getActionParameterType; 2882 /** 2883 * 2884 * Params: 2885 * actionGroup = a #GActionGroup 2886 * actionName = the name of the action to query 2887 * Return: the state type, if the action 2888 * is stateful 2889 */ 2890 extern(C) GVariantType* function(GActionGroup* actionGroup, const(char)* actionName) getActionStateType; 2891 /** 2892 * 2893 * Params: 2894 * actionGroup = a #GActionGroup 2895 * actionName = the name of the action to query 2896 * Return: the state range hint 2897 */ 2898 extern(C) GVariant* function(GActionGroup* actionGroup, const(char)* actionName) getActionStateHint; 2899 /** 2900 * 2901 * Params: 2902 * actionGroup = a #GActionGroup 2903 * actionName = the name of the action to query 2904 * Return: the current state of the action 2905 */ 2906 extern(C) GVariant* function(GActionGroup* actionGroup, const(char)* actionName) getActionState; 2907 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* value) changeActionState; 2908 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* parameter) activateAction; 2909 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName) actionAdded; 2910 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName) actionRemoved; 2911 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, int enabled) actionEnabledChanged; 2912 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* state) actionStateChanged; 2913 /** 2914 * 2915 * Params: 2916 * actionGroup = a #GActionGroup 2917 * actionName = the name of an action in the group 2918 * enabled = if the action is presently enabled 2919 * parameterType = the parameter type, or %NULL if none needed 2920 * stateType = the state type, or %NULL if stateless 2921 * stateHint = the state hint, or %NULL if none 2922 * state = the current state, or %NULL if stateless 2923 * Return: %TRUE if the action exists, else %FALSE 2924 */ 2925 extern(C) int function(GActionGroup* actionGroup, const(char)* actionName, int* enabled, GVariantType** parameterType, GVariantType** stateType, GVariant** stateHint, GVariant** state) queryAction; 2926 } 2927 2928 /** 2929 * The virtual function table for #GAction. 2930 * 2931 * Since: 2.28 2932 */ 2933 struct GActionInterface 2934 { 2935 GTypeInterface gIface; 2936 /** 2937 * 2938 * Params: 2939 * action = a #GAction 2940 * Return: the name of the action 2941 */ 2942 extern(C) const(char)* function(GAction* action) getName; 2943 /** 2944 * 2945 * Params: 2946 * action = a #GAction 2947 * Return: the parameter type 2948 */ 2949 extern(C) GVariantType* function(GAction* action) getParameterType; 2950 /** 2951 * 2952 * Params: 2953 * action = a #GAction 2954 * Return: the state type, if the action is stateful 2955 */ 2956 extern(C) GVariantType* function(GAction* action) getStateType; 2957 /** 2958 * 2959 * Params: 2960 * action = a #GAction 2961 * Return: the state range hint 2962 */ 2963 extern(C) GVariant* function(GAction* action) getStateHint; 2964 /** 2965 * 2966 * Params: 2967 * action = a #GAction 2968 * Return: whether the action is enabled 2969 */ 2970 extern(C) int function(GAction* action) getEnabled; 2971 /** 2972 * 2973 * Params: 2974 * action = a #GAction 2975 * Return: the current state of the action 2976 */ 2977 extern(C) GVariant* function(GAction* action) getState; 2978 extern(C) void function(GAction* action, GVariant* value) changeState; 2979 extern(C) void function(GAction* action, GVariant* parameter) activate; 2980 } 2981 2982 struct GActionMap; 2983 2984 /** 2985 * The virtual function table for #GActionMap. 2986 * 2987 * Since: 2.32 2988 */ 2989 struct GActionMapInterface 2990 { 2991 GTypeInterface gIface; 2992 /** 2993 * 2994 * Params: 2995 * actionMap = a #GActionMap 2996 * actionName = the name of an action 2997 * Return: a #GAction, or %NULL 2998 */ 2999 extern(C) GAction* function(GActionMap* actionMap, const(char)* actionName) lookupAction; 3000 extern(C) void function(GActionMap* actionMap, GAction* action) addAction; 3001 extern(C) void function(GActionMap* actionMap, const(char)* actionName) removeAction; 3002 } 3003 3004 struct GAppInfo; 3005 3006 /** 3007 * Application Information interface, for operating system portability. 3008 */ 3009 struct GAppInfoIface 3010 { 3011 /** 3012 * The parent interface. 3013 */ 3014 GTypeInterface gIface; 3015 /** 3016 * 3017 * Params: 3018 * appinfo = a #GAppInfo. 3019 * Return: a duplicate of @appinfo. 3020 */ 3021 extern(C) GAppInfo* function(GAppInfo* appinfo) dup; 3022 /** 3023 * 3024 * Params: 3025 * appinfo1 = the first #GAppInfo. 3026 * appinfo2 = the second #GAppInfo. 3027 * Return: %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise. 3028 */ 3029 extern(C) int function(GAppInfo* appinfo1, GAppInfo* appinfo2) equal; 3030 /** 3031 * 3032 * Params: 3033 * appinfo = a #GAppInfo. 3034 * Return: a string containing the application's ID. 3035 */ 3036 extern(C) const(char)* function(GAppInfo* appinfo) getId; 3037 /** 3038 * 3039 * Params: 3040 * appinfo = a #GAppInfo. 3041 * Return: the name of the application for @appinfo. 3042 */ 3043 extern(C) const(char)* function(GAppInfo* appinfo) getName; 3044 /** 3045 * 3046 * Params: 3047 * appinfo = a #GAppInfo. 3048 * Return: a string containing a description of the 3049 * application @appinfo, or %NULL if none. 3050 */ 3051 extern(C) const(char)* function(GAppInfo* appinfo) getDescription; 3052 /** 3053 * 3054 * Params: 3055 * appinfo = a #GAppInfo 3056 * Return: a string containing the @appinfo's application 3057 * binaries name 3058 */ 3059 extern(C) const(char)* function(GAppInfo* appinfo) getExecutable; 3060 /** 3061 * 3062 * Params: 3063 * appinfo = a #GAppInfo. 3064 * Return: the default #GIcon for @appinfo or %NULL 3065 * if there is no default icon. 3066 */ 3067 extern(C) GIcon* function(GAppInfo* appinfo) getIcon; 3068 /** 3069 * 3070 * Params: 3071 * appinfo = a #GAppInfo 3072 * files = a #GList of #GFile objects 3073 * launchContext = a #GAppLaunchContext or %NULL 3074 * Return: %TRUE on successful launch, %FALSE otherwise. 3075 * 3076 * Throws: GException on failure. 3077 */ 3078 extern(C) int function(GAppInfo* appinfo, GList* files, GAppLaunchContext* launchContext, GError** err) launch; 3079 /** 3080 * 3081 * Params: 3082 * appinfo = a #GAppInfo. 3083 * Return: %TRUE if the @appinfo supports URIs. 3084 */ 3085 extern(C) int function(GAppInfo* appinfo) supportsUris; 3086 /** 3087 * 3088 * Params: 3089 * appinfo = a #GAppInfo. 3090 * Return: %TRUE if the @appinfo supports files. 3091 */ 3092 extern(C) int function(GAppInfo* appinfo) supportsFiles; 3093 /** 3094 * 3095 * Params: 3096 * appinfo = a #GAppInfo 3097 * uris = a #GList containing URIs to launch. 3098 * launchContext = a #GAppLaunchContext or %NULL 3099 * Return: %TRUE on successful launch, %FALSE otherwise. 3100 * 3101 * Throws: GException on failure. 3102 */ 3103 extern(C) int function(GAppInfo* appinfo, GList* uris, GAppLaunchContext* launchContext, GError** err) launchUris; 3104 /** 3105 * 3106 * Params: 3107 * appinfo = a #GAppInfo. 3108 * Return: %TRUE if the @appinfo should be shown, %FALSE otherwise. 3109 */ 3110 extern(C) int function(GAppInfo* appinfo) shouldShow; 3111 /** 3112 * 3113 * Params: 3114 * appinfo = a #GAppInfo. 3115 * contentType = the content type. 3116 * Return: %TRUE on success, %FALSE on error. 3117 * 3118 * Throws: GException on failure. 3119 */ 3120 extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) setAsDefaultForType; 3121 /** 3122 * 3123 * Params: 3124 * appinfo = a #GAppInfo. 3125 * extension = a string containing the file extension (without the dot). 3126 * Return: %TRUE on success, %FALSE on error. 3127 * 3128 * Throws: GException on failure. 3129 */ 3130 extern(C) int function(GAppInfo* appinfo, const(char)* extension, GError** err) setAsDefaultForExtension; 3131 /** 3132 * 3133 * Params: 3134 * appinfo = a #GAppInfo. 3135 * contentType = a string. 3136 * Return: %TRUE on success, %FALSE on error. 3137 * 3138 * Throws: GException on failure. 3139 */ 3140 extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) addSupportsType; 3141 /** 3142 * 3143 * Params: 3144 * appinfo = a #GAppInfo. 3145 * Return: %TRUE if it is possible to remove supported 3146 * content types from a given @appinfo, %FALSE if not. 3147 */ 3148 extern(C) int function(GAppInfo* appinfo) canRemoveSupportsType; 3149 /** 3150 * 3151 * Params: 3152 * appinfo = a #GAppInfo. 3153 * contentType = a string. 3154 * Return: %TRUE on success, %FALSE on error. 3155 * 3156 * Throws: GException on failure. 3157 */ 3158 extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) removeSupportsType; 3159 /** 3160 * 3161 * Params: 3162 * appinfo = a #GAppInfo 3163 * Return: %TRUE if @appinfo can be deleted 3164 */ 3165 extern(C) int function(GAppInfo* appinfo) canDelete; 3166 /** 3167 * 3168 * Params: 3169 * appinfo = a #GAppInfo 3170 * Return: %TRUE if @appinfo has been deleted 3171 */ 3172 extern(C) int function(GAppInfo* appinfo) doDelete; 3173 /** 3174 * 3175 * Params: 3176 * appinfo = a #GAppInfo 3177 * Return: a string containing the @appinfo's commandline, 3178 * or %NULL if this information is not available 3179 */ 3180 extern(C) const(char)* function(GAppInfo* appinfo) getCommandline; 3181 /** 3182 * 3183 * Params: 3184 * appinfo = a #GAppInfo. 3185 * Return: the display name of the application for @appinfo, or the name if 3186 * no display name is available. 3187 */ 3188 extern(C) const(char)* function(GAppInfo* appinfo) getDisplayName; 3189 /** 3190 * 3191 * Params: 3192 * appinfo = a #GAppInfo. 3193 * contentType = the content type. 3194 * Return: %TRUE on success, %FALSE on error. 3195 * 3196 * Throws: GException on failure. 3197 */ 3198 extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) setAsLastUsedForType; 3199 /** 3200 * 3201 * Params: 3202 * appinfo = a #GAppInfo that can handle files 3203 * Return: a list of content types. 3204 */ 3205 extern(C) char** function(GAppInfo* appinfo) getSupportedTypes; 3206 } 3207 3208 struct GAppInfoMonitor; 3209 3210 struct GAppLaunchContext 3211 { 3212 GObject parentInstance; 3213 GAppLaunchContextPrivate* priv; 3214 } 3215 3216 struct GAppLaunchContextClass 3217 { 3218 GObjectClass parentClass; 3219 /** 3220 * 3221 * Params: 3222 * context = a #GAppLaunchContext 3223 * info = a #GAppInfo 3224 * files = a #GList of #GFile objects 3225 * Return: a display string for the display. 3226 */ 3227 extern(C) char* function(GAppLaunchContext* context, GAppInfo* info, GList* files) getDisplay; 3228 /** 3229 * 3230 * Params: 3231 * context = a #GAppLaunchContext 3232 * info = a #GAppInfo 3233 * files = a #GList of of #GFile objects 3234 * Return: a startup notification ID for the application, or %NULL if 3235 * not supported. 3236 */ 3237 extern(C) char* function(GAppLaunchContext* context, GAppInfo* info, GList* files) getStartupNotifyId; 3238 extern(C) void function(GAppLaunchContext* context, const(char)* startupNotifyId) launchFailed; 3239 extern(C) void function(GAppLaunchContext* context, GAppInfo* info, GVariant* platformData) launched; 3240 extern(C) void function() GReserved1; 3241 extern(C) void function() GReserved2; 3242 extern(C) void function() GReserved3; 3243 extern(C) void function() GReserved4; 3244 } 3245 3246 struct GAppLaunchContextPrivate; 3247 3248 struct GApplication 3249 { 3250 GObject parentInstance; 3251 GApplicationPrivate* priv; 3252 } 3253 3254 /** 3255 * Virtual function table for #GApplication. 3256 * 3257 * Since: 2.28 3258 */ 3259 struct GApplicationClass 3260 { 3261 GObjectClass parentClass; 3262 extern(C) void function(GApplication* application) startup; 3263 extern(C) void function(GApplication* application) activate; 3264 extern(C) void function(GApplication* application, GFile** files, int nFiles, const(char)* hint) open; 3265 extern(C) int function(GApplication* application, GApplicationCommandLine* commandLine) commandLine; 3266 /** 3267 * 3268 * Params: 3269 * application = a #GApplication 3270 * arguments = array of command line arguments 3271 * exitStatus = exit status to fill after processing the command line. 3272 * Return: %TRUE if the commandline has been completely handled 3273 */ 3274 extern(C) int function(GApplication* application, char*** arguments, int* exitStatus) localCommandLine; 3275 extern(C) void function(GApplication* application, GVariant* platformData) beforeEmit; 3276 extern(C) void function(GApplication* application, GVariant* platformData) afterEmit; 3277 extern(C) void function(GApplication* application, GVariantBuilder* builder) addPlatformData; 3278 extern(C) void function(GApplication* application) quitMainloop; 3279 extern(C) void function(GApplication* application) runMainloop; 3280 extern(C) void function(GApplication* application) shutdown; 3281 extern(C) int function(GApplication* application, GDBusConnection* connection, const(char)* objectPath, GError** err) dbusRegister; 3282 extern(C) void function(GApplication* application, GDBusConnection* connection, const(char)* objectPath) dbusUnregister; 3283 extern(C) int function(GApplication* application, GVariantDict* options) handleLocalOptions; 3284 void*[8] padding; 3285 } 3286 3287 struct GApplicationCommandLine 3288 { 3289 GObject parentInstance; 3290 GApplicationCommandLinePrivate* priv; 3291 } 3292 3293 /** 3294 * The #GApplicationCommandLineClass-struct 3295 * contains private data only. 3296 * 3297 * Since: 2.28 3298 */ 3299 struct GApplicationCommandLineClass 3300 { 3301 GObjectClass parentClass; 3302 extern(C) void function(GApplicationCommandLine* cmdline, const(char)* message) printLiteral; 3303 extern(C) void function(GApplicationCommandLine* cmdline, const(char)* message) printerrLiteral; 3304 /** 3305 * 3306 * Params: 3307 * cmdline = a #GApplicationCommandLine 3308 * Return: a #GInputStream for stdin 3309 */ 3310 extern(C) GInputStream* function(GApplicationCommandLine* cmdline) getStdin; 3311 void*[11] padding; 3312 } 3313 3314 struct GApplicationCommandLinePrivate; 3315 3316 struct GApplicationPrivate; 3317 3318 struct GAsyncInitable; 3319 3320 /** 3321 * Provides an interface for asynchronous initializing object such that 3322 * initialization may fail. 3323 * 3324 * Since: 2.22 3325 */ 3326 struct GAsyncInitableIface 3327 { 3328 /** 3329 * The parent interface. 3330 */ 3331 GTypeInterface gIface; 3332 extern(C) void function(GAsyncInitable* initable, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) initAsync; 3333 /** 3334 * 3335 * Params: 3336 * initable = a #GAsyncInitable. 3337 * res = a #GAsyncResult. 3338 * Return: %TRUE if successful. If an error has occurred, this function 3339 * will return %FALSE and set @error appropriately if present. 3340 * 3341 * Throws: GException on failure. 3342 */ 3343 extern(C) int function(GAsyncInitable* initable, GAsyncResult* res, GError** err) initFinish; 3344 } 3345 3346 struct GAsyncResult; 3347 3348 /** 3349 * Interface definition for #GAsyncResult. 3350 */ 3351 struct GAsyncResultIface 3352 { 3353 /** 3354 * The parent interface. 3355 */ 3356 GTypeInterface gIface; 3357 /** 3358 * 3359 * Params: 3360 * res = a #GAsyncResult. 3361 * Return: the user data for @res. 3362 */ 3363 extern(C) void* function(GAsyncResult* res) getUserData; 3364 /** 3365 * 3366 * Params: 3367 * res = a #GAsyncResult 3368 * Return: a new reference to the source object for the @res, 3369 * or %NULL if there is none. 3370 */ 3371 extern(C) GObject* function(GAsyncResult* res) getSourceObject; 3372 /** 3373 * 3374 * Params: 3375 * res = a #GAsyncResult 3376 * sourceTag = an application-defined tag 3377 * Return: %TRUE if @res has the indicated @source_tag, %FALSE if 3378 * not. 3379 */ 3380 extern(C) int function(GAsyncResult* res, void* sourceTag) isTagged; 3381 } 3382 3383 struct GBufferedInputStream 3384 { 3385 GFilterInputStream parentInstance; 3386 GBufferedInputStreamPrivate* priv; 3387 } 3388 3389 struct GBufferedInputStreamClass 3390 { 3391 GFilterInputStreamClass parentClass; 3392 /** 3393 * 3394 * Params: 3395 * stream = a #GBufferedInputStream 3396 * count = the number of bytes that will be read from the stream 3397 * cancellable = optional #GCancellable object, %NULL to ignore 3398 * Return: the number of bytes read into @stream's buffer, up to @count, 3399 * or -1 on error. 3400 * 3401 * Throws: GException on failure. 3402 */ 3403 extern(C) ptrdiff_t function(GBufferedInputStream* stream, ptrdiff_t count, GCancellable* cancellable, GError** err) fill; 3404 extern(C) void function(GBufferedInputStream* stream, ptrdiff_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) fillAsync; 3405 /** 3406 * 3407 * Params: 3408 * stream = a #GBufferedInputStream 3409 * result = a #GAsyncResult 3410 * Return: a #gssize of the read stream, or %-1 on an error. 3411 * 3412 * Throws: GException on failure. 3413 */ 3414 extern(C) ptrdiff_t function(GBufferedInputStream* stream, GAsyncResult* result, GError** err) fillFinish; 3415 extern(C) void function() GReserved1; 3416 extern(C) void function() GReserved2; 3417 extern(C) void function() GReserved3; 3418 extern(C) void function() GReserved4; 3419 extern(C) void function() GReserved5; 3420 } 3421 3422 struct GBufferedInputStreamPrivate; 3423 3424 struct GBufferedOutputStream 3425 { 3426 GFilterOutputStream parentInstance; 3427 GBufferedOutputStreamPrivate* priv; 3428 } 3429 3430 struct GBufferedOutputStreamClass 3431 { 3432 GFilterOutputStreamClass parentClass; 3433 extern(C) void function() GReserved1; 3434 extern(C) void function() GReserved2; 3435 } 3436 3437 struct GBufferedOutputStreamPrivate; 3438 3439 struct GBytesIcon; 3440 3441 struct GCancellable 3442 { 3443 GObject parentInstance; 3444 GCancellablePrivate* priv; 3445 } 3446 3447 struct GCancellableClass 3448 { 3449 GObjectClass parentClass; 3450 extern(C) void function(GCancellable* cancellable) cancelled; 3451 extern(C) void function() GReserved1; 3452 extern(C) void function() GReserved2; 3453 extern(C) void function() GReserved3; 3454 extern(C) void function() GReserved4; 3455 extern(C) void function() GReserved5; 3456 } 3457 3458 struct GCancellablePrivate; 3459 3460 struct GCharsetConverter; 3461 3462 struct GCharsetConverterClass 3463 { 3464 GObjectClass parentClass; 3465 } 3466 3467 struct GConverter; 3468 3469 /** 3470 * Provides an interface for converting data from one type 3471 * to another type. The conversion can be stateful 3472 * and may fail at any place. 3473 * 3474 * Since: 2.24 3475 */ 3476 struct GConverterIface 3477 { 3478 /** 3479 * The parent interface. 3480 */ 3481 GTypeInterface gIface; 3482 /** 3483 * 3484 * Params: 3485 * converter = a #GConverter. 3486 * inbuf = the buffer 3487 * containing the data to convert. 3488 * inbufSize = the number of bytes in @inbuf 3489 * outbuf = a buffer to write converted data in. 3490 * outbufSize = the number of bytes in @outbuf, must be at least one 3491 * flags = a #GConverterFlags controlling the conversion details 3492 * bytesRead = will be set to the number of bytes read from @inbuf on success 3493 * bytesWritten = will be set to the number of bytes written to @outbuf on success 3494 * Return: a #GConverterResult, %G_CONVERTER_ERROR on error. 3495 * 3496 * Throws: GException on failure. 3497 */ 3498 extern(C) GConverterResult function(GConverter* converter, void* inbuf, size_t inbufSize, void* outbuf, size_t outbufSize, GConverterFlags flags, size_t* bytesRead, size_t* bytesWritten, GError** err) convert; 3499 extern(C) void function(GConverter* converter) reset; 3500 } 3501 3502 struct GConverterInputStream 3503 { 3504 GFilterInputStream parentInstance; 3505 GConverterInputStreamPrivate* priv; 3506 } 3507 3508 struct GConverterInputStreamClass 3509 { 3510 GFilterInputStreamClass parentClass; 3511 extern(C) void function() GReserved1; 3512 extern(C) void function() GReserved2; 3513 extern(C) void function() GReserved3; 3514 extern(C) void function() GReserved4; 3515 extern(C) void function() GReserved5; 3516 } 3517 3518 struct GConverterInputStreamPrivate; 3519 3520 struct GConverterOutputStream 3521 { 3522 GFilterOutputStream parentInstance; 3523 GConverterOutputStreamPrivate* priv; 3524 } 3525 3526 struct GConverterOutputStreamClass 3527 { 3528 GFilterOutputStreamClass parentClass; 3529 extern(C) void function() GReserved1; 3530 extern(C) void function() GReserved2; 3531 extern(C) void function() GReserved3; 3532 extern(C) void function() GReserved4; 3533 extern(C) void function() GReserved5; 3534 } 3535 3536 struct GConverterOutputStreamPrivate; 3537 3538 struct GCredentials; 3539 3540 /** 3541 * Class structure for #GCredentials. 3542 * 3543 * Since: 2.26 3544 */ 3545 struct GCredentialsClass; 3546 3547 struct GDBusActionGroup; 3548 3549 struct GDBusAnnotationInfo 3550 { 3551 /** 3552 * The reference count or -1 if statically allocated. 3553 */ 3554 int refCount; 3555 /** 3556 * The name of the annotation, e.g. "org.freedesktop.DBus.Deprecated". 3557 */ 3558 char* key; 3559 /** 3560 * The value of the annotation. 3561 */ 3562 char* value; 3563 /** 3564 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3565 */ 3566 GDBusAnnotationInfo** annotations; 3567 } 3568 3569 struct GDBusArgInfo 3570 { 3571 /** 3572 * The reference count or -1 if statically allocated. 3573 */ 3574 int refCount; 3575 /** 3576 * Name of the argument, e.g. @unix_user_id. 3577 */ 3578 char* name; 3579 /** 3580 * D-Bus signature of the argument (a single complete type). 3581 */ 3582 char* signature; 3583 /** 3584 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3585 */ 3586 GDBusAnnotationInfo** annotations; 3587 } 3588 3589 struct GDBusAuthObserver; 3590 3591 struct GDBusConnection; 3592 3593 /** 3594 * Struct used in g_dbus_error_register_error_domain(). 3595 * 3596 * Since: 2.26 3597 */ 3598 struct GDBusErrorEntry 3599 { 3600 /** 3601 * An error code. 3602 */ 3603 int errorCode; 3604 /** 3605 * The D-Bus error name to associate with @error_code. 3606 */ 3607 const(char)* dbusErrorName; 3608 } 3609 3610 struct GDBusInterface; 3611 3612 /** 3613 * Base type for D-Bus interfaces. 3614 * 3615 * Since: 2.30 3616 */ 3617 struct GDBusInterfaceIface 3618 { 3619 /** 3620 * The parent interface. 3621 */ 3622 GTypeInterface parentIface; 3623 /** 3624 * 3625 * Params: 3626 * iface = An exported D-Bus interface. 3627 * Return: A #GDBusInterfaceInfo. Do not free. 3628 */ 3629 extern(C) GDBusInterfaceInfo* function(GDBusInterface* iface) getInfo; 3630 /** 3631 * 3632 * Params: 3633 * iface = An exported D-Bus interface 3634 * Return: A #GDBusObject or %NULL. The returned 3635 * reference belongs to @interface_ and should not be freed. 3636 */ 3637 extern(C) GDBusObject* function(GDBusInterface* iface) getObject; 3638 extern(C) void function(GDBusInterface* iface, GDBusObject* object) setObject; 3639 /** 3640 * 3641 * Params: 3642 * iface = An exported D-Bus interface. 3643 * Return: A #GDBusObject or %NULL. The returned 3644 * reference should be freed with g_object_unref(). 3645 */ 3646 extern(C) GDBusObject* function(GDBusInterface* iface) dupObject; 3647 } 3648 3649 struct GDBusInterfaceInfo 3650 { 3651 /** 3652 * The reference count or -1 if statically allocated. 3653 */ 3654 int refCount; 3655 /** 3656 * The name of the D-Bus interface, e.g. "org.freedesktop.DBus.Properties". 3657 */ 3658 char* name; 3659 /** 3660 * A pointer to a %NULL-terminated array of pointers to #GDBusMethodInfo structures or %NULL if there are no methods. 3661 */ 3662 GDBusMethodInfo** methods; 3663 /** 3664 * A pointer to a %NULL-terminated array of pointers to #GDBusSignalInfo structures or %NULL if there are no signals. 3665 */ 3666 GDBusSignalInfo** signals; 3667 /** 3668 * A pointer to a %NULL-terminated array of pointers to #GDBusPropertyInfo structures or %NULL if there are no properties. 3669 */ 3670 GDBusPropertyInfo** properties; 3671 /** 3672 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3673 */ 3674 GDBusAnnotationInfo** annotations; 3675 } 3676 3677 struct GDBusInterfaceSkeleton 3678 { 3679 GObject parentInstance; 3680 GDBusInterfaceSkeletonPrivate* priv; 3681 } 3682 3683 /** 3684 * Class structure for #GDBusInterfaceSkeleton. 3685 * 3686 * Since: 2.30 3687 */ 3688 struct GDBusInterfaceSkeletonClass 3689 { 3690 /** 3691 * The parent class. 3692 */ 3693 GObjectClass parentClass; 3694 /** 3695 * 3696 * Params: 3697 * iface = A #GDBusInterfaceSkeleton. 3698 * Return: A #GDBusInterfaceInfo (never %NULL). Do not free. 3699 */ 3700 extern(C) GDBusInterfaceInfo* function(GDBusInterfaceSkeleton* iface) getInfo; 3701 /** 3702 * 3703 * Params: 3704 * iface = A #GDBusInterfaceSkeleton. 3705 * Return: A #GDBusInterfaceVTable (never %NULL). 3706 */ 3707 extern(C) GDBusInterfaceVTable* function(GDBusInterfaceSkeleton* iface) getVtable; 3708 /** 3709 * 3710 * Params: 3711 * iface = A #GDBusInterfaceSkeleton. 3712 * Return: A #GVariant of type 3713 * ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS]. 3714 * Free with g_variant_unref(). 3715 */ 3716 extern(C) GVariant* function(GDBusInterfaceSkeleton* iface) getProperties; 3717 extern(C) void function(GDBusInterfaceSkeleton* iface) flush; 3718 void*[8] vfuncPadding; 3719 extern(C) int function(GDBusInterfaceSkeleton* iface, GDBusMethodInvocation* invocation) gAuthorizeMethod; 3720 void*[8] signalPadding; 3721 } 3722 3723 struct GDBusInterfaceSkeletonPrivate; 3724 3725 /** 3726 * Virtual table for handling properties and method calls for a D-Bus 3727 * interface. 3728 * 3729 * Since 2.38, if you want to handle getting/setting D-Bus properties 3730 * asynchronously, give %NULL as your get_property() or set_property() 3731 * function. The D-Bus call will be directed to your @method_call function, 3732 * with the provided @interface_name set to "org.freedesktop.DBus.Properties". 3733 * 3734 * Ownership of the #GDBusMethodInvocation object passed to the 3735 * method_call() function is transferred to your handler; you must 3736 * call one of the methods of #GDBusMethodInvocation to return a reply 3737 * (possibly empty), or an error. These functions also take ownership 3738 * of the passed-in invocation object, so unless the invocation 3739 * object has otherwise been referenced, it will be then be freed. 3740 * Calling one of these functions may be done within your 3741 * method_call() implementation but it also can be done at a later 3742 * point to handle the method asynchronously. 3743 * 3744 * The usual checks on the validity of the calls is performed. For 3745 * `Get` calls, an error is automatically returned if the property does 3746 * not exist or the permissions do not allow access. The same checks are 3747 * performed for `Set` calls, and the provided value is also checked for 3748 * being the correct type. 3749 * 3750 * For both `Get` and `Set` calls, the #GDBusMethodInvocation 3751 * passed to the @method_call handler can be queried with 3752 * g_dbus_method_invocation_get_property_info() to get a pointer 3753 * to the #GDBusPropertyInfo of the property. 3754 * 3755 * If you have readable properties specified in your interface info, 3756 * you must ensure that you either provide a non-%NULL @get_property() 3757 * function or provide implementations of both the `Get` and `GetAll` 3758 * methods on org.freedesktop.DBus.Properties interface in your @method_call 3759 * function. Note that the required return type of the `Get` call is 3760 * `(v)`, not the type of the property. `GetAll` expects a return value 3761 * of type `a{sv}`. 3762 * 3763 * If you have writable properties specified in your interface info, 3764 * you must ensure that you either provide a non-%NULL @set_property() 3765 * function or provide an implementation of the `Set` call. If implementing 3766 * the call, you must return the value of type %G_VARIANT_TYPE_UNIT. 3767 * 3768 * Since: 2.26 3769 */ 3770 struct GDBusInterfaceVTable 3771 { 3772 /** 3773 * Function for handling incoming method calls. 3774 */ 3775 GDBusInterfaceMethodCallFunc methodCall; 3776 /** 3777 * Function for getting a property. 3778 */ 3779 GDBusInterfaceGetPropertyFunc getProperty; 3780 /** 3781 * Function for setting a property. 3782 */ 3783 GDBusInterfaceSetPropertyFunc setProperty; 3784 void*[8] padding; 3785 } 3786 3787 struct GDBusMenuModel; 3788 3789 struct GDBusMessage; 3790 3791 struct GDBusMethodInfo 3792 { 3793 /** 3794 * The reference count or -1 if statically allocated. 3795 */ 3796 int refCount; 3797 /** 3798 * The name of the D-Bus method, e.g. @RequestName. 3799 */ 3800 char* name; 3801 /** 3802 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no in arguments. 3803 */ 3804 GDBusArgInfo** inArgs; 3805 /** 3806 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no out arguments. 3807 */ 3808 GDBusArgInfo** outArgs; 3809 /** 3810 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3811 */ 3812 GDBusAnnotationInfo** annotations; 3813 } 3814 3815 struct GDBusMethodInvocation; 3816 3817 struct GDBusNodeInfo 3818 { 3819 /** 3820 * The reference count or -1 if statically allocated. 3821 */ 3822 int refCount; 3823 /** 3824 * The path of the node or %NULL if omitted. Note that this may be a relative path. See the D-Bus specification for more details. 3825 */ 3826 char* path; 3827 /** 3828 * A pointer to a %NULL-terminated array of pointers to #GDBusInterfaceInfo structures or %NULL if there are no interfaces. 3829 */ 3830 GDBusInterfaceInfo** interfaces; 3831 /** 3832 * A pointer to a %NULL-terminated array of pointers to #GDBusNodeInfo structures or %NULL if there are no nodes. 3833 */ 3834 GDBusNodeInfo** nodes; 3835 /** 3836 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3837 */ 3838 GDBusAnnotationInfo** annotations; 3839 } 3840 3841 struct GDBusObject; 3842 3843 /** 3844 * Base object type for D-Bus objects. 3845 * 3846 * Since: 2.30 3847 */ 3848 struct GDBusObjectIface 3849 { 3850 /** 3851 * The parent interface. 3852 */ 3853 GTypeInterface parentIface; 3854 /** 3855 * 3856 * Params: 3857 * object = A #GDBusObject. 3858 * Return: A string owned by @object. Do not free. 3859 */ 3860 extern(C) const(char)* function(GDBusObject* object) getObjectPath; 3861 /** 3862 * 3863 * Params: 3864 * object = A #GDBusObject. 3865 * Return: A list of #GDBusInterface instances. 3866 * The returned list must be freed by g_list_free() after each element has been freed 3867 * with g_object_unref(). 3868 */ 3869 extern(C) GList* function(GDBusObject* object) getInterfaces; 3870 /** 3871 * 3872 * Params: 3873 * object = A #GDBusObject. 3874 * interfaceName = A D-Bus interface name. 3875 * Return: %NULL if not found, otherwise a 3876 * #GDBusInterface that must be freed with g_object_unref(). 3877 */ 3878 extern(C) GDBusInterface* function(GDBusObject* object, const(char)* interfaceName) getInterface; 3879 extern(C) void function(GDBusObject* object, GDBusInterface* iface) interfaceAdded; 3880 extern(C) void function(GDBusObject* object, GDBusInterface* iface) interfaceRemoved; 3881 } 3882 3883 struct GDBusObjectManager; 3884 3885 struct GDBusObjectManagerClient 3886 { 3887 GObject parentInstance; 3888 GDBusObjectManagerClientPrivate* priv; 3889 } 3890 3891 /** 3892 * Class structure for #GDBusObjectManagerClient. 3893 * 3894 * Since: 2.30 3895 */ 3896 struct GDBusObjectManagerClientClass 3897 { 3898 /** 3899 * The parent class. 3900 */ 3901 GObjectClass parentClass; 3902 extern(C) void function(GDBusObjectManagerClient* manager, GDBusObjectProxy* objectProxy, GDBusProxy* interfaceProxy, const(char)* senderName, const(char)* signalName, GVariant* parameters) interfaceProxySignal; 3903 extern(C) void function(GDBusObjectManagerClient* manager, GDBusObjectProxy* objectProxy, GDBusProxy* interfaceProxy, GVariant* changedProperties, const(char)* invalidatedProperties) interfaceProxyPropertiesChanged; 3904 void*[8] padding; 3905 } 3906 3907 struct GDBusObjectManagerClientPrivate; 3908 3909 /** 3910 * Base type for D-Bus object managers. 3911 * 3912 * Since: 2.30 3913 */ 3914 struct GDBusObjectManagerIface 3915 { 3916 /** 3917 * The parent interface. 3918 */ 3919 GTypeInterface parentIface; 3920 /** 3921 * 3922 * Params: 3923 * manager = A #GDBusObjectManager. 3924 * Return: A string owned by @manager. Do not free. 3925 */ 3926 extern(C) const(char)* function(GDBusObjectManager* manager) getObjectPath; 3927 /** 3928 * 3929 * Params: 3930 * manager = A #GDBusObjectManager. 3931 * Return: A list of 3932 * #GDBusObject objects. The returned list should be freed with 3933 * g_list_free() after each element has been freed with 3934 * g_object_unref(). 3935 */ 3936 extern(C) GList* function(GDBusObjectManager* manager) getObjects; 3937 /** 3938 * 3939 * Params: 3940 * manager = A #GDBusObjectManager. 3941 * objectPath = Object path to lookup. 3942 * Return: A #GDBusObject or %NULL. Free with 3943 * g_object_unref(). 3944 */ 3945 extern(C) GDBusObject* function(GDBusObjectManager* manager, const(char)* objectPath) getObject; 3946 /** 3947 * 3948 * Params: 3949 * manager = A #GDBusObjectManager. 3950 * objectPath = Object path to lookup. 3951 * interfaceName = D-Bus interface name to lookup. 3952 * Return: A #GDBusInterface instance or %NULL. Free 3953 * with g_object_unref(). 3954 */ 3955 extern(C) GDBusInterface* function(GDBusObjectManager* manager, const(char)* objectPath, const(char)* interfaceName) getInterface; 3956 extern(C) void function(GDBusObjectManager* manager, GDBusObject* object) objectAdded; 3957 extern(C) void function(GDBusObjectManager* manager, GDBusObject* object) objectRemoved; 3958 extern(C) void function(GDBusObjectManager* manager, GDBusObject* object, GDBusInterface* iface) interfaceAdded; 3959 extern(C) void function(GDBusObjectManager* manager, GDBusObject* object, GDBusInterface* iface) interfaceRemoved; 3960 } 3961 3962 struct GDBusObjectManagerServer 3963 { 3964 GObject parentInstance; 3965 GDBusObjectManagerServerPrivate* priv; 3966 } 3967 3968 /** 3969 * Class structure for #GDBusObjectManagerServer. 3970 * 3971 * Since: 2.30 3972 */ 3973 struct GDBusObjectManagerServerClass 3974 { 3975 /** 3976 * The parent class. 3977 */ 3978 GObjectClass parentClass; 3979 void*[8] padding; 3980 } 3981 3982 struct GDBusObjectManagerServerPrivate; 3983 3984 struct GDBusObjectProxy 3985 { 3986 GObject parentInstance; 3987 GDBusObjectProxyPrivate* priv; 3988 } 3989 3990 /** 3991 * Class structure for #GDBusObjectProxy. 3992 * 3993 * Since: 2.30 3994 */ 3995 struct GDBusObjectProxyClass 3996 { 3997 /** 3998 * The parent class. 3999 */ 4000 GObjectClass parentClass; 4001 void*[8] padding; 4002 } 4003 4004 struct GDBusObjectProxyPrivate; 4005 4006 struct GDBusObjectSkeleton 4007 { 4008 GObject parentInstance; 4009 GDBusObjectSkeletonPrivate* priv; 4010 } 4011 4012 /** 4013 * Class structure for #GDBusObjectSkeleton. 4014 * 4015 * Since: 2.30 4016 */ 4017 struct GDBusObjectSkeletonClass 4018 { 4019 /** 4020 * The parent class. 4021 */ 4022 GObjectClass parentClass; 4023 extern(C) int function(GDBusObjectSkeleton* object, GDBusInterfaceSkeleton* iface, GDBusMethodInvocation* invocation) authorizeMethod; 4024 void*[8] padding; 4025 } 4026 4027 struct GDBusObjectSkeletonPrivate; 4028 4029 struct GDBusPropertyInfo 4030 { 4031 /** 4032 * The reference count or -1 if statically allocated. 4033 */ 4034 int refCount; 4035 /** 4036 * The name of the D-Bus property, e.g. "SupportedFilesystems". 4037 */ 4038 char* name; 4039 /** 4040 * The D-Bus signature of the property (a single complete type). 4041 */ 4042 char* signature; 4043 /** 4044 * Access control flags for the property. 4045 */ 4046 GDBusPropertyInfoFlags flags; 4047 /** 4048 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 4049 */ 4050 GDBusAnnotationInfo** annotations; 4051 } 4052 4053 struct GDBusProxy 4054 { 4055 GObject parentInstance; 4056 GDBusProxyPrivate* priv; 4057 } 4058 4059 /** 4060 * Class structure for #GDBusProxy. 4061 * 4062 * Since: 2.26 4063 */ 4064 struct GDBusProxyClass 4065 { 4066 GObjectClass parentClass; 4067 extern(C) void function(GDBusProxy* proxy, GVariant* changedProperties, const(char)* invalidatedProperties) gPropertiesChanged; 4068 extern(C) void function(GDBusProxy* proxy, const(char)* senderName, const(char)* signalName, GVariant* parameters) gSignal; 4069 void*[32] padding; 4070 } 4071 4072 struct GDBusProxyPrivate; 4073 4074 struct GDBusServer; 4075 4076 struct GDBusSignalInfo 4077 { 4078 /** 4079 * The reference count or -1 if statically allocated. 4080 */ 4081 int refCount; 4082 /** 4083 * The name of the D-Bus signal, e.g. "NameOwnerChanged". 4084 */ 4085 char* name; 4086 /** 4087 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no arguments. 4088 */ 4089 GDBusArgInfo** args; 4090 /** 4091 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 4092 */ 4093 GDBusAnnotationInfo** annotations; 4094 } 4095 4096 /** 4097 * Virtual table for handling subtrees registered with g_dbus_connection_register_subtree(). 4098 * 4099 * Since: 2.26 4100 */ 4101 struct GDBusSubtreeVTable 4102 { 4103 /** 4104 * Function for enumerating child nodes. 4105 */ 4106 GDBusSubtreeEnumerateFunc enumerate; 4107 /** 4108 * Function for introspecting a child node. 4109 */ 4110 GDBusSubtreeIntrospectFunc introspect; 4111 /** 4112 * Function for dispatching a remote call on a child node. 4113 */ 4114 GDBusSubtreeDispatchFunc dispatch; 4115 void*[8] padding; 4116 } 4117 4118 struct GDataInputStream 4119 { 4120 GBufferedInputStream parentInstance; 4121 GDataInputStreamPrivate* priv; 4122 } 4123 4124 struct GDataInputStreamClass 4125 { 4126 GBufferedInputStreamClass parentClass; 4127 extern(C) void function() GReserved1; 4128 extern(C) void function() GReserved2; 4129 extern(C) void function() GReserved3; 4130 extern(C) void function() GReserved4; 4131 extern(C) void function() GReserved5; 4132 } 4133 4134 struct GDataInputStreamPrivate; 4135 4136 struct GDataOutputStream 4137 { 4138 GFilterOutputStream parentInstance; 4139 GDataOutputStreamPrivate* priv; 4140 } 4141 4142 struct GDataOutputStreamClass 4143 { 4144 GFilterOutputStreamClass parentClass; 4145 extern(C) void function() GReserved1; 4146 extern(C) void function() GReserved2; 4147 extern(C) void function() GReserved3; 4148 extern(C) void function() GReserved4; 4149 extern(C) void function() GReserved5; 4150 } 4151 4152 struct GDataOutputStreamPrivate; 4153 4154 struct GDesktopAppInfo; 4155 4156 struct GDesktopAppInfoClass 4157 { 4158 GObjectClass parentClass; 4159 } 4160 4161 struct GDesktopAppInfoLookup; 4162 4163 /** 4164 * Interface that is used by backends to associate default 4165 * handlers with URI schemes. 4166 */ 4167 struct GDesktopAppInfoLookupIface 4168 { 4169 GTypeInterface gIface; 4170 /** 4171 * 4172 * Params: 4173 * lookup = a #GDesktopAppInfoLookup 4174 * uriScheme = a string containing a URI scheme. 4175 * Return: #GAppInfo for given @uri_scheme or %NULL on error. 4176 */ 4177 extern(C) GAppInfo* function(GDesktopAppInfoLookup* lookup, const(char)* uriScheme) getDefaultForUriScheme; 4178 } 4179 4180 struct GDrive; 4181 4182 /** 4183 * Interface for creating #GDrive implementations. 4184 */ 4185 struct GDriveIface 4186 { 4187 /** 4188 * The parent interface. 4189 */ 4190 GTypeInterface gIface; 4191 extern(C) void function(GDrive* drive) changed; 4192 extern(C) void function(GDrive* drive) disconnected; 4193 extern(C) void function(GDrive* drive) ejectButton; 4194 /** 4195 * 4196 * Params: 4197 * drive = a #GDrive. 4198 * Return: a string containing @drive's name. The returned 4199 * string should be freed when no longer needed. 4200 */ 4201 extern(C) char* function(GDrive* drive) getName; 4202 /** 4203 * 4204 * Params: 4205 * drive = a #GDrive. 4206 * Return: #GIcon for the @drive. 4207 * Free the returned object with g_object_unref(). 4208 */ 4209 extern(C) GIcon* function(GDrive* drive) getIcon; 4210 /** 4211 * 4212 * Params: 4213 * drive = a #GDrive. 4214 * Return: %TRUE if the @drive contains volumes, %FALSE otherwise. 4215 */ 4216 extern(C) int function(GDrive* drive) hasVolumes; 4217 /** 4218 * 4219 * Params: 4220 * drive = a #GDrive. 4221 * Return: #GList containing any #GVolume objects on the given @drive. 4222 */ 4223 extern(C) GList* function(GDrive* drive) getVolumes; 4224 /** 4225 * 4226 * Params: 4227 * drive = a #GDrive. 4228 * Return: %TRUE if @drive supports removable media, %FALSE otherwise. 4229 */ 4230 extern(C) int function(GDrive* drive) isMediaRemovable; 4231 /** 4232 * 4233 * Params: 4234 * drive = a #GDrive. 4235 * Return: %TRUE if @drive has media, %FALSE otherwise. 4236 */ 4237 extern(C) int function(GDrive* drive) hasMedia; 4238 /** 4239 * 4240 * Params: 4241 * drive = a #GDrive. 4242 * Return: %TRUE if the @drive is capabable of automatically detecting 4243 * media changes, %FALSE otherwise. 4244 */ 4245 extern(C) int function(GDrive* drive) isMediaCheckAutomatic; 4246 /** 4247 * 4248 * Params: 4249 * drive = a #GDrive. 4250 * Return: %TRUE if the @drive can be ejected, %FALSE otherwise. 4251 */ 4252 extern(C) int function(GDrive* drive) canEject; 4253 /** 4254 * 4255 * Params: 4256 * drive = a #GDrive. 4257 * Return: %TRUE if the @drive can be polled for media changes, 4258 * %FALSE otherwise. 4259 */ 4260 extern(C) int function(GDrive* drive) canPollForMedia; 4261 extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject; 4262 /** 4263 * 4264 * Params: 4265 * drive = a #GDrive. 4266 * result = a #GAsyncResult. 4267 * Return: %TRUE if the drive has been ejected successfully, 4268 * %FALSE otherwise. 4269 * 4270 * Throws: GException on failure. 4271 */ 4272 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) ejectFinish; 4273 extern(C) void function(GDrive* drive, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) pollForMedia; 4274 /** 4275 * 4276 * Params: 4277 * drive = a #GDrive. 4278 * result = a #GAsyncResult. 4279 * Return: %TRUE if the drive has been poll_for_mediaed successfully, 4280 * %FALSE otherwise. 4281 * 4282 * Throws: GException on failure. 4283 */ 4284 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) pollForMediaFinish; 4285 /** 4286 * 4287 * Params: 4288 * drive = a #GDrive 4289 * kind = the kind of identifier to return 4290 * Return: a newly allocated string containing the 4291 * requested identfier, or %NULL if the #GDrive 4292 * doesn't have this kind of identifier. 4293 */ 4294 extern(C) char* function(GDrive* drive, const(char)* kind) getIdentifier; 4295 /** 4296 * 4297 * Params: 4298 * drive = a #GDrive 4299 * Return: a %NULL-terminated 4300 * array of strings containing kinds of identifiers. Use g_strfreev() 4301 * to free. 4302 */ 4303 extern(C) char** function(GDrive* drive) enumerateIdentifiers; 4304 /** 4305 * 4306 * Params: 4307 * drive = a #GDrive. 4308 * Return: A value from the #GDriveStartStopType enumeration. 4309 */ 4310 extern(C) GDriveStartStopType function(GDrive* drive) getStartStopType; 4311 /** 4312 * 4313 * Params: 4314 * drive = a #GDrive. 4315 * Return: %TRUE if the @drive can be started, %FALSE otherwise. 4316 */ 4317 extern(C) int function(GDrive* drive) canStart; 4318 /** 4319 * 4320 * Params: 4321 * drive = a #GDrive. 4322 * Return: %TRUE if the @drive can be started degraded, %FALSE otherwise. 4323 */ 4324 extern(C) int function(GDrive* drive) canStartDegraded; 4325 extern(C) void function(GDrive* drive, GDriveStartFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) start; 4326 /** 4327 * 4328 * Params: 4329 * drive = a #GDrive. 4330 * result = a #GAsyncResult. 4331 * Return: %TRUE if the drive has been started successfully, 4332 * %FALSE otherwise. 4333 * 4334 * Throws: GException on failure. 4335 */ 4336 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) startFinish; 4337 /** 4338 * 4339 * Params: 4340 * drive = a #GDrive. 4341 * Return: %TRUE if the @drive can be stopped, %FALSE otherwise. 4342 */ 4343 extern(C) int function(GDrive* drive) canStop; 4344 extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) stop; 4345 /** 4346 * 4347 * Params: 4348 * drive = a #GDrive. 4349 * result = a #GAsyncResult. 4350 * Return: %TRUE if the drive has been stopped successfully, 4351 * %FALSE otherwise. 4352 * 4353 * Throws: GException on failure. 4354 */ 4355 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) stopFinish; 4356 extern(C) void function(GDrive* drive) stopButton; 4357 extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation; 4358 /** 4359 * 4360 * Params: 4361 * drive = a #GDrive. 4362 * result = a #GAsyncResult. 4363 * Return: %TRUE if the drive was successfully ejected. %FALSE otherwise. 4364 * 4365 * Throws: GException on failure. 4366 */ 4367 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) ejectWithOperationFinish; 4368 /** 4369 * 4370 * Params: 4371 * drive = A #GDrive. 4372 * Return: Sorting key for @drive or %NULL if no such key is available. 4373 */ 4374 extern(C) const(char)* function(GDrive* drive) getSortKey; 4375 /** 4376 * 4377 * Params: 4378 * drive = a #GDrive. 4379 * Return: symbolic #GIcon for the @drive. 4380 * Free the returned object with g_object_unref(). 4381 */ 4382 extern(C) GIcon* function(GDrive* drive) getSymbolicIcon; 4383 } 4384 4385 struct GEmblem; 4386 4387 struct GEmblemClass; 4388 4389 struct GEmblemedIcon 4390 { 4391 GObject parentInstance; 4392 GEmblemedIconPrivate* priv; 4393 } 4394 4395 struct GEmblemedIconClass 4396 { 4397 GObjectClass parentClass; 4398 } 4399 4400 struct GEmblemedIconPrivate; 4401 4402 struct GFile; 4403 4404 /** 4405 * Information about a specific attribute. 4406 */ 4407 struct GFileAttributeInfo 4408 { 4409 /** 4410 * the name of the attribute. 4411 */ 4412 char* name; 4413 /** 4414 * the #GFileAttributeType type of the attribute. 4415 */ 4416 GFileAttributeType type; 4417 /** 4418 * a set of #GFileAttributeInfoFlags. 4419 */ 4420 GFileAttributeInfoFlags flags; 4421 } 4422 4423 struct GFileAttributeInfoList 4424 { 4425 /** 4426 * an array of #GFileAttributeInfos. 4427 */ 4428 GFileAttributeInfo* infos; 4429 /** 4430 * the number of values in the array. 4431 */ 4432 int nInfos; 4433 } 4434 4435 struct GFileAttributeMatcher; 4436 4437 struct GFileDescriptorBased; 4438 4439 /** 4440 * An interface for file descriptor based io objects. 4441 */ 4442 struct GFileDescriptorBasedIface 4443 { 4444 /** 4445 * The parent interface. 4446 */ 4447 GTypeInterface gIface; 4448 /** 4449 * 4450 * Params: 4451 * fdBased = a #GFileDescriptorBased. 4452 * Return: The file descriptor 4453 */ 4454 extern(C) int function(GFileDescriptorBased* fdBased) getFd; 4455 } 4456 4457 struct GFileEnumerator 4458 { 4459 GObject parentInstance; 4460 GFileEnumeratorPrivate* priv; 4461 } 4462 4463 struct GFileEnumeratorClass 4464 { 4465 GObjectClass parentClass; 4466 /** 4467 * 4468 * Params: 4469 * enumerator = a #GFileEnumerator. 4470 * cancellable = optional #GCancellable object, %NULL to ignore. 4471 * Return: A #GFileInfo or %NULL on error 4472 * or end of enumerator. Free the returned object with 4473 * g_object_unref() when no longer needed. 4474 * 4475 * Throws: GException on failure. 4476 */ 4477 extern(C) GFileInfo* function(GFileEnumerator* enumerator, GCancellable* cancellable, GError** err) nextFile; 4478 extern(C) int function(GFileEnumerator* enumerator, GCancellable* cancellable, GError** err) closeFn; 4479 extern(C) void function(GFileEnumerator* enumerator, int numFiles, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) nextFilesAsync; 4480 /** 4481 * 4482 * Params: 4483 * enumerator = a #GFileEnumerator. 4484 * result = a #GAsyncResult. 4485 * Return: a #GList of #GFileInfos. You must free the list with 4486 * g_list_free() and unref the infos with g_object_unref() when you're 4487 * done with them. 4488 * 4489 * Throws: GException on failure. 4490 */ 4491 extern(C) GList* function(GFileEnumerator* enumerator, GAsyncResult* result, GError** err) nextFilesFinish; 4492 extern(C) void function(GFileEnumerator* enumerator, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync; 4493 /** 4494 * 4495 * Params: 4496 * enumerator = a #GFileEnumerator. 4497 * result = a #GAsyncResult. 4498 * Return: %TRUE if the close operation has finished successfully. 4499 * 4500 * Throws: GException on failure. 4501 */ 4502 extern(C) int function(GFileEnumerator* enumerator, GAsyncResult* result, GError** err) closeFinish; 4503 extern(C) void function() GReserved1; 4504 extern(C) void function() GReserved2; 4505 extern(C) void function() GReserved3; 4506 extern(C) void function() GReserved4; 4507 extern(C) void function() GReserved5; 4508 extern(C) void function() GReserved6; 4509 extern(C) void function() GReserved7; 4510 } 4511 4512 struct GFileEnumeratorPrivate; 4513 4514 struct GFileIOStream 4515 { 4516 GIOStream parentInstance; 4517 GFileIOStreamPrivate* priv; 4518 } 4519 4520 struct GFileIOStreamClass 4521 { 4522 GIOStreamClass parentClass; 4523 extern(C) long function(GFileIOStream* stream) tell; 4524 extern(C) int function(GFileIOStream* stream) canSeek; 4525 extern(C) int function(GFileIOStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek; 4526 extern(C) int function(GFileIOStream* stream) canTruncate; 4527 extern(C) int function(GFileIOStream* stream, long size, GCancellable* cancellable, GError** err) truncateFn; 4528 /** 4529 * 4530 * Params: 4531 * stream = a #GFileIOStream. 4532 * attributes = a file attribute query string. 4533 * cancellable = optional #GCancellable object, %NULL to ignore. 4534 * Return: a #GFileInfo for the @stream, or %NULL on error. 4535 * 4536 * Throws: GException on failure. 4537 */ 4538 extern(C) GFileInfo* function(GFileIOStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo; 4539 extern(C) void function(GFileIOStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync; 4540 /** 4541 * 4542 * Params: 4543 * stream = a #GFileIOStream. 4544 * result = a #GAsyncResult. 4545 * Return: A #GFileInfo for the finished query. 4546 * 4547 * Throws: GException on failure. 4548 */ 4549 extern(C) GFileInfo* function(GFileIOStream* stream, GAsyncResult* result, GError** err) queryInfoFinish; 4550 /** 4551 * 4552 * Params: 4553 * stream = a #GFileIOStream. 4554 * Return: the entity tag for the stream. 4555 */ 4556 extern(C) char* function(GFileIOStream* stream) getEtag; 4557 extern(C) void function() GReserved1; 4558 extern(C) void function() GReserved2; 4559 extern(C) void function() GReserved3; 4560 extern(C) void function() GReserved4; 4561 extern(C) void function() GReserved5; 4562 } 4563 4564 struct GFileIOStreamPrivate; 4565 4566 struct GFileIcon; 4567 4568 struct GFileIconClass; 4569 4570 /** 4571 * An interface for writing VFS file handles. 4572 */ 4573 struct GFileIface 4574 { 4575 /** 4576 * The parent interface. 4577 */ 4578 GTypeInterface gIface; 4579 /** 4580 * 4581 * Params: 4582 * file = input #GFile 4583 * Return: a new #GFile that is a duplicate 4584 * of the given #GFile. 4585 */ 4586 extern(C) GFile* function(GFile* file) dup; 4587 /** 4588 * 4589 * Params: 4590 * file = #gconstpointer to a #GFile 4591 * Return: 0 if @file is not a valid #GFile, otherwise an 4592 * integer that can be used as hash value for the #GFile. 4593 * This function is intended for easily hashing a #GFile to 4594 * add to a #GHashTable or similar data structure. 4595 */ 4596 extern(C) uint function(GFile* file) hash; 4597 /** 4598 * 4599 * Params: 4600 * file1 = the first #GFile 4601 * file2 = the second #GFile 4602 * Return: %TRUE if @file1 and @file2 are equal. 4603 */ 4604 extern(C) int function(GFile* file1, GFile* file2) equal; 4605 /** 4606 * 4607 * Params: 4608 * file = input #GFile 4609 * Return: %TRUE if @file is native 4610 */ 4611 extern(C) int function(GFile* file) isNative; 4612 /** 4613 * 4614 * Params: 4615 * file = input #GFile 4616 * uriScheme = a string containing a URI scheme 4617 * Return: %TRUE if #GFile's backend supports the 4618 * given URI scheme, %FALSE if URI scheme is %NULL, 4619 * not supported, or #GFile is invalid. 4620 */ 4621 extern(C) int function(GFile* file, const(char)* uriScheme) hasUriScheme; 4622 /** 4623 * 4624 * Params: 4625 * file = input #GFile 4626 * Return: a string containing the URI scheme for the given 4627 * #GFile. The returned string should be freed with g_free() 4628 * when no longer needed. 4629 */ 4630 extern(C) char* function(GFile* file) getUriScheme; 4631 /** 4632 * 4633 * Params: 4634 * file = input #GFile 4635 * Return: string containing the #GFile's base name, or 4636 * %NULL if given #GFile is invalid. The returned string should be 4637 * freed with g_free() when no longer needed. 4638 */ 4639 extern(C) char* function(GFile* file) getBasename; 4640 /** 4641 * 4642 * Params: 4643 * file = input #GFile 4644 * Return: string containing the #GFile's path, or %NULL 4645 * if no such path exists. The returned string should be freed 4646 * with g_free() when no longer needed. 4647 */ 4648 extern(C) char* function(GFile* file) getPath; 4649 /** 4650 * 4651 * Params: 4652 * file = input #GFile 4653 * Return: a string containing the #GFile's URI. 4654 * The returned string should be freed with g_free() 4655 * when no longer needed. 4656 */ 4657 extern(C) char* function(GFile* file) getUri; 4658 /** 4659 * 4660 * Params: 4661 * file = input #GFile 4662 * Return: a string containing the #GFile's parse name. 4663 * The returned string should be freed with g_free() 4664 * when no longer needed. 4665 */ 4666 extern(C) char* function(GFile* file) getParseName; 4667 /** 4668 * 4669 * Params: 4670 * file = input #GFile 4671 * Return: a #GFile structure to the 4672 * parent of the given #GFile or %NULL if there is no parent. Free 4673 * the returned object with g_object_unref(). 4674 */ 4675 extern(C) GFile* function(GFile* file) getParent; 4676 /** 4677 * 4678 * Params: 4679 * prefix = input #GFile 4680 * file = input #GFile 4681 * Return: %TRUE if the @files's parent, grandparent, etc is @prefix, 4682 * %FALSE otherwise. 4683 */ 4684 extern(C) int function(GFile* prefix, GFile* file) prefixMatches; 4685 /** 4686 * 4687 * Params: 4688 * parent = input #GFile 4689 * descendant = input #GFile 4690 * Return: string with the relative path from @descendant 4691 * to @parent, or %NULL if @descendant doesn't have @parent as 4692 * prefix. The returned string should be freed with g_free() when 4693 * no longer needed. 4694 */ 4695 extern(C) char* function(GFile* parent, GFile* descendant) getRelativePath; 4696 /** 4697 * 4698 * Params: 4699 * file = input #GFile 4700 * relativePath = a given relative path string 4701 * Return: #GFile to the resolved path. 4702 * %NULL if @relative_path is %NULL or if @file is invalid. 4703 * Free the returned object with g_object_unref(). 4704 */ 4705 extern(C) GFile* function(GFile* file, const(char)* relativePath) resolveRelativePath; 4706 /** 4707 * 4708 * Params: 4709 * file = input #GFile 4710 * displayName = string to a possible child 4711 * Return: a #GFile to the specified child, or 4712 * %NULL if the display name couldn't be converted. 4713 * Free the returned object with g_object_unref(). 4714 * 4715 * Throws: GException on failure. 4716 */ 4717 extern(C) GFile* function(GFile* file, const(char)* displayName, GError** err) getChildForDisplayName; 4718 /** 4719 * 4720 * Params: 4721 * file = input #GFile 4722 * attributes = an attribute query string 4723 * flags = a set of #GFileQueryInfoFlags 4724 * cancellable = optional #GCancellable object, 4725 * %NULL to ignore 4726 * Return: A #GFileEnumerator if successful, 4727 * %NULL on error. Free the returned object with g_object_unref(). 4728 * 4729 * Throws: GException on failure. 4730 */ 4731 extern(C) GFileEnumerator* function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) enumerateChildren; 4732 extern(C) void function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) enumerateChildrenAsync; 4733 /** 4734 * 4735 * Params: 4736 * file = input #GFile 4737 * res = a #GAsyncResult 4738 * Return: a #GFileEnumerator or %NULL 4739 * if an error occurred. 4740 * Free the returned object with g_object_unref(). 4741 * 4742 * Throws: GException on failure. 4743 */ 4744 extern(C) GFileEnumerator* function(GFile* file, GAsyncResult* res, GError** err) enumerateChildrenFinish; 4745 /** 4746 * 4747 * Params: 4748 * file = input #GFile 4749 * attributes = an attribute query string 4750 * flags = a set of #GFileQueryInfoFlags 4751 * cancellable = optional #GCancellable object, 4752 * %NULL to ignore 4753 * Return: a #GFileInfo for the given @file, or %NULL 4754 * on error. Free the returned object with g_object_unref(). 4755 * 4756 * Throws: GException on failure. 4757 */ 4758 extern(C) GFileInfo* function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) queryInfo; 4759 extern(C) void function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync; 4760 /** 4761 * 4762 * Params: 4763 * file = input #GFile 4764 * res = a #GAsyncResult 4765 * Return: #GFileInfo for given @file 4766 * or %NULL on error. Free the returned object with 4767 * g_object_unref(). 4768 * 4769 * Throws: GException on failure. 4770 */ 4771 extern(C) GFileInfo* function(GFile* file, GAsyncResult* res, GError** err) queryInfoFinish; 4772 /** 4773 * 4774 * Params: 4775 * file = input #GFile 4776 * attributes = an attribute query string 4777 * cancellable = optional #GCancellable object, 4778 * %NULL to ignore 4779 * Return: a #GFileInfo or %NULL if there was an error. 4780 * Free the returned object with g_object_unref(). 4781 * 4782 * Throws: GException on failure. 4783 */ 4784 extern(C) GFileInfo* function(GFile* file, const(char)* attributes, GCancellable* cancellable, GError** err) queryFilesystemInfo; 4785 extern(C) void function(GFile* file, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryFilesystemInfoAsync; 4786 /** 4787 * 4788 * Params: 4789 * file = input #GFile 4790 * res = a #GAsyncResult 4791 * Return: #GFileInfo for given @file 4792 * or %NULL on error. 4793 * Free the returned object with g_object_unref(). 4794 * 4795 * Throws: GException on failure. 4796 */ 4797 extern(C) GFileInfo* function(GFile* file, GAsyncResult* res, GError** err) queryFilesystemInfoFinish; 4798 /** 4799 * 4800 * Params: 4801 * file = input #GFile 4802 * cancellable = optional #GCancellable object, 4803 * %NULL to ignore 4804 * Return: a #GMount where the @file is located 4805 * or %NULL on error. 4806 * Free the returned object with g_object_unref(). 4807 * 4808 * Throws: GException on failure. 4809 */ 4810 extern(C) GMount* function(GFile* file, GCancellable* cancellable, GError** err) findEnclosingMount; 4811 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) findEnclosingMountAsync; 4812 /** 4813 * 4814 * Params: 4815 * file = a #GFile 4816 * res = a #GAsyncResult 4817 * Return: #GMount for given @file or %NULL on error. 4818 * Free the returned object with g_object_unref(). 4819 * 4820 * Throws: GException on failure. 4821 */ 4822 extern(C) GMount* function(GFile* file, GAsyncResult* res, GError** err) findEnclosingMountFinish; 4823 /** 4824 * 4825 * Params: 4826 * file = input #GFile 4827 * displayName = a string 4828 * cancellable = optional #GCancellable object, 4829 * %NULL to ignore 4830 * Return: a #GFile specifying what @file was renamed to, 4831 * or %NULL if there was an error. 4832 * Free the returned object with g_object_unref(). 4833 * 4834 * Throws: GException on failure. 4835 */ 4836 extern(C) GFile* function(GFile* file, const(char)* displayName, GCancellable* cancellable, GError** err) setDisplayName; 4837 extern(C) void function(GFile* file, const(char)* displayName, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) setDisplayNameAsync; 4838 /** 4839 * 4840 * Params: 4841 * file = input #GFile 4842 * res = a #GAsyncResult 4843 * Return: a #GFile or %NULL on error. 4844 * Free the returned object with g_object_unref(). 4845 * 4846 * Throws: GException on failure. 4847 */ 4848 extern(C) GFile* function(GFile* file, GAsyncResult* res, GError** err) setDisplayNameFinish; 4849 /** 4850 * 4851 * Params: 4852 * file = input #GFile 4853 * cancellable = optional #GCancellable object, 4854 * %NULL to ignore 4855 * Return: a #GFileAttributeInfoList describing the settable attributes. 4856 * When you are done with it, release it with 4857 * g_file_attribute_info_list_unref() 4858 * 4859 * Throws: GException on failure. 4860 */ 4861 extern(C) GFileAttributeInfoList* function(GFile* file, GCancellable* cancellable, GError** err) querySettableAttributes; 4862 extern(C) void function() QuerySettableAttributesAsync; 4863 extern(C) void function() QuerySettableAttributesFinish; 4864 /** 4865 * 4866 * Params: 4867 * file = input #GFile 4868 * cancellable = optional #GCancellable object, 4869 * %NULL to ignore 4870 * Return: a #GFileAttributeInfoList describing the writable namespaces. 4871 * When you are done with it, release it with 4872 * g_file_attribute_info_list_unref() 4873 * 4874 * Throws: GException on failure. 4875 */ 4876 extern(C) GFileAttributeInfoList* function(GFile* file, GCancellable* cancellable, GError** err) queryWritableNamespaces; 4877 extern(C) void function() QueryWritableNamespacesAsync; 4878 extern(C) void function() QueryWritableNamespacesFinish; 4879 /** 4880 * 4881 * Params: 4882 * file = input #GFile 4883 * attribute = a string containing the attribute's name 4884 * type = The type of the attribute 4885 * valueP = a pointer to the value (or the pointer 4886 * itself if the type is a pointer type) 4887 * flags = a set of #GFileQueryInfoFlags 4888 * cancellable = optional #GCancellable object, 4889 * %NULL to ignore 4890 * Return: %TRUE if the attribute was set, %FALSE otherwise. 4891 * 4892 * Throws: GException on failure. 4893 */ 4894 extern(C) int function(GFile* file, const(char)* attribute, GFileAttributeType type, void* valueP, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) setAttribute; 4895 /** 4896 * 4897 * Params: 4898 * file = input #GFile 4899 * info = a #GFileInfo 4900 * flags = #GFileQueryInfoFlags 4901 * cancellable = optional #GCancellable object, 4902 * %NULL to ignore 4903 * Return: %FALSE if there was any error, %TRUE otherwise. 4904 * 4905 * Throws: GException on failure. 4906 */ 4907 extern(C) int function(GFile* file, GFileInfo* info, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) setAttributesFromInfo; 4908 extern(C) void function(GFile* file, GFileInfo* info, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) setAttributesAsync; 4909 /** 4910 * 4911 * Params: 4912 * file = input #GFile 4913 * result = a #GAsyncResult 4914 * info = a #GFileInfo 4915 * Return: %TRUE if the attributes were set correctly, %FALSE otherwise. 4916 * 4917 * Throws: GException on failure. 4918 */ 4919 extern(C) int function(GFile* file, GAsyncResult* result, GFileInfo** info, GError** err) setAttributesFinish; 4920 /** 4921 * 4922 * Params: 4923 * file = #GFile to read 4924 * cancellable = a #GCancellable 4925 * Return: #GFileInputStream or %NULL on error. 4926 * Free the returned object with g_object_unref(). 4927 * 4928 * Throws: GException on failure. 4929 */ 4930 extern(C) GFileInputStream* function(GFile* file, GCancellable* cancellable, GError** err) readFn; 4931 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) readAsync; 4932 /** 4933 * 4934 * Params: 4935 * file = input #GFile 4936 * res = a #GAsyncResult 4937 * Return: a #GFileInputStream or %NULL on error. 4938 * Free the returned object with g_object_unref(). 4939 * 4940 * Throws: GException on failure. 4941 */ 4942 extern(C) GFileInputStream* function(GFile* file, GAsyncResult* res, GError** err) readFinish; 4943 /** 4944 * 4945 * Params: 4946 * file = input #GFile 4947 * flags = a set of #GFileCreateFlags 4948 * cancellable = optional #GCancellable object, 4949 * %NULL to ignore 4950 * Return: a #GFileOutputStream, or %NULL on error. 4951 * Free the returned object with g_object_unref(). 4952 * 4953 * Throws: GException on failure. 4954 */ 4955 extern(C) GFileOutputStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) appendTo; 4956 extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) appendToAsync; 4957 /** 4958 * 4959 * Params: 4960 * file = input #GFile 4961 * res = #GAsyncResult 4962 * Return: a valid #GFileOutputStream 4963 * or %NULL on error. 4964 * Free the returned object with g_object_unref(). 4965 * 4966 * Throws: GException on failure. 4967 */ 4968 extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) appendToFinish; 4969 /** 4970 * 4971 * Params: 4972 * file = input #GFile 4973 * flags = a set of #GFileCreateFlags 4974 * cancellable = optional #GCancellable object, 4975 * %NULL to ignore 4976 * Return: a #GFileOutputStream for the newly created 4977 * file, or %NULL on error. 4978 * Free the returned object with g_object_unref(). 4979 * 4980 * Throws: GException on failure. 4981 */ 4982 extern(C) GFileOutputStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) create; 4983 extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) createAsync; 4984 /** 4985 * 4986 * Params: 4987 * file = input #GFile 4988 * res = a #GAsyncResult 4989 * Return: a #GFileOutputStream or %NULL on error. 4990 * Free the returned object with g_object_unref(). 4991 * 4992 * Throws: GException on failure. 4993 */ 4994 extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) createFinish; 4995 /** 4996 * 4997 * Params: 4998 * file = input #GFile 4999 * etag = an optional [entity tag][gfile-etag] 5000 * for the current #GFile, or #NULL to ignore 5001 * makeBackup = %TRUE if a backup should be created 5002 * flags = a set of #GFileCreateFlags 5003 * cancellable = optional #GCancellable object, 5004 * %NULL to ignore 5005 * Return: a #GFileOutputStream or %NULL on error. 5006 * Free the returned object with g_object_unref(). 5007 * 5008 * Throws: GException on failure. 5009 */ 5010 extern(C) GFileOutputStream* function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GError** err) replace; 5011 extern(C) void function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) replaceAsync; 5012 /** 5013 * 5014 * Params: 5015 * file = input #GFile 5016 * res = a #GAsyncResult 5017 * Return: a #GFileOutputStream, or %NULL on error. 5018 * Free the returned object with g_object_unref(). 5019 * 5020 * Throws: GException on failure. 5021 */ 5022 extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) replaceFinish; 5023 /** 5024 * 5025 * Params: 5026 * file = input #GFile 5027 * cancellable = optional #GCancellable object, 5028 * %NULL to ignore 5029 * Return: %TRUE if the file was deleted. %FALSE otherwise. 5030 * 5031 * Throws: GException on failure. 5032 */ 5033 extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) deleteFile; 5034 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) deleteFileAsync; 5035 /** 5036 * 5037 * Params: 5038 * file = input #GFile 5039 * result = a #GAsyncResult 5040 * Return: %TRUE if the file was deleted. %FALSE otherwise. 5041 * 5042 * Throws: GException on failure. 5043 */ 5044 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) deleteFileFinish; 5045 /** 5046 * 5047 * Params: 5048 * file = #GFile to send to trash 5049 * cancellable = optional #GCancellable object, 5050 * %NULL to ignore 5051 * Return: %TRUE on successful trash, %FALSE otherwise. 5052 * 5053 * Throws: GException on failure. 5054 */ 5055 extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) trash; 5056 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) trashAsync; 5057 /** 5058 * 5059 * Params: 5060 * file = input #GFile 5061 * result = a #GAsyncResult 5062 * Return: %TRUE on successful trash, %FALSE otherwise. 5063 * 5064 * Throws: GException on failure. 5065 */ 5066 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) trashFinish; 5067 /** 5068 * 5069 * Params: 5070 * file = input #GFile 5071 * cancellable = optional #GCancellable object, 5072 * %NULL to ignore 5073 * Return: %TRUE on successful creation, %FALSE otherwise. 5074 * 5075 * Throws: GException on failure. 5076 */ 5077 extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) makeDirectory; 5078 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) makeDirectoryAsync; 5079 /** 5080 * 5081 * Params: 5082 * file = input #GFile 5083 * result = a #GAsyncResult 5084 * Return: %TRUE on successful directory creation, %FALSE otherwise. 5085 * 5086 * Throws: GException on failure. 5087 */ 5088 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) makeDirectoryFinish; 5089 /** 5090 * 5091 * Params: 5092 * file = a #GFile with the name of the symlink to create 5093 * symlinkValue = a string with the path for the target of the new symlink 5094 * cancellable = optional #GCancellable object, 5095 * %NULL to ignore 5096 * Return: %TRUE on the creation of a new symlink, %FALSE otherwise. 5097 * 5098 * Throws: GException on failure. 5099 */ 5100 extern(C) int function(GFile* file, const(char)* symlinkValue, GCancellable* cancellable, GError** err) makeSymbolicLink; 5101 extern(C) void function() MakeSymbolicLinkAsync; 5102 extern(C) void function() MakeSymbolicLinkFinish; 5103 /** 5104 * 5105 * Params: 5106 * source = input #GFile 5107 * destination = destination #GFile 5108 * flags = set of #GFileCopyFlags 5109 * cancellable = optional #GCancellable object, 5110 * %NULL to ignore 5111 * progressCallback = function to callback with 5112 * progress information, or %NULL if progress information is not needed 5113 * progressCallbackData = user data to pass to @progress_callback 5114 * Return: %TRUE on success, %FALSE otherwise. 5115 * 5116 * Throws: GException on failure. 5117 */ 5118 extern(C) int function(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GError** err) copy; 5119 extern(C) void function(GFile* source, GFile* destination, GFileCopyFlags flags, int ioPriority, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GAsyncReadyCallback callback, void* userData) copyAsync; 5120 /** 5121 * 5122 * Params: 5123 * file = input #GFile 5124 * res = a #GAsyncResult 5125 * Return: a %TRUE on success, %FALSE on error. 5126 * 5127 * Throws: GException on failure. 5128 */ 5129 extern(C) int function(GFile* file, GAsyncResult* res, GError** err) copyFinish; 5130 /** 5131 * 5132 * Params: 5133 * source = #GFile pointing to the source location 5134 * destination = #GFile pointing to the destination location 5135 * flags = set of #GFileCopyFlags 5136 * cancellable = optional #GCancellable object, 5137 * %NULL to ignore 5138 * progressCallback = #GFileProgressCallback 5139 * function for updates 5140 * progressCallbackData = gpointer to user data for 5141 * the callback function 5142 * Return: %TRUE on successful move, %FALSE otherwise. 5143 * 5144 * Throws: GException on failure. 5145 */ 5146 extern(C) int function(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GError** err) move; 5147 extern(C) void function() MoveAsync; 5148 extern(C) void function() MoveFinish; 5149 extern(C) void function(GFile* file, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountMountable; 5150 /** 5151 * 5152 * Params: 5153 * file = input #GFile 5154 * result = a #GAsyncResult 5155 * Return: a #GFile or %NULL on error. 5156 * Free the returned object with g_object_unref(). 5157 * 5158 * Throws: GException on failure. 5159 */ 5160 extern(C) GFile* function(GFile* file, GAsyncResult* result, GError** err) mountMountableFinish; 5161 extern(C) void function(GFile* file, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountMountable; 5162 /** 5163 * 5164 * Params: 5165 * file = input #GFile 5166 * result = a #GAsyncResult 5167 * Return: %TRUE if the operation finished successfully. 5168 * %FALSE otherwise. 5169 * 5170 * Throws: GException on failure. 5171 */ 5172 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) unmountMountableFinish; 5173 extern(C) void function(GFile* file, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectMountable; 5174 /** 5175 * 5176 * Params: 5177 * file = input #GFile 5178 * result = a #GAsyncResult 5179 * Return: %TRUE if the @file was ejected successfully. 5180 * %FALSE otherwise. 5181 * 5182 * Throws: GException on failure. 5183 */ 5184 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) ejectMountableFinish; 5185 extern(C) void function(GFile* location, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountEnclosingVolume; 5186 /** 5187 * 5188 * Params: 5189 * location = input #GFile 5190 * result = a #GAsyncResult 5191 * Return: %TRUE if successful. If an error has occurred, 5192 * this function will return %FALSE and set @error 5193 * appropriately if present. 5194 * 5195 * Throws: GException on failure. 5196 */ 5197 extern(C) int function(GFile* location, GAsyncResult* result, GError** err) mountEnclosingVolumeFinish; 5198 /** 5199 * 5200 * Params: 5201 * file = input #GFile 5202 * flags = a set of #GFileMonitorFlags 5203 * cancellable = optional #GCancellable object, 5204 * %NULL to ignore 5205 * Return: a #GFileMonitor for the given @file, 5206 * or %NULL on error. 5207 * Free the returned object with g_object_unref(). 5208 * 5209 * Throws: GException on failure. 5210 */ 5211 extern(C) GFileMonitor* function(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err) monitorDir; 5212 /** 5213 * 5214 * Params: 5215 * file = input #GFile 5216 * flags = a set of #GFileMonitorFlags 5217 * cancellable = optional #GCancellable object, 5218 * %NULL to ignore 5219 * Return: a #GFileMonitor for the given @file, 5220 * or %NULL on error. 5221 * Free the returned object with g_object_unref(). 5222 * 5223 * Throws: GException on failure. 5224 */ 5225 extern(C) GFileMonitor* function(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err) monitorFile; 5226 /** 5227 * 5228 * Params: 5229 * file = #GFile to open 5230 * cancellable = a #GCancellable 5231 * Return: #GFileIOStream or %NULL on error. 5232 * Free the returned object with g_object_unref(). 5233 * 5234 * Throws: GException on failure. 5235 */ 5236 extern(C) GFileIOStream* function(GFile* file, GCancellable* cancellable, GError** err) openReadwrite; 5237 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) openReadwriteAsync; 5238 /** 5239 * 5240 * Params: 5241 * file = input #GFile 5242 * res = a #GAsyncResult 5243 * Return: a #GFileIOStream or %NULL on error. 5244 * Free the returned object with g_object_unref(). 5245 * 5246 * Throws: GException on failure. 5247 */ 5248 extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) openReadwriteFinish; 5249 /** 5250 * 5251 * Params: 5252 * file = a #GFile 5253 * flags = a set of #GFileCreateFlags 5254 * cancellable = optional #GCancellable object, 5255 * %NULL to ignore 5256 * Return: a #GFileIOStream for the newly created 5257 * file, or %NULL on error. 5258 * Free the returned object with g_object_unref(). 5259 * 5260 * Throws: GException on failure. 5261 */ 5262 extern(C) GFileIOStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) createReadwrite; 5263 extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) createReadwriteAsync; 5264 /** 5265 * 5266 * Params: 5267 * file = input #GFile 5268 * res = a #GAsyncResult 5269 * Return: a #GFileIOStream or %NULL on error. 5270 * Free the returned object with g_object_unref(). 5271 * 5272 * Throws: GException on failure. 5273 */ 5274 extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) createReadwriteFinish; 5275 /** 5276 * 5277 * Params: 5278 * file = a #GFile 5279 * etag = an optional [entity tag][gfile-etag] 5280 * for the current #GFile, or #NULL to ignore 5281 * makeBackup = %TRUE if a backup should be created 5282 * flags = a set of #GFileCreateFlags 5283 * cancellable = optional #GCancellable object, 5284 * %NULL to ignore 5285 * Return: a #GFileIOStream or %NULL on error. 5286 * Free the returned object with g_object_unref(). 5287 * 5288 * Throws: GException on failure. 5289 */ 5290 extern(C) GFileIOStream* function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GError** err) replaceReadwrite; 5291 extern(C) void function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) replaceReadwriteAsync; 5292 /** 5293 * 5294 * Params: 5295 * file = input #GFile 5296 * res = a #GAsyncResult 5297 * Return: a #GFileIOStream, or %NULL on error. 5298 * Free the returned object with g_object_unref(). 5299 * 5300 * Throws: GException on failure. 5301 */ 5302 extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) replaceReadwriteFinish; 5303 extern(C) void function(GFile* file, GDriveStartFlags flags, GMountOperation* startOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) startMountable; 5304 /** 5305 * 5306 * Params: 5307 * file = input #GFile 5308 * result = a #GAsyncResult 5309 * Return: %TRUE if the operation finished successfully. %FALSE 5310 * otherwise. 5311 * 5312 * Throws: GException on failure. 5313 */ 5314 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) startMountableFinish; 5315 extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) stopMountable; 5316 /** 5317 * 5318 * Params: 5319 * file = input #GFile 5320 * result = a #GAsyncResult 5321 * Return: %TRUE if the operation finished successfully. 5322 * %FALSE otherwise. 5323 * 5324 * Throws: GException on failure. 5325 */ 5326 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) stopMountableFinish; 5327 /** 5328 * a boolean that indicates whether the #GFile implementation supports thread-default contexts. Since 2.22. 5329 */ 5330 bool supportsThreadContexts; 5331 extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountMountableWithOperation; 5332 /** 5333 * 5334 * Params: 5335 * file = input #GFile 5336 * result = a #GAsyncResult 5337 * Return: %TRUE if the operation finished successfully. 5338 * %FALSE otherwise. 5339 * 5340 * Throws: GException on failure. 5341 */ 5342 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) unmountMountableWithOperationFinish; 5343 extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectMountableWithOperation; 5344 /** 5345 * 5346 * Params: 5347 * file = input #GFile 5348 * result = a #GAsyncResult 5349 * Return: %TRUE if the @file was ejected successfully. 5350 * %FALSE otherwise. 5351 * 5352 * Throws: GException on failure. 5353 */ 5354 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) ejectMountableWithOperationFinish; 5355 extern(C) void function(GFile* file, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) pollMountable; 5356 /** 5357 * 5358 * Params: 5359 * file = input #GFile 5360 * result = a #GAsyncResult 5361 * Return: %TRUE if the operation finished successfully. %FALSE 5362 * otherwise. 5363 * 5364 * Throws: GException on failure. 5365 */ 5366 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) pollMountableFinish; 5367 /** 5368 * 5369 * Params: 5370 * file = a #GFile 5371 * flags = #GFileMeasureFlags 5372 * cancellable = optional #GCancellable 5373 * progressCallback = a #GFileMeasureProgressCallback 5374 * progressData = user_data for @progress_callback 5375 * diskUsage = the number of bytes of disk space used 5376 * numDirs = the number of directories encountered 5377 * numFiles = the number of non-directories encountered 5378 * Return: %TRUE if successful, with the out parameters set. 5379 * %FALSE otherwise, with @error set. 5380 * 5381 * Throws: GException on failure. 5382 */ 5383 extern(C) int function(GFile* file, GFileMeasureFlags flags, GCancellable* cancellable, GFileMeasureProgressCallback progressCallback, void* progressData, ulong* diskUsage, ulong* numDirs, ulong* numFiles, GError** err) measureDiskUsage; 5384 extern(C) void function(GFile* file, GFileMeasureFlags flags, int ioPriority, GCancellable* cancellable, GFileMeasureProgressCallback progressCallback, void* progressData, GAsyncReadyCallback callback, void* userData) measureDiskUsageAsync; 5385 /** 5386 * 5387 * Params: 5388 * file = a #GFile 5389 * result = the #GAsyncResult passed to your #GAsyncReadyCallback 5390 * diskUsage = the number of bytes of disk space used 5391 * numDirs = the number of directories encountered 5392 * numFiles = the number of non-directories encountered 5393 * Return: %TRUE if successful, with the out parameters set. 5394 * %FALSE otherwise, with @error set. 5395 * 5396 * Throws: GException on failure. 5397 */ 5398 extern(C) int function(GFile* file, GAsyncResult* result, ulong* diskUsage, ulong* numDirs, ulong* numFiles, GError** err) measureDiskUsageFinish; 5399 } 5400 5401 struct GFileInfo; 5402 5403 struct GFileInfoClass; 5404 5405 struct GFileInputStream 5406 { 5407 GInputStream parentInstance; 5408 GFileInputStreamPrivate* priv; 5409 } 5410 5411 struct GFileInputStreamClass 5412 { 5413 GInputStreamClass parentClass; 5414 extern(C) long function(GFileInputStream* stream) tell; 5415 extern(C) int function(GFileInputStream* stream) canSeek; 5416 extern(C) int function(GFileInputStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek; 5417 /** 5418 * 5419 * Params: 5420 * stream = a #GFileInputStream. 5421 * attributes = a file attribute query string. 5422 * cancellable = optional #GCancellable object, %NULL to ignore. 5423 * Return: a #GFileInfo, or %NULL on error. 5424 * 5425 * Throws: GException on failure. 5426 */ 5427 extern(C) GFileInfo* function(GFileInputStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo; 5428 extern(C) void function(GFileInputStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync; 5429 /** 5430 * 5431 * Params: 5432 * stream = a #GFileInputStream. 5433 * result = a #GAsyncResult. 5434 * Return: #GFileInfo. 5435 * 5436 * Throws: GException on failure. 5437 */ 5438 extern(C) GFileInfo* function(GFileInputStream* stream, GAsyncResult* result, GError** err) queryInfoFinish; 5439 extern(C) void function() GReserved1; 5440 extern(C) void function() GReserved2; 5441 extern(C) void function() GReserved3; 5442 extern(C) void function() GReserved4; 5443 extern(C) void function() GReserved5; 5444 } 5445 5446 struct GFileInputStreamPrivate; 5447 5448 struct GFileMonitor 5449 { 5450 GObject parentInstance; 5451 GFileMonitorPrivate* priv; 5452 } 5453 5454 struct GFileMonitorClass 5455 { 5456 GObjectClass parentClass; 5457 extern(C) void function(GFileMonitor* monitor, GFile* file, GFile* otherFile, GFileMonitorEvent eventType) changed; 5458 /** 5459 * 5460 * Params: 5461 * monitor = a #GFileMonitor. 5462 * Return: %TRUE if monitor was cancelled. 5463 */ 5464 extern(C) int function(GFileMonitor* monitor) cancel; 5465 extern(C) void function() GReserved1; 5466 extern(C) void function() GReserved2; 5467 extern(C) void function() GReserved3; 5468 extern(C) void function() GReserved4; 5469 extern(C) void function() GReserved5; 5470 } 5471 5472 struct GFileMonitorPrivate; 5473 5474 struct GFileOutputStream 5475 { 5476 GOutputStream parentInstance; 5477 GFileOutputStreamPrivate* priv; 5478 } 5479 5480 struct GFileOutputStreamClass 5481 { 5482 GOutputStreamClass parentClass; 5483 extern(C) long function(GFileOutputStream* stream) tell; 5484 extern(C) int function(GFileOutputStream* stream) canSeek; 5485 extern(C) int function(GFileOutputStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek; 5486 extern(C) int function(GFileOutputStream* stream) canTruncate; 5487 extern(C) int function(GFileOutputStream* stream, long size, GCancellable* cancellable, GError** err) truncateFn; 5488 /** 5489 * 5490 * Params: 5491 * stream = a #GFileOutputStream. 5492 * attributes = a file attribute query string. 5493 * cancellable = optional #GCancellable object, %NULL to ignore. 5494 * Return: a #GFileInfo for the @stream, or %NULL on error. 5495 * 5496 * Throws: GException on failure. 5497 */ 5498 extern(C) GFileInfo* function(GFileOutputStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo; 5499 extern(C) void function(GFileOutputStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync; 5500 /** 5501 * 5502 * Params: 5503 * stream = a #GFileOutputStream. 5504 * result = a #GAsyncResult. 5505 * Return: A #GFileInfo for the finished query. 5506 * 5507 * Throws: GException on failure. 5508 */ 5509 extern(C) GFileInfo* function(GFileOutputStream* stream, GAsyncResult* result, GError** err) queryInfoFinish; 5510 /** 5511 * 5512 * Params: 5513 * stream = a #GFileOutputStream. 5514 * Return: the entity tag for the stream. 5515 */ 5516 extern(C) char* function(GFileOutputStream* stream) getEtag; 5517 extern(C) void function() GReserved1; 5518 extern(C) void function() GReserved2; 5519 extern(C) void function() GReserved3; 5520 extern(C) void function() GReserved4; 5521 extern(C) void function() GReserved5; 5522 } 5523 5524 struct GFileOutputStreamPrivate; 5525 5526 struct GFilenameCompleter; 5527 5528 struct GFilenameCompleterClass 5529 { 5530 GObjectClass parentClass; 5531 extern(C) void function(GFilenameCompleter* filenameCompleter) gotCompletionData; 5532 extern(C) void function() GReserved1; 5533 extern(C) void function() GReserved2; 5534 extern(C) void function() GReserved3; 5535 } 5536 5537 struct GFilterInputStream 5538 { 5539 GInputStream parentInstance; 5540 GInputStream* baseStream; 5541 } 5542 5543 struct GFilterInputStreamClass 5544 { 5545 GInputStreamClass parentClass; 5546 extern(C) void function() GReserved1; 5547 extern(C) void function() GReserved2; 5548 extern(C) void function() GReserved3; 5549 } 5550 5551 struct GFilterOutputStream 5552 { 5553 GOutputStream parentInstance; 5554 GOutputStream* baseStream; 5555 } 5556 5557 struct GFilterOutputStreamClass 5558 { 5559 GOutputStreamClass parentClass; 5560 extern(C) void function() GReserved1; 5561 extern(C) void function() GReserved2; 5562 extern(C) void function() GReserved3; 5563 } 5564 5565 struct GIOExtension; 5566 5567 struct GIOExtensionPoint; 5568 5569 struct GIOModule; 5570 5571 struct GIOModuleClass; 5572 5573 struct GIOModuleScope; 5574 5575 struct GIOSchedulerJob; 5576 5577 struct GIOStream 5578 { 5579 GObject parentInstance; 5580 GIOStreamPrivate* priv; 5581 } 5582 5583 struct GIOStreamAdapter; 5584 5585 struct GIOStreamClass 5586 { 5587 GObjectClass parentClass; 5588 /** 5589 * 5590 * Params: 5591 * stream = a #GIOStream 5592 * Return: a #GInputStream, owned by the #GIOStream. 5593 * Do not free. 5594 */ 5595 extern(C) GInputStream* function(GIOStream* stream) getInputStream; 5596 /** 5597 * 5598 * Params: 5599 * stream = a #GIOStream 5600 * Return: a #GOutputStream, owned by the #GIOStream. 5601 * Do not free. 5602 */ 5603 extern(C) GOutputStream* function(GIOStream* stream) getOutputStream; 5604 extern(C) int function(GIOStream* stream, GCancellable* cancellable, GError** err) closeFn; 5605 extern(C) void function(GIOStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync; 5606 /** 5607 * 5608 * Params: 5609 * stream = a #GIOStream 5610 * result = a #GAsyncResult 5611 * Return: %TRUE if stream was successfully closed, %FALSE otherwise. 5612 * 5613 * Throws: GException on failure. 5614 */ 5615 extern(C) int function(GIOStream* stream, GAsyncResult* result, GError** err) closeFinish; 5616 extern(C) void function() GReserved1; 5617 extern(C) void function() GReserved2; 5618 extern(C) void function() GReserved3; 5619 extern(C) void function() GReserved4; 5620 extern(C) void function() GReserved5; 5621 extern(C) void function() GReserved6; 5622 extern(C) void function() GReserved7; 5623 extern(C) void function() GReserved8; 5624 extern(C) void function() GReserved9; 5625 extern(C) void function() GReserved10; 5626 } 5627 5628 struct GIOStreamPrivate; 5629 5630 struct GIcon; 5631 5632 /** 5633 * GIconIface is used to implement GIcon types for various 5634 * different systems. See #GThemedIcon and #GLoadableIcon for 5635 * examples of how to implement this interface. 5636 */ 5637 struct GIconIface 5638 { 5639 /** 5640 * The parent interface. 5641 */ 5642 GTypeInterface gIface; 5643 /** 5644 * 5645 * Params: 5646 * icon = #gconstpointer to an icon object. 5647 * Return: a #guint containing a hash for the @icon, suitable for 5648 * use in a #GHashTable or similar data structure. 5649 */ 5650 extern(C) uint function(GIcon* icon) hash; 5651 /** 5652 * 5653 * Params: 5654 * icon1 = pointer to the first #GIcon. 5655 * icon2 = pointer to the second #GIcon. 5656 * Return: %TRUE if @icon1 is equal to @icon2. %FALSE otherwise. 5657 */ 5658 extern(C) int function(GIcon* icon1, GIcon* icon2) equal; 5659 /** 5660 * 5661 * Params: 5662 * icon = a #GIcon. 5663 * Return: An allocated NUL-terminated UTF8 string or 5664 * %NULL if @icon can't be serialized. Use g_free() to free. 5665 */ 5666 extern(C) int function(GIcon* icon, GPtrArray* tokens, int* outVersion) toTokens; 5667 extern(C) GIcon* function(char** tokens, int numTokens, int versio, GError** err) fromTokens; 5668 /** 5669 * 5670 * Params: 5671 * icon = a #GIcon 5672 * Return: a #GVariant, or %NULL when serialization fails. 5673 */ 5674 extern(C) GVariant* function(GIcon* icon) serialize; 5675 } 5676 5677 struct GInetAddress 5678 { 5679 GObject parentInstance; 5680 GInetAddressPrivate* priv; 5681 } 5682 5683 struct GInetAddressClass 5684 { 5685 GObjectClass parentClass; 5686 /** 5687 * 5688 * Params: 5689 * address = a #GInetAddress 5690 * Return: a representation of @address as a string, which should be 5691 * freed after use. 5692 */ 5693 extern(C) char* function(GInetAddress* address) toString; 5694 /** 5695 * 5696 * Params: 5697 * address = a #GInetAddress 5698 * Return: a pointer to an internal array of the bytes in @address, 5699 * which should not be modified, stored, or freed. The size of this 5700 * array can be gotten with g_inet_address_get_native_size(). 5701 */ 5702 extern(C) ubyte* function(GInetAddress* address) toBytes; 5703 } 5704 5705 struct GInetAddressMask 5706 { 5707 GObject parentInstance; 5708 GInetAddressMaskPrivate* priv; 5709 } 5710 5711 struct GInetAddressMaskClass 5712 { 5713 GObjectClass parentClass; 5714 } 5715 5716 struct GInetAddressMaskPrivate; 5717 5718 struct GInetAddressPrivate; 5719 5720 struct GInetSocketAddress 5721 { 5722 GSocketAddress parentInstance; 5723 GInetSocketAddressPrivate* priv; 5724 } 5725 5726 struct GInetSocketAddressClass 5727 { 5728 GSocketAddressClass parentClass; 5729 } 5730 5731 struct GInetSocketAddressPrivate; 5732 5733 struct GInitable; 5734 5735 /** 5736 * Provides an interface for initializing object such that initialization 5737 * may fail. 5738 * 5739 * Since: 2.22 5740 */ 5741 struct GInitableIface 5742 { 5743 /** 5744 * The parent interface. 5745 */ 5746 GTypeInterface gIface; 5747 /** 5748 * 5749 * Params: 5750 * initable = a #GInitable. 5751 * cancellable = optional #GCancellable object, %NULL to ignore. 5752 * Return: %TRUE if successful. If an error has occurred, this function will 5753 * return %FALSE and set @error appropriately if present. 5754 * 5755 * Throws: GException on failure. 5756 */ 5757 extern(C) int function(GInitable* initable, GCancellable* cancellable, GError** err) init; 5758 } 5759 5760 struct GInputStream 5761 { 5762 GObject parentInstance; 5763 GInputStreamPrivate* priv; 5764 } 5765 5766 struct GInputStreamClass 5767 { 5768 GObjectClass parentClass; 5769 extern(C) ptrdiff_t function(GInputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err) readFn; 5770 /** 5771 * 5772 * Params: 5773 * stream = a #GInputStream. 5774 * count = the number of bytes that will be skipped from the stream 5775 * cancellable = optional #GCancellable object, %NULL to ignore. 5776 * Return: Number of bytes skipped, or -1 on error 5777 * 5778 * Throws: GException on failure. 5779 */ 5780 extern(C) ptrdiff_t function(GInputStream* stream, size_t count, GCancellable* cancellable, GError** err) skip; 5781 extern(C) int function(GInputStream* stream, GCancellable* cancellable, GError** err) closeFn; 5782 extern(C) void function(GInputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) readAsync; 5783 /** 5784 * 5785 * Params: 5786 * stream = a #GInputStream. 5787 * result = a #GAsyncResult. 5788 * Return: number of bytes read in, or -1 on error, or 0 on end of file. 5789 * 5790 * Throws: GException on failure. 5791 */ 5792 extern(C) ptrdiff_t function(GInputStream* stream, GAsyncResult* result, GError** err) readFinish; 5793 extern(C) void function(GInputStream* stream, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) skipAsync; 5794 /** 5795 * 5796 * Params: 5797 * stream = a #GInputStream. 5798 * result = a #GAsyncResult. 5799 * Return: the size of the bytes skipped, or %-1 on error. 5800 * 5801 * Throws: GException on failure. 5802 */ 5803 extern(C) ptrdiff_t function(GInputStream* stream, GAsyncResult* result, GError** err) skipFinish; 5804 extern(C) void function(GInputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync; 5805 /** 5806 * 5807 * Params: 5808 * stream = a #GInputStream. 5809 * result = a #GAsyncResult. 5810 * Return: %TRUE if the stream was closed successfully. 5811 * 5812 * Throws: GException on failure. 5813 */ 5814 extern(C) int function(GInputStream* stream, GAsyncResult* result, GError** err) closeFinish; 5815 extern(C) void function() GReserved1; 5816 extern(C) void function() GReserved2; 5817 extern(C) void function() GReserved3; 5818 extern(C) void function() GReserved4; 5819 extern(C) void function() GReserved5; 5820 } 5821 5822 struct GInputStreamPrivate; 5823 5824 /** 5825 * Structure used for scatter/gather data input. 5826 * You generally pass in an array of #GInputVectors 5827 * and the operation will store the read data starting in the 5828 * first buffer, switching to the next as needed. 5829 * 5830 * Since: 2.22 5831 */ 5832 struct GInputVector 5833 { 5834 /** 5835 * Pointer to a buffer where data will be written. 5836 */ 5837 void* buffer; 5838 /** 5839 * the available size in @buffer. 5840 */ 5841 size_t size; 5842 } 5843 5844 struct GListModel; 5845 5846 /** 5847 * The virtual function table for #GListModel. 5848 * 5849 * Since: 2.44 5850 */ 5851 struct GListModelInterface 5852 { 5853 /** 5854 * parent #GTypeInterface 5855 */ 5856 GTypeInterface gIface; 5857 /** 5858 * 5859 * Params: 5860 * list = a #GListModel 5861 * Return: the #GType of the items contained in @list. 5862 */ 5863 extern(C) GType function(GListModel* list) getItemType; 5864 /** 5865 * 5866 * Params: 5867 * list = a #GListModel 5868 * Return: the number of items in @list. 5869 */ 5870 extern(C) uint function(GListModel* list) getNItems; 5871 extern(C) void* function(GListModel* list, uint position) getItem; 5872 } 5873 5874 struct GListStore; 5875 5876 struct GListStoreClass 5877 { 5878 GObjectClass parentClass; 5879 } 5880 5881 struct GLoadableIcon; 5882 5883 /** 5884 * Interface for icons that can be loaded as a stream. 5885 */ 5886 struct GLoadableIconIface 5887 { 5888 /** 5889 * The parent interface. 5890 */ 5891 GTypeInterface gIface; 5892 /** 5893 * 5894 * Params: 5895 * icon = a #GLoadableIcon. 5896 * size = an integer. 5897 * type = a location to store the type of the loaded 5898 * icon, %NULL to ignore. 5899 * cancellable = optional #GCancellable object, %NULL to 5900 * ignore. 5901 * Return: a #GInputStream to read the icon from. 5902 * 5903 * Throws: GException on failure. 5904 */ 5905 extern(C) GInputStream* function(GLoadableIcon* icon, int size, char** type, GCancellable* cancellable, GError** err) load; 5906 extern(C) void function(GLoadableIcon* icon, int size, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) loadAsync; 5907 /** 5908 * 5909 * Params: 5910 * icon = a #GLoadableIcon. 5911 * res = a #GAsyncResult. 5912 * type = a location to store the type of the loaded 5913 * icon, %NULL to ignore. 5914 * Return: a #GInputStream to read the icon from. 5915 * 5916 * Throws: GException on failure. 5917 */ 5918 extern(C) GInputStream* function(GLoadableIcon* icon, GAsyncResult* res, char** type, GError** err) loadFinish; 5919 } 5920 5921 struct GMemoryInputStream 5922 { 5923 GInputStream parentInstance; 5924 GMemoryInputStreamPrivate* priv; 5925 } 5926 5927 struct GMemoryInputStreamClass 5928 { 5929 GInputStreamClass parentClass; 5930 extern(C) void function() GReserved1; 5931 extern(C) void function() GReserved2; 5932 extern(C) void function() GReserved3; 5933 extern(C) void function() GReserved4; 5934 extern(C) void function() GReserved5; 5935 } 5936 5937 struct GMemoryInputStreamPrivate; 5938 5939 struct GMemoryOutputStream 5940 { 5941 GOutputStream parentInstance; 5942 GMemoryOutputStreamPrivate* priv; 5943 } 5944 5945 struct GMemoryOutputStreamClass 5946 { 5947 GOutputStreamClass parentClass; 5948 extern(C) void function() GReserved1; 5949 extern(C) void function() GReserved2; 5950 extern(C) void function() GReserved3; 5951 extern(C) void function() GReserved4; 5952 extern(C) void function() GReserved5; 5953 } 5954 5955 struct GMemoryOutputStreamPrivate; 5956 5957 struct GMenu; 5958 5959 struct GMenuAttributeIter 5960 { 5961 GObject parentInstance; 5962 GMenuAttributeIterPrivate* priv; 5963 } 5964 5965 struct GMenuAttributeIterClass 5966 { 5967 GObjectClass parentClass; 5968 /** 5969 * 5970 * Params: 5971 * iter = a #GMenuAttributeIter 5972 * outName = the type of the attribute 5973 * value = the attribute value 5974 * Return: %TRUE on success, or %FALSE if there is no additional 5975 * attribute 5976 */ 5977 extern(C) int function(GMenuAttributeIter* iter, char** outName, GVariant** value) getNext; 5978 } 5979 5980 struct GMenuAttributeIterPrivate; 5981 5982 struct GMenuItem; 5983 5984 struct GMenuLinkIter 5985 { 5986 GObject parentInstance; 5987 GMenuLinkIterPrivate* priv; 5988 } 5989 5990 struct GMenuLinkIterClass 5991 { 5992 GObjectClass parentClass; 5993 /** 5994 * 5995 * Params: 5996 * iter = a #GMenuLinkIter 5997 * outLink = the name of the link 5998 * value = the linked #GMenuModel 5999 * Return: %TRUE on success, or %FALSE if there is no additional link 6000 */ 6001 extern(C) int function(GMenuLinkIter* iter, char** outLink, GMenuModel** value) getNext; 6002 } 6003 6004 struct GMenuLinkIterPrivate; 6005 6006 struct GMenuModel 6007 { 6008 GObject parentInstance; 6009 GMenuModelPrivate* priv; 6010 } 6011 6012 struct GMenuModelClass 6013 { 6014 GObjectClass parentClass; 6015 /** 6016 * 6017 * Params: 6018 * model = a #GMenuModel 6019 * Return: %TRUE if the model is mutable (ie: "items-changed" may be 6020 * emitted). 6021 */ 6022 extern(C) int function(GMenuModel* model) isMutable; 6023 /** 6024 * 6025 * Params: 6026 * model = a #GMenuModel 6027 * Return: the number of items 6028 */ 6029 extern(C) int function(GMenuModel* model) getNItems; 6030 extern(C) void function(GMenuModel* model, int itemIndex, GHashTable** attributes) getItemAttributes; 6031 /** 6032 * 6033 * Params: 6034 * model = a #GMenuModel 6035 * itemIndex = the index of the item 6036 * Return: a new #GMenuAttributeIter 6037 */ 6038 extern(C) GMenuAttributeIter* function(GMenuModel* model, int itemIndex) iterateItemAttributes; 6039 /** 6040 * 6041 * Params: 6042 * model = a #GMenuModel 6043 * itemIndex = the index of the item 6044 * attribute = the attribute to query 6045 * expectedType = the expected type of the attribute, or 6046 * %NULL 6047 * Return: the value of the attribute 6048 */ 6049 extern(C) GVariant* function(GMenuModel* model, int itemIndex, const(char)* attribute, GVariantType* expectedType) getItemAttributeValue; 6050 extern(C) void function(GMenuModel* model, int itemIndex, GHashTable** links) getItemLinks; 6051 /** 6052 * 6053 * Params: 6054 * model = a #GMenuModel 6055 * itemIndex = the index of the item 6056 * Return: a new #GMenuLinkIter 6057 */ 6058 extern(C) GMenuLinkIter* function(GMenuModel* model, int itemIndex) iterateItemLinks; 6059 /** 6060 * 6061 * Params: 6062 * model = a #GMenuModel 6063 * itemIndex = the index of the item 6064 * link = the link to query 6065 * Return: the linked #GMenuModel, or %NULL 6066 */ 6067 extern(C) GMenuModel* function(GMenuModel* model, int itemIndex, const(char)* link) getItemLink; 6068 } 6069 6070 struct GMenuModelPrivate; 6071 6072 struct GMount; 6073 6074 /** 6075 * Interface for implementing operations for mounts. 6076 */ 6077 struct GMountIface 6078 { 6079 /** 6080 * The parent interface. 6081 */ 6082 GTypeInterface gIface; 6083 extern(C) void function(GMount* mount) changed; 6084 extern(C) void function(GMount* mount) unmounted; 6085 /** 6086 * 6087 * Params: 6088 * mount = a #GMount. 6089 * Return: a #GFile. 6090 * The returned object should be unreffed with 6091 * g_object_unref() when no longer needed. 6092 */ 6093 extern(C) GFile* function(GMount* mount) getRoot; 6094 /** 6095 * 6096 * Params: 6097 * mount = a #GMount. 6098 * Return: the name for the given @mount. 6099 * The returned string should be freed with g_free() 6100 * when no longer needed. 6101 */ 6102 extern(C) char* function(GMount* mount) getName; 6103 /** 6104 * 6105 * Params: 6106 * mount = a #GMount. 6107 * Return: a #GIcon. 6108 * The returned object should be unreffed with 6109 * g_object_unref() when no longer needed. 6110 */ 6111 extern(C) GIcon* function(GMount* mount) getIcon; 6112 /** 6113 * 6114 * Params: 6115 * mount = a #GMount. 6116 * Return: the UUID for @mount or %NULL if no UUID can be computed. 6117 * The returned string should be freed with g_free() 6118 * when no longer needed. 6119 */ 6120 extern(C) char* function(GMount* mount) getUuid; 6121 /** 6122 * 6123 * Params: 6124 * mount = a #GMount. 6125 * Return: a #GVolume or %NULL if @mount is not associated with a volume. 6126 * The returned object should be unreffed with 6127 * g_object_unref() when no longer needed. 6128 */ 6129 extern(C) GVolume* function(GMount* mount) getVolume; 6130 /** 6131 * 6132 * Params: 6133 * mount = a #GMount. 6134 * Return: a #GDrive or %NULL if @mount is not associated with a volume or a drive. 6135 * The returned object should be unreffed with 6136 * g_object_unref() when no longer needed. 6137 */ 6138 extern(C) GDrive* function(GMount* mount) getDrive; 6139 /** 6140 * 6141 * Params: 6142 * mount = a #GMount. 6143 * Return: %TRUE if the @mount can be unmounted. 6144 */ 6145 extern(C) int function(GMount* mount) canUnmount; 6146 /** 6147 * 6148 * Params: 6149 * mount = a #GMount. 6150 * Return: %TRUE if the @mount can be ejected. 6151 */ 6152 extern(C) int function(GMount* mount) canEject; 6153 extern(C) void function(GMount* mount, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmount; 6154 /** 6155 * 6156 * Params: 6157 * mount = a #GMount. 6158 * result = a #GAsyncResult. 6159 * Return: %TRUE if the mount was successfully unmounted. %FALSE otherwise. 6160 * 6161 * Throws: GException on failure. 6162 */ 6163 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) unmountFinish; 6164 extern(C) void function(GMount* mount, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject; 6165 /** 6166 * 6167 * Params: 6168 * mount = a #GMount. 6169 * result = a #GAsyncResult. 6170 * Return: %TRUE if the mount was successfully ejected. %FALSE otherwise. 6171 * 6172 * Throws: GException on failure. 6173 */ 6174 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) ejectFinish; 6175 extern(C) void function(GMount* mount, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) remount; 6176 /** 6177 * 6178 * Params: 6179 * mount = a #GMount. 6180 * result = a #GAsyncResult. 6181 * Return: %TRUE if the mount was successfully remounted. %FALSE otherwise. 6182 * 6183 * Throws: GException on failure. 6184 */ 6185 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) remountFinish; 6186 extern(C) void function(GMount* mount, int forceRescan, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) guessContentType; 6187 /** 6188 * 6189 * Params: 6190 * mount = a #GMount 6191 * result = a #GAsyncResult 6192 * Return: a %NULL-terminated array of content types or %NULL on error. 6193 * Caller should free this array with g_strfreev() when done with it. 6194 * 6195 * Throws: GException on failure. 6196 */ 6197 extern(C) char** function(GMount* mount, GAsyncResult* result, GError** err) guessContentTypeFinish; 6198 /** 6199 * 6200 * Params: 6201 * mount = a #GMount 6202 * forceRescan = Whether to force a rescan of the content. 6203 * Otherwise a cached result will be used if available 6204 * cancellable = optional #GCancellable object, %NULL to ignore 6205 * Return: a %NULL-terminated array of content types or %NULL on error. 6206 * Caller should free this array with g_strfreev() when done with it. 6207 * 6208 * Throws: GException on failure. 6209 */ 6210 extern(C) char** function(GMount* mount, int forceRescan, GCancellable* cancellable, GError** err) guessContentTypeSync; 6211 extern(C) void function(GMount* mount) preUnmount; 6212 extern(C) void function(GMount* mount, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountWithOperation; 6213 /** 6214 * 6215 * Params: 6216 * mount = a #GMount. 6217 * result = a #GAsyncResult. 6218 * Return: %TRUE if the mount was successfully unmounted. %FALSE otherwise. 6219 * 6220 * Throws: GException on failure. 6221 */ 6222 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) unmountWithOperationFinish; 6223 extern(C) void function(GMount* mount, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation; 6224 /** 6225 * 6226 * Params: 6227 * mount = a #GMount. 6228 * result = a #GAsyncResult. 6229 * Return: %TRUE if the mount was successfully ejected. %FALSE otherwise. 6230 * 6231 * Throws: GException on failure. 6232 */ 6233 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) ejectWithOperationFinish; 6234 /** 6235 * 6236 * Params: 6237 * mount = a #GMount. 6238 * Return: a #GFile. 6239 * The returned object should be unreffed with 6240 * g_object_unref() when no longer needed. 6241 */ 6242 extern(C) GFile* function(GMount* mount) getDefaultLocation; 6243 /** 6244 * 6245 * Params: 6246 * mount = A #GMount. 6247 * Return: Sorting key for @mount or %NULL if no such key is available. 6248 */ 6249 extern(C) const(char)* function(GMount* mount) getSortKey; 6250 /** 6251 * 6252 * Params: 6253 * mount = a #GMount. 6254 * Return: a #GIcon. 6255 * The returned object should be unreffed with 6256 * g_object_unref() when no longer needed. 6257 */ 6258 extern(C) GIcon* function(GMount* mount) getSymbolicIcon; 6259 } 6260 6261 struct GMountOperation 6262 { 6263 GObject parentInstance; 6264 GMountOperationPrivate* priv; 6265 } 6266 6267 struct GMountOperationClass 6268 { 6269 GObjectClass parentClass; 6270 extern(C) void function(GMountOperation* op, const(char)* message, const(char)* defaultUser, const(char)* defaultDomain, GAskPasswordFlags flags) askPassword; 6271 extern(C) void function(GMountOperation* op, const(char)* message, const(char)* choices) askQuestion; 6272 extern(C) void function(GMountOperation* op, GMountOperationResult result) reply; 6273 extern(C) void function(GMountOperation* op) aborted; 6274 extern(C) void function(GMountOperation* op, const(char)* message, GArray* processes, const(char)* choices) showProcesses; 6275 extern(C) void function(GMountOperation* op, const(char)* message, long timeLeft, long bytesLeft) showUnmountProgress; 6276 extern(C) void function() GReserved1; 6277 extern(C) void function() GReserved2; 6278 extern(C) void function() GReserved3; 6279 extern(C) void function() GReserved4; 6280 extern(C) void function() GReserved5; 6281 extern(C) void function() GReserved6; 6282 extern(C) void function() GReserved7; 6283 extern(C) void function() GReserved8; 6284 extern(C) void function() GReserved9; 6285 } 6286 6287 struct GMountOperationPrivate; 6288 6289 struct GNativeVolumeMonitor 6290 { 6291 GVolumeMonitor parentInstance; 6292 } 6293 6294 struct GNativeVolumeMonitorClass 6295 { 6296 GVolumeMonitorClass parentClass; 6297 extern(C) GMount* function(const(char)* mountPath, GCancellable* cancellable) getMountForMountPath; 6298 } 6299 6300 struct GNetworkAddress 6301 { 6302 GObject parentInstance; 6303 GNetworkAddressPrivate* priv; 6304 } 6305 6306 struct GNetworkAddressClass 6307 { 6308 GObjectClass parentClass; 6309 } 6310 6311 struct GNetworkAddressPrivate; 6312 6313 struct GNetworkMonitor; 6314 6315 /** 6316 * The virtual function table for #GNetworkMonitor. 6317 * 6318 * Since: 2.32 6319 */ 6320 struct GNetworkMonitorInterface 6321 { 6322 /** 6323 * The parent interface. 6324 */ 6325 GTypeInterface gIface; 6326 extern(C) void function(GNetworkMonitor* monitor, int available) networkChanged; 6327 /** 6328 * 6329 * Params: 6330 * monitor = a #GNetworkMonitor 6331 * connectable = a #GSocketConnectable 6332 * cancellable = a #GCancellable, or %NULL 6333 * Return: %TRUE if @connectable is reachable, %FALSE if not. 6334 * 6335 * Throws: GException on failure. 6336 */ 6337 extern(C) int function(GNetworkMonitor* monitor, GSocketConnectable* connectable, GCancellable* cancellable, GError** err) canReach; 6338 extern(C) void function(GNetworkMonitor* monitor, GSocketConnectable* connectable, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) canReachAsync; 6339 /** 6340 * 6341 * Params: 6342 * monitor = a #GNetworkMonitor 6343 * result = a #GAsyncResult 6344 * Return: %TRUE if network is reachable, %FALSE if not. 6345 * 6346 * Throws: GException on failure. 6347 */ 6348 extern(C) int function(GNetworkMonitor* monitor, GAsyncResult* result, GError** err) canReachFinish; 6349 } 6350 6351 struct GNetworkService 6352 { 6353 GObject parentInstance; 6354 GNetworkServicePrivate* priv; 6355 } 6356 6357 struct GNetworkServiceClass 6358 { 6359 GObjectClass parentClass; 6360 } 6361 6362 struct GNetworkServicePrivate; 6363 6364 struct GNotification; 6365 6366 /** 6367 * Structure used for scatter/gather data output when sending multiple 6368 * messages or packets in one go. You generally pass in an array of 6369 * #GOutputVectors and the operation will use all the buffers as if they 6370 * were one buffer. 6371 * 6372 * If @address is %NULL then the message is sent to the default receiver 6373 * (as previously set by g_socket_connect()). 6374 * 6375 * Since: 2.44 6376 */ 6377 struct GOutputMessage 6378 { 6379 /** 6380 * a #GSocketAddress, or %NULL 6381 */ 6382 GSocketAddress* address; 6383 /** 6384 * pointer to an array of output vectors 6385 */ 6386 GOutputVector* vectors; 6387 /** 6388 * the number of output vectors pointed to by @vectors. 6389 */ 6390 uint numVectors; 6391 /** 6392 * initialize to 0. Will be set to the number of bytes 6393 * that have been sent 6394 */ 6395 uint bytesSent; 6396 /** 6397 * a pointer 6398 * to an array of #GSocketControlMessages, or %NULL. 6399 */ 6400 GSocketControlMessage** controlMessages; 6401 /** 6402 * number of elements in @control_messages. 6403 */ 6404 uint numControlMessages; 6405 } 6406 6407 struct GOutputStream 6408 { 6409 GObject parentInstance; 6410 GOutputStreamPrivate* priv; 6411 } 6412 6413 struct GOutputStreamClass 6414 { 6415 GObjectClass parentClass; 6416 /** 6417 * 6418 * Params: 6419 * stream = a #GOutputStream. 6420 * buffer = the buffer containing the data to write. 6421 * count = the number of bytes to write 6422 * cancellable = optional cancellable object 6423 * Return: Number of bytes written, or -1 on error 6424 * 6425 * Throws: GException on failure. 6426 */ 6427 extern(C) ptrdiff_t function(GOutputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err) writeFn; 6428 /** 6429 * 6430 * Params: 6431 * stream = a #GOutputStream. 6432 * source = a #GInputStream. 6433 * flags = a set of #GOutputStreamSpliceFlags. 6434 * cancellable = optional #GCancellable object, %NULL to ignore. 6435 * Return: a #gssize containing the size of the data spliced, or 6436 * -1 if an error occurred. Note that if the number of bytes 6437 * spliced is greater than %G_MAXSSIZE, then that will be 6438 * returned, and there is no way to determine the actual number 6439 * of bytes spliced. 6440 * 6441 * Throws: GException on failure. 6442 */ 6443 extern(C) ptrdiff_t function(GOutputStream* stream, GInputStream* source, GOutputStreamSpliceFlags flags, GCancellable* cancellable, GError** err) splice; 6444 /** 6445 * 6446 * Params: 6447 * stream = a #GOutputStream. 6448 * cancellable = optional cancellable object 6449 * Return: %TRUE on success, %FALSE on error 6450 * 6451 * Throws: GException on failure. 6452 */ 6453 extern(C) int function(GOutputStream* stream, GCancellable* cancellable, GError** err) flush; 6454 extern(C) int function(GOutputStream* stream, GCancellable* cancellable, GError** err) closeFn; 6455 extern(C) void function(GOutputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) writeAsync; 6456 /** 6457 * 6458 * Params: 6459 * stream = a #GOutputStream. 6460 * result = a #GAsyncResult. 6461 * Return: a #gssize containing the number of bytes written to the stream. 6462 * 6463 * Throws: GException on failure. 6464 */ 6465 extern(C) ptrdiff_t function(GOutputStream* stream, GAsyncResult* result, GError** err) writeFinish; 6466 extern(C) void function(GOutputStream* stream, GInputStream* source, GOutputStreamSpliceFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) spliceAsync; 6467 /** 6468 * 6469 * Params: 6470 * stream = a #GOutputStream. 6471 * result = a #GAsyncResult. 6472 * Return: a #gssize of the number of bytes spliced. Note that if the 6473 * number of bytes spliced is greater than %G_MAXSSIZE, then that 6474 * will be returned, and there is no way to determine the actual 6475 * number of bytes spliced. 6476 * 6477 * Throws: GException on failure. 6478 */ 6479 extern(C) ptrdiff_t function(GOutputStream* stream, GAsyncResult* result, GError** err) spliceFinish; 6480 extern(C) void function(GOutputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) flushAsync; 6481 /** 6482 * 6483 * Params: 6484 * stream = a #GOutputStream. 6485 * result = a GAsyncResult. 6486 * Return: %TRUE if flush operation succeeded, %FALSE otherwise. 6487 * 6488 * Throws: GException on failure. 6489 */ 6490 extern(C) int function(GOutputStream* stream, GAsyncResult* result, GError** err) flushFinish; 6491 extern(C) void function(GOutputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync; 6492 /** 6493 * 6494 * Params: 6495 * stream = a #GOutputStream. 6496 * result = a #GAsyncResult. 6497 * Return: %TRUE if stream was successfully closed, %FALSE otherwise. 6498 * 6499 * Throws: GException on failure. 6500 */ 6501 extern(C) int function(GOutputStream* stream, GAsyncResult* result, GError** err) closeFinish; 6502 extern(C) void function() GReserved1; 6503 extern(C) void function() GReserved2; 6504 extern(C) void function() GReserved3; 6505 extern(C) void function() GReserved4; 6506 extern(C) void function() GReserved5; 6507 extern(C) void function() GReserved6; 6508 extern(C) void function() GReserved7; 6509 extern(C) void function() GReserved8; 6510 } 6511 6512 struct GOutputStreamPrivate; 6513 6514 /** 6515 * Structure used for scatter/gather data output. 6516 * You generally pass in an array of #GOutputVectors 6517 * and the operation will use all the buffers as if they were 6518 * one buffer. 6519 * 6520 * Since: 2.22 6521 */ 6522 struct GOutputVector 6523 { 6524 /** 6525 * Pointer to a buffer of data to read. 6526 */ 6527 void* buffer; 6528 /** 6529 * the size of @buffer. 6530 */ 6531 size_t size; 6532 } 6533 6534 struct GPermission 6535 { 6536 GObject parentInstance; 6537 GPermissionPrivate* priv; 6538 } 6539 6540 struct GPermissionClass 6541 { 6542 GObjectClass parentClass; 6543 /** 6544 * 6545 * Params: 6546 * permission = a #GPermission instance 6547 * cancellable = a #GCancellable, or %NULL 6548 * Return: %TRUE if the permission was successfully acquired 6549 * 6550 * Throws: GException on failure. 6551 */ 6552 extern(C) int function(GPermission* permission, GCancellable* cancellable, GError** err) acquire; 6553 extern(C) void function(GPermission* permission, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) acquireAsync; 6554 /** 6555 * 6556 * Params: 6557 * permission = a #GPermission instance 6558 * result = the #GAsyncResult given to the #GAsyncReadyCallback 6559 * Return: %TRUE if the permission was successfully acquired 6560 * 6561 * Throws: GException on failure. 6562 */ 6563 extern(C) int function(GPermission* permission, GAsyncResult* result, GError** err) acquireFinish; 6564 /** 6565 * 6566 * Params: 6567 * permission = a #GPermission instance 6568 * cancellable = a #GCancellable, or %NULL 6569 * Return: %TRUE if the permission was successfully released 6570 * 6571 * Throws: GException on failure. 6572 */ 6573 extern(C) int function(GPermission* permission, GCancellable* cancellable, GError** err) release; 6574 extern(C) void function(GPermission* permission, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) releaseAsync; 6575 /** 6576 * 6577 * Params: 6578 * permission = a #GPermission instance 6579 * result = the #GAsyncResult given to the #GAsyncReadyCallback 6580 * Return: %TRUE if the permission was successfully released 6581 * 6582 * Throws: GException on failure. 6583 */ 6584 extern(C) int function(GPermission* permission, GAsyncResult* result, GError** err) releaseFinish; 6585 void*[16] reserved; 6586 } 6587 6588 struct GPermissionPrivate; 6589 6590 struct GPollableInputStream; 6591 6592 /** 6593 * The interface for pollable input streams. 6594 * 6595 * The default implementation of @can_poll always returns %TRUE. 6596 * 6597 * The default implementation of @read_nonblocking calls 6598 * g_pollable_input_stream_is_readable(), and then calls 6599 * g_input_stream_read() if it returns %TRUE. This means you only need 6600 * to override it if it is possible that your @is_readable 6601 * implementation may return %TRUE when the stream is not actually 6602 * readable. 6603 * 6604 * Since: 2.28 6605 */ 6606 struct GPollableInputStreamInterface 6607 { 6608 /** 6609 * The parent interface. 6610 */ 6611 GTypeInterface gIface; 6612 /** 6613 * 6614 * Params: 6615 * stream = a #GPollableInputStream. 6616 * Return: %TRUE if @stream is pollable, %FALSE if not. 6617 */ 6618 extern(C) int function(GPollableInputStream* stream) canPoll; 6619 /** 6620 * 6621 * Params: 6622 * stream = a #GPollableInputStream. 6623 * Return: %TRUE if @stream is readable, %FALSE if not. If an error 6624 * has occurred on @stream, this will result in 6625 * g_pollable_input_stream_is_readable() returning %TRUE, and the 6626 * next attempt to read will return the error. 6627 */ 6628 extern(C) int function(GPollableInputStream* stream) isReadable; 6629 /** 6630 * 6631 * Params: 6632 * stream = a #GPollableInputStream. 6633 * cancellable = a #GCancellable, or %NULL 6634 * Return: a new #GSource 6635 */ 6636 extern(C) GSource* function(GPollableInputStream* stream, GCancellable* cancellable) createSource; 6637 /** 6638 * 6639 * Params: 6640 * stream = a #GPollableInputStream 6641 * buffer = a buffer to 6642 * read data into (which should be at least @count bytes long). 6643 * count = the number of bytes you want to read 6644 * Return: the number of bytes read, or -1 on error (including 6645 * %G_IO_ERROR_WOULD_BLOCK). 6646 * 6647 * Throws: GException on failure. 6648 */ 6649 extern(C) ptrdiff_t function(GPollableInputStream* stream, void* buffer, size_t count, GError** err) readNonblocking; 6650 } 6651 6652 struct GPollableOutputStream; 6653 6654 /** 6655 * The interface for pollable output streams. 6656 * 6657 * The default implementation of @can_poll always returns %TRUE. 6658 * 6659 * The default implementation of @write_nonblocking calls 6660 * g_pollable_output_stream_is_writable(), and then calls 6661 * g_output_stream_write() if it returns %TRUE. This means you only 6662 * need to override it if it is possible that your @is_writable 6663 * implementation may return %TRUE when the stream is not actually 6664 * writable. 6665 * 6666 * Since: 2.28 6667 */ 6668 struct GPollableOutputStreamInterface 6669 { 6670 /** 6671 * The parent interface. 6672 */ 6673 GTypeInterface gIface; 6674 /** 6675 * 6676 * Params: 6677 * stream = a #GPollableOutputStream. 6678 * Return: %TRUE if @stream is pollable, %FALSE if not. 6679 */ 6680 extern(C) int function(GPollableOutputStream* stream) canPoll; 6681 /** 6682 * 6683 * Params: 6684 * stream = a #GPollableOutputStream. 6685 * Return: %TRUE if @stream is writable, %FALSE if not. If an error 6686 * has occurred on @stream, this will result in 6687 * g_pollable_output_stream_is_writable() returning %TRUE, and the 6688 * next attempt to write will return the error. 6689 */ 6690 extern(C) int function(GPollableOutputStream* stream) isWritable; 6691 /** 6692 * 6693 * Params: 6694 * stream = a #GPollableOutputStream. 6695 * cancellable = a #GCancellable, or %NULL 6696 * Return: a new #GSource 6697 */ 6698 extern(C) GSource* function(GPollableOutputStream* stream, GCancellable* cancellable) createSource; 6699 /** 6700 * 6701 * Params: 6702 * stream = a #GPollableOutputStream 6703 * buffer = a buffer to write 6704 * data from 6705 * count = the number of bytes you want to write 6706 * Return: the number of bytes written, or -1 on error (including 6707 * %G_IO_ERROR_WOULD_BLOCK). 6708 * 6709 * Throws: GException on failure. 6710 */ 6711 extern(C) ptrdiff_t function(GPollableOutputStream* stream, void* buffer, size_t count, GError** err) writeNonblocking; 6712 } 6713 6714 struct GPropertyAction; 6715 6716 struct GProxy; 6717 6718 struct GProxyAddress 6719 { 6720 GInetSocketAddress parentInstance; 6721 GProxyAddressPrivate* priv; 6722 } 6723 6724 /** 6725 * Class structure for #GProxyAddress. 6726 * 6727 * Since: 2.26 6728 */ 6729 struct GProxyAddressClass 6730 { 6731 GInetSocketAddressClass parentClass; 6732 } 6733 6734 struct GProxyAddressEnumerator 6735 { 6736 GSocketAddressEnumerator parentInstance; 6737 GProxyAddressEnumeratorPrivate* priv; 6738 } 6739 6740 struct GProxyAddressEnumeratorClass 6741 { 6742 GSocketAddressEnumeratorClass parentClass; 6743 extern(C) void function() GReserved1; 6744 extern(C) void function() GReserved2; 6745 extern(C) void function() GReserved3; 6746 extern(C) void function() GReserved4; 6747 extern(C) void function() GReserved5; 6748 extern(C) void function() GReserved6; 6749 extern(C) void function() GReserved7; 6750 } 6751 6752 struct GProxyAddressEnumeratorPrivate; 6753 6754 struct GProxyAddressPrivate; 6755 6756 /** 6757 * Provides an interface for handling proxy connection and payload. 6758 * 6759 * Since: 2.26 6760 */ 6761 struct GProxyInterface 6762 { 6763 /** 6764 * The parent interface. 6765 */ 6766 GTypeInterface gIface; 6767 /** 6768 * 6769 * Params: 6770 * proxy = a #GProxy 6771 * connection = a #GIOStream 6772 * proxyAddress = a #GProxyAddress 6773 * cancellable = a #GCancellable 6774 * Return: a #GIOStream that will replace @connection. This might 6775 * be the same as @connection, in which case a reference 6776 * will be added. 6777 * 6778 * Throws: GException on failure. 6779 */ 6780 extern(C) GIOStream* function(GProxy* proxy, GIOStream* connection, GProxyAddress* proxyAddress, GCancellable* cancellable, GError** err) connect; 6781 extern(C) void function(GProxy* proxy, GIOStream* connection, GProxyAddress* proxyAddress, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) connectAsync; 6782 /** 6783 * 6784 * Params: 6785 * proxy = a #GProxy 6786 * result = a #GAsyncResult 6787 * Return: a #GIOStream. 6788 * 6789 * Throws: GException on failure. 6790 */ 6791 extern(C) GIOStream* function(GProxy* proxy, GAsyncResult* result, GError** err) connectFinish; 6792 /** 6793 * 6794 * Params: 6795 * proxy = a #GProxy 6796 * Return: %TRUE if hostname resolution is supported. 6797 */ 6798 extern(C) int function(GProxy* proxy) supportsHostname; 6799 } 6800 6801 struct GProxyResolver; 6802 6803 /** 6804 * The virtual function table for #GProxyResolver. 6805 */ 6806 struct GProxyResolverInterface 6807 { 6808 /** 6809 * The parent interface. 6810 */ 6811 GTypeInterface gIface; 6812 /** 6813 * 6814 * Params: 6815 * resolver = a #GProxyResolver 6816 * Return: %TRUE if @resolver is supported. 6817 */ 6818 extern(C) int function(GProxyResolver* resolver) isSupported; 6819 /** 6820 * 6821 * Params: 6822 * resolver = a #GProxyResolver 6823 * uri = a URI representing the destination to connect to 6824 * cancellable = a #GCancellable, or %NULL 6825 * Return: A 6826 * NULL-terminated array of proxy URIs. Must be freed 6827 * with g_strfreev(). 6828 * 6829 * Throws: GException on failure. 6830 */ 6831 extern(C) char** function(GProxyResolver* resolver, const(char)* uri, GCancellable* cancellable, GError** err) lookup; 6832 extern(C) void function(GProxyResolver* resolver, const(char)* uri, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupAsync; 6833 /** 6834 * 6835 * Params: 6836 * resolver = a #GProxyResolver 6837 * result = the result passed to your #GAsyncReadyCallback 6838 * Return: A 6839 * NULL-terminated array of proxy URIs. Must be freed 6840 * with g_strfreev(). 6841 * 6842 * Throws: GException on failure. 6843 */ 6844 extern(C) char** function(GProxyResolver* resolver, GAsyncResult* result, GError** err) lookupFinish; 6845 } 6846 6847 struct GRemoteActionGroup; 6848 6849 /** 6850 * The virtual function table for #GRemoteActionGroup. 6851 * 6852 * Since: 2.32 6853 */ 6854 struct GRemoteActionGroupInterface 6855 { 6856 GTypeInterface gIface; 6857 extern(C) void function(GRemoteActionGroup* remote, const(char)* actionName, GVariant* parameter, GVariant* platformData) activateActionFull; 6858 extern(C) void function(GRemoteActionGroup* remote, const(char)* actionName, GVariant* value, GVariant* platformData) changeActionStateFull; 6859 } 6860 6861 struct GResolver 6862 { 6863 GObject parentInstance; 6864 GResolverPrivate* priv; 6865 } 6866 6867 struct GResolverClass 6868 { 6869 GObjectClass parentClass; 6870 extern(C) void function(GResolver* resolver) reload; 6871 /** 6872 * 6873 * Params: 6874 * resolver = a #GResolver 6875 * hostname = the hostname to look up 6876 * cancellable = a #GCancellable, or %NULL 6877 * Return: a non-empty #GList 6878 * of #GInetAddress, or %NULL on error. You 6879 * must unref each of the addresses and free the list when you are 6880 * done with it. (You can use g_resolver_free_addresses() to do this.) 6881 * 6882 * Throws: GException on failure. 6883 */ 6884 extern(C) GList* function(GResolver* resolver, const(char)* hostname, GCancellable* cancellable, GError** err) lookupByName; 6885 extern(C) void function(GResolver* resolver, const(char)* hostname, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupByNameAsync; 6886 /** 6887 * 6888 * Params: 6889 * resolver = a #GResolver 6890 * result = the result passed to your #GAsyncReadyCallback 6891 * Return: a #GList 6892 * of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() 6893 * for more details. 6894 * 6895 * Throws: GException on failure. 6896 */ 6897 extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupByNameFinish; 6898 /** 6899 * 6900 * Params: 6901 * resolver = a #GResolver 6902 * address = the address to reverse-resolve 6903 * cancellable = a #GCancellable, or %NULL 6904 * Return: a hostname (either ASCII-only, or in ASCII-encoded 6905 * form), or %NULL on error. 6906 * 6907 * Throws: GException on failure. 6908 */ 6909 extern(C) char* function(GResolver* resolver, GInetAddress* address, GCancellable* cancellable, GError** err) lookupByAddress; 6910 extern(C) void function(GResolver* resolver, GInetAddress* address, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupByAddressAsync; 6911 /** 6912 * 6913 * Params: 6914 * resolver = a #GResolver 6915 * result = the result passed to your #GAsyncReadyCallback 6916 * Return: a hostname (either ASCII-only, or in ASCII-encoded 6917 * form), or %NULL on error. 6918 * 6919 * Throws: GException on failure. 6920 */ 6921 extern(C) char* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupByAddressFinish; 6922 extern(C) GList* function(GResolver* resolver, const(char)* rrname, GCancellable* cancellable, GError** err) lookupService; 6923 extern(C) void function(GResolver* resolver, const(char)* rrname, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupServiceAsync; 6924 /** 6925 * 6926 * Params: 6927 * resolver = a #GResolver 6928 * result = the result passed to your #GAsyncReadyCallback 6929 * Return: a non-empty #GList of 6930 * #GSrvTarget, or %NULL on error. See g_resolver_lookup_service() for more 6931 * details. 6932 * 6933 * Throws: GException on failure. 6934 */ 6935 extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupServiceFinish; 6936 /** 6937 * 6938 * Params: 6939 * resolver = a #GResolver 6940 * rrname = the DNS name to lookup the record for 6941 * recordType = the type of DNS record to lookup 6942 * cancellable = a #GCancellable, or %NULL 6943 * Return: a non-empty #GList of 6944 * #GVariant, or %NULL on error. You must free each of the records and the list 6945 * when you are done with it. (You can use g_list_free_full() with 6946 * g_variant_unref() to do this.) 6947 * 6948 * Throws: GException on failure. 6949 */ 6950 extern(C) GList* function(GResolver* resolver, const(char)* rrname, GResolverRecordType recordType, GCancellable* cancellable, GError** err) lookupRecords; 6951 extern(C) void function(GResolver* resolver, const(char)* rrname, GResolverRecordType recordType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupRecordsAsync; 6952 /** 6953 * 6954 * Params: 6955 * resolver = a #GResolver 6956 * result = the result passed to your #GAsyncReadyCallback 6957 * Return: a non-empty #GList of 6958 * #GVariant, or %NULL on error. You must free each of the records and the list 6959 * when you are done with it. (You can use g_list_free_full() with 6960 * g_variant_unref() to do this.) 6961 * 6962 * Throws: GException on failure. 6963 */ 6964 extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupRecordsFinish; 6965 extern(C) void function() GReserved4; 6966 extern(C) void function() GReserved5; 6967 extern(C) void function() GReserved6; 6968 } 6969 6970 struct GResolverPrivate; 6971 6972 struct GResource; 6973 6974 struct GSeekable; 6975 6976 /** 6977 * Provides an interface for implementing seekable functionality on I/O Streams. 6978 */ 6979 struct GSeekableIface 6980 { 6981 /** 6982 * The parent interface. 6983 */ 6984 GTypeInterface gIface; 6985 /** 6986 * 6987 * Params: 6988 * seekable = a #GSeekable. 6989 * Return: the offset from the beginning of the buffer. 6990 */ 6991 extern(C) long function(GSeekable* seekable) tell; 6992 /** 6993 * 6994 * Params: 6995 * seekable = a #GSeekable. 6996 * Return: %TRUE if @seekable can be seeked. %FALSE otherwise. 6997 */ 6998 extern(C) int function(GSeekable* seekable) canSeek; 6999 /** 7000 * 7001 * Params: 7002 * seekable = a #GSeekable. 7003 * offset = a #goffset. 7004 * type = a #GSeekType. 7005 * cancellable = optional #GCancellable object, %NULL to ignore. 7006 * Return: %TRUE if successful. If an error 7007 * has occurred, this function will return %FALSE and set @error 7008 * appropriately if present. 7009 * 7010 * Throws: GException on failure. 7011 */ 7012 extern(C) int function(GSeekable* seekable, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek; 7013 /** 7014 * 7015 * Params: 7016 * seekable = a #GSeekable. 7017 * Return: %TRUE if the stream can be truncated, %FALSE otherwise. 7018 */ 7019 extern(C) int function(GSeekable* seekable) canTruncate; 7020 /** 7021 * 7022 * Params: 7023 * seekable = a #GSeekable. 7024 * offset = a #goffset. 7025 * cancellable = optional #GCancellable object, %NULL to ignore. 7026 * Return: %TRUE if successful. If an error 7027 * has occurred, this function will return %FALSE and set @error 7028 * appropriately if present. 7029 * 7030 * Throws: GException on failure. 7031 */ 7032 extern(C) int function(GSeekable* seekable, long offset, GCancellable* cancellable, GError** err) truncateFn; 7033 } 7034 7035 struct GSettings 7036 { 7037 GObject parentInstance; 7038 GSettingsPrivate* priv; 7039 } 7040 7041 /** 7042 * The #GSettingsBackend interface defines a generic interface for 7043 * non-strictly-typed data that is stored in a hierarchy. To implement 7044 * an alternative storage backend for #GSettings, you need to implement 7045 * the #GSettingsBackend interface and then make it implement the 7046 * extension point #G_SETTINGS_BACKEND_EXTENSION_POINT_NAME. 7047 * 7048 * The interface defines methods for reading and writing values, a 7049 * method for determining if writing of certain values will fail 7050 * (lockdown) and a change notification mechanism. 7051 * 7052 * The semantics of the interface are very precisely defined and 7053 * implementations must carefully adhere to the expectations of 7054 * callers that are documented on each of the interface methods. 7055 * 7056 * Some of the GSettingsBackend functions accept or return a #GTree. 7057 * These trees always have strings as keys and #GVariant as values. 7058 * g_settings_backend_create_tree() is a convenience function to create 7059 * suitable trees. 7060 * 7061 * The GSettingsBackend API is exported to allow third-party 7062 * implementations, but does not carry the same stability guarantees 7063 * as the public GIO API. For this reason, you have to define the 7064 * C preprocessor symbol %G_SETTINGS_ENABLE_BACKEND before including 7065 * `gio/gsettingsbackend.h`. 7066 */ 7067 struct GSettingsBackend; 7068 7069 struct GSettingsClass 7070 { 7071 GObjectClass parentClass; 7072 extern(C) void function(GSettings* settings, const(char)* key) writableChanged; 7073 extern(C) void function(GSettings* settings, const(char)* key) changed; 7074 extern(C) int function(GSettings* settings, GQuark key) writableChangeEvent; 7075 extern(C) int function(GSettings* settings, GQuark* keys, int nKeys) changeEvent; 7076 void*[20] padding; 7077 } 7078 7079 struct GSettingsPrivate; 7080 7081 struct GSettingsSchema; 7082 7083 struct GSettingsSchemaKey; 7084 7085 struct GSettingsSchemaSource; 7086 7087 struct GSimpleAction; 7088 7089 struct GSimpleActionGroup 7090 { 7091 GObject parentInstance; 7092 GSimpleActionGroupPrivate* priv; 7093 } 7094 7095 struct GSimpleActionGroupClass 7096 { 7097 GObjectClass parentClass; 7098 void*[12] padding; 7099 } 7100 7101 struct GSimpleActionGroupPrivate; 7102 7103 struct GSimpleAsyncResult; 7104 7105 struct GSimpleAsyncResultClass; 7106 7107 struct GSimpleIOStream; 7108 7109 struct GSimplePermission; 7110 7111 struct GSimpleProxyResolver 7112 { 7113 GObject parentInstance; 7114 GSimpleProxyResolverPrivate* priv; 7115 } 7116 7117 struct GSimpleProxyResolverClass 7118 { 7119 GObjectClass parentClass; 7120 extern(C) void function() GReserved1; 7121 extern(C) void function() GReserved2; 7122 extern(C) void function() GReserved3; 7123 extern(C) void function() GReserved4; 7124 extern(C) void function() GReserved5; 7125 } 7126 7127 struct GSimpleProxyResolverPrivate; 7128 7129 struct GSocket 7130 { 7131 GObject parentInstance; 7132 GSocketPrivate* priv; 7133 } 7134 7135 struct GSocketAddress 7136 { 7137 GObject parentInstance; 7138 } 7139 7140 struct GSocketAddressClass 7141 { 7142 GObjectClass parentClass; 7143 /** 7144 * 7145 * Params: 7146 * address = a #GSocketAddress 7147 * Return: the socket family type of @address 7148 */ 7149 extern(C) GSocketFamily function(GSocketAddress* address) getFamily; 7150 /** 7151 * 7152 * Params: 7153 * address = a #GSocketAddress 7154 * Return: the size of the native struct sockaddr that 7155 * @address represents 7156 */ 7157 extern(C) ptrdiff_t function(GSocketAddress* address) getNativeSize; 7158 /** 7159 * 7160 * Params: 7161 * address = a #GSocketAddress 7162 * dest = a pointer to a memory location that will contain the native 7163 * struct sockaddr 7164 * destlen = the size of @dest. Must be at least as large as 7165 * g_socket_address_get_native_size() 7166 * Return: %TRUE if @dest was filled in, %FALSE on error 7167 * 7168 * Throws: GException on failure. 7169 */ 7170 extern(C) int function(GSocketAddress* address, void* dest, size_t destlen, GError** err) toNative; 7171 } 7172 7173 struct GSocketAddressEnumerator 7174 { 7175 GObject parentInstance; 7176 } 7177 7178 struct GSocketAddressEnumeratorClass 7179 { 7180 GObjectClass parentClass; 7181 /** 7182 * 7183 * Params: 7184 * enumerator = a #GSocketAddressEnumerator 7185 * cancellable = optional #GCancellable object, %NULL to ignore. 7186 * Return: a #GSocketAddress (owned by the caller), or %NULL on 7187 * error (in which case *@error will be set) or if there are no 7188 * more addresses. 7189 * 7190 * Throws: GException on failure. 7191 */ 7192 extern(C) GSocketAddress* function(GSocketAddressEnumerator* enumerator, GCancellable* cancellable, GError** err) next; 7193 extern(C) void function(GSocketAddressEnumerator* enumerator, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) nextAsync; 7194 /** 7195 * 7196 * Params: 7197 * enumerator = a #GSocketAddressEnumerator 7198 * result = a #GAsyncResult 7199 * Return: a #GSocketAddress (owned by the caller), or %NULL on 7200 * error (in which case *@error will be set) or if there are no 7201 * more addresses. 7202 * 7203 * Throws: GException on failure. 7204 */ 7205 extern(C) GSocketAddress* function(GSocketAddressEnumerator* enumerator, GAsyncResult* result, GError** err) nextFinish; 7206 } 7207 7208 struct GSocketClass 7209 { 7210 GObjectClass parentClass; 7211 extern(C) void function() GReserved1; 7212 extern(C) void function() GReserved2; 7213 extern(C) void function() GReserved3; 7214 extern(C) void function() GReserved4; 7215 extern(C) void function() GReserved5; 7216 extern(C) void function() GReserved6; 7217 extern(C) void function() GReserved7; 7218 extern(C) void function() GReserved8; 7219 extern(C) void function() GReserved9; 7220 extern(C) void function() GReserved10; 7221 } 7222 7223 struct GSocketClient 7224 { 7225 GObject parentInstance; 7226 GSocketClientPrivate* priv; 7227 } 7228 7229 struct GSocketClientClass 7230 { 7231 GObjectClass parentClass; 7232 extern(C) void function(GSocketClient* client, GSocketClientEvent event, GSocketConnectable* connectable, GIOStream* connection) event; 7233 extern(C) void function() GReserved1; 7234 extern(C) void function() GReserved2; 7235 extern(C) void function() GReserved3; 7236 extern(C) void function() GReserved4; 7237 } 7238 7239 struct GSocketClientPrivate; 7240 7241 struct GSocketConnectable; 7242 7243 /** 7244 * Provides an interface for returning a #GSocketAddressEnumerator 7245 * and #GProxyAddressEnumerator 7246 */ 7247 struct GSocketConnectableIface 7248 { 7249 /** 7250 * The parent interface. 7251 */ 7252 GTypeInterface gIface; 7253 /** 7254 * 7255 * Params: 7256 * connectable = a #GSocketConnectable 7257 * Return: a new #GSocketAddressEnumerator. 7258 */ 7259 extern(C) GSocketAddressEnumerator* function(GSocketConnectable* connectable) enumerate; 7260 /** 7261 * 7262 * Params: 7263 * connectable = a #GSocketConnectable 7264 * Return: a new #GSocketAddressEnumerator. 7265 */ 7266 extern(C) GSocketAddressEnumerator* function(GSocketConnectable* connectable) proxyEnumerate; 7267 } 7268 7269 struct GSocketConnection 7270 { 7271 GIOStream parentInstance; 7272 GSocketConnectionPrivate* priv; 7273 } 7274 7275 struct GSocketConnectionClass 7276 { 7277 GIOStreamClass parentClass; 7278 extern(C) void function() GReserved1; 7279 extern(C) void function() GReserved2; 7280 extern(C) void function() GReserved3; 7281 extern(C) void function() GReserved4; 7282 extern(C) void function() GReserved5; 7283 extern(C) void function() GReserved6; 7284 } 7285 7286 struct GSocketConnectionPrivate; 7287 7288 struct GSocketControlMessage 7289 { 7290 GObject parentInstance; 7291 GSocketControlMessagePrivate* priv; 7292 } 7293 7294 /** 7295 * Class structure for #GSocketControlMessage. 7296 */ 7297 struct GSocketControlMessageClass 7298 { 7299 GObjectClass parentClass; 7300 /** 7301 * 7302 * Params: 7303 * message = a #GSocketControlMessage 7304 * Return: The number of bytes required. 7305 */ 7306 extern(C) size_t function(GSocketControlMessage* message) getSize; 7307 /** 7308 * 7309 * Params: 7310 * message = a #GSocketControlMessage 7311 * Return: an integer describing the level 7312 */ 7313 extern(C) int function(GSocketControlMessage* message) getLevel; 7314 extern(C) int function(GSocketControlMessage* message) getType; 7315 extern(C) void function(GSocketControlMessage* message, void* data) serialize; 7316 extern(C) GSocketControlMessage* function(int level, int type, size_t size, void* data) deserialize; 7317 extern(C) void function() GReserved1; 7318 extern(C) void function() GReserved2; 7319 extern(C) void function() GReserved3; 7320 extern(C) void function() GReserved4; 7321 extern(C) void function() GReserved5; 7322 } 7323 7324 struct GSocketControlMessagePrivate; 7325 7326 struct GSocketListener 7327 { 7328 GObject parentInstance; 7329 GSocketListenerPrivate* priv; 7330 } 7331 7332 /** 7333 * Class structure for #GSocketListener. 7334 */ 7335 struct GSocketListenerClass 7336 { 7337 GObjectClass parentClass; 7338 extern(C) void function(GSocketListener* listener) changed; 7339 extern(C) void function() GReserved1; 7340 extern(C) void function() GReserved2; 7341 extern(C) void function() GReserved3; 7342 extern(C) void function() GReserved4; 7343 extern(C) void function() GReserved5; 7344 extern(C) void function() GReserved6; 7345 } 7346 7347 struct GSocketListenerPrivate; 7348 7349 struct GSocketPrivate; 7350 7351 struct GSocketService 7352 { 7353 GSocketListener parentInstance; 7354 GSocketServicePrivate* priv; 7355 } 7356 7357 /** 7358 * Class structure for #GSocketService. 7359 */ 7360 struct GSocketServiceClass 7361 { 7362 GSocketListenerClass parentClass; 7363 extern(C) int function(GSocketService* service, GSocketConnection* connection, GObject* sourceObject) incoming; 7364 extern(C) void function() GReserved1; 7365 extern(C) void function() GReserved2; 7366 extern(C) void function() GReserved3; 7367 extern(C) void function() GReserved4; 7368 extern(C) void function() GReserved5; 7369 extern(C) void function() GReserved6; 7370 } 7371 7372 struct GSocketServicePrivate; 7373 7374 struct GSrvTarget; 7375 7376 struct GStaticResource 7377 { 7378 ubyte* data; 7379 size_t dataLen; 7380 GResource* resource; 7381 GStaticResource* next; 7382 void* padding; 7383 } 7384 7385 struct GSubprocess; 7386 7387 struct GSubprocessLauncher; 7388 7389 struct GTask; 7390 7391 struct GTaskClass; 7392 7393 struct GTcpConnection 7394 { 7395 GSocketConnection parentInstance; 7396 GTcpConnectionPrivate* priv; 7397 } 7398 7399 struct GTcpConnectionClass 7400 { 7401 GSocketConnectionClass parentClass; 7402 } 7403 7404 struct GTcpConnectionPrivate; 7405 7406 struct GTcpWrapperConnection 7407 { 7408 GTcpConnection parentInstance; 7409 GTcpWrapperConnectionPrivate* priv; 7410 } 7411 7412 struct GTcpWrapperConnectionClass 7413 { 7414 GTcpConnectionClass parentClass; 7415 } 7416 7417 struct GTcpWrapperConnectionPrivate; 7418 7419 struct GTestDBus; 7420 7421 struct GThemedIcon; 7422 7423 struct GThemedIconClass; 7424 7425 struct GThreadedSocketService 7426 { 7427 GSocketService parentInstance; 7428 GThreadedSocketServicePrivate* priv; 7429 } 7430 7431 struct GThreadedSocketServiceClass 7432 { 7433 GSocketServiceClass parentClass; 7434 extern(C) int function(GThreadedSocketService* service, GSocketConnection* connection, GObject* sourceObject) run; 7435 extern(C) void function() GReserved1; 7436 extern(C) void function() GReserved2; 7437 extern(C) void function() GReserved3; 7438 extern(C) void function() GReserved4; 7439 extern(C) void function() GReserved5; 7440 } 7441 7442 struct GThreadedSocketServicePrivate; 7443 7444 struct GTlsBackend; 7445 7446 /** 7447 * Provides an interface for describing TLS-related types. 7448 * 7449 * Since: 2.28 7450 */ 7451 struct GTlsBackendInterface 7452 { 7453 /** 7454 * The parent interface. 7455 */ 7456 GTypeInterface gIface; 7457 /** 7458 * 7459 * Params: 7460 * backend = the #GTlsBackend 7461 * Return: whether or not TLS is supported 7462 */ 7463 extern(C) int function(GTlsBackend* backend) supportsTls; 7464 extern(C) GType function() getCertificateType; 7465 extern(C) GType function() getClientConnectionType; 7466 extern(C) GType function() getServerConnectionType; 7467 extern(C) GType function() getFileDatabaseType; 7468 /** 7469 * 7470 * Params: 7471 * backend = the #GTlsBackend 7472 * Return: the default database, which should be 7473 * unreffed when done. 7474 */ 7475 extern(C) GTlsDatabase* function(GTlsBackend* backend) getDefaultDatabase; 7476 } 7477 7478 struct GTlsCertificate 7479 { 7480 GObject parentInstance; 7481 GTlsCertificatePrivate* priv; 7482 } 7483 7484 struct GTlsCertificateClass 7485 { 7486 GObjectClass parentClass; 7487 /** 7488 * 7489 * Params: 7490 * cert = a #GTlsCertificate 7491 * identity = the expected peer identity 7492 * trustedCa = the certificate of a trusted authority 7493 * Return: the appropriate #GTlsCertificateFlags 7494 */ 7495 extern(C) GTlsCertificateFlags function(GTlsCertificate* cert, GSocketConnectable* identity, GTlsCertificate* trustedCa) verify; 7496 void*[8] padding; 7497 } 7498 7499 struct GTlsCertificatePrivate; 7500 7501 struct GTlsClientConnection; 7502 7503 /** 7504 * vtable for a #GTlsClientConnection implementation. 7505 * 7506 * Since: 2.26 7507 */ 7508 struct GTlsClientConnectionInterface 7509 { 7510 /** 7511 * The parent interface. 7512 */ 7513 GTypeInterface gIface; 7514 } 7515 7516 struct GTlsConnection 7517 { 7518 GIOStream parentInstance; 7519 GTlsConnectionPrivate* priv; 7520 } 7521 7522 struct GTlsConnectionClass 7523 { 7524 GIOStreamClass parentClass; 7525 extern(C) int function(GTlsConnection* connection, GTlsCertificate* peerCert, GTlsCertificateFlags errors) acceptCertificate; 7526 /** 7527 * 7528 * Params: 7529 * conn = a #GTlsConnection 7530 * cancellable = a #GCancellable, or %NULL 7531 * Return: success or failure 7532 * 7533 * Throws: GException on failure. 7534 */ 7535 extern(C) int function(GTlsConnection* conn, GCancellable* cancellable, GError** err) handshake; 7536 extern(C) void function(GTlsConnection* conn, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) handshakeAsync; 7537 /** 7538 * 7539 * Params: 7540 * conn = a #GTlsConnection 7541 * result = a #GAsyncResult. 7542 * Return: %TRUE on success, %FALSE on failure, in which 7543 * case @error will be set. 7544 * 7545 * Throws: GException on failure. 7546 */ 7547 extern(C) int function(GTlsConnection* conn, GAsyncResult* result, GError** err) handshakeFinish; 7548 void*[8] padding; 7549 } 7550 7551 struct GTlsConnectionPrivate; 7552 7553 struct GTlsDatabase 7554 { 7555 GObject parentInstance; 7556 GTlsDatabasePrivate* priv; 7557 } 7558 7559 struct GTlsDatabaseClass 7560 { 7561 GObjectClass parentClass; 7562 /** 7563 * 7564 * Params: 7565 * self = a #GTlsDatabase 7566 * chain = a #GTlsCertificate chain 7567 * purpose = the purpose that this certificate chain will be used for. 7568 * identity = the expected peer identity 7569 * interaction = used to interact with the user if necessary 7570 * flags = additional verify flags 7571 * cancellable = a #GCancellable, or %NULL 7572 * Return: the appropriate #GTlsCertificateFlags which represents the 7573 * result of verification. 7574 * 7575 * Throws: GException on failure. 7576 */ 7577 extern(C) GTlsCertificateFlags function(GTlsDatabase* self, GTlsCertificate* chain, const(char)* purpose, GSocketConnectable* identity, GTlsInteraction* interaction, GTlsDatabaseVerifyFlags flags, GCancellable* cancellable, GError** err) verifyChain; 7578 extern(C) void function(GTlsDatabase* self, GTlsCertificate* chain, const(char)* purpose, GSocketConnectable* identity, GTlsInteraction* interaction, GTlsDatabaseVerifyFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) verifyChainAsync; 7579 /** 7580 * 7581 * Params: 7582 * self = a #GTlsDatabase 7583 * result = a #GAsyncResult. 7584 * Return: the appropriate #GTlsCertificateFlags which represents the 7585 * result of verification. 7586 * 7587 * Throws: GException on failure. 7588 */ 7589 extern(C) GTlsCertificateFlags function(GTlsDatabase* self, GAsyncResult* result, GError** err) verifyChainFinish; 7590 /** 7591 * 7592 * Params: 7593 * self = a #GTlsDatabase 7594 * certificate = certificate for which to create a handle. 7595 * Return: a newly allocated string containing the 7596 * handle. 7597 */ 7598 extern(C) char* function(GTlsDatabase* self, GTlsCertificate* certificate) createCertificateHandle; 7599 /** 7600 * 7601 * Params: 7602 * self = a #GTlsDatabase 7603 * handle = a certificate handle 7604 * interaction = used to interact with the user if necessary 7605 * flags = Flags which affect the lookup. 7606 * cancellable = a #GCancellable, or %NULL 7607 * Return: a newly allocated 7608 * #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. 7609 * 7610 * Throws: GException on failure. 7611 */ 7612 extern(C) GTlsCertificate* function(GTlsDatabase* self, const(char)* handle, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificateForHandle; 7613 extern(C) void function(GTlsDatabase* self, const(char)* handle, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificateForHandleAsync; 7614 /** 7615 * 7616 * Params: 7617 * self = a #GTlsDatabase 7618 * result = a #GAsyncResult. 7619 * Return: a newly allocated #GTlsCertificate object. 7620 * Use g_object_unref() to release the certificate. 7621 * 7622 * Throws: GException on failure. 7623 */ 7624 extern(C) GTlsCertificate* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificateForHandleFinish; 7625 /** 7626 * 7627 * Params: 7628 * self = a #GTlsDatabase 7629 * certificate = a #GTlsCertificate 7630 * interaction = used to interact with the user if necessary 7631 * flags = flags which affect the lookup operation 7632 * cancellable = a #GCancellable, or %NULL 7633 * Return: a newly allocated issuer #GTlsCertificate, 7634 * or %NULL. Use g_object_unref() to release the certificate. 7635 * 7636 * Throws: GException on failure. 7637 */ 7638 extern(C) GTlsCertificate* function(GTlsDatabase* self, GTlsCertificate* certificate, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificateIssuer; 7639 extern(C) void function(GTlsDatabase* self, GTlsCertificate* certificate, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificateIssuerAsync; 7640 /** 7641 * 7642 * Params: 7643 * self = a #GTlsDatabase 7644 * result = a #GAsyncResult. 7645 * Return: a newly allocated issuer #GTlsCertificate, 7646 * or %NULL. Use g_object_unref() to release the certificate. 7647 * 7648 * Throws: GException on failure. 7649 */ 7650 extern(C) GTlsCertificate* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificateIssuerFinish; 7651 /** 7652 * 7653 * Params: 7654 * self = a #GTlsDatabase 7655 * issuerRawDn = a #GByteArray which holds the DER encoded issuer DN. 7656 * interaction = used to interact with the user if necessary 7657 * flags = Flags which affect the lookup operation. 7658 * cancellable = a #GCancellable, or %NULL 7659 * Return: a newly allocated list of #GTlsCertificate 7660 * objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. 7661 * 7662 * Throws: GException on failure. 7663 */ 7664 extern(C) GList* function(GTlsDatabase* self, GByteArray* issuerRawDn, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificatesIssuedBy; 7665 extern(C) void function(GTlsDatabase* self, GByteArray* issuerRawDn, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificatesIssuedByAsync; 7666 /** 7667 * 7668 * Params: 7669 * self = a #GTlsDatabase 7670 * result = a #GAsyncResult. 7671 * Return: a newly allocated list of #GTlsCertificate 7672 * objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. 7673 * 7674 * Throws: GException on failure. 7675 */ 7676 extern(C) GList* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificatesIssuedByFinish; 7677 void*[16] padding; 7678 } 7679 7680 struct GTlsDatabasePrivate; 7681 7682 struct GTlsFileDatabase; 7683 7684 /** 7685 * Provides an interface for #GTlsFileDatabase implementations. 7686 */ 7687 struct GTlsFileDatabaseInterface 7688 { 7689 /** 7690 * The parent interface. 7691 */ 7692 GTypeInterface gIface; 7693 void*[8] padding; 7694 } 7695 7696 struct GTlsInteraction 7697 { 7698 GObject parentInstance; 7699 GTlsInteractionPrivate* priv; 7700 } 7701 7702 /** 7703 * The class for #GTlsInteraction. Derived classes implement the various 7704 * virtual interaction methods to handle TLS interactions. 7705 * 7706 * Derived classes can choose to implement whichever interactions methods they'd 7707 * like to support by overriding those virtual methods in their class 7708 * initialization function. If a derived class implements an async method, 7709 * it must also implement the corresponding finish method. 7710 * 7711 * The synchronous interaction methods should implement to display modal dialogs, 7712 * and the asynchronous methods to display modeless dialogs. 7713 * 7714 * If the user cancels an interaction, then the result should be 7715 * %G_TLS_INTERACTION_FAILED and the error should be set with a domain of 7716 * %G_IO_ERROR and code of %G_IO_ERROR_CANCELLED. 7717 * 7718 * Since: 2.30 7719 */ 7720 struct GTlsInteractionClass 7721 { 7722 GObjectClass parentClass; 7723 /** 7724 * 7725 * Params: 7726 * interaction = a #GTlsInteraction object 7727 * password = a #GTlsPassword object 7728 * cancellable = an optional #GCancellable cancellation object 7729 * Return: The status of the ask password interaction. 7730 * 7731 * Throws: GException on failure. 7732 */ 7733 extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GError** err) askPassword; 7734 extern(C) void function(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) askPasswordAsync; 7735 /** 7736 * 7737 * Params: 7738 * interaction = a #GTlsInteraction object 7739 * result = the result passed to the callback 7740 * Return: The status of the ask password interaction. 7741 * 7742 * Throws: GException on failure. 7743 */ 7744 extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GAsyncResult* result, GError** err) askPasswordFinish; 7745 /** 7746 * 7747 * Params: 7748 * interaction = a #GTlsInteraction object 7749 * connection = a #GTlsConnection object 7750 * flags = flags providing more information about the request 7751 * cancellable = an optional #GCancellable cancellation object 7752 * Return: The status of the request certificate interaction. 7753 * 7754 * Throws: GException on failure. 7755 */ 7756 extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GError** err) requestCertificate; 7757 extern(C) void function(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) requestCertificateAsync; 7758 /** 7759 * 7760 * Params: 7761 * interaction = a #GTlsInteraction object 7762 * result = the result passed to the callback 7763 * Return: The status of the request certificate interaction. 7764 * 7765 * Throws: GException on failure. 7766 */ 7767 extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GAsyncResult* result, GError** err) requestCertificateFinish; 7768 void*[21] padding; 7769 } 7770 7771 struct GTlsInteractionPrivate; 7772 7773 struct GTlsPassword 7774 { 7775 GObject parentInstance; 7776 GTlsPasswordPrivate* priv; 7777 } 7778 7779 /** 7780 * Class structure for #GTlsPassword. 7781 */ 7782 struct GTlsPasswordClass 7783 { 7784 GObjectClass parentClass; 7785 /** 7786 * 7787 * Params: 7788 * password = a #GTlsPassword object 7789 * length = location to place the length of the password. 7790 * Return: The password value (owned by the password object). 7791 */ 7792 extern(C) char* function(GTlsPassword* password, size_t* length) getValue; 7793 extern(C) void function(GTlsPassword* password, char* value, ptrdiff_t length, GDestroyNotify destroy) setValue; 7794 extern(C) const(char)* function(GTlsPassword* password) getDefaultWarning; 7795 void*[4] padding; 7796 } 7797 7798 struct GTlsPasswordPrivate; 7799 7800 struct GTlsServerConnection; 7801 7802 /** 7803 * vtable for a #GTlsServerConnection implementation. 7804 * 7805 * Since: 2.26 7806 */ 7807 struct GTlsServerConnectionInterface 7808 { 7809 /** 7810 * The parent interface. 7811 */ 7812 GTypeInterface gIface; 7813 } 7814 7815 struct GUnixConnection 7816 { 7817 GSocketConnection parentInstance; 7818 GUnixConnectionPrivate* priv; 7819 } 7820 7821 struct GUnixConnectionClass 7822 { 7823 GSocketConnectionClass parentClass; 7824 } 7825 7826 struct GUnixConnectionPrivate; 7827 7828 struct GUnixCredentialsMessage 7829 { 7830 GSocketControlMessage parentInstance; 7831 GUnixCredentialsMessagePrivate* priv; 7832 } 7833 7834 /** 7835 * Class structure for #GUnixCredentialsMessage. 7836 * 7837 * Since: 2.26 7838 */ 7839 struct GUnixCredentialsMessageClass 7840 { 7841 GSocketControlMessageClass parentClass; 7842 extern(C) void function() GReserved1; 7843 extern(C) void function() GReserved2; 7844 } 7845 7846 struct GUnixCredentialsMessagePrivate; 7847 7848 struct GUnixFDList 7849 { 7850 GObject parentInstance; 7851 GUnixFDListPrivate* priv; 7852 } 7853 7854 struct GUnixFDListClass 7855 { 7856 GObjectClass parentClass; 7857 extern(C) void function() GReserved1; 7858 extern(C) void function() GReserved2; 7859 extern(C) void function() GReserved3; 7860 extern(C) void function() GReserved4; 7861 extern(C) void function() GReserved5; 7862 } 7863 7864 struct GUnixFDListPrivate; 7865 7866 struct GUnixFDMessage 7867 { 7868 GSocketControlMessage parentInstance; 7869 GUnixFDMessagePrivate* priv; 7870 } 7871 7872 struct GUnixFDMessageClass 7873 { 7874 GSocketControlMessageClass parentClass; 7875 extern(C) void function() GReserved1; 7876 extern(C) void function() GReserved2; 7877 } 7878 7879 struct GUnixFDMessagePrivate; 7880 7881 struct GUnixInputStream 7882 { 7883 GInputStream parentInstance; 7884 GUnixInputStreamPrivate* priv; 7885 } 7886 7887 struct GUnixInputStreamClass 7888 { 7889 GInputStreamClass parentClass; 7890 extern(C) void function() GReserved1; 7891 extern(C) void function() GReserved2; 7892 extern(C) void function() GReserved3; 7893 extern(C) void function() GReserved4; 7894 extern(C) void function() GReserved5; 7895 } 7896 7897 struct GUnixInputStreamPrivate; 7898 7899 /** 7900 * Defines a Unix mount entry (e.g. <filename>/media/cdrom</filename>). 7901 * This corresponds roughly to a mtab entry. 7902 */ 7903 struct GUnixMountEntry; 7904 7905 struct GUnixMountMonitor; 7906 7907 struct GUnixMountMonitorClass; 7908 7909 struct GUnixMountPoint; 7910 7911 struct GUnixOutputStream 7912 { 7913 GOutputStream parentInstance; 7914 GUnixOutputStreamPrivate* priv; 7915 } 7916 7917 struct GUnixOutputStreamClass 7918 { 7919 GOutputStreamClass parentClass; 7920 extern(C) void function() GReserved1; 7921 extern(C) void function() GReserved2; 7922 extern(C) void function() GReserved3; 7923 extern(C) void function() GReserved4; 7924 extern(C) void function() GReserved5; 7925 } 7926 7927 struct GUnixOutputStreamPrivate; 7928 7929 struct GUnixSocketAddress 7930 { 7931 GSocketAddress parentInstance; 7932 GUnixSocketAddressPrivate* priv; 7933 } 7934 7935 struct GUnixSocketAddressClass 7936 { 7937 GSocketAddressClass parentClass; 7938 } 7939 7940 struct GUnixSocketAddressPrivate; 7941 7942 struct GVfs 7943 { 7944 GObject parentInstance; 7945 } 7946 7947 struct GVfsClass 7948 { 7949 GObjectClass parentClass; 7950 /** 7951 * 7952 * Params: 7953 * vfs = a #GVfs. 7954 * Return: %TRUE if construction of the @vfs was successful 7955 * and it is now active. 7956 */ 7957 extern(C) int function(GVfs* vfs) isActive; 7958 /** 7959 * 7960 * Params: 7961 * vfs = a #GVfs. 7962 * path = a string containing a VFS path. 7963 * Return: a #GFile. 7964 * Free the returned object with g_object_unref(). 7965 */ 7966 extern(C) GFile* function(GVfs* vfs, const(char)* path) getFileForPath; 7967 /** 7968 * 7969 * Params: 7970 * vfs = a#GVfs. 7971 * uri = a string containing a URI 7972 * Return: a #GFile. 7973 * Free the returned object with g_object_unref(). 7974 */ 7975 extern(C) GFile* function(GVfs* vfs, const(char)* uri) getFileForUri; 7976 /** 7977 * 7978 * Params: 7979 * vfs = a #GVfs. 7980 * Return: a %NULL-terminated array of strings. 7981 * The returned array belongs to GIO and must 7982 * not be freed or modified. 7983 */ 7984 extern(C) char** function(GVfs* vfs) getSupportedUriSchemes; 7985 /** 7986 * 7987 * Params: 7988 * vfs = a #GVfs. 7989 * parseName = a string to be parsed by the VFS module. 7990 * Return: a #GFile for the given @parse_name. 7991 * Free the returned object with g_object_unref(). 7992 */ 7993 extern(C) GFile* function(GVfs* vfs, const(char)* parseName) parseName; 7994 extern(C) void function(GVfs* vfs, const(char)* filename, ulong device, GFileAttributeMatcher* attributeMatcher, GFileInfo* info, GCancellable* cancellable, void** extraData, GDestroyNotify* freeExtraData) localFileAddInfo; 7995 extern(C) void function(GVfs* vfs, GFileAttributeInfoList* list) addWritableNamespaces; 7996 extern(C) int function(GVfs* vfs, const(char)* filename, GFileInfo* info, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) localFileSetAttributes; 7997 extern(C) void function(GVfs* vfs, const(char)* filename) localFileRemoved; 7998 extern(C) void function(GVfs* vfs, const(char)* source, const(char)* dest) localFileMoved; 7999 extern(C) GIcon* function(GVfs* vfs, GVariant* value) deserializeIcon; 8000 extern(C) void function() GReserved1; 8001 extern(C) void function() GReserved2; 8002 extern(C) void function() GReserved3; 8003 extern(C) void function() GReserved4; 8004 extern(C) void function() GReserved5; 8005 extern(C) void function() GReserved6; 8006 } 8007 8008 struct GVolume; 8009 8010 /** 8011 * Interface for implementing operations for mountable volumes. 8012 */ 8013 struct GVolumeIface 8014 { 8015 /** 8016 * The parent interface. 8017 */ 8018 GTypeInterface gIface; 8019 extern(C) void function(GVolume* volume) changed; 8020 extern(C) void function(GVolume* volume) removed; 8021 /** 8022 * 8023 * Params: 8024 * volume = a #GVolume 8025 * Return: the name for the given @volume. The returned string should 8026 * be freed with g_free() when no longer needed. 8027 */ 8028 extern(C) char* function(GVolume* volume) getName; 8029 /** 8030 * 8031 * Params: 8032 * volume = a #GVolume 8033 * Return: a #GIcon. 8034 * The returned object should be unreffed with g_object_unref() 8035 * when no longer needed. 8036 */ 8037 extern(C) GIcon* function(GVolume* volume) getIcon; 8038 /** 8039 * 8040 * Params: 8041 * volume = a #GVolume 8042 * Return: the UUID for @volume or %NULL if no UUID can be computed. 8043 * The returned string should be freed with g_free() 8044 * when no longer needed. 8045 */ 8046 extern(C) char* function(GVolume* volume) getUuid; 8047 /** 8048 * 8049 * Params: 8050 * volume = a #GVolume 8051 * Return: a #GDrive or %NULL if @volume is not 8052 * associated with a drive. The returned object should be unreffed 8053 * with g_object_unref() when no longer needed. 8054 */ 8055 extern(C) GDrive* function(GVolume* volume) getDrive; 8056 /** 8057 * 8058 * Params: 8059 * volume = a #GVolume 8060 * Return: a #GMount or %NULL if @volume isn't mounted. 8061 * The returned object should be unreffed with g_object_unref() 8062 * when no longer needed. 8063 */ 8064 extern(C) GMount* function(GVolume* volume) getMount; 8065 /** 8066 * 8067 * Params: 8068 * volume = a #GVolume 8069 * Return: %TRUE if the @volume can be mounted. %FALSE otherwise 8070 */ 8071 extern(C) int function(GVolume* volume) canMount; 8072 /** 8073 * 8074 * Params: 8075 * volume = a #GVolume 8076 * Return: %TRUE if the @volume can be ejected. %FALSE otherwise 8077 */ 8078 extern(C) int function(GVolume* volume) canEject; 8079 extern(C) void function(GVolume* volume, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountFn; 8080 /** 8081 * 8082 * Params: 8083 * volume = a #GVolume 8084 * result = a #GAsyncResult 8085 * Return: %TRUE, %FALSE if operation failed 8086 * 8087 * Throws: GException on failure. 8088 */ 8089 extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) mountFinish; 8090 extern(C) void function(GVolume* volume, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject; 8091 /** 8092 * 8093 * Params: 8094 * volume = pointer to a #GVolume 8095 * result = a #GAsyncResult 8096 * Return: %TRUE, %FALSE if operation failed 8097 * 8098 * Throws: GException on failure. 8099 */ 8100 extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) ejectFinish; 8101 /** 8102 * 8103 * Params: 8104 * volume = a #GVolume 8105 * kind = the kind of identifier to return 8106 * Return: a newly allocated string containing the 8107 * requested identfier, or %NULL if the #GVolume 8108 * doesn't have this kind of identifier 8109 */ 8110 extern(C) char* function(GVolume* volume, const(char)* kind) getIdentifier; 8111 /** 8112 * 8113 * Params: 8114 * volume = a #GVolume 8115 * Return: a %NULL-terminated array 8116 * of strings containing kinds of identifiers. Use g_strfreev() to free. 8117 */ 8118 extern(C) char** function(GVolume* volume) enumerateIdentifiers; 8119 /** 8120 * 8121 * Params: 8122 * volume = a #GVolume 8123 * Return: %TRUE if the volume should be automatically mounted 8124 */ 8125 extern(C) int function(GVolume* volume) shouldAutomount; 8126 /** 8127 * 8128 * Params: 8129 * volume = a #GVolume 8130 * Return: the activation root of @volume 8131 * or %NULL. Use g_object_unref() to free. 8132 */ 8133 extern(C) GFile* function(GVolume* volume) getActivationRoot; 8134 extern(C) void function(GVolume* volume, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation; 8135 /** 8136 * 8137 * Params: 8138 * volume = a #GVolume 8139 * result = a #GAsyncResult 8140 * Return: %TRUE if the volume was successfully ejected. %FALSE otherwise 8141 * 8142 * Throws: GException on failure. 8143 */ 8144 extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) ejectWithOperationFinish; 8145 /** 8146 * 8147 * Params: 8148 * volume = a #GVolume 8149 * Return: Sorting key for @volume or %NULL if no such key is available 8150 */ 8151 extern(C) const(char)* function(GVolume* volume) getSortKey; 8152 /** 8153 * 8154 * Params: 8155 * volume = a #GVolume 8156 * Return: a #GIcon. 8157 * The returned object should be unreffed with g_object_unref() 8158 * when no longer needed. 8159 */ 8160 extern(C) GIcon* function(GVolume* volume) getSymbolicIcon; 8161 } 8162 8163 struct GVolumeMonitor 8164 { 8165 GObject parentInstance; 8166 void* priv; 8167 } 8168 8169 struct GVolumeMonitorClass 8170 { 8171 GObjectClass parentClass; 8172 extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeAdded; 8173 extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeRemoved; 8174 extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeChanged; 8175 extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountAdded; 8176 extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountRemoved; 8177 extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountPreUnmount; 8178 extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountChanged; 8179 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveConnected; 8180 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveDisconnected; 8181 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveChanged; 8182 extern(C) int function() isSupported; 8183 /** 8184 * 8185 * Params: 8186 * volumeMonitor = a #GVolumeMonitor. 8187 * Return: a #GList of connected #GDrive objects. 8188 */ 8189 extern(C) GList* function(GVolumeMonitor* volumeMonitor) getConnectedDrives; 8190 /** 8191 * 8192 * Params: 8193 * volumeMonitor = a #GVolumeMonitor. 8194 * Return: a #GList of #GVolume objects. 8195 */ 8196 extern(C) GList* function(GVolumeMonitor* volumeMonitor) getVolumes; 8197 /** 8198 * 8199 * Params: 8200 * volumeMonitor = a #GVolumeMonitor. 8201 * Return: a #GList of #GMount objects. 8202 */ 8203 extern(C) GList* function(GVolumeMonitor* volumeMonitor) getMounts; 8204 /** 8205 * 8206 * Params: 8207 * volumeMonitor = a #GVolumeMonitor. 8208 * uuid = the UUID to look for 8209 * Return: a #GVolume or %NULL if no such volume is available. 8210 * Free the returned object with g_object_unref(). 8211 */ 8212 extern(C) GVolume* function(GVolumeMonitor* volumeMonitor, const(char)* uuid) getVolumeForUuid; 8213 /** 8214 * 8215 * Params: 8216 * volumeMonitor = a #GVolumeMonitor. 8217 * uuid = the UUID to look for 8218 * Return: a #GMount or %NULL if no such mount is available. 8219 * Free the returned object with g_object_unref(). 8220 */ 8221 extern(C) GMount* function(GVolumeMonitor* volumeMonitor, const(char)* uuid) getMountForUuid; 8222 extern(C) GVolume* function(GMount* mount, GVolumeMonitor* volumeMonitor) adoptOrphanMount; 8223 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveEjectButton; 8224 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveStopButton; 8225 extern(C) void function() GReserved1; 8226 extern(C) void function() GReserved2; 8227 extern(C) void function() GReserved3; 8228 extern(C) void function() GReserved4; 8229 extern(C) void function() GReserved5; 8230 extern(C) void function() GReserved6; 8231 } 8232 8233 struct GZlibCompressor; 8234 8235 struct GZlibCompressorClass 8236 { 8237 GObjectClass parentClass; 8238 } 8239 8240 struct GZlibDecompressor; 8241 8242 struct GZlibDecompressorClass 8243 { 8244 GObjectClass parentClass; 8245 } 8246 8247 /** 8248 * Type definition for a function that will be called back when an asynchronous 8249 * operation within GIO has been completed. 8250 * 8251 * Params: 8252 * sourceObject = the object the asynchronous operation was started with. 8253 * res = a #GAsyncResult. 8254 * userData = user data passed to the callback. 8255 */ 8256 public alias extern(C) void function(GObject* sourceObject, GAsyncResult* res, void* userData) GAsyncReadyCallback; 8257 8258 /** 8259 * Invoked when a connection to a message bus has been obtained. 8260 * 8261 * Params: 8262 * connection = The #GDBusConnection to a message bus. 8263 * name = The name that is requested to be owned. 8264 * userData = User data passed to g_bus_own_name(). 8265 * 8266 * Since: 2.26 8267 */ 8268 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusAcquiredCallback; 8269 8270 /** 8271 * Invoked when the name is acquired. 8272 * 8273 * Params: 8274 * connection = The #GDBusConnection on which to acquired the name. 8275 * name = The name being owned. 8276 * userData = User data passed to g_bus_own_name() or g_bus_own_name_on_connection(). 8277 * 8278 * Since: 2.26 8279 */ 8280 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameAcquiredCallback; 8281 8282 /** 8283 * Invoked when the name being watched is known to have to have a owner. 8284 * 8285 * Params: 8286 * connection = The #GDBusConnection the name is being watched on. 8287 * name = The name being watched. 8288 * nameOwner = Unique name of the owner of the name being watched. 8289 * userData = User data passed to g_bus_watch_name(). 8290 * 8291 * Since: 2.26 8292 */ 8293 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, const(char)* nameOwner, void* userData) GBusNameAppearedCallback; 8294 8295 /** 8296 * Invoked when the name is lost or @connection has been closed. 8297 * 8298 * Params: 8299 * connection = The #GDBusConnection on which to acquire the name or %NULL if 8300 * the connection was disconnected. 8301 * name = The name being owned. 8302 * userData = User data passed to g_bus_own_name() or g_bus_own_name_on_connection(). 8303 * 8304 * Since: 2.26 8305 */ 8306 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameLostCallback; 8307 8308 /** 8309 * Invoked when the name being watched is known not to have to have a owner. 8310 * 8311 * This is also invoked when the #GDBusConection on which the watch was 8312 * established has been closed. In that case, @connection will be 8313 * %NULL. 8314 * 8315 * Params: 8316 * connection = The #GDBusConnection the name is being watched on, or 8317 * %NULL. 8318 * name = The name being watched. 8319 * userData = User data passed to g_bus_watch_name(). 8320 * 8321 * Since: 2.26 8322 */ 8323 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameVanishedCallback; 8324 8325 /** 8326 * This is the function type of the callback used for the #GSource 8327 * returned by g_cancellable_source_new(). 8328 * 8329 * Params: 8330 * cancellable = the #GCancellable 8331 * userData = data passed in by the user. 8332 * 8333 * Return: it should return %FALSE if the source should be removed. 8334 * 8335 * Since: 2.28 8336 */ 8337 public alias extern(C) int function(GCancellable* cancellable, void* userData) GCancellableSourceFunc; 8338 8339 /** 8340 * The type of the @get_property function in #GDBusInterfaceVTable. 8341 * 8342 * Params: 8343 * connection = A #GDBusConnection. 8344 * sender = The unique bus name of the remote caller. 8345 * objectPath = The object path that the method was invoked on. 8346 * interfaceName = The D-Bus interface name for the property. 8347 * propertyName = The name of the property to get the value of. 8348 * error = Return location for error. 8349 * userData = The @user_data #gpointer passed to g_dbus_connection_register_object(). 8350 * 8351 * Return: A #GVariant with the value for @property_name or %NULL if 8352 * @error is set. If the returned #GVariant is floating, it is 8353 * consumed - otherwise its reference count is decreased by one. 8354 * 8355 * Since: 2.26 8356 */ 8357 public alias extern(C) GVariant* function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* interfaceName, const(char)* propertyName, GError** error, void* userData) GDBusInterfaceGetPropertyFunc; 8358 8359 /** 8360 * The type of the @method_call function in #GDBusInterfaceVTable. 8361 * 8362 * Params: 8363 * connection = A #GDBusConnection. 8364 * sender = The unique bus name of the remote caller. 8365 * objectPath = The object path that the method was invoked on. 8366 * interfaceName = The D-Bus interface name the method was invoked on. 8367 * methodName = The name of the method that was invoked. 8368 * parameters = A #GVariant tuple with parameters. 8369 * invocation = A #GDBusMethodInvocation object that must be used to return a value or error. 8370 * userData = The @user_data #gpointer passed to g_dbus_connection_register_object(). 8371 * 8372 * Since: 2.26 8373 */ 8374 public alias extern(C) void function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* interfaceName, const(char)* methodName, GVariant* parameters, GDBusMethodInvocation* invocation, void* userData) GDBusInterfaceMethodCallFunc; 8375 8376 /** 8377 * The type of the @set_property function in #GDBusInterfaceVTable. 8378 * 8379 * Params: 8380 * connection = A #GDBusConnection. 8381 * sender = The unique bus name of the remote caller. 8382 * objectPath = The object path that the method was invoked on. 8383 * interfaceName = The D-Bus interface name for the property. 8384 * propertyName = The name of the property to get the value of. 8385 * value = The value to set the property to. 8386 * error = Return location for error. 8387 * userData = The @user_data #gpointer passed to g_dbus_connection_register_object(). 8388 * 8389 * Return: %TRUE if the property was set to @value, %FALSE if @error is set. 8390 * 8391 * Since: 2.26 8392 */ 8393 public alias extern(C) int function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* interfaceName, const(char)* propertyName, GVariant* value, GError** error, void* userData) GDBusInterfaceSetPropertyFunc; 8394 8395 /** 8396 * Signature for function used in g_dbus_connection_add_filter(). 8397 * 8398 * A filter function is passed a #GDBusMessage and expected to return 8399 * a #GDBusMessage too. Passive filter functions that don't modify the 8400 * message can simply return the @message object: 8401 * |[ 8402 * static GDBusMessage * 8403 * passive_filter (GDBusConnection *connection 8404 * GDBusMessage *message, 8405 * gboolean incoming, 8406 * gpointer user_data) 8407 * { 8408 * /<!-- -->* inspect @message *<!-- -->/ 8409 * return message; 8410 * } 8411 * ]| 8412 * Filter functions that wants to drop a message can simply return %NULL: 8413 * |[ 8414 * static GDBusMessage * 8415 * drop_filter (GDBusConnection *connection 8416 * GDBusMessage *message, 8417 * gboolean incoming, 8418 * gpointer user_data) 8419 * { 8420 * if (should_drop_message) 8421 * { 8422 * g_object_unref (message); 8423 * message = NULL; 8424 * } 8425 * return message; 8426 * } 8427 * ]| 8428 * Finally, a filter function may modify a message by copying it: 8429 * |[ 8430 * static GDBusMessage * 8431 * modifying_filter (GDBusConnection *connection 8432 * GDBusMessage *message, 8433 * gboolean incoming, 8434 * gpointer user_data) 8435 * { 8436 * GDBusMessage *copy; 8437 * GError *error; 8438 * 8439 * error = NULL; 8440 * copy = g_dbus_message_copy (message, &error); 8441 * /<!-- -->* handle @error being is set *<!-- -->/ 8442 * g_object_unref (message); 8443 * 8444 * /<!-- -->* modify @copy *<!-- -->/ 8445 * 8446 * return copy; 8447 * } 8448 * ]| 8449 * If the returned #GDBusMessage is different from @message and cannot 8450 * be sent on @connection (it could use features, such as file 8451 * descriptors, not compatible with @connection), then a warning is 8452 * logged to <emphasis>standard error</emphasis>. Applications can 8453 * check this ahead of time using g_dbus_message_to_blob() passing a 8454 * #GDBusCapabilityFlags value obtained from @connection. 8455 * 8456 * Params: 8457 * connection = A #GDBusConnection. 8458 * message = A locked #GDBusMessage that the filter function takes ownership of. 8459 * incoming = %TRUE if it is a message received from the other peer, %FALSE if it is 8460 * a message to be sent to the other peer. 8461 * userData = User data passed when adding the filter. 8462 * 8463 * Return: A #GDBusMessage that will be freed with 8464 * g_object_unref() or %NULL to drop the message. Passive filter 8465 * functions can simply return the passed @message object. 8466 * 8467 * Since: 2.26 8468 */ 8469 public alias extern(C) GDBusMessage* function(GDBusConnection* connection, GDBusMessage* message, int incoming, void* userData) GDBusMessageFilterFunction; 8470 8471 /** 8472 * Function signature for a function used to determine the #GType to 8473 * use for an interface proxy (if @interface_name is not %NULL) or 8474 * object proxy (if @interface_name is %NULL). 8475 * 8476 * This function is called in the 8477 * [thread-default main loop][g-main-context-push-thread-default] 8478 * that @manager was constructed in. 8479 * 8480 * Params: 8481 * manager = A #GDBusObjectManagerClient. 8482 * objectPath = The object path of the remote object. 8483 * interfaceName = The interface name of the remote object or %NULL if a #GDBusObjectProxy #GType is requested. 8484 * userData = User data. 8485 * 8486 * Return: A #GType to use for the remote object. The returned type 8487 * must be a #GDBusProxy<!-- -->- or #GDBusObjectProxy<!-- -->-derived 8488 * type. 8489 * 8490 * Since: 2.30 8491 */ 8492 public alias extern(C) GType function(GDBusObjectManagerClient* manager, const(char)* objectPath, const(char)* interfaceName, void* userData) GDBusProxyTypeFunc; 8493 8494 /** 8495 * Signature for callback function used in g_dbus_connection_signal_subscribe(). 8496 * 8497 * Params: 8498 * connection = A #GDBusConnection. 8499 * senderName = The unique bus name of the sender of the signal. 8500 * objectPath = The object path that the signal was emitted on. 8501 * interfaceName = The name of the interface. 8502 * signalName = The name of the signal. 8503 * parameters = A #GVariant tuple with parameters for the signal. 8504 * userData = User data passed when subscribing to the signal. 8505 * 8506 * Since: 2.26 8507 */ 8508 public alias extern(C) void function(GDBusConnection* connection, const(char)* senderName, const(char)* objectPath, const(char)* interfaceName, const(char)* signalName, GVariant* parameters, void* userData) GDBusSignalCallback; 8509 8510 /** 8511 * The type of the @dispatch function in #GDBusSubtreeVTable. 8512 * 8513 * Subtrees are flat. @node, if non-%NULL, is always exactly one 8514 * segment of the object path (ie: it never contains a slash). 8515 * 8516 * Params: 8517 * connection = A #GDBusConnection. 8518 * sender = The unique bus name of the remote caller. 8519 * objectPath = The object path that was registered with g_dbus_connection_register_subtree(). 8520 * interfaceName = The D-Bus interface name that the method call or property access is for. 8521 * node = A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree. 8522 * outUserData = Return location for user data to pass to functions in the returned #GDBusInterfaceVTable (never %NULL). 8523 * userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree(). 8524 * 8525 * Return: A #GDBusInterfaceVTable or %NULL if you don't want to handle the methods. 8526 * 8527 * Since: 2.26 8528 */ 8529 public alias extern(C) GDBusInterfaceVTable* function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* interfaceName, const(char)* node, void** outUserData, void* userData) GDBusSubtreeDispatchFunc; 8530 8531 /** 8532 * The type of the @enumerate function in #GDBusSubtreeVTable. 8533 * 8534 * This function is called when generating introspection data and also 8535 * when preparing to dispatch incoming messages in the event that the 8536 * %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not 8537 * specified (ie: to verify that the object path is valid). 8538 * 8539 * Hierarchies are not supported; the items that you return should not 8540 * contain the '/' character. 8541 * 8542 * The return value will be freed with g_strfreev(). 8543 * 8544 * Params: 8545 * connection = A #GDBusConnection. 8546 * sender = The unique bus name of the remote caller. 8547 * objectPath = The object path that was registered with g_dbus_connection_register_subtree(). 8548 * userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree(). 8549 * 8550 * Return: A newly allocated array of strings for node names that are children of @object_path. 8551 * 8552 * Since: 2.26 8553 */ 8554 public alias extern(C) char** function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, void* userData) GDBusSubtreeEnumerateFunc; 8555 8556 /** 8557 * The type of the @introspect function in #GDBusSubtreeVTable. 8558 * 8559 * Subtrees are flat. @node, if non-%NULL, is always exactly one 8560 * segment of the object path (ie: it never contains a slash). 8561 * 8562 * This function should return %NULL to indicate that there is no object 8563 * at this node. 8564 * 8565 * If this function returns non-%NULL, the return value is expected to 8566 * be a %NULL-terminated array of pointers to #GDBusInterfaceInfo 8567 * structures describing the interfaces implemented by @node. This 8568 * array will have g_dbus_interface_info_unref() called on each item 8569 * before being freed with g_free(). 8570 * 8571 * The difference between returning %NULL and an array containing zero 8572 * items is that the standard DBus interfaces will returned to the 8573 * remote introspector in the empty array case, but not in the %NULL 8574 * case. 8575 * 8576 * Params: 8577 * connection = A #GDBusConnection. 8578 * sender = The unique bus name of the remote caller. 8579 * objectPath = The object path that was registered with g_dbus_connection_register_subtree(). 8580 * node = A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree. 8581 * userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree(). 8582 * 8583 * Return: A %NULL-terminated array of pointers to #GDBusInterfaceInfo, or %NULL. 8584 * 8585 * Since: 2.26 8586 */ 8587 public alias extern(C) GDBusInterfaceInfo** function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* node, void* userData) GDBusSubtreeIntrospectFunc; 8588 8589 /** 8590 * During invocation, g_desktop_app_info_launch_uris_as_manager() may 8591 * create one or more child processes. This callback is invoked once 8592 * for each, providing the process ID. 8593 * 8594 * Params: 8595 * appinfo = a #GDesktopAppInfo 8596 * pid = Process identifier 8597 * userData = User data 8598 */ 8599 public alias extern(C) void function(GDesktopAppInfo* appinfo, GPid pid, void* userData) GDesktopAppLaunchCallback; 8600 8601 /** 8602 * This callback type is used by g_file_measure_disk_usage() to make 8603 * periodic progress reports when measuring the amount of disk spaced 8604 * used by a directory. 8605 * 8606 * These calls are made on a best-effort basis and not all types of 8607 * #GFile will support them. At the minimum, however, one call will 8608 * always be made immediately. 8609 * 8610 * In the case that there is no support, @reporting will be set to 8611 * %FALSE (and the other values undefined) and no further calls will be 8612 * made. Otherwise, the @reporting will be %TRUE and the other values 8613 * all-zeros during the first (immediate) call. In this way, you can 8614 * know which type of progress UI to show without a delay. 8615 * 8616 * For g_file_measure_disk_usage() the callback is made directly. For 8617 * g_file_measure_disk_usage_async() the callback is made via the 8618 * default main context of the calling thread (ie: the same way that the 8619 * final async result would be reported). 8620 * 8621 * @current_size is in the same units as requested by the operation (see 8622 * %G_FILE_DISK_USAGE_APPARENT_SIZE). 8623 * 8624 * The frequency of the updates is implementation defined, but is 8625 * ideally about once every 200ms. 8626 * 8627 * The last progress callback may or may not be equal to the final 8628 * result. Always check the async result to get the final value. 8629 * 8630 * Params: 8631 * reporting = %TRUE if more reports will come 8632 * currentSize = the current cumulative size measurement 8633 * numDirs = the number of directories visited so far 8634 * numFiles = the number of non-directory files encountered 8635 * userData = the data passed to the original request for this callback 8636 * 8637 * Since: 2.38 8638 */ 8639 public alias extern(C) void function(int reporting, ulong currentSize, ulong numDirs, ulong numFiles, void* userData) GFileMeasureProgressCallback; 8640 8641 /** 8642 * When doing file operations that may take a while, such as moving 8643 * a file or copying a file, a progress callback is used to pass how 8644 * far along that operation is to the application. 8645 * 8646 * Params: 8647 * currentNumBytes = the current number of bytes in the operation. 8648 * totalNumBytes = the total number of bytes in the operation. 8649 * userData = user data passed to the callback. 8650 */ 8651 public alias extern(C) void function(long currentNumBytes, long totalNumBytes, void* userData) GFileProgressCallback; 8652 8653 /** 8654 * When loading the partial contents of a file with g_file_load_partial_contents_async(), 8655 * it may become necessary to determine if any more data from the file should be loaded. 8656 * A #GFileReadMoreCallback function facilitates this by returning %TRUE if more data 8657 * should be read, or %FALSE otherwise. 8658 * 8659 * Params: 8660 * fileContents = the data as currently read. 8661 * fileSize = the size of the data currently read. 8662 * callbackData = data passed to the callback. 8663 * 8664 * Return: %TRUE if more data should be read back. %FALSE otherwise. 8665 */ 8666 public alias extern(C) int function(const(char)* fileContents, long fileSize, void* callbackData) GFileReadMoreCallback; 8667 8668 /** 8669 * I/O Job function. 8670 * 8671 * Long-running jobs should periodically check the @cancellable 8672 * to see if they have been cancelled. 8673 * 8674 * Params: 8675 * job = a #GIOSchedulerJob. 8676 * cancellable = optional #GCancellable object, %NULL to ignore. 8677 * userData = the data to pass to callback function 8678 * 8679 * Return: %TRUE if this function should be called again to 8680 * complete the job, %FALSE if the job is complete (or cancelled) 8681 */ 8682 public alias extern(C) int function(GIOSchedulerJob* job, GCancellable* cancellable, void* userData) GIOSchedulerJobFunc; 8683 8684 /** 8685 * This is the function type of the callback used for the #GSource 8686 * returned by g_pollable_input_stream_create_source() and 8687 * g_pollable_output_stream_create_source(). 8688 * 8689 * Params: 8690 * pollableStream = the #GPollableInputStream or #GPollableOutputStream 8691 * userData = data passed in by the user. 8692 * 8693 * Return: it should return %FALSE if the source should be removed. 8694 * 8695 * Since: 2.28 8696 */ 8697 public alias extern(C) int function(GObject* pollableStream, void* userData) GPollableSourceFunc; 8698 8699 /** 8700 * Changes the size of the memory block pointed to by @data to 8701 * @size bytes. 8702 * 8703 * The function should have the same semantics as realloc(). 8704 * 8705 * Params: 8706 * data = memory block to reallocate 8707 * size = size to reallocate @data to 8708 * 8709 * Return: a pointer to the reallocated memory 8710 */ 8711 public alias extern(C) void* function(void* data, size_t size) GReallocFunc; 8712 8713 /** 8714 * The type for the function that is used to convert from #GSettings to 8715 * an object property. The @value is already initialized to hold values 8716 * of the appropriate type. 8717 * 8718 * Params: 8719 * value = return location for the property value 8720 * variant = the #GVariant 8721 * userData = user data that was specified when the binding was created 8722 * 8723 * Return: %TRUE if the conversion succeeded, %FALSE in case of an error 8724 */ 8725 public alias extern(C) int function(GValue* value, GVariant* variant, void* userData) GSettingsBindGetMapping; 8726 8727 /** 8728 * The type for the function that is used to convert an object property 8729 * value to a #GVariant for storing it in #GSettings. 8730 * 8731 * Params: 8732 * value = a #GValue containing the property value to map 8733 * expectedType = the #GVariantType to create 8734 * userData = user data that was specified when the binding was created 8735 * 8736 * Return: a new #GVariant holding the data from @value, 8737 * or %NULL in case of an error 8738 */ 8739 public alias extern(C) GVariant* function(GValue* value, GVariantType* expectedType, void* userData) GSettingsBindSetMapping; 8740 8741 /** 8742 * The type of the function that is used to convert from a value stored 8743 * in a #GSettings to a value that is useful to the application. 8744 * 8745 * If the value is successfully mapped, the result should be stored at 8746 * @result and %TRUE returned. If mapping fails (for example, if @value 8747 * is not in the right format) then %FALSE should be returned. 8748 * 8749 * If @value is %NULL then it means that the mapping function is being 8750 * given a "last chance" to successfully return a valid value. %TRUE 8751 * must be returned in this case. 8752 * 8753 * Params: 8754 * value = the #GVariant to map, or %NULL 8755 * result = the result of the mapping 8756 * userData = the user data that was passed to 8757 * g_settings_get_mapped() 8758 * 8759 * Return: %TRUE if the conversion succeeded, %FALSE in case of an error 8760 */ 8761 public alias extern(C) int function(GVariant* value, void** result, void* userData) GSettingsGetMapping; 8762 8763 /** 8764 * Simple thread function that runs an asynchronous operation and 8765 * checks for cancellation. 8766 * 8767 * Params: 8768 * res = a #GSimpleAsyncResult. 8769 * object = a #GObject. 8770 * cancellable = optional #GCancellable object, %NULL to ignore. 8771 */ 8772 public alias extern(C) void function(GSimpleAsyncResult* res, GObject* object, GCancellable* cancellable) GSimpleAsyncThreadFunc; 8773 8774 /** 8775 * This is the function type of the callback used for the #GSource 8776 * returned by g_socket_create_source(). 8777 * 8778 * Params: 8779 * socket = the #GSocket 8780 * condition = the current condition at the source fired. 8781 * userData = data passed in by the user. 8782 * 8783 * Return: it should return %FALSE if the source should be removed. 8784 * 8785 * Since: 2.22 8786 */ 8787 public alias extern(C) int function(GSocket* socket, GIOCondition condition, void* userData) GSocketSourceFunc; 8788 8789 /** 8790 * The prototype for a task function to be run in a thread via 8791 * g_task_run_in_thread() or g_task_run_in_thread_sync(). 8792 * 8793 * If the return-on-cancel flag is set on @task, and @cancellable gets 8794 * cancelled, then the #GTask will be completed immediately (as though 8795 * g_task_return_error_if_cancelled() had been called), without 8796 * waiting for the task function to complete. However, the task 8797 * function will continue running in its thread in the background. The 8798 * function therefore needs to be careful about how it uses 8799 * externally-visible state in this case. See 8800 * g_task_set_return_on_cancel() for more details. 8801 * 8802 * Other than in that case, @task will be completed when the 8803 * #GTaskThreadFunc returns, not when it calls a 8804 * `g_task_return_` function. 8805 * 8806 * Params: 8807 * task = the #GTask 8808 * sourceObject = @task's source object 8809 * taskData = @task's task data 8810 * cancellable = @task's #GCancellable, or %NULL 8811 * 8812 * Since: 2.36 8813 */ 8814 public alias extern(C) void function(GTask* task, void* sourceObject, void* taskData, GCancellable* cancellable) GTaskThreadFunc;