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