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 /** */ 2891 extern(C) void function(GSimpleAction* action, GVariant* parameter, void* userData) activate; 2892 /** 2893 * the type of the parameter that must be passed to the 2894 * activate function for this action, given as a single 2895 * GVariant type string (or %NULL for no parameter) 2896 */ 2897 const(char)* parameterType; 2898 /** 2899 * the initial state for this action, given in 2900 * [GVariant text format][gvariant-text]. The state is parsed 2901 * with no extra type information, so type tags must be added to 2902 * the string if they are necessary. Stateless actions should 2903 * give %NULL here. 2904 */ 2905 const(char)* state; 2906 /** */ 2907 extern(C) void function(GSimpleAction* action, GVariant* value, void* userData) changeState; 2908 size_t[3] padding; 2909 } 2910 2911 struct GActionGroup; 2912 2913 /** 2914 * The virtual function table for #GActionGroup. 2915 * 2916 * Since: 2.28 2917 */ 2918 struct GActionGroupInterface 2919 { 2920 GTypeInterface gIface; 2921 /** 2922 * 2923 * Params: 2924 * actionGroup = a #GActionGroup 2925 * actionName = the name of the action to check for 2926 * Return: whether the named action exists 2927 */ 2928 extern(C) int function(GActionGroup* actionGroup, const(char)* actionName) hasAction; 2929 /** 2930 * 2931 * Params: 2932 * actionGroup = a #GActionGroup 2933 * Return: a %NULL-terminated array of the names of the 2934 * actions in the groupb 2935 */ 2936 extern(C) char** function(GActionGroup* actionGroup) listActions; 2937 /** 2938 * 2939 * Params: 2940 * actionGroup = a #GActionGroup 2941 * actionName = the name of the action to query 2942 * Return: whether or not the action is currently enabled 2943 */ 2944 extern(C) int function(GActionGroup* actionGroup, const(char)* actionName) getActionEnabled; 2945 /** 2946 * 2947 * Params: 2948 * actionGroup = a #GActionGroup 2949 * actionName = the name of the action to query 2950 * Return: the parameter type 2951 */ 2952 extern(C) GVariantType* function(GActionGroup* actionGroup, const(char)* actionName) getActionParameterType; 2953 /** 2954 * 2955 * Params: 2956 * actionGroup = a #GActionGroup 2957 * actionName = the name of the action to query 2958 * Return: the state type, if the action is stateful 2959 */ 2960 extern(C) GVariantType* function(GActionGroup* actionGroup, const(char)* actionName) getActionStateType; 2961 /** 2962 * 2963 * Params: 2964 * actionGroup = a #GActionGroup 2965 * actionName = the name of the action to query 2966 * Return: the state range hint 2967 */ 2968 extern(C) GVariant* function(GActionGroup* actionGroup, const(char)* actionName) getActionStateHint; 2969 /** 2970 * 2971 * Params: 2972 * actionGroup = a #GActionGroup 2973 * actionName = the name of the action to query 2974 * Return: the current state of the action 2975 */ 2976 extern(C) GVariant* function(GActionGroup* actionGroup, const(char)* actionName) getActionState; 2977 /** */ 2978 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* value) changeActionState; 2979 /** */ 2980 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* parameter) activateAction; 2981 /** */ 2982 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName) actionAdded; 2983 /** */ 2984 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName) actionRemoved; 2985 /** */ 2986 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, int enabled) actionEnabledChanged; 2987 /** */ 2988 extern(C) void function(GActionGroup* actionGroup, const(char)* actionName, GVariant* state) actionStateChanged; 2989 /** 2990 * 2991 * Params: 2992 * actionGroup = a #GActionGroup 2993 * actionName = the name of an action in the group 2994 * enabled = if the action is presently enabled 2995 * parameterType = the parameter type, or %NULL if none needed 2996 * stateType = the state type, or %NULL if stateless 2997 * stateHint = the state hint, or %NULL if none 2998 * state = the current state, or %NULL if stateless 2999 * Return: %TRUE if the action exists, else %FALSE 3000 */ 3001 extern(C) int function(GActionGroup* actionGroup, const(char)* actionName, int* enabled, GVariantType** parameterType, GVariantType** stateType, GVariant** stateHint, GVariant** state) queryAction; 3002 } 3003 3004 /** 3005 * The virtual function table for #GAction. 3006 * 3007 * Since: 2.28 3008 */ 3009 struct GActionInterface 3010 { 3011 GTypeInterface gIface; 3012 /** 3013 * 3014 * Params: 3015 * action = a #GAction 3016 * Return: the name of the action 3017 */ 3018 extern(C) const(char)* function(GAction* action) getName; 3019 /** 3020 * 3021 * Params: 3022 * action = a #GAction 3023 * Return: the parameter type 3024 */ 3025 extern(C) GVariantType* function(GAction* action) getParameterType; 3026 /** 3027 * 3028 * Params: 3029 * action = a #GAction 3030 * Return: the state type, if the action is stateful 3031 */ 3032 extern(C) GVariantType* function(GAction* action) getStateType; 3033 /** 3034 * 3035 * Params: 3036 * action = a #GAction 3037 * Return: the state range hint 3038 */ 3039 extern(C) GVariant* function(GAction* action) getStateHint; 3040 /** 3041 * 3042 * Params: 3043 * action = a #GAction 3044 * Return: whether the action is enabled 3045 */ 3046 extern(C) int function(GAction* action) getEnabled; 3047 /** 3048 * 3049 * Params: 3050 * action = a #GAction 3051 * Return: the current state of the action 3052 */ 3053 extern(C) GVariant* function(GAction* action) getState; 3054 /** */ 3055 extern(C) void function(GAction* action, GVariant* value) changeState; 3056 /** */ 3057 extern(C) void function(GAction* action, GVariant* parameter) activate; 3058 } 3059 3060 struct GActionMap; 3061 3062 /** 3063 * The virtual function table for #GActionMap. 3064 * 3065 * Since: 2.32 3066 */ 3067 struct GActionMapInterface 3068 { 3069 GTypeInterface gIface; 3070 /** 3071 * 3072 * Params: 3073 * actionMap = a #GActionMap 3074 * actionName = the name of an action 3075 * Return: a #GAction, or %NULL 3076 */ 3077 extern(C) GAction* function(GActionMap* actionMap, const(char)* actionName) lookupAction; 3078 /** */ 3079 extern(C) void function(GActionMap* actionMap, GAction* action) addAction; 3080 /** */ 3081 extern(C) void function(GActionMap* actionMap, const(char)* actionName) removeAction; 3082 } 3083 3084 struct GAppInfo; 3085 3086 /** 3087 * Application Information interface, for operating system portability. 3088 */ 3089 struct GAppInfoIface 3090 { 3091 /** 3092 * The parent interface. 3093 */ 3094 GTypeInterface gIface; 3095 /** 3096 * 3097 * Params: 3098 * appinfo = a #GAppInfo. 3099 * Return: a duplicate of @appinfo. 3100 */ 3101 extern(C) GAppInfo* function(GAppInfo* appinfo) dup; 3102 /** 3103 * 3104 * Params: 3105 * appinfo1 = the first #GAppInfo. 3106 * appinfo2 = the second #GAppInfo. 3107 * Return: %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise. 3108 */ 3109 extern(C) int function(GAppInfo* appinfo1, GAppInfo* appinfo2) equal; 3110 /** 3111 * 3112 * Params: 3113 * appinfo = a #GAppInfo. 3114 * Return: a string containing the application's ID. 3115 */ 3116 extern(C) const(char)* function(GAppInfo* appinfo) getId; 3117 /** 3118 * 3119 * Params: 3120 * appinfo = a #GAppInfo. 3121 * Return: the name of the application for @appinfo. 3122 */ 3123 extern(C) const(char)* function(GAppInfo* appinfo) getName; 3124 /** 3125 * 3126 * Params: 3127 * appinfo = a #GAppInfo. 3128 * Return: a string containing a description of the 3129 * application @appinfo, or %NULL if none. 3130 */ 3131 extern(C) const(char)* function(GAppInfo* appinfo) getDescription; 3132 /** 3133 * 3134 * Params: 3135 * appinfo = a #GAppInfo 3136 * Return: a string containing the @appinfo's application 3137 * binaries name 3138 */ 3139 extern(C) const(char)* function(GAppInfo* appinfo) getExecutable; 3140 /** 3141 * 3142 * Params: 3143 * appinfo = a #GAppInfo. 3144 * Return: the default #GIcon for @appinfo or %NULL 3145 * if there is no default icon. 3146 */ 3147 extern(C) GIcon* function(GAppInfo* appinfo) getIcon; 3148 /** 3149 * 3150 * Params: 3151 * appinfo = a #GAppInfo 3152 * files = a #GList of #GFile objects 3153 * launchContext = a #GAppLaunchContext or %NULL 3154 * Return: %TRUE on successful launch, %FALSE otherwise. 3155 * 3156 * Throws: GException on failure. 3157 */ 3158 extern(C) int function(GAppInfo* appinfo, GList* files, GAppLaunchContext* launchContext, GError** err) launch; 3159 /** 3160 * 3161 * Params: 3162 * appinfo = a #GAppInfo. 3163 * Return: %TRUE if the @appinfo supports URIs. 3164 */ 3165 extern(C) int function(GAppInfo* appinfo) supportsUris; 3166 /** 3167 * 3168 * Params: 3169 * appinfo = a #GAppInfo. 3170 * Return: %TRUE if the @appinfo supports files. 3171 */ 3172 extern(C) int function(GAppInfo* appinfo) supportsFiles; 3173 /** 3174 * 3175 * Params: 3176 * appinfo = a #GAppInfo 3177 * uris = a #GList containing URIs to launch. 3178 * launchContext = a #GAppLaunchContext or %NULL 3179 * Return: %TRUE on successful launch, %FALSE otherwise. 3180 * 3181 * Throws: GException on failure. 3182 */ 3183 extern(C) int function(GAppInfo* appinfo, GList* uris, GAppLaunchContext* launchContext, GError** err) launchUris; 3184 /** 3185 * 3186 * Params: 3187 * appinfo = a #GAppInfo. 3188 * Return: %TRUE if the @appinfo should be shown, %FALSE otherwise. 3189 */ 3190 extern(C) int function(GAppInfo* appinfo) shouldShow; 3191 /** 3192 * 3193 * Params: 3194 * appinfo = a #GAppInfo. 3195 * contentType = the content type. 3196 * Return: %TRUE on success, %FALSE on error. 3197 * 3198 * Throws: GException on failure. 3199 */ 3200 extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) setAsDefaultForType; 3201 /** 3202 * 3203 * Params: 3204 * appinfo = a #GAppInfo. 3205 * extension = a string containing the file extension (without the dot). 3206 * Return: %TRUE on success, %FALSE on error. 3207 * 3208 * Throws: GException on failure. 3209 */ 3210 extern(C) int function(GAppInfo* appinfo, const(char)* extension, GError** err) setAsDefaultForExtension; 3211 /** 3212 * 3213 * Params: 3214 * appinfo = a #GAppInfo. 3215 * contentType = a string. 3216 * Return: %TRUE on success, %FALSE on error. 3217 * 3218 * Throws: GException on failure. 3219 */ 3220 extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) addSupportsType; 3221 /** 3222 * 3223 * Params: 3224 * appinfo = a #GAppInfo. 3225 * Return: %TRUE if it is possible to remove supported 3226 * content types from a given @appinfo, %FALSE if not. 3227 */ 3228 extern(C) int function(GAppInfo* appinfo) canRemoveSupportsType; 3229 /** 3230 * 3231 * Params: 3232 * appinfo = a #GAppInfo. 3233 * contentType = a string. 3234 * Return: %TRUE on success, %FALSE on error. 3235 * 3236 * Throws: GException on failure. 3237 */ 3238 extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) removeSupportsType; 3239 /** 3240 * 3241 * Params: 3242 * appinfo = a #GAppInfo 3243 * Return: %TRUE if @appinfo can be deleted 3244 */ 3245 extern(C) int function(GAppInfo* appinfo) canDelete; 3246 /** 3247 * 3248 * Params: 3249 * appinfo = a #GAppInfo 3250 * Return: %TRUE if @appinfo has been deleted 3251 */ 3252 extern(C) int function(GAppInfo* appinfo) doDelete; 3253 /** 3254 * 3255 * Params: 3256 * appinfo = a #GAppInfo 3257 * Return: a string containing the @appinfo's commandline, 3258 * or %NULL if this information is not available 3259 */ 3260 extern(C) const(char)* function(GAppInfo* appinfo) getCommandline; 3261 /** 3262 * 3263 * Params: 3264 * appinfo = a #GAppInfo. 3265 * Return: the display name of the application for @appinfo, or the name if 3266 * no display name is available. 3267 */ 3268 extern(C) const(char)* function(GAppInfo* appinfo) getDisplayName; 3269 /** 3270 * 3271 * Params: 3272 * appinfo = a #GAppInfo. 3273 * contentType = the content type. 3274 * Return: %TRUE on success, %FALSE on error. 3275 * 3276 * Throws: GException on failure. 3277 */ 3278 extern(C) int function(GAppInfo* appinfo, const(char)* contentType, GError** err) setAsLastUsedForType; 3279 /** 3280 * 3281 * Params: 3282 * appinfo = a #GAppInfo that can handle files 3283 * Return: a list of content types. 3284 */ 3285 extern(C) char** function(GAppInfo* appinfo) getSupportedTypes; 3286 } 3287 3288 struct GAppInfoMonitor; 3289 3290 struct GAppLaunchContext 3291 { 3292 GObject parentInstance; 3293 GAppLaunchContextPrivate* priv; 3294 } 3295 3296 struct GAppLaunchContextClass 3297 { 3298 GObjectClass parentClass; 3299 /** 3300 * 3301 * Params: 3302 * context = a #GAppLaunchContext 3303 * info = a #GAppInfo 3304 * files = a #GList of #GFile objects 3305 * Return: a display string for the display. 3306 */ 3307 extern(C) char* function(GAppLaunchContext* context, GAppInfo* info, GList* files) getDisplay; 3308 /** 3309 * 3310 * Params: 3311 * context = a #GAppLaunchContext 3312 * info = a #GAppInfo 3313 * files = a #GList of of #GFile objects 3314 * Return: a startup notification ID for the application, or %NULL if 3315 * not supported. 3316 */ 3317 extern(C) char* function(GAppLaunchContext* context, GAppInfo* info, GList* files) getStartupNotifyId; 3318 /** */ 3319 extern(C) void function(GAppLaunchContext* context, const(char)* startupNotifyId) launchFailed; 3320 /** */ 3321 extern(C) void function(GAppLaunchContext* context, GAppInfo* info, GVariant* platformData) launched; 3322 /** */ 3323 extern(C) void function() GReserved1; 3324 /** */ 3325 extern(C) void function() GReserved2; 3326 /** */ 3327 extern(C) void function() GReserved3; 3328 /** */ 3329 extern(C) void function() GReserved4; 3330 } 3331 3332 struct GAppLaunchContextPrivate; 3333 3334 struct GApplication 3335 { 3336 GObject parentInstance; 3337 GApplicationPrivate* priv; 3338 } 3339 3340 /** 3341 * Virtual function table for #GApplication. 3342 * 3343 * Since: 2.28 3344 */ 3345 struct GApplicationClass 3346 { 3347 GObjectClass parentClass; 3348 /** */ 3349 extern(C) void function(GApplication* application) startup; 3350 /** */ 3351 extern(C) void function(GApplication* application) activate; 3352 /** */ 3353 extern(C) void function(GApplication* application, GFile** files, int nFiles, const(char)* hint) open; 3354 /** */ 3355 extern(C) int function(GApplication* application, GApplicationCommandLine* commandLine) commandLine; 3356 /** 3357 * 3358 * Params: 3359 * application = a #GApplication 3360 * arguments = array of command line arguments 3361 * exitStatus = exit status to fill after processing the command line. 3362 * Return: %TRUE if the commandline has been completely handled 3363 */ 3364 extern(C) int function(GApplication* application, char*** arguments, int* exitStatus) localCommandLine; 3365 /** */ 3366 extern(C) void function(GApplication* application, GVariant* platformData) beforeEmit; 3367 /** */ 3368 extern(C) void function(GApplication* application, GVariant* platformData) afterEmit; 3369 /** */ 3370 extern(C) void function(GApplication* application, GVariantBuilder* builder) addPlatformData; 3371 /** */ 3372 extern(C) void function(GApplication* application) quitMainloop; 3373 /** */ 3374 extern(C) void function(GApplication* application) runMainloop; 3375 /** */ 3376 extern(C) void function(GApplication* application) shutdown; 3377 /** */ 3378 extern(C) int function(GApplication* application, GDBusConnection* connection, const(char)* objectPath, GError** err) dbusRegister; 3379 /** */ 3380 extern(C) void function(GApplication* application, GDBusConnection* connection, const(char)* objectPath) dbusUnregister; 3381 /** */ 3382 extern(C) int function(GApplication* application, GVariantDict* options) handleLocalOptions; 3383 void*[8] padding; 3384 } 3385 3386 struct GApplicationCommandLine 3387 { 3388 GObject parentInstance; 3389 GApplicationCommandLinePrivate* priv; 3390 } 3391 3392 /** 3393 * The #GApplicationCommandLineClass-struct 3394 * contains private data only. 3395 * 3396 * Since: 2.28 3397 */ 3398 struct GApplicationCommandLineClass 3399 { 3400 GObjectClass parentClass; 3401 /** */ 3402 extern(C) void function(GApplicationCommandLine* cmdline, const(char)* message) printLiteral; 3403 /** */ 3404 extern(C) void function(GApplicationCommandLine* cmdline, const(char)* message) printerrLiteral; 3405 /** 3406 * 3407 * Params: 3408 * cmdline = a #GApplicationCommandLine 3409 * Return: a #GInputStream for stdin 3410 */ 3411 extern(C) GInputStream* function(GApplicationCommandLine* cmdline) getStdin; 3412 void*[11] padding; 3413 } 3414 3415 struct GApplicationCommandLinePrivate; 3416 3417 struct GApplicationPrivate; 3418 3419 struct GAsyncInitable; 3420 3421 /** 3422 * Provides an interface for asynchronous initializing object such that 3423 * initialization may fail. 3424 * 3425 * Since: 2.22 3426 */ 3427 struct GAsyncInitableIface 3428 { 3429 /** 3430 * The parent interface. 3431 */ 3432 GTypeInterface gIface; 3433 /** */ 3434 extern(C) void function(GAsyncInitable* initable, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) initAsync; 3435 /** 3436 * 3437 * Params: 3438 * initable = a #GAsyncInitable. 3439 * res = a #GAsyncResult. 3440 * Return: %TRUE if successful. If an error has occurred, this function 3441 * will return %FALSE and set @error appropriately if present. 3442 * 3443 * Throws: GException on failure. 3444 */ 3445 extern(C) int function(GAsyncInitable* initable, GAsyncResult* res, GError** err) initFinish; 3446 } 3447 3448 struct GAsyncResult; 3449 3450 /** 3451 * Interface definition for #GAsyncResult. 3452 */ 3453 struct GAsyncResultIface 3454 { 3455 /** 3456 * The parent interface. 3457 */ 3458 GTypeInterface gIface; 3459 /** 3460 * 3461 * Params: 3462 * res = a #GAsyncResult. 3463 * Return: the user data for @res. 3464 */ 3465 extern(C) void* function(GAsyncResult* res) getUserData; 3466 /** 3467 * 3468 * Params: 3469 * res = a #GAsyncResult 3470 * Return: a new reference to the source object for the @res, 3471 * or %NULL if there is none. 3472 */ 3473 extern(C) GObject* function(GAsyncResult* res) getSourceObject; 3474 /** 3475 * 3476 * Params: 3477 * res = a #GAsyncResult 3478 * sourceTag = an application-defined tag 3479 * Return: %TRUE if @res has the indicated @source_tag, %FALSE if 3480 * not. 3481 */ 3482 extern(C) int function(GAsyncResult* res, void* sourceTag) isTagged; 3483 } 3484 3485 struct GBufferedInputStream 3486 { 3487 GFilterInputStream parentInstance; 3488 GBufferedInputStreamPrivate* priv; 3489 } 3490 3491 struct GBufferedInputStreamClass 3492 { 3493 GFilterInputStreamClass parentClass; 3494 /** 3495 * 3496 * Params: 3497 * stream = a #GBufferedInputStream 3498 * count = the number of bytes that will be read from the stream 3499 * cancellable = optional #GCancellable object, %NULL to ignore 3500 * Return: the number of bytes read into @stream's buffer, up to @count, 3501 * or -1 on error. 3502 * 3503 * Throws: GException on failure. 3504 */ 3505 extern(C) ptrdiff_t function(GBufferedInputStream* stream, ptrdiff_t count, GCancellable* cancellable, GError** err) fill; 3506 /** */ 3507 extern(C) void function(GBufferedInputStream* stream, ptrdiff_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) fillAsync; 3508 /** 3509 * 3510 * Params: 3511 * stream = a #GBufferedInputStream 3512 * result = a #GAsyncResult 3513 * Return: a #gssize of the read stream, or %-1 on an error. 3514 * 3515 * Throws: GException on failure. 3516 */ 3517 extern(C) ptrdiff_t function(GBufferedInputStream* stream, GAsyncResult* result, GError** err) fillFinish; 3518 /** */ 3519 extern(C) void function() GReserved1; 3520 /** */ 3521 extern(C) void function() GReserved2; 3522 /** */ 3523 extern(C) void function() GReserved3; 3524 /** */ 3525 extern(C) void function() GReserved4; 3526 /** */ 3527 extern(C) void function() GReserved5; 3528 } 3529 3530 struct GBufferedInputStreamPrivate; 3531 3532 struct GBufferedOutputStream 3533 { 3534 GFilterOutputStream parentInstance; 3535 GBufferedOutputStreamPrivate* priv; 3536 } 3537 3538 struct GBufferedOutputStreamClass 3539 { 3540 GFilterOutputStreamClass parentClass; 3541 /** */ 3542 extern(C) void function() GReserved1; 3543 /** */ 3544 extern(C) void function() GReserved2; 3545 } 3546 3547 struct GBufferedOutputStreamPrivate; 3548 3549 struct GBytesIcon; 3550 3551 struct GCancellable 3552 { 3553 GObject parentInstance; 3554 GCancellablePrivate* priv; 3555 } 3556 3557 struct GCancellableClass 3558 { 3559 GObjectClass parentClass; 3560 /** */ 3561 extern(C) void function(GCancellable* cancellable) cancelled; 3562 /** */ 3563 extern(C) void function() GReserved1; 3564 /** */ 3565 extern(C) void function() GReserved2; 3566 /** */ 3567 extern(C) void function() GReserved3; 3568 /** */ 3569 extern(C) void function() GReserved4; 3570 /** */ 3571 extern(C) void function() GReserved5; 3572 } 3573 3574 struct GCancellablePrivate; 3575 3576 struct GCharsetConverter; 3577 3578 struct GCharsetConverterClass 3579 { 3580 GObjectClass parentClass; 3581 } 3582 3583 struct GConverter; 3584 3585 /** 3586 * Provides an interface for converting data from one type 3587 * to another type. The conversion can be stateful 3588 * and may fail at any place. 3589 * 3590 * Since: 2.24 3591 */ 3592 struct GConverterIface 3593 { 3594 /** 3595 * The parent interface. 3596 */ 3597 GTypeInterface gIface; 3598 /** 3599 * 3600 * Params: 3601 * converter = a #GConverter. 3602 * inbuf = the buffer 3603 * containing the data to convert. 3604 * inbufSize = the number of bytes in @inbuf 3605 * outbuf = a buffer to write converted data in. 3606 * outbufSize = the number of bytes in @outbuf, must be at least one 3607 * flags = a #GConverterFlags controlling the conversion details 3608 * bytesRead = will be set to the number of bytes read from @inbuf on success 3609 * bytesWritten = will be set to the number of bytes written to @outbuf on success 3610 * Return: a #GConverterResult, %G_CONVERTER_ERROR on error. 3611 * 3612 * Throws: GException on failure. 3613 */ 3614 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; 3615 /** */ 3616 extern(C) void function(GConverter* converter) reset; 3617 } 3618 3619 struct GConverterInputStream 3620 { 3621 GFilterInputStream parentInstance; 3622 GConverterInputStreamPrivate* priv; 3623 } 3624 3625 struct GConverterInputStreamClass 3626 { 3627 GFilterInputStreamClass parentClass; 3628 /** */ 3629 extern(C) void function() GReserved1; 3630 /** */ 3631 extern(C) void function() GReserved2; 3632 /** */ 3633 extern(C) void function() GReserved3; 3634 /** */ 3635 extern(C) void function() GReserved4; 3636 /** */ 3637 extern(C) void function() GReserved5; 3638 } 3639 3640 struct GConverterInputStreamPrivate; 3641 3642 struct GConverterOutputStream 3643 { 3644 GFilterOutputStream parentInstance; 3645 GConverterOutputStreamPrivate* priv; 3646 } 3647 3648 struct GConverterOutputStreamClass 3649 { 3650 GFilterOutputStreamClass parentClass; 3651 /** */ 3652 extern(C) void function() GReserved1; 3653 /** */ 3654 extern(C) void function() GReserved2; 3655 /** */ 3656 extern(C) void function() GReserved3; 3657 /** */ 3658 extern(C) void function() GReserved4; 3659 /** */ 3660 extern(C) void function() GReserved5; 3661 } 3662 3663 struct GConverterOutputStreamPrivate; 3664 3665 struct GCredentials; 3666 3667 /** 3668 * Class structure for #GCredentials. 3669 * 3670 * Since: 2.26 3671 */ 3672 struct GCredentialsClass; 3673 3674 struct GDBusActionGroup; 3675 3676 struct GDBusAnnotationInfo 3677 { 3678 /** 3679 * The reference count or -1 if statically allocated. 3680 */ 3681 int refCount; 3682 /** 3683 * The name of the annotation, e.g. "org.freedesktop.DBus.Deprecated". 3684 */ 3685 char* key; 3686 /** 3687 * The value of the annotation. 3688 */ 3689 char* value; 3690 /** 3691 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3692 */ 3693 GDBusAnnotationInfo** annotations; 3694 } 3695 3696 struct GDBusArgInfo 3697 { 3698 /** 3699 * The reference count or -1 if statically allocated. 3700 */ 3701 int refCount; 3702 /** 3703 * Name of the argument, e.g. @unix_user_id. 3704 */ 3705 char* name; 3706 /** 3707 * D-Bus signature of the argument (a single complete type). 3708 */ 3709 char* signature; 3710 /** 3711 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3712 */ 3713 GDBusAnnotationInfo** annotations; 3714 } 3715 3716 struct GDBusAuthObserver; 3717 3718 struct GDBusConnection; 3719 3720 /** 3721 * Struct used in g_dbus_error_register_error_domain(). 3722 * 3723 * Since: 2.26 3724 */ 3725 struct GDBusErrorEntry 3726 { 3727 /** 3728 * An error code. 3729 */ 3730 int errorCode; 3731 /** 3732 * The D-Bus error name to associate with @error_code. 3733 */ 3734 const(char)* dbusErrorName; 3735 } 3736 3737 struct GDBusInterface; 3738 3739 /** 3740 * Base type for D-Bus interfaces. 3741 * 3742 * Since: 2.30 3743 */ 3744 struct GDBusInterfaceIface 3745 { 3746 /** 3747 * The parent interface. 3748 */ 3749 GTypeInterface parentIface; 3750 /** 3751 * 3752 * Params: 3753 * iface = An exported D-Bus interface. 3754 * Return: A #GDBusInterfaceInfo. Do not free. 3755 */ 3756 extern(C) GDBusInterfaceInfo* function(GDBusInterface* iface) getInfo; 3757 /** 3758 * 3759 * Params: 3760 * iface = An exported D-Bus interface 3761 * Return: A #GDBusObject or %NULL. The returned 3762 * reference belongs to @interface_ and should not be freed. 3763 */ 3764 extern(C) GDBusObject* function(GDBusInterface* iface) getObject; 3765 /** */ 3766 extern(C) void function(GDBusInterface* iface, GDBusObject* object) setObject; 3767 /** 3768 * 3769 * Params: 3770 * iface = An exported D-Bus interface. 3771 * Return: A #GDBusObject or %NULL. The returned 3772 * reference should be freed with g_object_unref(). 3773 */ 3774 extern(C) GDBusObject* function(GDBusInterface* iface) dupObject; 3775 } 3776 3777 struct GDBusInterfaceInfo 3778 { 3779 /** 3780 * The reference count or -1 if statically allocated. 3781 */ 3782 int refCount; 3783 /** 3784 * The name of the D-Bus interface, e.g. "org.freedesktop.DBus.Properties". 3785 */ 3786 char* name; 3787 /** 3788 * A pointer to a %NULL-terminated array of pointers to #GDBusMethodInfo structures or %NULL if there are no methods. 3789 */ 3790 GDBusMethodInfo** methods; 3791 /** 3792 * A pointer to a %NULL-terminated array of pointers to #GDBusSignalInfo structures or %NULL if there are no signals. 3793 */ 3794 GDBusSignalInfo** signals; 3795 /** 3796 * A pointer to a %NULL-terminated array of pointers to #GDBusPropertyInfo structures or %NULL if there are no properties. 3797 */ 3798 GDBusPropertyInfo** properties; 3799 /** 3800 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3801 */ 3802 GDBusAnnotationInfo** annotations; 3803 } 3804 3805 struct GDBusInterfaceSkeleton 3806 { 3807 GObject parentInstance; 3808 GDBusInterfaceSkeletonPrivate* priv; 3809 } 3810 3811 /** 3812 * Class structure for #GDBusInterfaceSkeleton. 3813 * 3814 * Since: 2.30 3815 */ 3816 struct GDBusInterfaceSkeletonClass 3817 { 3818 /** 3819 * The parent class. 3820 */ 3821 GObjectClass parentClass; 3822 /** 3823 * 3824 * Params: 3825 * iface = A #GDBusInterfaceSkeleton. 3826 * Return: A #GDBusInterfaceInfo (never %NULL). Do not free. 3827 */ 3828 extern(C) GDBusInterfaceInfo* function(GDBusInterfaceSkeleton* iface) getInfo; 3829 /** 3830 * 3831 * Params: 3832 * iface = A #GDBusInterfaceSkeleton. 3833 * Return: A #GDBusInterfaceVTable (never %NULL). 3834 */ 3835 extern(C) GDBusInterfaceVTable* function(GDBusInterfaceSkeleton* iface) getVtable; 3836 /** 3837 * 3838 * Params: 3839 * iface = A #GDBusInterfaceSkeleton. 3840 * Return: A #GVariant of type 3841 * ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS]. 3842 * Free with g_variant_unref(). 3843 */ 3844 extern(C) GVariant* function(GDBusInterfaceSkeleton* iface) getProperties; 3845 /** */ 3846 extern(C) void function(GDBusInterfaceSkeleton* iface) flush; 3847 void*[8] vfuncPadding; 3848 /** */ 3849 extern(C) int function(GDBusInterfaceSkeleton* iface, GDBusMethodInvocation* invocation) gAuthorizeMethod; 3850 void*[8] signalPadding; 3851 } 3852 3853 struct GDBusInterfaceSkeletonPrivate; 3854 3855 /** 3856 * Virtual table for handling properties and method calls for a D-Bus 3857 * interface. 3858 * 3859 * Since 2.38, if you want to handle getting/setting D-Bus properties 3860 * asynchronously, give %NULL as your get_property() or set_property() 3861 * function. The D-Bus call will be directed to your @method_call function, 3862 * with the provided @interface_name set to "org.freedesktop.DBus.Properties". 3863 * 3864 * Ownership of the #GDBusMethodInvocation object passed to the 3865 * method_call() function is transferred to your handler; you must 3866 * call one of the methods of #GDBusMethodInvocation to return a reply 3867 * (possibly empty), or an error. These functions also take ownership 3868 * of the passed-in invocation object, so unless the invocation 3869 * object has otherwise been referenced, it will be then be freed. 3870 * Calling one of these functions may be done within your 3871 * method_call() implementation but it also can be done at a later 3872 * point to handle the method asynchronously. 3873 * 3874 * The usual checks on the validity of the calls is performed. For 3875 * `Get` calls, an error is automatically returned if the property does 3876 * not exist or the permissions do not allow access. The same checks are 3877 * performed for `Set` calls, and the provided value is also checked for 3878 * being the correct type. 3879 * 3880 * For both `Get` and `Set` calls, the #GDBusMethodInvocation 3881 * passed to the @method_call handler can be queried with 3882 * g_dbus_method_invocation_get_property_info() to get a pointer 3883 * to the #GDBusPropertyInfo of the property. 3884 * 3885 * If you have readable properties specified in your interface info, 3886 * you must ensure that you either provide a non-%NULL @get_property() 3887 * function or provide implementations of both the `Get` and `GetAll` 3888 * methods on org.freedesktop.DBus.Properties interface in your @method_call 3889 * function. Note that the required return type of the `Get` call is 3890 * `(v)`, not the type of the property. `GetAll` expects a return value 3891 * of type `a{sv}`. 3892 * 3893 * If you have writable properties specified in your interface info, 3894 * you must ensure that you either provide a non-%NULL @set_property() 3895 * function or provide an implementation of the `Set` call. If implementing 3896 * the call, you must return the value of type %G_VARIANT_TYPE_UNIT. 3897 * 3898 * Since: 2.26 3899 */ 3900 struct GDBusInterfaceVTable 3901 { 3902 /** 3903 * Function for handling incoming method calls. 3904 */ 3905 GDBusInterfaceMethodCallFunc methodCall; 3906 /** 3907 * Function for getting a property. 3908 */ 3909 GDBusInterfaceGetPropertyFunc getProperty; 3910 /** 3911 * Function for setting a property. 3912 */ 3913 GDBusInterfaceSetPropertyFunc setProperty; 3914 void*[8] padding; 3915 } 3916 3917 struct GDBusMenuModel; 3918 3919 struct GDBusMessage; 3920 3921 struct GDBusMethodInfo 3922 { 3923 /** 3924 * The reference count or -1 if statically allocated. 3925 */ 3926 int refCount; 3927 /** 3928 * The name of the D-Bus method, e.g. @RequestName. 3929 */ 3930 char* name; 3931 /** 3932 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no in arguments. 3933 */ 3934 GDBusArgInfo** inArgs; 3935 /** 3936 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no out arguments. 3937 */ 3938 GDBusArgInfo** outArgs; 3939 /** 3940 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3941 */ 3942 GDBusAnnotationInfo** annotations; 3943 } 3944 3945 struct GDBusMethodInvocation; 3946 3947 struct GDBusNodeInfo 3948 { 3949 /** 3950 * The reference count or -1 if statically allocated. 3951 */ 3952 int refCount; 3953 /** 3954 * 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. 3955 */ 3956 char* path; 3957 /** 3958 * A pointer to a %NULL-terminated array of pointers to #GDBusInterfaceInfo structures or %NULL if there are no interfaces. 3959 */ 3960 GDBusInterfaceInfo** interfaces; 3961 /** 3962 * A pointer to a %NULL-terminated array of pointers to #GDBusNodeInfo structures or %NULL if there are no nodes. 3963 */ 3964 GDBusNodeInfo** nodes; 3965 /** 3966 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 3967 */ 3968 GDBusAnnotationInfo** annotations; 3969 } 3970 3971 struct GDBusObject; 3972 3973 /** 3974 * Base object type for D-Bus objects. 3975 * 3976 * Since: 2.30 3977 */ 3978 struct GDBusObjectIface 3979 { 3980 /** 3981 * The parent interface. 3982 */ 3983 GTypeInterface parentIface; 3984 /** 3985 * 3986 * Params: 3987 * object = A #GDBusObject. 3988 * Return: A string owned by @object. Do not free. 3989 */ 3990 extern(C) const(char)* function(GDBusObject* object) getObjectPath; 3991 /** 3992 * 3993 * Params: 3994 * object = A #GDBusObject. 3995 * Return: A list of #GDBusInterface instances. 3996 * The returned list must be freed by g_list_free() after each element has been freed 3997 * with g_object_unref(). 3998 */ 3999 extern(C) GList* function(GDBusObject* object) getInterfaces; 4000 /** 4001 * 4002 * Params: 4003 * object = A #GDBusObject. 4004 * interfaceName = A D-Bus interface name. 4005 * Return: %NULL if not found, otherwise a 4006 * #GDBusInterface that must be freed with g_object_unref(). 4007 */ 4008 extern(C) GDBusInterface* function(GDBusObject* object, const(char)* interfaceName) getInterface; 4009 /** */ 4010 extern(C) void function(GDBusObject* object, GDBusInterface* iface) interfaceAdded; 4011 /** */ 4012 extern(C) void function(GDBusObject* object, GDBusInterface* iface) interfaceRemoved; 4013 } 4014 4015 struct GDBusObjectManager; 4016 4017 struct GDBusObjectManagerClient 4018 { 4019 GObject parentInstance; 4020 GDBusObjectManagerClientPrivate* priv; 4021 } 4022 4023 /** 4024 * Class structure for #GDBusObjectManagerClient. 4025 * 4026 * Since: 2.30 4027 */ 4028 struct GDBusObjectManagerClientClass 4029 { 4030 /** 4031 * The parent class. 4032 */ 4033 GObjectClass parentClass; 4034 /** */ 4035 extern(C) void function(GDBusObjectManagerClient* manager, GDBusObjectProxy* objectProxy, GDBusProxy* interfaceProxy, const(char)* senderName, const(char)* signalName, GVariant* parameters) interfaceProxySignal; 4036 /** */ 4037 extern(C) void function(GDBusObjectManagerClient* manager, GDBusObjectProxy* objectProxy, GDBusProxy* interfaceProxy, GVariant* changedProperties, const(char)* invalidatedProperties) interfaceProxyPropertiesChanged; 4038 void*[8] padding; 4039 } 4040 4041 struct GDBusObjectManagerClientPrivate; 4042 4043 /** 4044 * Base type for D-Bus object managers. 4045 * 4046 * Since: 2.30 4047 */ 4048 struct GDBusObjectManagerIface 4049 { 4050 /** 4051 * The parent interface. 4052 */ 4053 GTypeInterface parentIface; 4054 /** 4055 * 4056 * Params: 4057 * manager = A #GDBusObjectManager. 4058 * Return: A string owned by @manager. Do not free. 4059 */ 4060 extern(C) const(char)* function(GDBusObjectManager* manager) getObjectPath; 4061 /** 4062 * 4063 * Params: 4064 * manager = A #GDBusObjectManager. 4065 * Return: A list of 4066 * #GDBusObject objects. The returned list should be freed with 4067 * g_list_free() after each element has been freed with 4068 * g_object_unref(). 4069 */ 4070 extern(C) GList* function(GDBusObjectManager* manager) getObjects; 4071 /** 4072 * 4073 * Params: 4074 * manager = A #GDBusObjectManager. 4075 * objectPath = Object path to lookup. 4076 * Return: A #GDBusObject or %NULL. Free with 4077 * g_object_unref(). 4078 */ 4079 extern(C) GDBusObject* function(GDBusObjectManager* manager, const(char)* objectPath) getObject; 4080 /** 4081 * 4082 * Params: 4083 * manager = A #GDBusObjectManager. 4084 * objectPath = Object path to lookup. 4085 * interfaceName = D-Bus interface name to lookup. 4086 * Return: A #GDBusInterface instance or %NULL. Free 4087 * with g_object_unref(). 4088 */ 4089 extern(C) GDBusInterface* function(GDBusObjectManager* manager, const(char)* objectPath, const(char)* interfaceName) getInterface; 4090 /** */ 4091 extern(C) void function(GDBusObjectManager* manager, GDBusObject* object) objectAdded; 4092 /** */ 4093 extern(C) void function(GDBusObjectManager* manager, GDBusObject* object) objectRemoved; 4094 /** */ 4095 extern(C) void function(GDBusObjectManager* manager, GDBusObject* object, GDBusInterface* iface) interfaceAdded; 4096 /** */ 4097 extern(C) void function(GDBusObjectManager* manager, GDBusObject* object, GDBusInterface* iface) interfaceRemoved; 4098 } 4099 4100 struct GDBusObjectManagerServer 4101 { 4102 GObject parentInstance; 4103 GDBusObjectManagerServerPrivate* priv; 4104 } 4105 4106 /** 4107 * Class structure for #GDBusObjectManagerServer. 4108 * 4109 * Since: 2.30 4110 */ 4111 struct GDBusObjectManagerServerClass 4112 { 4113 /** 4114 * The parent class. 4115 */ 4116 GObjectClass parentClass; 4117 void*[8] padding; 4118 } 4119 4120 struct GDBusObjectManagerServerPrivate; 4121 4122 struct GDBusObjectProxy 4123 { 4124 GObject parentInstance; 4125 GDBusObjectProxyPrivate* priv; 4126 } 4127 4128 /** 4129 * Class structure for #GDBusObjectProxy. 4130 * 4131 * Since: 2.30 4132 */ 4133 struct GDBusObjectProxyClass 4134 { 4135 /** 4136 * The parent class. 4137 */ 4138 GObjectClass parentClass; 4139 void*[8] padding; 4140 } 4141 4142 struct GDBusObjectProxyPrivate; 4143 4144 struct GDBusObjectSkeleton 4145 { 4146 GObject parentInstance; 4147 GDBusObjectSkeletonPrivate* priv; 4148 } 4149 4150 /** 4151 * Class structure for #GDBusObjectSkeleton. 4152 * 4153 * Since: 2.30 4154 */ 4155 struct GDBusObjectSkeletonClass 4156 { 4157 /** 4158 * The parent class. 4159 */ 4160 GObjectClass parentClass; 4161 /** */ 4162 extern(C) int function(GDBusObjectSkeleton* object, GDBusInterfaceSkeleton* iface, GDBusMethodInvocation* invocation) authorizeMethod; 4163 void*[8] padding; 4164 } 4165 4166 struct GDBusObjectSkeletonPrivate; 4167 4168 struct GDBusPropertyInfo 4169 { 4170 /** 4171 * The reference count or -1 if statically allocated. 4172 */ 4173 int refCount; 4174 /** 4175 * The name of the D-Bus property, e.g. "SupportedFilesystems". 4176 */ 4177 char* name; 4178 /** 4179 * The D-Bus signature of the property (a single complete type). 4180 */ 4181 char* signature; 4182 /** 4183 * Access control flags for the property. 4184 */ 4185 GDBusPropertyInfoFlags flags; 4186 /** 4187 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 4188 */ 4189 GDBusAnnotationInfo** annotations; 4190 } 4191 4192 struct GDBusProxy 4193 { 4194 GObject parentInstance; 4195 GDBusProxyPrivate* priv; 4196 } 4197 4198 /** 4199 * Class structure for #GDBusProxy. 4200 * 4201 * Since: 2.26 4202 */ 4203 struct GDBusProxyClass 4204 { 4205 GObjectClass parentClass; 4206 /** */ 4207 extern(C) void function(GDBusProxy* proxy, GVariant* changedProperties, const(char)* invalidatedProperties) gPropertiesChanged; 4208 /** */ 4209 extern(C) void function(GDBusProxy* proxy, const(char)* senderName, const(char)* signalName, GVariant* parameters) gSignal; 4210 void*[32] padding; 4211 } 4212 4213 struct GDBusProxyPrivate; 4214 4215 struct GDBusServer; 4216 4217 struct GDBusSignalInfo 4218 { 4219 /** 4220 * The reference count or -1 if statically allocated. 4221 */ 4222 int refCount; 4223 /** 4224 * The name of the D-Bus signal, e.g. "NameOwnerChanged". 4225 */ 4226 char* name; 4227 /** 4228 * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no arguments. 4229 */ 4230 GDBusArgInfo** args; 4231 /** 4232 * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations. 4233 */ 4234 GDBusAnnotationInfo** annotations; 4235 } 4236 4237 /** 4238 * Virtual table for handling subtrees registered with g_dbus_connection_register_subtree(). 4239 * 4240 * Since: 2.26 4241 */ 4242 struct GDBusSubtreeVTable 4243 { 4244 /** 4245 * Function for enumerating child nodes. 4246 */ 4247 GDBusSubtreeEnumerateFunc enumerate; 4248 /** 4249 * Function for introspecting a child node. 4250 */ 4251 GDBusSubtreeIntrospectFunc introspect; 4252 /** 4253 * Function for dispatching a remote call on a child node. 4254 */ 4255 GDBusSubtreeDispatchFunc dispatch; 4256 void*[8] padding; 4257 } 4258 4259 struct GDataInputStream 4260 { 4261 GBufferedInputStream parentInstance; 4262 GDataInputStreamPrivate* priv; 4263 } 4264 4265 struct GDataInputStreamClass 4266 { 4267 GBufferedInputStreamClass parentClass; 4268 /** */ 4269 extern(C) void function() GReserved1; 4270 /** */ 4271 extern(C) void function() GReserved2; 4272 /** */ 4273 extern(C) void function() GReserved3; 4274 /** */ 4275 extern(C) void function() GReserved4; 4276 /** */ 4277 extern(C) void function() GReserved5; 4278 } 4279 4280 struct GDataInputStreamPrivate; 4281 4282 struct GDataOutputStream 4283 { 4284 GFilterOutputStream parentInstance; 4285 GDataOutputStreamPrivate* priv; 4286 } 4287 4288 struct GDataOutputStreamClass 4289 { 4290 GFilterOutputStreamClass parentClass; 4291 /** */ 4292 extern(C) void function() GReserved1; 4293 /** */ 4294 extern(C) void function() GReserved2; 4295 /** */ 4296 extern(C) void function() GReserved3; 4297 /** */ 4298 extern(C) void function() GReserved4; 4299 /** */ 4300 extern(C) void function() GReserved5; 4301 } 4302 4303 struct GDataOutputStreamPrivate; 4304 4305 struct GDesktopAppInfo; 4306 4307 struct GDesktopAppInfoClass 4308 { 4309 GObjectClass parentClass; 4310 } 4311 4312 struct GDesktopAppInfoLookup; 4313 4314 /** 4315 * Interface that is used by backends to associate default 4316 * handlers with URI schemes. 4317 */ 4318 struct GDesktopAppInfoLookupIface 4319 { 4320 GTypeInterface gIface; 4321 /** 4322 * 4323 * Params: 4324 * lookup = a #GDesktopAppInfoLookup 4325 * uriScheme = a string containing a URI scheme. 4326 * Return: #GAppInfo for given @uri_scheme or %NULL on error. 4327 */ 4328 extern(C) GAppInfo* function(GDesktopAppInfoLookup* lookup, const(char)* uriScheme) getDefaultForUriScheme; 4329 } 4330 4331 struct GDrive; 4332 4333 /** 4334 * Interface for creating #GDrive implementations. 4335 */ 4336 struct GDriveIface 4337 { 4338 /** 4339 * The parent interface. 4340 */ 4341 GTypeInterface gIface; 4342 /** */ 4343 extern(C) void function(GDrive* drive) changed; 4344 /** */ 4345 extern(C) void function(GDrive* drive) disconnected; 4346 /** */ 4347 extern(C) void function(GDrive* drive) ejectButton; 4348 /** 4349 * 4350 * Params: 4351 * drive = a #GDrive. 4352 * Return: a string containing @drive's name. The returned 4353 * string should be freed when no longer needed. 4354 */ 4355 extern(C) char* function(GDrive* drive) getName; 4356 /** 4357 * 4358 * Params: 4359 * drive = a #GDrive. 4360 * Return: #GIcon for the @drive. 4361 * Free the returned object with g_object_unref(). 4362 */ 4363 extern(C) GIcon* function(GDrive* drive) getIcon; 4364 /** 4365 * 4366 * Params: 4367 * drive = a #GDrive. 4368 * Return: %TRUE if the @drive contains volumes, %FALSE otherwise. 4369 */ 4370 extern(C) int function(GDrive* drive) hasVolumes; 4371 /** 4372 * 4373 * Params: 4374 * drive = a #GDrive. 4375 * Return: #GList containing any #GVolume objects on the given @drive. 4376 */ 4377 extern(C) GList* function(GDrive* drive) getVolumes; 4378 /** 4379 * 4380 * Params: 4381 * drive = a #GDrive. 4382 * Return: %TRUE if @drive supports removable media, %FALSE otherwise. 4383 */ 4384 extern(C) int function(GDrive* drive) isMediaRemovable; 4385 /** 4386 * 4387 * Params: 4388 * drive = a #GDrive. 4389 * Return: %TRUE if @drive has media, %FALSE otherwise. 4390 */ 4391 extern(C) int function(GDrive* drive) hasMedia; 4392 /** 4393 * 4394 * Params: 4395 * drive = a #GDrive. 4396 * Return: %TRUE if the @drive is capabable of automatically detecting 4397 * media changes, %FALSE otherwise. 4398 */ 4399 extern(C) int function(GDrive* drive) isMediaCheckAutomatic; 4400 /** 4401 * 4402 * Params: 4403 * drive = a #GDrive. 4404 * Return: %TRUE if the @drive can be ejected, %FALSE otherwise. 4405 */ 4406 extern(C) int function(GDrive* drive) canEject; 4407 /** 4408 * 4409 * Params: 4410 * drive = a #GDrive. 4411 * Return: %TRUE if the @drive can be polled for media changes, 4412 * %FALSE otherwise. 4413 */ 4414 extern(C) int function(GDrive* drive) canPollForMedia; 4415 /** */ 4416 extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject; 4417 /** 4418 * 4419 * Params: 4420 * drive = a #GDrive. 4421 * result = a #GAsyncResult. 4422 * Return: %TRUE if the drive has been ejected successfully, 4423 * %FALSE otherwise. 4424 * 4425 * Throws: GException on failure. 4426 */ 4427 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) ejectFinish; 4428 /** */ 4429 extern(C) void function(GDrive* drive, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) pollForMedia; 4430 /** 4431 * 4432 * Params: 4433 * drive = a #GDrive. 4434 * result = a #GAsyncResult. 4435 * Return: %TRUE if the drive has been poll_for_mediaed successfully, 4436 * %FALSE otherwise. 4437 * 4438 * Throws: GException on failure. 4439 */ 4440 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) pollForMediaFinish; 4441 /** 4442 * 4443 * Params: 4444 * drive = a #GDrive 4445 * kind = the kind of identifier to return 4446 * Return: a newly allocated string containing the 4447 * requested identfier, or %NULL if the #GDrive 4448 * doesn't have this kind of identifier. 4449 */ 4450 extern(C) char* function(GDrive* drive, const(char)* kind) getIdentifier; 4451 /** 4452 * 4453 * Params: 4454 * drive = a #GDrive 4455 * Return: a %NULL-terminated 4456 * array of strings containing kinds of identifiers. Use g_strfreev() 4457 * to free. 4458 */ 4459 extern(C) char** function(GDrive* drive) enumerateIdentifiers; 4460 /** 4461 * 4462 * Params: 4463 * drive = a #GDrive. 4464 * Return: A value from the #GDriveStartStopType enumeration. 4465 */ 4466 extern(C) GDriveStartStopType function(GDrive* drive) getStartStopType; 4467 /** 4468 * 4469 * Params: 4470 * drive = a #GDrive. 4471 * Return: %TRUE if the @drive can be started, %FALSE otherwise. 4472 */ 4473 extern(C) int function(GDrive* drive) canStart; 4474 /** 4475 * 4476 * Params: 4477 * drive = a #GDrive. 4478 * Return: %TRUE if the @drive can be started degraded, %FALSE otherwise. 4479 */ 4480 extern(C) int function(GDrive* drive) canStartDegraded; 4481 /** */ 4482 extern(C) void function(GDrive* drive, GDriveStartFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) start; 4483 /** 4484 * 4485 * Params: 4486 * drive = a #GDrive. 4487 * result = a #GAsyncResult. 4488 * Return: %TRUE if the drive has been started successfully, 4489 * %FALSE otherwise. 4490 * 4491 * Throws: GException on failure. 4492 */ 4493 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) startFinish; 4494 /** 4495 * 4496 * Params: 4497 * drive = a #GDrive. 4498 * Return: %TRUE if the @drive can be stopped, %FALSE otherwise. 4499 */ 4500 extern(C) int function(GDrive* drive) canStop; 4501 /** */ 4502 extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) stop; 4503 /** 4504 * 4505 * Params: 4506 * drive = a #GDrive. 4507 * result = a #GAsyncResult. 4508 * Return: %TRUE if the drive has been stopped successfully, 4509 * %FALSE otherwise. 4510 * 4511 * Throws: GException on failure. 4512 */ 4513 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) stopFinish; 4514 /** */ 4515 extern(C) void function(GDrive* drive) stopButton; 4516 /** */ 4517 extern(C) void function(GDrive* drive, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation; 4518 /** 4519 * 4520 * Params: 4521 * drive = a #GDrive. 4522 * result = a #GAsyncResult. 4523 * Return: %TRUE if the drive was successfully ejected. %FALSE otherwise. 4524 * 4525 * Throws: GException on failure. 4526 */ 4527 extern(C) int function(GDrive* drive, GAsyncResult* result, GError** err) ejectWithOperationFinish; 4528 /** 4529 * 4530 * Params: 4531 * drive = A #GDrive. 4532 * Return: Sorting key for @drive or %NULL if no such key is available. 4533 */ 4534 extern(C) const(char)* function(GDrive* drive) getSortKey; 4535 /** 4536 * 4537 * Params: 4538 * drive = a #GDrive. 4539 * Return: symbolic #GIcon for the @drive. 4540 * Free the returned object with g_object_unref(). 4541 */ 4542 extern(C) GIcon* function(GDrive* drive) getSymbolicIcon; 4543 } 4544 4545 struct GEmblem; 4546 4547 struct GEmblemClass; 4548 4549 struct GEmblemedIcon 4550 { 4551 GObject parentInstance; 4552 GEmblemedIconPrivate* priv; 4553 } 4554 4555 struct GEmblemedIconClass 4556 { 4557 GObjectClass parentClass; 4558 } 4559 4560 struct GEmblemedIconPrivate; 4561 4562 struct GFile; 4563 4564 /** 4565 * Information about a specific attribute. 4566 */ 4567 struct GFileAttributeInfo 4568 { 4569 /** 4570 * the name of the attribute. 4571 */ 4572 char* name; 4573 /** 4574 * the #GFileAttributeType type of the attribute. 4575 */ 4576 GFileAttributeType type; 4577 /** 4578 * a set of #GFileAttributeInfoFlags. 4579 */ 4580 GFileAttributeInfoFlags flags; 4581 } 4582 4583 struct GFileAttributeInfoList 4584 { 4585 /** 4586 * an array of #GFileAttributeInfos. 4587 */ 4588 GFileAttributeInfo* infos; 4589 /** 4590 * the number of values in the array. 4591 */ 4592 int nInfos; 4593 } 4594 4595 struct GFileAttributeMatcher; 4596 4597 struct GFileDescriptorBased; 4598 4599 /** 4600 * An interface for file descriptor based io objects. 4601 */ 4602 struct GFileDescriptorBasedIface 4603 { 4604 /** 4605 * The parent interface. 4606 */ 4607 GTypeInterface gIface; 4608 /** 4609 * 4610 * Params: 4611 * fdBased = a #GFileDescriptorBased. 4612 * Return: The file descriptor 4613 */ 4614 extern(C) int function(GFileDescriptorBased* fdBased) getFd; 4615 } 4616 4617 struct GFileEnumerator 4618 { 4619 GObject parentInstance; 4620 GFileEnumeratorPrivate* priv; 4621 } 4622 4623 struct GFileEnumeratorClass 4624 { 4625 GObjectClass parentClass; 4626 /** 4627 * 4628 * Params: 4629 * enumerator = a #GFileEnumerator. 4630 * cancellable = optional #GCancellable object, %NULL to ignore. 4631 * Return: A #GFileInfo or %NULL on error 4632 * or end of enumerator. Free the returned object with 4633 * g_object_unref() when no longer needed. 4634 * 4635 * Throws: GException on failure. 4636 */ 4637 extern(C) GFileInfo* function(GFileEnumerator* enumerator, GCancellable* cancellable, GError** err) nextFile; 4638 /** */ 4639 extern(C) int function(GFileEnumerator* enumerator, GCancellable* cancellable, GError** err) closeFn; 4640 /** */ 4641 extern(C) void function(GFileEnumerator* enumerator, int numFiles, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) nextFilesAsync; 4642 /** 4643 * 4644 * Params: 4645 * enumerator = a #GFileEnumerator. 4646 * result = a #GAsyncResult. 4647 * Return: a #GList of #GFileInfos. You must free the list with 4648 * g_list_free() and unref the infos with g_object_unref() when you're 4649 * done with them. 4650 * 4651 * Throws: GException on failure. 4652 */ 4653 extern(C) GList* function(GFileEnumerator* enumerator, GAsyncResult* result, GError** err) nextFilesFinish; 4654 /** */ 4655 extern(C) void function(GFileEnumerator* enumerator, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync; 4656 /** 4657 * 4658 * Params: 4659 * enumerator = a #GFileEnumerator. 4660 * result = a #GAsyncResult. 4661 * Return: %TRUE if the close operation has finished successfully. 4662 * 4663 * Throws: GException on failure. 4664 */ 4665 extern(C) int function(GFileEnumerator* enumerator, GAsyncResult* result, GError** err) closeFinish; 4666 /** */ 4667 extern(C) void function() GReserved1; 4668 /** */ 4669 extern(C) void function() GReserved2; 4670 /** */ 4671 extern(C) void function() GReserved3; 4672 /** */ 4673 extern(C) void function() GReserved4; 4674 /** */ 4675 extern(C) void function() GReserved5; 4676 /** */ 4677 extern(C) void function() GReserved6; 4678 /** */ 4679 extern(C) void function() GReserved7; 4680 } 4681 4682 struct GFileEnumeratorPrivate; 4683 4684 struct GFileIOStream 4685 { 4686 GIOStream parentInstance; 4687 GFileIOStreamPrivate* priv; 4688 } 4689 4690 struct GFileIOStreamClass 4691 { 4692 GIOStreamClass parentClass; 4693 /** */ 4694 extern(C) long function(GFileIOStream* stream) tell; 4695 /** */ 4696 extern(C) int function(GFileIOStream* stream) canSeek; 4697 /** */ 4698 extern(C) int function(GFileIOStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek; 4699 /** */ 4700 extern(C) int function(GFileIOStream* stream) canTruncate; 4701 /** */ 4702 extern(C) int function(GFileIOStream* stream, long size, GCancellable* cancellable, GError** err) truncateFn; 4703 /** 4704 * 4705 * Params: 4706 * stream = a #GFileIOStream. 4707 * attributes = a file attribute query string. 4708 * cancellable = optional #GCancellable object, %NULL to ignore. 4709 * Return: a #GFileInfo for the @stream, or %NULL on error. 4710 * 4711 * Throws: GException on failure. 4712 */ 4713 extern(C) GFileInfo* function(GFileIOStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo; 4714 /** */ 4715 extern(C) void function(GFileIOStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync; 4716 /** 4717 * 4718 * Params: 4719 * stream = a #GFileIOStream. 4720 * result = a #GAsyncResult. 4721 * Return: A #GFileInfo for the finished query. 4722 * 4723 * Throws: GException on failure. 4724 */ 4725 extern(C) GFileInfo* function(GFileIOStream* stream, GAsyncResult* result, GError** err) queryInfoFinish; 4726 /** 4727 * 4728 * Params: 4729 * stream = a #GFileIOStream. 4730 * Return: the entity tag for the stream. 4731 */ 4732 extern(C) char* function(GFileIOStream* stream) getEtag; 4733 /** */ 4734 extern(C) void function() GReserved1; 4735 /** */ 4736 extern(C) void function() GReserved2; 4737 /** */ 4738 extern(C) void function() GReserved3; 4739 /** */ 4740 extern(C) void function() GReserved4; 4741 /** */ 4742 extern(C) void function() GReserved5; 4743 } 4744 4745 struct GFileIOStreamPrivate; 4746 4747 struct GFileIcon; 4748 4749 struct GFileIconClass; 4750 4751 /** 4752 * An interface for writing VFS file handles. 4753 */ 4754 struct GFileIface 4755 { 4756 /** 4757 * The parent interface. 4758 */ 4759 GTypeInterface gIface; 4760 /** 4761 * 4762 * Params: 4763 * file = input #GFile 4764 * Return: a new #GFile that is a duplicate 4765 * of the given #GFile. 4766 */ 4767 extern(C) GFile* function(GFile* file) dup; 4768 /** 4769 * 4770 * Params: 4771 * file = #gconstpointer to a #GFile 4772 * Return: 0 if @file is not a valid #GFile, otherwise an 4773 * integer that can be used as hash value for the #GFile. 4774 * This function is intended for easily hashing a #GFile to 4775 * add to a #GHashTable or similar data structure. 4776 */ 4777 extern(C) uint function(GFile* file) hash; 4778 /** 4779 * 4780 * Params: 4781 * file1 = the first #GFile 4782 * file2 = the second #GFile 4783 * Return: %TRUE if @file1 and @file2 are equal. 4784 */ 4785 extern(C) int function(GFile* file1, GFile* file2) equal; 4786 /** 4787 * 4788 * Params: 4789 * file = input #GFile 4790 * Return: %TRUE if @file is native 4791 */ 4792 extern(C) int function(GFile* file) isNative; 4793 /** 4794 * 4795 * Params: 4796 * file = input #GFile 4797 * uriScheme = a string containing a URI scheme 4798 * Return: %TRUE if #GFile's backend supports the 4799 * given URI scheme, %FALSE if URI scheme is %NULL, 4800 * not supported, or #GFile is invalid. 4801 */ 4802 extern(C) int function(GFile* file, const(char)* uriScheme) hasUriScheme; 4803 /** 4804 * 4805 * Params: 4806 * file = input #GFile 4807 * Return: a string containing the URI scheme for the given 4808 * #GFile. The returned string should be freed with g_free() 4809 * when no longer needed. 4810 */ 4811 extern(C) char* function(GFile* file) getUriScheme; 4812 /** 4813 * 4814 * Params: 4815 * file = input #GFile 4816 * Return: string containing the #GFile's base name, or 4817 * %NULL if given #GFile is invalid. The returned string should be 4818 * freed with g_free() when no longer needed. 4819 */ 4820 extern(C) char* function(GFile* file) getBasename; 4821 /** 4822 * 4823 * Params: 4824 * file = input #GFile 4825 * Return: string containing the #GFile's path, or %NULL 4826 * if no such path exists. The returned string should be freed 4827 * with g_free() when no longer needed. 4828 */ 4829 extern(C) char* function(GFile* file) getPath; 4830 /** 4831 * 4832 * Params: 4833 * file = input #GFile 4834 * Return: a string containing the #GFile's URI. 4835 * The returned string should be freed with g_free() 4836 * when no longer needed. 4837 */ 4838 extern(C) char* function(GFile* file) getUri; 4839 /** 4840 * 4841 * Params: 4842 * file = input #GFile 4843 * Return: a string containing the #GFile's parse name. 4844 * The returned string should be freed with g_free() 4845 * when no longer needed. 4846 */ 4847 extern(C) char* function(GFile* file) getParseName; 4848 /** 4849 * 4850 * Params: 4851 * file = input #GFile 4852 * Return: a #GFile structure to the 4853 * parent of the given #GFile or %NULL if there is no parent. Free 4854 * the returned object with g_object_unref(). 4855 */ 4856 extern(C) GFile* function(GFile* file) getParent; 4857 /** 4858 * 4859 * Params: 4860 * prefix = input #GFile 4861 * file = input #GFile 4862 * Return: %TRUE if the @files's parent, grandparent, etc is @prefix, 4863 * %FALSE otherwise. 4864 */ 4865 extern(C) int function(GFile* prefix, GFile* file) prefixMatches; 4866 /** 4867 * 4868 * Params: 4869 * parent = input #GFile 4870 * descendant = input #GFile 4871 * Return: string with the relative path from @descendant 4872 * to @parent, or %NULL if @descendant doesn't have @parent as 4873 * prefix. The returned string should be freed with g_free() when 4874 * no longer needed. 4875 */ 4876 extern(C) char* function(GFile* parent, GFile* descendant) getRelativePath; 4877 /** 4878 * 4879 * Params: 4880 * file = input #GFile 4881 * relativePath = a given relative path string 4882 * Return: #GFile to the resolved path. 4883 * %NULL if @relative_path is %NULL or if @file is invalid. 4884 * Free the returned object with g_object_unref(). 4885 */ 4886 extern(C) GFile* function(GFile* file, const(char)* relativePath) resolveRelativePath; 4887 /** 4888 * 4889 * Params: 4890 * file = input #GFile 4891 * displayName = string to a possible child 4892 * Return: a #GFile to the specified child, or 4893 * %NULL if the display name couldn't be converted. 4894 * Free the returned object with g_object_unref(). 4895 * 4896 * Throws: GException on failure. 4897 */ 4898 extern(C) GFile* function(GFile* file, const(char)* displayName, GError** err) getChildForDisplayName; 4899 /** 4900 * 4901 * Params: 4902 * file = input #GFile 4903 * attributes = an attribute query string 4904 * flags = a set of #GFileQueryInfoFlags 4905 * cancellable = optional #GCancellable object, 4906 * %NULL to ignore 4907 * Return: A #GFileEnumerator if successful, 4908 * %NULL on error. Free the returned object with g_object_unref(). 4909 * 4910 * Throws: GException on failure. 4911 */ 4912 extern(C) GFileEnumerator* function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) enumerateChildren; 4913 /** */ 4914 extern(C) void function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) enumerateChildrenAsync; 4915 /** 4916 * 4917 * Params: 4918 * file = input #GFile 4919 * res = a #GAsyncResult 4920 * Return: a #GFileEnumerator or %NULL 4921 * if an error occurred. 4922 * Free the returned object with g_object_unref(). 4923 * 4924 * Throws: GException on failure. 4925 */ 4926 extern(C) GFileEnumerator* function(GFile* file, GAsyncResult* res, GError** err) enumerateChildrenFinish; 4927 /** 4928 * 4929 * Params: 4930 * file = input #GFile 4931 * attributes = an attribute query string 4932 * flags = a set of #GFileQueryInfoFlags 4933 * cancellable = optional #GCancellable object, 4934 * %NULL to ignore 4935 * Return: a #GFileInfo for the given @file, or %NULL 4936 * on error. Free the returned object with g_object_unref(). 4937 * 4938 * Throws: GException on failure. 4939 */ 4940 extern(C) GFileInfo* function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) queryInfo; 4941 /** */ 4942 extern(C) void function(GFile* file, const(char)* attributes, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync; 4943 /** 4944 * 4945 * Params: 4946 * file = input #GFile 4947 * res = a #GAsyncResult 4948 * Return: #GFileInfo for given @file 4949 * or %NULL on error. Free the returned object with 4950 * g_object_unref(). 4951 * 4952 * Throws: GException on failure. 4953 */ 4954 extern(C) GFileInfo* function(GFile* file, GAsyncResult* res, GError** err) queryInfoFinish; 4955 /** 4956 * 4957 * Params: 4958 * file = input #GFile 4959 * attributes = an attribute query string 4960 * cancellable = optional #GCancellable object, 4961 * %NULL to ignore 4962 * Return: a #GFileInfo or %NULL if there was an error. 4963 * Free the returned object with g_object_unref(). 4964 * 4965 * Throws: GException on failure. 4966 */ 4967 extern(C) GFileInfo* function(GFile* file, const(char)* attributes, GCancellable* cancellable, GError** err) queryFilesystemInfo; 4968 /** */ 4969 extern(C) void function(GFile* file, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryFilesystemInfoAsync; 4970 /** 4971 * 4972 * Params: 4973 * file = input #GFile 4974 * res = a #GAsyncResult 4975 * Return: #GFileInfo for given @file 4976 * or %NULL on error. 4977 * Free the returned object with g_object_unref(). 4978 * 4979 * Throws: GException on failure. 4980 */ 4981 extern(C) GFileInfo* function(GFile* file, GAsyncResult* res, GError** err) queryFilesystemInfoFinish; 4982 /** 4983 * 4984 * Params: 4985 * file = input #GFile 4986 * cancellable = optional #GCancellable object, 4987 * %NULL to ignore 4988 * Return: a #GMount where the @file is located 4989 * or %NULL on error. 4990 * Free the returned object with g_object_unref(). 4991 * 4992 * Throws: GException on failure. 4993 */ 4994 extern(C) GMount* function(GFile* file, GCancellable* cancellable, GError** err) findEnclosingMount; 4995 /** */ 4996 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) findEnclosingMountAsync; 4997 /** 4998 * 4999 * Params: 5000 * file = a #GFile 5001 * res = a #GAsyncResult 5002 * Return: #GMount for given @file or %NULL on error. 5003 * Free the returned object with g_object_unref(). 5004 * 5005 * Throws: GException on failure. 5006 */ 5007 extern(C) GMount* function(GFile* file, GAsyncResult* res, GError** err) findEnclosingMountFinish; 5008 /** 5009 * 5010 * Params: 5011 * file = input #GFile 5012 * displayName = a string 5013 * cancellable = optional #GCancellable object, 5014 * %NULL to ignore 5015 * Return: a #GFile specifying what @file was renamed to, 5016 * or %NULL if there was an error. 5017 * Free the returned object with g_object_unref(). 5018 * 5019 * Throws: GException on failure. 5020 */ 5021 extern(C) GFile* function(GFile* file, const(char)* displayName, GCancellable* cancellable, GError** err) setDisplayName; 5022 /** */ 5023 extern(C) void function(GFile* file, const(char)* displayName, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) setDisplayNameAsync; 5024 /** 5025 * 5026 * Params: 5027 * file = input #GFile 5028 * res = a #GAsyncResult 5029 * Return: a #GFile or %NULL on error. 5030 * Free the returned object with g_object_unref(). 5031 * 5032 * Throws: GException on failure. 5033 */ 5034 extern(C) GFile* function(GFile* file, GAsyncResult* res, GError** err) setDisplayNameFinish; 5035 /** 5036 * 5037 * Params: 5038 * file = input #GFile 5039 * cancellable = optional #GCancellable object, 5040 * %NULL to ignore 5041 * Return: a #GFileAttributeInfoList describing the settable attributes. 5042 * When you are done with it, release it with 5043 * g_file_attribute_info_list_unref() 5044 * 5045 * Throws: GException on failure. 5046 */ 5047 extern(C) GFileAttributeInfoList* function(GFile* file, GCancellable* cancellable, GError** err) querySettableAttributes; 5048 /** */ 5049 extern(C) void function() QuerySettableAttributesAsync; 5050 /** */ 5051 extern(C) void function() QuerySettableAttributesFinish; 5052 /** 5053 * 5054 * Params: 5055 * file = input #GFile 5056 * cancellable = optional #GCancellable object, 5057 * %NULL to ignore 5058 * Return: a #GFileAttributeInfoList describing the writable namespaces. 5059 * When you are done with it, release it with 5060 * g_file_attribute_info_list_unref() 5061 * 5062 * Throws: GException on failure. 5063 */ 5064 extern(C) GFileAttributeInfoList* function(GFile* file, GCancellable* cancellable, GError** err) queryWritableNamespaces; 5065 /** */ 5066 extern(C) void function() QueryWritableNamespacesAsync; 5067 /** */ 5068 extern(C) void function() QueryWritableNamespacesFinish; 5069 /** 5070 * 5071 * Params: 5072 * file = input #GFile 5073 * attribute = a string containing the attribute's name 5074 * type = The type of the attribute 5075 * valueP = a pointer to the value (or the pointer 5076 * itself if the type is a pointer type) 5077 * flags = a set of #GFileQueryInfoFlags 5078 * cancellable = optional #GCancellable object, 5079 * %NULL to ignore 5080 * Return: %TRUE if the attribute was set, %FALSE otherwise. 5081 * 5082 * Throws: GException on failure. 5083 */ 5084 extern(C) int function(GFile* file, const(char)* attribute, GFileAttributeType type, void* valueP, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) setAttribute; 5085 /** 5086 * 5087 * Params: 5088 * file = input #GFile 5089 * info = a #GFileInfo 5090 * flags = #GFileQueryInfoFlags 5091 * cancellable = optional #GCancellable object, 5092 * %NULL to ignore 5093 * Return: %FALSE if there was any error, %TRUE otherwise. 5094 * 5095 * Throws: GException on failure. 5096 */ 5097 extern(C) int function(GFile* file, GFileInfo* info, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) setAttributesFromInfo; 5098 /** */ 5099 extern(C) void function(GFile* file, GFileInfo* info, GFileQueryInfoFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) setAttributesAsync; 5100 /** 5101 * 5102 * Params: 5103 * file = input #GFile 5104 * result = a #GAsyncResult 5105 * info = a #GFileInfo 5106 * Return: %TRUE if the attributes were set correctly, %FALSE otherwise. 5107 * 5108 * Throws: GException on failure. 5109 */ 5110 extern(C) int function(GFile* file, GAsyncResult* result, GFileInfo** info, GError** err) setAttributesFinish; 5111 /** 5112 * 5113 * Params: 5114 * file = #GFile to read 5115 * cancellable = a #GCancellable 5116 * Return: #GFileInputStream or %NULL on error. 5117 * Free the returned object with g_object_unref(). 5118 * 5119 * Throws: GException on failure. 5120 */ 5121 extern(C) GFileInputStream* function(GFile* file, GCancellable* cancellable, GError** err) readFn; 5122 /** */ 5123 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) readAsync; 5124 /** 5125 * 5126 * Params: 5127 * file = input #GFile 5128 * res = a #GAsyncResult 5129 * Return: a #GFileInputStream or %NULL on error. 5130 * Free the returned object with g_object_unref(). 5131 * 5132 * Throws: GException on failure. 5133 */ 5134 extern(C) GFileInputStream* function(GFile* file, GAsyncResult* res, GError** err) readFinish; 5135 /** 5136 * 5137 * Params: 5138 * file = input #GFile 5139 * flags = a set of #GFileCreateFlags 5140 * cancellable = optional #GCancellable object, 5141 * %NULL to ignore 5142 * Return: a #GFileOutputStream, or %NULL on error. 5143 * Free the returned object with g_object_unref(). 5144 * 5145 * Throws: GException on failure. 5146 */ 5147 extern(C) GFileOutputStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) appendTo; 5148 /** */ 5149 extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) appendToAsync; 5150 /** 5151 * 5152 * Params: 5153 * file = input #GFile 5154 * res = #GAsyncResult 5155 * Return: a valid #GFileOutputStream 5156 * or %NULL on error. 5157 * Free the returned object with g_object_unref(). 5158 * 5159 * Throws: GException on failure. 5160 */ 5161 extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) appendToFinish; 5162 /** 5163 * 5164 * Params: 5165 * file = input #GFile 5166 * flags = a set of #GFileCreateFlags 5167 * cancellable = optional #GCancellable object, 5168 * %NULL to ignore 5169 * Return: a #GFileOutputStream for the newly created 5170 * file, or %NULL on error. 5171 * Free the returned object with g_object_unref(). 5172 * 5173 * Throws: GException on failure. 5174 */ 5175 extern(C) GFileOutputStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) create; 5176 /** */ 5177 extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) createAsync; 5178 /** 5179 * 5180 * Params: 5181 * file = input #GFile 5182 * res = a #GAsyncResult 5183 * Return: a #GFileOutputStream or %NULL on error. 5184 * Free the returned object with g_object_unref(). 5185 * 5186 * Throws: GException on failure. 5187 */ 5188 extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) createFinish; 5189 /** 5190 * 5191 * Params: 5192 * file = input #GFile 5193 * etag = an optional [entity tag][gfile-etag] 5194 * for the current #GFile, or #NULL to ignore 5195 * makeBackup = %TRUE if a backup should be created 5196 * flags = a set of #GFileCreateFlags 5197 * cancellable = optional #GCancellable object, 5198 * %NULL to ignore 5199 * Return: a #GFileOutputStream or %NULL on error. 5200 * Free the returned object with g_object_unref(). 5201 * 5202 * Throws: GException on failure. 5203 */ 5204 extern(C) GFileOutputStream* function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GError** err) replace; 5205 /** */ 5206 extern(C) void function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) replaceAsync; 5207 /** 5208 * 5209 * Params: 5210 * file = input #GFile 5211 * res = a #GAsyncResult 5212 * Return: a #GFileOutputStream, or %NULL on error. 5213 * Free the returned object with g_object_unref(). 5214 * 5215 * Throws: GException on failure. 5216 */ 5217 extern(C) GFileOutputStream* function(GFile* file, GAsyncResult* res, GError** err) replaceFinish; 5218 /** 5219 * 5220 * Params: 5221 * file = input #GFile 5222 * cancellable = optional #GCancellable object, 5223 * %NULL to ignore 5224 * Return: %TRUE if the file was deleted. %FALSE otherwise. 5225 * 5226 * Throws: GException on failure. 5227 */ 5228 extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) deleteFile; 5229 /** */ 5230 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) deleteFileAsync; 5231 /** 5232 * 5233 * Params: 5234 * file = input #GFile 5235 * result = a #GAsyncResult 5236 * Return: %TRUE if the file was deleted. %FALSE otherwise. 5237 * 5238 * Throws: GException on failure. 5239 */ 5240 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) deleteFileFinish; 5241 /** 5242 * 5243 * Params: 5244 * file = #GFile to send to trash 5245 * cancellable = optional #GCancellable object, 5246 * %NULL to ignore 5247 * Return: %TRUE on successful trash, %FALSE otherwise. 5248 * 5249 * Throws: GException on failure. 5250 */ 5251 extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) trash; 5252 /** */ 5253 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) trashAsync; 5254 /** 5255 * 5256 * Params: 5257 * file = input #GFile 5258 * result = a #GAsyncResult 5259 * Return: %TRUE on successful trash, %FALSE otherwise. 5260 * 5261 * Throws: GException on failure. 5262 */ 5263 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) trashFinish; 5264 /** 5265 * 5266 * Params: 5267 * file = input #GFile 5268 * cancellable = optional #GCancellable object, 5269 * %NULL to ignore 5270 * Return: %TRUE on successful creation, %FALSE otherwise. 5271 * 5272 * Throws: GException on failure. 5273 */ 5274 extern(C) int function(GFile* file, GCancellable* cancellable, GError** err) makeDirectory; 5275 /** */ 5276 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) makeDirectoryAsync; 5277 /** 5278 * 5279 * Params: 5280 * file = input #GFile 5281 * result = a #GAsyncResult 5282 * Return: %TRUE on successful directory creation, %FALSE otherwise. 5283 * 5284 * Throws: GException on failure. 5285 */ 5286 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) makeDirectoryFinish; 5287 /** 5288 * 5289 * Params: 5290 * file = a #GFile with the name of the symlink to create 5291 * symlinkValue = a string with the path for the target of the new symlink 5292 * cancellable = optional #GCancellable object, 5293 * %NULL to ignore 5294 * Return: %TRUE on the creation of a new symlink, %FALSE otherwise. 5295 * 5296 * Throws: GException on failure. 5297 */ 5298 extern(C) int function(GFile* file, const(char)* symlinkValue, GCancellable* cancellable, GError** err) makeSymbolicLink; 5299 /** */ 5300 extern(C) void function() MakeSymbolicLinkAsync; 5301 /** */ 5302 extern(C) void function() MakeSymbolicLinkFinish; 5303 /** 5304 * 5305 * Params: 5306 * source = input #GFile 5307 * destination = destination #GFile 5308 * flags = set of #GFileCopyFlags 5309 * cancellable = optional #GCancellable object, 5310 * %NULL to ignore 5311 * progressCallback = function to callback with 5312 * progress information, or %NULL if progress information is not needed 5313 * progressCallbackData = user data to pass to @progress_callback 5314 * Return: %TRUE on success, %FALSE otherwise. 5315 * 5316 * Throws: GException on failure. 5317 */ 5318 extern(C) int function(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GError** err) copy; 5319 /** */ 5320 extern(C) void function(GFile* source, GFile* destination, GFileCopyFlags flags, int ioPriority, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GAsyncReadyCallback callback, void* userData) copyAsync; 5321 /** 5322 * 5323 * Params: 5324 * file = input #GFile 5325 * res = a #GAsyncResult 5326 * Return: a %TRUE on success, %FALSE on error. 5327 * 5328 * Throws: GException on failure. 5329 */ 5330 extern(C) int function(GFile* file, GAsyncResult* res, GError** err) copyFinish; 5331 /** 5332 * 5333 * Params: 5334 * source = #GFile pointing to the source location 5335 * destination = #GFile pointing to the destination location 5336 * flags = set of #GFileCopyFlags 5337 * cancellable = optional #GCancellable object, 5338 * %NULL to ignore 5339 * progressCallback = #GFileProgressCallback 5340 * function for updates 5341 * progressCallbackData = gpointer to user data for 5342 * the callback function 5343 * Return: %TRUE on successful move, %FALSE otherwise. 5344 * 5345 * Throws: GException on failure. 5346 */ 5347 extern(C) int function(GFile* source, GFile* destination, GFileCopyFlags flags, GCancellable* cancellable, GFileProgressCallback progressCallback, void* progressCallbackData, GError** err) move; 5348 /** */ 5349 extern(C) void function() MoveAsync; 5350 /** */ 5351 extern(C) void function() MoveFinish; 5352 /** */ 5353 extern(C) void function(GFile* file, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountMountable; 5354 /** 5355 * 5356 * Params: 5357 * file = input #GFile 5358 * result = a #GAsyncResult 5359 * Return: a #GFile or %NULL on error. 5360 * Free the returned object with g_object_unref(). 5361 * 5362 * Throws: GException on failure. 5363 */ 5364 extern(C) GFile* function(GFile* file, GAsyncResult* result, GError** err) mountMountableFinish; 5365 /** */ 5366 extern(C) void function(GFile* file, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountMountable; 5367 /** 5368 * 5369 * Params: 5370 * file = input #GFile 5371 * result = a #GAsyncResult 5372 * Return: %TRUE if the operation finished successfully. 5373 * %FALSE otherwise. 5374 * 5375 * Throws: GException on failure. 5376 */ 5377 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) unmountMountableFinish; 5378 /** */ 5379 extern(C) void function(GFile* file, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectMountable; 5380 /** 5381 * 5382 * Params: 5383 * file = input #GFile 5384 * result = a #GAsyncResult 5385 * Return: %TRUE if the @file was ejected successfully. 5386 * %FALSE otherwise. 5387 * 5388 * Throws: GException on failure. 5389 */ 5390 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) ejectMountableFinish; 5391 /** */ 5392 extern(C) void function(GFile* location, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountEnclosingVolume; 5393 /** 5394 * 5395 * Params: 5396 * location = input #GFile 5397 * result = a #GAsyncResult 5398 * Return: %TRUE if successful. If an error has occurred, 5399 * this function will return %FALSE and set @error 5400 * appropriately if present. 5401 * 5402 * Throws: GException on failure. 5403 */ 5404 extern(C) int function(GFile* location, GAsyncResult* result, GError** err) mountEnclosingVolumeFinish; 5405 /** 5406 * 5407 * Params: 5408 * file = input #GFile 5409 * flags = a set of #GFileMonitorFlags 5410 * cancellable = optional #GCancellable object, 5411 * %NULL to ignore 5412 * Return: a #GFileMonitor for the given @file, 5413 * or %NULL on error. 5414 * Free the returned object with g_object_unref(). 5415 * 5416 * Throws: GException on failure. 5417 */ 5418 extern(C) GFileMonitor* function(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err) monitorDir; 5419 /** 5420 * 5421 * Params: 5422 * file = input #GFile 5423 * flags = a set of #GFileMonitorFlags 5424 * cancellable = optional #GCancellable object, 5425 * %NULL to ignore 5426 * Return: a #GFileMonitor for the given @file, 5427 * or %NULL on error. 5428 * Free the returned object with g_object_unref(). 5429 * 5430 * Throws: GException on failure. 5431 */ 5432 extern(C) GFileMonitor* function(GFile* file, GFileMonitorFlags flags, GCancellable* cancellable, GError** err) monitorFile; 5433 /** 5434 * 5435 * Params: 5436 * file = #GFile to open 5437 * cancellable = a #GCancellable 5438 * Return: #GFileIOStream or %NULL on error. 5439 * Free the returned object with g_object_unref(). 5440 * 5441 * Throws: GException on failure. 5442 */ 5443 extern(C) GFileIOStream* function(GFile* file, GCancellable* cancellable, GError** err) openReadwrite; 5444 /** */ 5445 extern(C) void function(GFile* file, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) openReadwriteAsync; 5446 /** 5447 * 5448 * Params: 5449 * file = input #GFile 5450 * res = a #GAsyncResult 5451 * Return: a #GFileIOStream or %NULL on error. 5452 * Free the returned object with g_object_unref(). 5453 * 5454 * Throws: GException on failure. 5455 */ 5456 extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) openReadwriteFinish; 5457 /** 5458 * 5459 * Params: 5460 * file = a #GFile 5461 * flags = a set of #GFileCreateFlags 5462 * cancellable = optional #GCancellable object, 5463 * %NULL to ignore 5464 * Return: a #GFileIOStream for the newly created 5465 * file, or %NULL on error. 5466 * Free the returned object with g_object_unref(). 5467 * 5468 * Throws: GException on failure. 5469 */ 5470 extern(C) GFileIOStream* function(GFile* file, GFileCreateFlags flags, GCancellable* cancellable, GError** err) createReadwrite; 5471 /** */ 5472 extern(C) void function(GFile* file, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) createReadwriteAsync; 5473 /** 5474 * 5475 * Params: 5476 * file = input #GFile 5477 * res = a #GAsyncResult 5478 * Return: a #GFileIOStream or %NULL on error. 5479 * Free the returned object with g_object_unref(). 5480 * 5481 * Throws: GException on failure. 5482 */ 5483 extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) createReadwriteFinish; 5484 /** 5485 * 5486 * Params: 5487 * file = a #GFile 5488 * etag = an optional [entity tag][gfile-etag] 5489 * for the current #GFile, or #NULL to ignore 5490 * makeBackup = %TRUE if a backup should be created 5491 * flags = a set of #GFileCreateFlags 5492 * cancellable = optional #GCancellable object, 5493 * %NULL to ignore 5494 * Return: a #GFileIOStream or %NULL on error. 5495 * Free the returned object with g_object_unref(). 5496 * 5497 * Throws: GException on failure. 5498 */ 5499 extern(C) GFileIOStream* function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, GCancellable* cancellable, GError** err) replaceReadwrite; 5500 /** */ 5501 extern(C) void function(GFile* file, const(char)* etag, int makeBackup, GFileCreateFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) replaceReadwriteAsync; 5502 /** 5503 * 5504 * Params: 5505 * file = input #GFile 5506 * res = a #GAsyncResult 5507 * Return: a #GFileIOStream, or %NULL on error. 5508 * Free the returned object with g_object_unref(). 5509 * 5510 * Throws: GException on failure. 5511 */ 5512 extern(C) GFileIOStream* function(GFile* file, GAsyncResult* res, GError** err) replaceReadwriteFinish; 5513 /** */ 5514 extern(C) void function(GFile* file, GDriveStartFlags flags, GMountOperation* startOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) startMountable; 5515 /** 5516 * 5517 * Params: 5518 * file = input #GFile 5519 * result = a #GAsyncResult 5520 * Return: %TRUE if the operation finished successfully. %FALSE 5521 * otherwise. 5522 * 5523 * Throws: GException on failure. 5524 */ 5525 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) startMountableFinish; 5526 /** */ 5527 extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) stopMountable; 5528 /** 5529 * 5530 * Params: 5531 * file = input #GFile 5532 * result = a #GAsyncResult 5533 * Return: %TRUE if the operation finished successfully. 5534 * %FALSE otherwise. 5535 * 5536 * Throws: GException on failure. 5537 */ 5538 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) stopMountableFinish; 5539 /** 5540 * a boolean that indicates whether the #GFile implementation supports thread-default contexts. Since 2.22. 5541 */ 5542 bool supportsThreadContexts; 5543 /** */ 5544 extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountMountableWithOperation; 5545 /** 5546 * 5547 * Params: 5548 * file = input #GFile 5549 * result = a #GAsyncResult 5550 * Return: %TRUE if the operation finished successfully. 5551 * %FALSE otherwise. 5552 * 5553 * Throws: GException on failure. 5554 */ 5555 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) unmountMountableWithOperationFinish; 5556 /** */ 5557 extern(C) void function(GFile* file, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectMountableWithOperation; 5558 /** 5559 * 5560 * Params: 5561 * file = input #GFile 5562 * result = a #GAsyncResult 5563 * Return: %TRUE if the @file was ejected successfully. 5564 * %FALSE otherwise. 5565 * 5566 * Throws: GException on failure. 5567 */ 5568 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) ejectMountableWithOperationFinish; 5569 /** */ 5570 extern(C) void function(GFile* file, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) pollMountable; 5571 /** 5572 * 5573 * Params: 5574 * file = input #GFile 5575 * result = a #GAsyncResult 5576 * Return: %TRUE if the operation finished successfully. %FALSE 5577 * otherwise. 5578 * 5579 * Throws: GException on failure. 5580 */ 5581 extern(C) int function(GFile* file, GAsyncResult* result, GError** err) pollMountableFinish; 5582 /** 5583 * 5584 * Params: 5585 * file = a #GFile 5586 * flags = #GFileMeasureFlags 5587 * cancellable = optional #GCancellable 5588 * progressCallback = a #GFileMeasureProgressCallback 5589 * progressData = user_data for @progress_callback 5590 * diskUsage = the number of bytes of disk space used 5591 * numDirs = the number of directories encountered 5592 * numFiles = the number of non-directories encountered 5593 * Return: %TRUE if successful, with the out parameters set. 5594 * %FALSE otherwise, with @error set. 5595 * 5596 * Throws: GException on failure. 5597 */ 5598 extern(C) int function(GFile* file, GFileMeasureFlags flags, GCancellable* cancellable, GFileMeasureProgressCallback progressCallback, void* progressData, ulong* diskUsage, ulong* numDirs, ulong* numFiles, GError** err) measureDiskUsage; 5599 /** */ 5600 extern(C) void function(GFile* file, GFileMeasureFlags flags, int ioPriority, GCancellable* cancellable, GFileMeasureProgressCallback progressCallback, void* progressData, GAsyncReadyCallback callback, void* userData) measureDiskUsageAsync; 5601 /** 5602 * 5603 * Params: 5604 * file = a #GFile 5605 * result = the #GAsyncResult passed to your #GAsyncReadyCallback 5606 * diskUsage = the number of bytes of disk space used 5607 * numDirs = the number of directories encountered 5608 * numFiles = the number of non-directories encountered 5609 * Return: %TRUE if successful, with the out parameters set. 5610 * %FALSE otherwise, with @error set. 5611 * 5612 * Throws: GException on failure. 5613 */ 5614 extern(C) int function(GFile* file, GAsyncResult* result, ulong* diskUsage, ulong* numDirs, ulong* numFiles, GError** err) measureDiskUsageFinish; 5615 } 5616 5617 struct GFileInfo; 5618 5619 struct GFileInfoClass; 5620 5621 struct GFileInputStream 5622 { 5623 GInputStream parentInstance; 5624 GFileInputStreamPrivate* priv; 5625 } 5626 5627 struct GFileInputStreamClass 5628 { 5629 GInputStreamClass parentClass; 5630 /** */ 5631 extern(C) long function(GFileInputStream* stream) tell; 5632 /** */ 5633 extern(C) int function(GFileInputStream* stream) canSeek; 5634 /** */ 5635 extern(C) int function(GFileInputStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek; 5636 /** 5637 * 5638 * Params: 5639 * stream = a #GFileInputStream. 5640 * attributes = a file attribute query string. 5641 * cancellable = optional #GCancellable object, %NULL to ignore. 5642 * Return: a #GFileInfo, or %NULL on error. 5643 * 5644 * Throws: GException on failure. 5645 */ 5646 extern(C) GFileInfo* function(GFileInputStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo; 5647 /** */ 5648 extern(C) void function(GFileInputStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync; 5649 /** 5650 * 5651 * Params: 5652 * stream = a #GFileInputStream. 5653 * result = a #GAsyncResult. 5654 * Return: #GFileInfo. 5655 * 5656 * Throws: GException on failure. 5657 */ 5658 extern(C) GFileInfo* function(GFileInputStream* stream, GAsyncResult* result, GError** err) queryInfoFinish; 5659 /** */ 5660 extern(C) void function() GReserved1; 5661 /** */ 5662 extern(C) void function() GReserved2; 5663 /** */ 5664 extern(C) void function() GReserved3; 5665 /** */ 5666 extern(C) void function() GReserved4; 5667 /** */ 5668 extern(C) void function() GReserved5; 5669 } 5670 5671 struct GFileInputStreamPrivate; 5672 5673 struct GFileMonitor 5674 { 5675 GObject parentInstance; 5676 GFileMonitorPrivate* priv; 5677 } 5678 5679 struct GFileMonitorClass 5680 { 5681 GObjectClass parentClass; 5682 /** */ 5683 extern(C) void function(GFileMonitor* monitor, GFile* file, GFile* otherFile, GFileMonitorEvent eventType) changed; 5684 /** 5685 * 5686 * Params: 5687 * monitor = a #GFileMonitor. 5688 * Return: always %TRUE 5689 */ 5690 extern(C) int function(GFileMonitor* monitor) cancel; 5691 /** */ 5692 extern(C) void function() GReserved1; 5693 /** */ 5694 extern(C) void function() GReserved2; 5695 /** */ 5696 extern(C) void function() GReserved3; 5697 /** */ 5698 extern(C) void function() GReserved4; 5699 /** */ 5700 extern(C) void function() GReserved5; 5701 } 5702 5703 struct GFileMonitorPrivate; 5704 5705 struct GFileOutputStream 5706 { 5707 GOutputStream parentInstance; 5708 GFileOutputStreamPrivate* priv; 5709 } 5710 5711 struct GFileOutputStreamClass 5712 { 5713 GOutputStreamClass parentClass; 5714 /** */ 5715 extern(C) long function(GFileOutputStream* stream) tell; 5716 /** */ 5717 extern(C) int function(GFileOutputStream* stream) canSeek; 5718 /** */ 5719 extern(C) int function(GFileOutputStream* stream, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek; 5720 /** */ 5721 extern(C) int function(GFileOutputStream* stream) canTruncate; 5722 /** */ 5723 extern(C) int function(GFileOutputStream* stream, long size, GCancellable* cancellable, GError** err) truncateFn; 5724 /** 5725 * 5726 * Params: 5727 * stream = a #GFileOutputStream. 5728 * attributes = a file attribute query string. 5729 * cancellable = optional #GCancellable object, %NULL to ignore. 5730 * Return: a #GFileInfo for the @stream, or %NULL on error. 5731 * 5732 * Throws: GException on failure. 5733 */ 5734 extern(C) GFileInfo* function(GFileOutputStream* stream, const(char)* attributes, GCancellable* cancellable, GError** err) queryInfo; 5735 /** */ 5736 extern(C) void function(GFileOutputStream* stream, const(char)* attributes, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) queryInfoAsync; 5737 /** 5738 * 5739 * Params: 5740 * stream = a #GFileOutputStream. 5741 * result = a #GAsyncResult. 5742 * Return: A #GFileInfo for the finished query. 5743 * 5744 * Throws: GException on failure. 5745 */ 5746 extern(C) GFileInfo* function(GFileOutputStream* stream, GAsyncResult* result, GError** err) queryInfoFinish; 5747 /** 5748 * 5749 * Params: 5750 * stream = a #GFileOutputStream. 5751 * Return: the entity tag for the stream. 5752 */ 5753 extern(C) char* function(GFileOutputStream* stream) getEtag; 5754 /** */ 5755 extern(C) void function() GReserved1; 5756 /** */ 5757 extern(C) void function() GReserved2; 5758 /** */ 5759 extern(C) void function() GReserved3; 5760 /** */ 5761 extern(C) void function() GReserved4; 5762 /** */ 5763 extern(C) void function() GReserved5; 5764 } 5765 5766 struct GFileOutputStreamPrivate; 5767 5768 struct GFilenameCompleter; 5769 5770 struct GFilenameCompleterClass 5771 { 5772 GObjectClass parentClass; 5773 /** */ 5774 extern(C) void function(GFilenameCompleter* filenameCompleter) gotCompletionData; 5775 /** */ 5776 extern(C) void function() GReserved1; 5777 /** */ 5778 extern(C) void function() GReserved2; 5779 /** */ 5780 extern(C) void function() GReserved3; 5781 } 5782 5783 struct GFilterInputStream 5784 { 5785 GInputStream parentInstance; 5786 GInputStream* baseStream; 5787 } 5788 5789 struct GFilterInputStreamClass 5790 { 5791 GInputStreamClass parentClass; 5792 /** */ 5793 extern(C) void function() GReserved1; 5794 /** */ 5795 extern(C) void function() GReserved2; 5796 /** */ 5797 extern(C) void function() GReserved3; 5798 } 5799 5800 struct GFilterOutputStream 5801 { 5802 GOutputStream parentInstance; 5803 GOutputStream* baseStream; 5804 } 5805 5806 struct GFilterOutputStreamClass 5807 { 5808 GOutputStreamClass parentClass; 5809 /** */ 5810 extern(C) void function() GReserved1; 5811 /** */ 5812 extern(C) void function() GReserved2; 5813 /** */ 5814 extern(C) void function() GReserved3; 5815 } 5816 5817 struct GIOExtension; 5818 5819 struct GIOExtensionPoint; 5820 5821 struct GIOModule; 5822 5823 struct GIOModuleClass; 5824 5825 struct GIOModuleScope; 5826 5827 struct GIOSchedulerJob; 5828 5829 struct GIOStream 5830 { 5831 GObject parentInstance; 5832 GIOStreamPrivate* priv; 5833 } 5834 5835 struct GIOStreamAdapter; 5836 5837 struct GIOStreamClass 5838 { 5839 GObjectClass parentClass; 5840 /** 5841 * 5842 * Params: 5843 * stream = a #GIOStream 5844 * Return: a #GInputStream, owned by the #GIOStream. 5845 * Do not free. 5846 */ 5847 extern(C) GInputStream* function(GIOStream* stream) getInputStream; 5848 /** 5849 * 5850 * Params: 5851 * stream = a #GIOStream 5852 * Return: a #GOutputStream, owned by the #GIOStream. 5853 * Do not free. 5854 */ 5855 extern(C) GOutputStream* function(GIOStream* stream) getOutputStream; 5856 /** */ 5857 extern(C) int function(GIOStream* stream, GCancellable* cancellable, GError** err) closeFn; 5858 /** */ 5859 extern(C) void function(GIOStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync; 5860 /** 5861 * 5862 * Params: 5863 * stream = a #GIOStream 5864 * result = a #GAsyncResult 5865 * Return: %TRUE if stream was successfully closed, %FALSE otherwise. 5866 * 5867 * Throws: GException on failure. 5868 */ 5869 extern(C) int function(GIOStream* stream, GAsyncResult* result, GError** err) closeFinish; 5870 /** */ 5871 extern(C) void function() GReserved1; 5872 /** */ 5873 extern(C) void function() GReserved2; 5874 /** */ 5875 extern(C) void function() GReserved3; 5876 /** */ 5877 extern(C) void function() GReserved4; 5878 /** */ 5879 extern(C) void function() GReserved5; 5880 /** */ 5881 extern(C) void function() GReserved6; 5882 /** */ 5883 extern(C) void function() GReserved7; 5884 /** */ 5885 extern(C) void function() GReserved8; 5886 /** */ 5887 extern(C) void function() GReserved9; 5888 /** */ 5889 extern(C) void function() GReserved10; 5890 } 5891 5892 struct GIOStreamPrivate; 5893 5894 struct GIcon; 5895 5896 /** 5897 * GIconIface is used to implement GIcon types for various 5898 * different systems. See #GThemedIcon and #GLoadableIcon for 5899 * examples of how to implement this interface. 5900 */ 5901 struct GIconIface 5902 { 5903 /** 5904 * The parent interface. 5905 */ 5906 GTypeInterface gIface; 5907 /** 5908 * 5909 * Params: 5910 * icon = #gconstpointer to an icon object. 5911 * Return: a #guint containing a hash for the @icon, suitable for 5912 * use in a #GHashTable or similar data structure. 5913 */ 5914 extern(C) uint function(GIcon* icon) hash; 5915 /** 5916 * 5917 * Params: 5918 * icon1 = pointer to the first #GIcon. 5919 * icon2 = pointer to the second #GIcon. 5920 * Return: %TRUE if @icon1 is equal to @icon2. %FALSE otherwise. 5921 */ 5922 extern(C) int function(GIcon* icon1, GIcon* icon2) equal; 5923 /** 5924 * 5925 * Params: 5926 * icon = a #GIcon. 5927 * Return: An allocated NUL-terminated UTF8 string or 5928 * %NULL if @icon can't be serialized. Use g_free() to free. 5929 */ 5930 extern(C) int function(GIcon* icon, GPtrArray* tokens, int* outVersion) toTokens; 5931 /** */ 5932 extern(C) GIcon* function(char** tokens, int numTokens, int versio, GError** err) fromTokens; 5933 /** 5934 * 5935 * Params: 5936 * icon = a #GIcon 5937 * Return: a #GVariant, or %NULL when serialization fails. 5938 */ 5939 extern(C) GVariant* function(GIcon* icon) serialize; 5940 } 5941 5942 struct GInetAddress 5943 { 5944 GObject parentInstance; 5945 GInetAddressPrivate* priv; 5946 } 5947 5948 struct GInetAddressClass 5949 { 5950 GObjectClass parentClass; 5951 /** 5952 * 5953 * Params: 5954 * address = a #GInetAddress 5955 * Return: a representation of @address as a string, which should be 5956 * freed after use. 5957 */ 5958 extern(C) char* function(GInetAddress* address) toString; 5959 /** 5960 * 5961 * Params: 5962 * address = a #GInetAddress 5963 * Return: a pointer to an internal array of the bytes in @address, 5964 * which should not be modified, stored, or freed. The size of this 5965 * array can be gotten with g_inet_address_get_native_size(). 5966 */ 5967 extern(C) ubyte* function(GInetAddress* address) toBytes; 5968 } 5969 5970 struct GInetAddressMask 5971 { 5972 GObject parentInstance; 5973 GInetAddressMaskPrivate* priv; 5974 } 5975 5976 struct GInetAddressMaskClass 5977 { 5978 GObjectClass parentClass; 5979 } 5980 5981 struct GInetAddressMaskPrivate; 5982 5983 struct GInetAddressPrivate; 5984 5985 struct GInetSocketAddress 5986 { 5987 GSocketAddress parentInstance; 5988 GInetSocketAddressPrivate* priv; 5989 } 5990 5991 struct GInetSocketAddressClass 5992 { 5993 GSocketAddressClass parentClass; 5994 } 5995 5996 struct GInetSocketAddressPrivate; 5997 5998 struct GInitable; 5999 6000 /** 6001 * Provides an interface for initializing object such that initialization 6002 * may fail. 6003 * 6004 * Since: 2.22 6005 */ 6006 struct GInitableIface 6007 { 6008 /** 6009 * The parent interface. 6010 */ 6011 GTypeInterface gIface; 6012 /** 6013 * 6014 * Params: 6015 * initable = a #GInitable. 6016 * cancellable = optional #GCancellable object, %NULL to ignore. 6017 * Return: %TRUE if successful. If an error has occurred, this function will 6018 * return %FALSE and set @error appropriately if present. 6019 * 6020 * Throws: GException on failure. 6021 */ 6022 extern(C) int function(GInitable* initable, GCancellable* cancellable, GError** err) init; 6023 } 6024 6025 struct GInputStream 6026 { 6027 GObject parentInstance; 6028 GInputStreamPrivate* priv; 6029 } 6030 6031 struct GInputStreamClass 6032 { 6033 GObjectClass parentClass; 6034 /** */ 6035 extern(C) ptrdiff_t function(GInputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err) readFn; 6036 /** 6037 * 6038 * Params: 6039 * stream = a #GInputStream. 6040 * count = the number of bytes that will be skipped from the stream 6041 * cancellable = optional #GCancellable object, %NULL to ignore. 6042 * Return: Number of bytes skipped, or -1 on error 6043 * 6044 * Throws: GException on failure. 6045 */ 6046 extern(C) ptrdiff_t function(GInputStream* stream, size_t count, GCancellable* cancellable, GError** err) skip; 6047 /** */ 6048 extern(C) int function(GInputStream* stream, GCancellable* cancellable, GError** err) closeFn; 6049 /** */ 6050 extern(C) void function(GInputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) readAsync; 6051 /** 6052 * 6053 * Params: 6054 * stream = a #GInputStream. 6055 * result = a #GAsyncResult. 6056 * Return: number of bytes read in, or -1 on error, or 0 on end of file. 6057 * 6058 * Throws: GException on failure. 6059 */ 6060 extern(C) ptrdiff_t function(GInputStream* stream, GAsyncResult* result, GError** err) readFinish; 6061 /** */ 6062 extern(C) void function(GInputStream* stream, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) skipAsync; 6063 /** 6064 * 6065 * Params: 6066 * stream = a #GInputStream. 6067 * result = a #GAsyncResult. 6068 * Return: the size of the bytes skipped, or %-1 on error. 6069 * 6070 * Throws: GException on failure. 6071 */ 6072 extern(C) ptrdiff_t function(GInputStream* stream, GAsyncResult* result, GError** err) skipFinish; 6073 /** */ 6074 extern(C) void function(GInputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync; 6075 /** 6076 * 6077 * Params: 6078 * stream = a #GInputStream. 6079 * result = a #GAsyncResult. 6080 * Return: %TRUE if the stream was closed successfully. 6081 * 6082 * Throws: GException on failure. 6083 */ 6084 extern(C) int function(GInputStream* stream, GAsyncResult* result, GError** err) closeFinish; 6085 /** */ 6086 extern(C) void function() GReserved1; 6087 /** */ 6088 extern(C) void function() GReserved2; 6089 /** */ 6090 extern(C) void function() GReserved3; 6091 /** */ 6092 extern(C) void function() GReserved4; 6093 /** */ 6094 extern(C) void function() GReserved5; 6095 } 6096 6097 struct GInputStreamPrivate; 6098 6099 /** 6100 * Structure used for scatter/gather data input. 6101 * You generally pass in an array of #GInputVectors 6102 * and the operation will store the read data starting in the 6103 * first buffer, switching to the next as needed. 6104 * 6105 * Since: 2.22 6106 */ 6107 struct GInputVector 6108 { 6109 /** 6110 * Pointer to a buffer where data will be written. 6111 */ 6112 void* buffer; 6113 /** 6114 * the available size in @buffer. 6115 */ 6116 size_t size; 6117 } 6118 6119 struct GListModel; 6120 6121 /** 6122 * The virtual function table for #GListModel. 6123 * 6124 * Since: 2.44 6125 */ 6126 struct GListModelInterface 6127 { 6128 /** 6129 * parent #GTypeInterface 6130 */ 6131 GTypeInterface gIface; 6132 /** 6133 * 6134 * Params: 6135 * list = a #GListModel 6136 * Return: the #GType of the items contained in @list. 6137 */ 6138 extern(C) GType function(GListModel* list) getItemType; 6139 /** 6140 * 6141 * Params: 6142 * list = a #GListModel 6143 * Return: the number of items in @list. 6144 */ 6145 extern(C) uint function(GListModel* list) getNItems; 6146 /** */ 6147 extern(C) void* function(GListModel* list, uint position) getItem; 6148 } 6149 6150 struct GListStore; 6151 6152 struct GListStoreClass 6153 { 6154 GObjectClass parentClass; 6155 } 6156 6157 struct GLoadableIcon; 6158 6159 /** 6160 * Interface for icons that can be loaded as a stream. 6161 */ 6162 struct GLoadableIconIface 6163 { 6164 /** 6165 * The parent interface. 6166 */ 6167 GTypeInterface gIface; 6168 /** 6169 * 6170 * Params: 6171 * icon = a #GLoadableIcon. 6172 * size = an integer. 6173 * type = a location to store the type of the loaded 6174 * icon, %NULL to ignore. 6175 * cancellable = optional #GCancellable object, %NULL to 6176 * ignore. 6177 * Return: a #GInputStream to read the icon from. 6178 * 6179 * Throws: GException on failure. 6180 */ 6181 extern(C) GInputStream* function(GLoadableIcon* icon, int size, char** type, GCancellable* cancellable, GError** err) load; 6182 /** */ 6183 extern(C) void function(GLoadableIcon* icon, int size, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) loadAsync; 6184 /** 6185 * 6186 * Params: 6187 * icon = a #GLoadableIcon. 6188 * res = a #GAsyncResult. 6189 * type = a location to store the type of the loaded 6190 * icon, %NULL to ignore. 6191 * Return: a #GInputStream to read the icon from. 6192 * 6193 * Throws: GException on failure. 6194 */ 6195 extern(C) GInputStream* function(GLoadableIcon* icon, GAsyncResult* res, char** type, GError** err) loadFinish; 6196 } 6197 6198 struct GMemoryInputStream 6199 { 6200 GInputStream parentInstance; 6201 GMemoryInputStreamPrivate* priv; 6202 } 6203 6204 struct GMemoryInputStreamClass 6205 { 6206 GInputStreamClass parentClass; 6207 /** */ 6208 extern(C) void function() GReserved1; 6209 /** */ 6210 extern(C) void function() GReserved2; 6211 /** */ 6212 extern(C) void function() GReserved3; 6213 /** */ 6214 extern(C) void function() GReserved4; 6215 /** */ 6216 extern(C) void function() GReserved5; 6217 } 6218 6219 struct GMemoryInputStreamPrivate; 6220 6221 struct GMemoryOutputStream 6222 { 6223 GOutputStream parentInstance; 6224 GMemoryOutputStreamPrivate* priv; 6225 } 6226 6227 struct GMemoryOutputStreamClass 6228 { 6229 GOutputStreamClass parentClass; 6230 /** */ 6231 extern(C) void function() GReserved1; 6232 /** */ 6233 extern(C) void function() GReserved2; 6234 /** */ 6235 extern(C) void function() GReserved3; 6236 /** */ 6237 extern(C) void function() GReserved4; 6238 /** */ 6239 extern(C) void function() GReserved5; 6240 } 6241 6242 struct GMemoryOutputStreamPrivate; 6243 6244 struct GMenu; 6245 6246 struct GMenuAttributeIter 6247 { 6248 GObject parentInstance; 6249 GMenuAttributeIterPrivate* priv; 6250 } 6251 6252 struct GMenuAttributeIterClass 6253 { 6254 GObjectClass parentClass; 6255 /** 6256 * 6257 * Params: 6258 * iter = a #GMenuAttributeIter 6259 * outName = the type of the attribute 6260 * value = the attribute value 6261 * Return: %TRUE on success, or %FALSE if there is no additional 6262 * attribute 6263 */ 6264 extern(C) int function(GMenuAttributeIter* iter, char** outName, GVariant** value) getNext; 6265 } 6266 6267 struct GMenuAttributeIterPrivate; 6268 6269 struct GMenuItem; 6270 6271 struct GMenuLinkIter 6272 { 6273 GObject parentInstance; 6274 GMenuLinkIterPrivate* priv; 6275 } 6276 6277 struct GMenuLinkIterClass 6278 { 6279 GObjectClass parentClass; 6280 /** 6281 * 6282 * Params: 6283 * iter = a #GMenuLinkIter 6284 * outLink = the name of the link 6285 * value = the linked #GMenuModel 6286 * Return: %TRUE on success, or %FALSE if there is no additional link 6287 */ 6288 extern(C) int function(GMenuLinkIter* iter, char** outLink, GMenuModel** value) getNext; 6289 } 6290 6291 struct GMenuLinkIterPrivate; 6292 6293 struct GMenuModel 6294 { 6295 GObject parentInstance; 6296 GMenuModelPrivate* priv; 6297 } 6298 6299 struct GMenuModelClass 6300 { 6301 GObjectClass parentClass; 6302 /** 6303 * 6304 * Params: 6305 * model = a #GMenuModel 6306 * Return: %TRUE if the model is mutable (ie: "items-changed" may be 6307 * emitted). 6308 */ 6309 extern(C) int function(GMenuModel* model) isMutable; 6310 /** 6311 * 6312 * Params: 6313 * model = a #GMenuModel 6314 * Return: the number of items 6315 */ 6316 extern(C) int function(GMenuModel* model) getNItems; 6317 /** */ 6318 extern(C) void function(GMenuModel* model, int itemIndex, GHashTable** attributes) getItemAttributes; 6319 /** 6320 * 6321 * Params: 6322 * model = a #GMenuModel 6323 * itemIndex = the index of the item 6324 * Return: a new #GMenuAttributeIter 6325 */ 6326 extern(C) GMenuAttributeIter* function(GMenuModel* model, int itemIndex) iterateItemAttributes; 6327 /** 6328 * 6329 * Params: 6330 * model = a #GMenuModel 6331 * itemIndex = the index of the item 6332 * attribute = the attribute to query 6333 * expectedType = the expected type of the attribute, or 6334 * %NULL 6335 * Return: the value of the attribute 6336 */ 6337 extern(C) GVariant* function(GMenuModel* model, int itemIndex, const(char)* attribute, GVariantType* expectedType) getItemAttributeValue; 6338 /** */ 6339 extern(C) void function(GMenuModel* model, int itemIndex, GHashTable** links) getItemLinks; 6340 /** 6341 * 6342 * Params: 6343 * model = a #GMenuModel 6344 * itemIndex = the index of the item 6345 * Return: a new #GMenuLinkIter 6346 */ 6347 extern(C) GMenuLinkIter* function(GMenuModel* model, int itemIndex) iterateItemLinks; 6348 /** 6349 * 6350 * Params: 6351 * model = a #GMenuModel 6352 * itemIndex = the index of the item 6353 * link = the link to query 6354 * Return: the linked #GMenuModel, or %NULL 6355 */ 6356 extern(C) GMenuModel* function(GMenuModel* model, int itemIndex, const(char)* link) getItemLink; 6357 } 6358 6359 struct GMenuModelPrivate; 6360 6361 struct GMount; 6362 6363 /** 6364 * Interface for implementing operations for mounts. 6365 */ 6366 struct GMountIface 6367 { 6368 /** 6369 * The parent interface. 6370 */ 6371 GTypeInterface gIface; 6372 /** */ 6373 extern(C) void function(GMount* mount) changed; 6374 /** */ 6375 extern(C) void function(GMount* mount) unmounted; 6376 /** 6377 * 6378 * Params: 6379 * mount = a #GMount. 6380 * Return: a #GFile. 6381 * The returned object should be unreffed with 6382 * g_object_unref() when no longer needed. 6383 */ 6384 extern(C) GFile* function(GMount* mount) getRoot; 6385 /** 6386 * 6387 * Params: 6388 * mount = a #GMount. 6389 * Return: the name for the given @mount. 6390 * The returned string should be freed with g_free() 6391 * when no longer needed. 6392 */ 6393 extern(C) char* function(GMount* mount) getName; 6394 /** 6395 * 6396 * Params: 6397 * mount = a #GMount. 6398 * Return: a #GIcon. 6399 * The returned object should be unreffed with 6400 * g_object_unref() when no longer needed. 6401 */ 6402 extern(C) GIcon* function(GMount* mount) getIcon; 6403 /** 6404 * 6405 * Params: 6406 * mount = a #GMount. 6407 * Return: the UUID for @mount or %NULL if no UUID can be computed. 6408 * The returned string should be freed with g_free() 6409 * when no longer needed. 6410 */ 6411 extern(C) char* function(GMount* mount) getUuid; 6412 /** 6413 * 6414 * Params: 6415 * mount = a #GMount. 6416 * Return: a #GVolume or %NULL if @mount is not associated with a volume. 6417 * The returned object should be unreffed with 6418 * g_object_unref() when no longer needed. 6419 */ 6420 extern(C) GVolume* function(GMount* mount) getVolume; 6421 /** 6422 * 6423 * Params: 6424 * mount = a #GMount. 6425 * Return: a #GDrive or %NULL if @mount is not associated with a volume or a drive. 6426 * The returned object should be unreffed with 6427 * g_object_unref() when no longer needed. 6428 */ 6429 extern(C) GDrive* function(GMount* mount) getDrive; 6430 /** 6431 * 6432 * Params: 6433 * mount = a #GMount. 6434 * Return: %TRUE if the @mount can be unmounted. 6435 */ 6436 extern(C) int function(GMount* mount) canUnmount; 6437 /** 6438 * 6439 * Params: 6440 * mount = a #GMount. 6441 * Return: %TRUE if the @mount can be ejected. 6442 */ 6443 extern(C) int function(GMount* mount) canEject; 6444 /** */ 6445 extern(C) void function(GMount* mount, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmount; 6446 /** 6447 * 6448 * Params: 6449 * mount = a #GMount. 6450 * result = a #GAsyncResult. 6451 * Return: %TRUE if the mount was successfully unmounted. %FALSE otherwise. 6452 * 6453 * Throws: GException on failure. 6454 */ 6455 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) unmountFinish; 6456 /** */ 6457 extern(C) void function(GMount* mount, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject; 6458 /** 6459 * 6460 * Params: 6461 * mount = a #GMount. 6462 * result = a #GAsyncResult. 6463 * Return: %TRUE if the mount was successfully ejected. %FALSE otherwise. 6464 * 6465 * Throws: GException on failure. 6466 */ 6467 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) ejectFinish; 6468 /** */ 6469 extern(C) void function(GMount* mount, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) remount; 6470 /** 6471 * 6472 * Params: 6473 * mount = a #GMount. 6474 * result = a #GAsyncResult. 6475 * Return: %TRUE if the mount was successfully remounted. %FALSE otherwise. 6476 * 6477 * Throws: GException on failure. 6478 */ 6479 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) remountFinish; 6480 /** */ 6481 extern(C) void function(GMount* mount, int forceRescan, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) guessContentType; 6482 /** 6483 * 6484 * Params: 6485 * mount = a #GMount 6486 * result = a #GAsyncResult 6487 * Return: a %NULL-terminated array of content types or %NULL on error. 6488 * Caller should free this array with g_strfreev() when done with it. 6489 * 6490 * Throws: GException on failure. 6491 */ 6492 extern(C) char** function(GMount* mount, GAsyncResult* result, GError** err) guessContentTypeFinish; 6493 /** 6494 * 6495 * Params: 6496 * mount = a #GMount 6497 * forceRescan = Whether to force a rescan of the content. 6498 * Otherwise a cached result will be used if available 6499 * cancellable = optional #GCancellable object, %NULL to ignore 6500 * Return: a %NULL-terminated array of content types or %NULL on error. 6501 * Caller should free this array with g_strfreev() when done with it. 6502 * 6503 * Throws: GException on failure. 6504 */ 6505 extern(C) char** function(GMount* mount, int forceRescan, GCancellable* cancellable, GError** err) guessContentTypeSync; 6506 /** */ 6507 extern(C) void function(GMount* mount) preUnmount; 6508 /** */ 6509 extern(C) void function(GMount* mount, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) unmountWithOperation; 6510 /** 6511 * 6512 * Params: 6513 * mount = a #GMount. 6514 * result = a #GAsyncResult. 6515 * Return: %TRUE if the mount was successfully unmounted. %FALSE otherwise. 6516 * 6517 * Throws: GException on failure. 6518 */ 6519 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) unmountWithOperationFinish; 6520 /** */ 6521 extern(C) void function(GMount* mount, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation; 6522 /** 6523 * 6524 * Params: 6525 * mount = a #GMount. 6526 * result = a #GAsyncResult. 6527 * Return: %TRUE if the mount was successfully ejected. %FALSE otherwise. 6528 * 6529 * Throws: GException on failure. 6530 */ 6531 extern(C) int function(GMount* mount, GAsyncResult* result, GError** err) ejectWithOperationFinish; 6532 /** 6533 * 6534 * Params: 6535 * mount = a #GMount. 6536 * Return: a #GFile. 6537 * The returned object should be unreffed with 6538 * g_object_unref() when no longer needed. 6539 */ 6540 extern(C) GFile* function(GMount* mount) getDefaultLocation; 6541 /** 6542 * 6543 * Params: 6544 * mount = A #GMount. 6545 * Return: Sorting key for @mount or %NULL if no such key is available. 6546 */ 6547 extern(C) const(char)* function(GMount* mount) getSortKey; 6548 /** 6549 * 6550 * Params: 6551 * mount = a #GMount. 6552 * Return: a #GIcon. 6553 * The returned object should be unreffed with 6554 * g_object_unref() when no longer needed. 6555 */ 6556 extern(C) GIcon* function(GMount* mount) getSymbolicIcon; 6557 } 6558 6559 struct GMountOperation 6560 { 6561 GObject parentInstance; 6562 GMountOperationPrivate* priv; 6563 } 6564 6565 struct GMountOperationClass 6566 { 6567 GObjectClass parentClass; 6568 /** */ 6569 extern(C) void function(GMountOperation* op, const(char)* message, const(char)* defaultUser, const(char)* defaultDomain, GAskPasswordFlags flags) askPassword; 6570 /** */ 6571 extern(C) void function(GMountOperation* op, const(char)* message, const(char)* choices) askQuestion; 6572 /** */ 6573 extern(C) void function(GMountOperation* op, GMountOperationResult result) reply; 6574 /** */ 6575 extern(C) void function(GMountOperation* op) aborted; 6576 /** */ 6577 extern(C) void function(GMountOperation* op, const(char)* message, GArray* processes, const(char)* choices) showProcesses; 6578 /** */ 6579 extern(C) void function(GMountOperation* op, const(char)* message, long timeLeft, long bytesLeft) showUnmountProgress; 6580 /** */ 6581 extern(C) void function() GReserved1; 6582 /** */ 6583 extern(C) void function() GReserved2; 6584 /** */ 6585 extern(C) void function() GReserved3; 6586 /** */ 6587 extern(C) void function() GReserved4; 6588 /** */ 6589 extern(C) void function() GReserved5; 6590 /** */ 6591 extern(C) void function() GReserved6; 6592 /** */ 6593 extern(C) void function() GReserved7; 6594 /** */ 6595 extern(C) void function() GReserved8; 6596 /** */ 6597 extern(C) void function() GReserved9; 6598 } 6599 6600 struct GMountOperationPrivate; 6601 6602 /** 6603 * An socket address of some unknown native type. 6604 */ 6605 struct GNativeSocketAddress; 6606 6607 struct GNativeVolumeMonitor 6608 { 6609 GVolumeMonitor parentInstance; 6610 } 6611 6612 struct GNativeVolumeMonitorClass 6613 { 6614 GVolumeMonitorClass parentClass; 6615 /** */ 6616 extern(C) GMount* function(const(char)* mountPath, GCancellable* cancellable) getMountForMountPath; 6617 } 6618 6619 struct GNetworkAddress 6620 { 6621 GObject parentInstance; 6622 GNetworkAddressPrivate* priv; 6623 } 6624 6625 struct GNetworkAddressClass 6626 { 6627 GObjectClass parentClass; 6628 } 6629 6630 struct GNetworkAddressPrivate; 6631 6632 struct GNetworkMonitor; 6633 6634 /** 6635 * The virtual function table for #GNetworkMonitor. 6636 * 6637 * Since: 2.32 6638 */ 6639 struct GNetworkMonitorInterface 6640 { 6641 /** 6642 * The parent interface. 6643 */ 6644 GTypeInterface gIface; 6645 /** */ 6646 extern(C) void function(GNetworkMonitor* monitor, int available) networkChanged; 6647 /** 6648 * 6649 * Params: 6650 * monitor = a #GNetworkMonitor 6651 * connectable = a #GSocketConnectable 6652 * cancellable = a #GCancellable, or %NULL 6653 * Return: %TRUE if @connectable is reachable, %FALSE if not. 6654 * 6655 * Throws: GException on failure. 6656 */ 6657 extern(C) int function(GNetworkMonitor* monitor, GSocketConnectable* connectable, GCancellable* cancellable, GError** err) canReach; 6658 /** */ 6659 extern(C) void function(GNetworkMonitor* monitor, GSocketConnectable* connectable, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) canReachAsync; 6660 /** 6661 * 6662 * Params: 6663 * monitor = a #GNetworkMonitor 6664 * result = a #GAsyncResult 6665 * Return: %TRUE if network is reachable, %FALSE if not. 6666 * 6667 * Throws: GException on failure. 6668 */ 6669 extern(C) int function(GNetworkMonitor* monitor, GAsyncResult* result, GError** err) canReachFinish; 6670 } 6671 6672 struct GNetworkService 6673 { 6674 GObject parentInstance; 6675 GNetworkServicePrivate* priv; 6676 } 6677 6678 struct GNetworkServiceClass 6679 { 6680 GObjectClass parentClass; 6681 } 6682 6683 struct GNetworkServicePrivate; 6684 6685 struct GNotification; 6686 6687 /** 6688 * Structure used for scatter/gather data output when sending multiple 6689 * messages or packets in one go. You generally pass in an array of 6690 * #GOutputVectors and the operation will use all the buffers as if they 6691 * were one buffer. 6692 * 6693 * If @address is %NULL then the message is sent to the default receiver 6694 * (as previously set by g_socket_connect()). 6695 * 6696 * Since: 2.44 6697 */ 6698 struct GOutputMessage 6699 { 6700 /** 6701 * a #GSocketAddress, or %NULL 6702 */ 6703 GSocketAddress* address; 6704 /** 6705 * pointer to an array of output vectors 6706 */ 6707 GOutputVector* vectors; 6708 /** 6709 * the number of output vectors pointed to by @vectors. 6710 */ 6711 uint numVectors; 6712 /** 6713 * initialize to 0. Will be set to the number of bytes 6714 * that have been sent 6715 */ 6716 uint bytesSent; 6717 /** 6718 * a pointer 6719 * to an array of #GSocketControlMessages, or %NULL. 6720 */ 6721 GSocketControlMessage** controlMessages; 6722 /** 6723 * number of elements in @control_messages. 6724 */ 6725 uint numControlMessages; 6726 } 6727 6728 struct GOutputStream 6729 { 6730 GObject parentInstance; 6731 GOutputStreamPrivate* priv; 6732 } 6733 6734 struct GOutputStreamClass 6735 { 6736 GObjectClass parentClass; 6737 /** 6738 * 6739 * Params: 6740 * stream = a #GOutputStream. 6741 * buffer = the buffer containing the data to write. 6742 * count = the number of bytes to write 6743 * cancellable = optional cancellable object 6744 * Return: Number of bytes written, or -1 on error 6745 * 6746 * Throws: GException on failure. 6747 */ 6748 extern(C) ptrdiff_t function(GOutputStream* stream, void* buffer, size_t count, GCancellable* cancellable, GError** err) writeFn; 6749 /** 6750 * 6751 * Params: 6752 * stream = a #GOutputStream. 6753 * source = a #GInputStream. 6754 * flags = a set of #GOutputStreamSpliceFlags. 6755 * cancellable = optional #GCancellable object, %NULL to ignore. 6756 * Return: a #gssize containing the size of the data spliced, or 6757 * -1 if an error occurred. Note that if the number of bytes 6758 * spliced is greater than %G_MAXSSIZE, then that will be 6759 * returned, and there is no way to determine the actual number 6760 * of bytes spliced. 6761 * 6762 * Throws: GException on failure. 6763 */ 6764 extern(C) ptrdiff_t function(GOutputStream* stream, GInputStream* source, GOutputStreamSpliceFlags flags, GCancellable* cancellable, GError** err) splice; 6765 /** 6766 * 6767 * Params: 6768 * stream = a #GOutputStream. 6769 * cancellable = optional cancellable object 6770 * Return: %TRUE on success, %FALSE on error 6771 * 6772 * Throws: GException on failure. 6773 */ 6774 extern(C) int function(GOutputStream* stream, GCancellable* cancellable, GError** err) flush; 6775 /** */ 6776 extern(C) int function(GOutputStream* stream, GCancellable* cancellable, GError** err) closeFn; 6777 /** */ 6778 extern(C) void function(GOutputStream* stream, void* buffer, size_t count, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) writeAsync; 6779 /** 6780 * 6781 * Params: 6782 * stream = a #GOutputStream. 6783 * result = a #GAsyncResult. 6784 * Return: a #gssize containing the number of bytes written to the stream. 6785 * 6786 * Throws: GException on failure. 6787 */ 6788 extern(C) ptrdiff_t function(GOutputStream* stream, GAsyncResult* result, GError** err) writeFinish; 6789 /** */ 6790 extern(C) void function(GOutputStream* stream, GInputStream* source, GOutputStreamSpliceFlags flags, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) spliceAsync; 6791 /** 6792 * 6793 * Params: 6794 * stream = a #GOutputStream. 6795 * result = a #GAsyncResult. 6796 * Return: a #gssize of the number of bytes spliced. Note that if the 6797 * number of bytes spliced is greater than %G_MAXSSIZE, then that 6798 * will be returned, and there is no way to determine the actual 6799 * number of bytes spliced. 6800 * 6801 * Throws: GException on failure. 6802 */ 6803 extern(C) ptrdiff_t function(GOutputStream* stream, GAsyncResult* result, GError** err) spliceFinish; 6804 /** */ 6805 extern(C) void function(GOutputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) flushAsync; 6806 /** 6807 * 6808 * Params: 6809 * stream = a #GOutputStream. 6810 * result = a GAsyncResult. 6811 * Return: %TRUE if flush operation succeeded, %FALSE otherwise. 6812 * 6813 * Throws: GException on failure. 6814 */ 6815 extern(C) int function(GOutputStream* stream, GAsyncResult* result, GError** err) flushFinish; 6816 /** */ 6817 extern(C) void function(GOutputStream* stream, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) closeAsync; 6818 /** 6819 * 6820 * Params: 6821 * stream = a #GOutputStream. 6822 * result = a #GAsyncResult. 6823 * Return: %TRUE if stream was successfully closed, %FALSE otherwise. 6824 * 6825 * Throws: GException on failure. 6826 */ 6827 extern(C) int function(GOutputStream* stream, GAsyncResult* result, GError** err) closeFinish; 6828 /** */ 6829 extern(C) void function() GReserved1; 6830 /** */ 6831 extern(C) void function() GReserved2; 6832 /** */ 6833 extern(C) void function() GReserved3; 6834 /** */ 6835 extern(C) void function() GReserved4; 6836 /** */ 6837 extern(C) void function() GReserved5; 6838 /** */ 6839 extern(C) void function() GReserved6; 6840 /** */ 6841 extern(C) void function() GReserved7; 6842 /** */ 6843 extern(C) void function() GReserved8; 6844 } 6845 6846 struct GOutputStreamPrivate; 6847 6848 /** 6849 * Structure used for scatter/gather data output. 6850 * You generally pass in an array of #GOutputVectors 6851 * and the operation will use all the buffers as if they were 6852 * one buffer. 6853 * 6854 * Since: 2.22 6855 */ 6856 struct GOutputVector 6857 { 6858 /** 6859 * Pointer to a buffer of data to read. 6860 */ 6861 void* buffer; 6862 /** 6863 * the size of @buffer. 6864 */ 6865 size_t size; 6866 } 6867 6868 struct GPermission 6869 { 6870 GObject parentInstance; 6871 GPermissionPrivate* priv; 6872 } 6873 6874 struct GPermissionClass 6875 { 6876 GObjectClass parentClass; 6877 /** 6878 * 6879 * Params: 6880 * permission = a #GPermission instance 6881 * cancellable = a #GCancellable, or %NULL 6882 * Return: %TRUE if the permission was successfully acquired 6883 * 6884 * Throws: GException on failure. 6885 */ 6886 extern(C) int function(GPermission* permission, GCancellable* cancellable, GError** err) acquire; 6887 /** */ 6888 extern(C) void function(GPermission* permission, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) acquireAsync; 6889 /** 6890 * 6891 * Params: 6892 * permission = a #GPermission instance 6893 * result = the #GAsyncResult given to the #GAsyncReadyCallback 6894 * Return: %TRUE if the permission was successfully acquired 6895 * 6896 * Throws: GException on failure. 6897 */ 6898 extern(C) int function(GPermission* permission, GAsyncResult* result, GError** err) acquireFinish; 6899 /** 6900 * 6901 * Params: 6902 * permission = a #GPermission instance 6903 * cancellable = a #GCancellable, or %NULL 6904 * Return: %TRUE if the permission was successfully released 6905 * 6906 * Throws: GException on failure. 6907 */ 6908 extern(C) int function(GPermission* permission, GCancellable* cancellable, GError** err) release; 6909 /** */ 6910 extern(C) void function(GPermission* permission, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) releaseAsync; 6911 /** 6912 * 6913 * Params: 6914 * permission = a #GPermission instance 6915 * result = the #GAsyncResult given to the #GAsyncReadyCallback 6916 * Return: %TRUE if the permission was successfully released 6917 * 6918 * Throws: GException on failure. 6919 */ 6920 extern(C) int function(GPermission* permission, GAsyncResult* result, GError** err) releaseFinish; 6921 void*[16] reserved; 6922 } 6923 6924 struct GPermissionPrivate; 6925 6926 struct GPollableInputStream; 6927 6928 /** 6929 * The interface for pollable input streams. 6930 * 6931 * The default implementation of @can_poll always returns %TRUE. 6932 * 6933 * The default implementation of @read_nonblocking calls 6934 * g_pollable_input_stream_is_readable(), and then calls 6935 * g_input_stream_read() if it returns %TRUE. This means you only need 6936 * to override it if it is possible that your @is_readable 6937 * implementation may return %TRUE when the stream is not actually 6938 * readable. 6939 * 6940 * Since: 2.28 6941 */ 6942 struct GPollableInputStreamInterface 6943 { 6944 /** 6945 * The parent interface. 6946 */ 6947 GTypeInterface gIface; 6948 /** 6949 * 6950 * Params: 6951 * stream = a #GPollableInputStream. 6952 * Return: %TRUE if @stream is pollable, %FALSE if not. 6953 */ 6954 extern(C) int function(GPollableInputStream* stream) canPoll; 6955 /** 6956 * 6957 * Params: 6958 * stream = a #GPollableInputStream. 6959 * Return: %TRUE if @stream is readable, %FALSE if not. If an error 6960 * has occurred on @stream, this will result in 6961 * g_pollable_input_stream_is_readable() returning %TRUE, and the 6962 * next attempt to read will return the error. 6963 */ 6964 extern(C) int function(GPollableInputStream* stream) isReadable; 6965 /** 6966 * 6967 * Params: 6968 * stream = a #GPollableInputStream. 6969 * cancellable = a #GCancellable, or %NULL 6970 * Return: a new #GSource 6971 */ 6972 extern(C) GSource* function(GPollableInputStream* stream, GCancellable* cancellable) createSource; 6973 /** 6974 * 6975 * Params: 6976 * stream = a #GPollableInputStream 6977 * buffer = a buffer to 6978 * read data into (which should be at least @count bytes long). 6979 * count = the number of bytes you want to read 6980 * Return: the number of bytes read, or -1 on error (including 6981 * %G_IO_ERROR_WOULD_BLOCK). 6982 * 6983 * Throws: GException on failure. 6984 */ 6985 extern(C) ptrdiff_t function(GPollableInputStream* stream, void* buffer, size_t count, GError** err) readNonblocking; 6986 } 6987 6988 struct GPollableOutputStream; 6989 6990 /** 6991 * The interface for pollable output streams. 6992 * 6993 * The default implementation of @can_poll always returns %TRUE. 6994 * 6995 * The default implementation of @write_nonblocking calls 6996 * g_pollable_output_stream_is_writable(), and then calls 6997 * g_output_stream_write() if it returns %TRUE. This means you only 6998 * need to override it if it is possible that your @is_writable 6999 * implementation may return %TRUE when the stream is not actually 7000 * writable. 7001 * 7002 * Since: 2.28 7003 */ 7004 struct GPollableOutputStreamInterface 7005 { 7006 /** 7007 * The parent interface. 7008 */ 7009 GTypeInterface gIface; 7010 /** 7011 * 7012 * Params: 7013 * stream = a #GPollableOutputStream. 7014 * Return: %TRUE if @stream is pollable, %FALSE if not. 7015 */ 7016 extern(C) int function(GPollableOutputStream* stream) canPoll; 7017 /** 7018 * 7019 * Params: 7020 * stream = a #GPollableOutputStream. 7021 * Return: %TRUE if @stream is writable, %FALSE if not. If an error 7022 * has occurred on @stream, this will result in 7023 * g_pollable_output_stream_is_writable() returning %TRUE, and the 7024 * next attempt to write will return the error. 7025 */ 7026 extern(C) int function(GPollableOutputStream* stream) isWritable; 7027 /** 7028 * 7029 * Params: 7030 * stream = a #GPollableOutputStream. 7031 * cancellable = a #GCancellable, or %NULL 7032 * Return: a new #GSource 7033 */ 7034 extern(C) GSource* function(GPollableOutputStream* stream, GCancellable* cancellable) createSource; 7035 /** 7036 * 7037 * Params: 7038 * stream = a #GPollableOutputStream 7039 * buffer = a buffer to write 7040 * data from 7041 * count = the number of bytes you want to write 7042 * Return: the number of bytes written, or -1 on error (including 7043 * %G_IO_ERROR_WOULD_BLOCK). 7044 * 7045 * Throws: GException on failure. 7046 */ 7047 extern(C) ptrdiff_t function(GPollableOutputStream* stream, void* buffer, size_t count, GError** err) writeNonblocking; 7048 } 7049 7050 struct GPropertyAction; 7051 7052 struct GProxy; 7053 7054 struct GProxyAddress 7055 { 7056 GInetSocketAddress parentInstance; 7057 GProxyAddressPrivate* priv; 7058 } 7059 7060 /** 7061 * Class structure for #GProxyAddress. 7062 * 7063 * Since: 2.26 7064 */ 7065 struct GProxyAddressClass 7066 { 7067 GInetSocketAddressClass parentClass; 7068 } 7069 7070 struct GProxyAddressEnumerator 7071 { 7072 GSocketAddressEnumerator parentInstance; 7073 GProxyAddressEnumeratorPrivate* priv; 7074 } 7075 7076 struct GProxyAddressEnumeratorClass 7077 { 7078 GSocketAddressEnumeratorClass parentClass; 7079 /** */ 7080 extern(C) void function() GReserved1; 7081 /** */ 7082 extern(C) void function() GReserved2; 7083 /** */ 7084 extern(C) void function() GReserved3; 7085 /** */ 7086 extern(C) void function() GReserved4; 7087 /** */ 7088 extern(C) void function() GReserved5; 7089 /** */ 7090 extern(C) void function() GReserved6; 7091 /** */ 7092 extern(C) void function() GReserved7; 7093 } 7094 7095 struct GProxyAddressEnumeratorPrivate; 7096 7097 struct GProxyAddressPrivate; 7098 7099 /** 7100 * Provides an interface for handling proxy connection and payload. 7101 * 7102 * Since: 2.26 7103 */ 7104 struct GProxyInterface 7105 { 7106 /** 7107 * The parent interface. 7108 */ 7109 GTypeInterface gIface; 7110 /** 7111 * 7112 * Params: 7113 * proxy = a #GProxy 7114 * connection = a #GIOStream 7115 * proxyAddress = a #GProxyAddress 7116 * cancellable = a #GCancellable 7117 * Return: a #GIOStream that will replace @connection. This might 7118 * be the same as @connection, in which case a reference 7119 * will be added. 7120 * 7121 * Throws: GException on failure. 7122 */ 7123 extern(C) GIOStream* function(GProxy* proxy, GIOStream* connection, GProxyAddress* proxyAddress, GCancellable* cancellable, GError** err) connect; 7124 /** */ 7125 extern(C) void function(GProxy* proxy, GIOStream* connection, GProxyAddress* proxyAddress, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) connectAsync; 7126 /** 7127 * 7128 * Params: 7129 * proxy = a #GProxy 7130 * result = a #GAsyncResult 7131 * Return: a #GIOStream. 7132 * 7133 * Throws: GException on failure. 7134 */ 7135 extern(C) GIOStream* function(GProxy* proxy, GAsyncResult* result, GError** err) connectFinish; 7136 /** 7137 * 7138 * Params: 7139 * proxy = a #GProxy 7140 * Return: %TRUE if hostname resolution is supported. 7141 */ 7142 extern(C) int function(GProxy* proxy) supportsHostname; 7143 } 7144 7145 struct GProxyResolver; 7146 7147 /** 7148 * The virtual function table for #GProxyResolver. 7149 */ 7150 struct GProxyResolverInterface 7151 { 7152 /** 7153 * The parent interface. 7154 */ 7155 GTypeInterface gIface; 7156 /** 7157 * 7158 * Params: 7159 * resolver = a #GProxyResolver 7160 * Return: %TRUE if @resolver is supported. 7161 */ 7162 extern(C) int function(GProxyResolver* resolver) isSupported; 7163 /** 7164 * 7165 * Params: 7166 * resolver = a #GProxyResolver 7167 * uri = a URI representing the destination to connect to 7168 * cancellable = a #GCancellable, or %NULL 7169 * Return: A 7170 * NULL-terminated array of proxy URIs. Must be freed 7171 * with g_strfreev(). 7172 * 7173 * Throws: GException on failure. 7174 */ 7175 extern(C) char** function(GProxyResolver* resolver, const(char)* uri, GCancellable* cancellable, GError** err) lookup; 7176 /** */ 7177 extern(C) void function(GProxyResolver* resolver, const(char)* uri, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupAsync; 7178 /** 7179 * 7180 * Params: 7181 * resolver = a #GProxyResolver 7182 * result = the result passed to your #GAsyncReadyCallback 7183 * Return: A 7184 * NULL-terminated array of proxy URIs. Must be freed 7185 * with g_strfreev(). 7186 * 7187 * Throws: GException on failure. 7188 */ 7189 extern(C) char** function(GProxyResolver* resolver, GAsyncResult* result, GError** err) lookupFinish; 7190 } 7191 7192 struct GRemoteActionGroup; 7193 7194 /** 7195 * The virtual function table for #GRemoteActionGroup. 7196 * 7197 * Since: 2.32 7198 */ 7199 struct GRemoteActionGroupInterface 7200 { 7201 GTypeInterface gIface; 7202 /** */ 7203 extern(C) void function(GRemoteActionGroup* remote, const(char)* actionName, GVariant* parameter, GVariant* platformData) activateActionFull; 7204 /** */ 7205 extern(C) void function(GRemoteActionGroup* remote, const(char)* actionName, GVariant* value, GVariant* platformData) changeActionStateFull; 7206 } 7207 7208 struct GResolver 7209 { 7210 GObject parentInstance; 7211 GResolverPrivate* priv; 7212 } 7213 7214 struct GResolverClass 7215 { 7216 GObjectClass parentClass; 7217 /** */ 7218 extern(C) void function(GResolver* resolver) reload; 7219 /** 7220 * 7221 * Params: 7222 * resolver = a #GResolver 7223 * hostname = the hostname to look up 7224 * cancellable = a #GCancellable, or %NULL 7225 * Return: a non-empty #GList 7226 * of #GInetAddress, or %NULL on error. You 7227 * must unref each of the addresses and free the list when you are 7228 * done with it. (You can use g_resolver_free_addresses() to do this.) 7229 * 7230 * Throws: GException on failure. 7231 */ 7232 extern(C) GList* function(GResolver* resolver, const(char)* hostname, GCancellable* cancellable, GError** err) lookupByName; 7233 /** */ 7234 extern(C) void function(GResolver* resolver, const(char)* hostname, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupByNameAsync; 7235 /** 7236 * 7237 * Params: 7238 * resolver = a #GResolver 7239 * result = the result passed to your #GAsyncReadyCallback 7240 * Return: a #GList 7241 * of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() 7242 * for more details. 7243 * 7244 * Throws: GException on failure. 7245 */ 7246 extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupByNameFinish; 7247 /** 7248 * 7249 * Params: 7250 * resolver = a #GResolver 7251 * address = the address to reverse-resolve 7252 * cancellable = a #GCancellable, or %NULL 7253 * Return: a hostname (either ASCII-only, or in ASCII-encoded 7254 * form), or %NULL on error. 7255 * 7256 * Throws: GException on failure. 7257 */ 7258 extern(C) char* function(GResolver* resolver, GInetAddress* address, GCancellable* cancellable, GError** err) lookupByAddress; 7259 /** */ 7260 extern(C) void function(GResolver* resolver, GInetAddress* address, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupByAddressAsync; 7261 /** 7262 * 7263 * Params: 7264 * resolver = a #GResolver 7265 * result = the result passed to your #GAsyncReadyCallback 7266 * Return: a hostname (either ASCII-only, or in ASCII-encoded 7267 * form), or %NULL on error. 7268 * 7269 * Throws: GException on failure. 7270 */ 7271 extern(C) char* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupByAddressFinish; 7272 /** */ 7273 extern(C) GList* function(GResolver* resolver, const(char)* rrname, GCancellable* cancellable, GError** err) lookupService; 7274 /** */ 7275 extern(C) void function(GResolver* resolver, const(char)* rrname, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupServiceAsync; 7276 /** 7277 * 7278 * Params: 7279 * resolver = a #GResolver 7280 * result = the result passed to your #GAsyncReadyCallback 7281 * Return: a non-empty #GList of 7282 * #GSrvTarget, or %NULL on error. See g_resolver_lookup_service() for more 7283 * details. 7284 * 7285 * Throws: GException on failure. 7286 */ 7287 extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupServiceFinish; 7288 /** 7289 * 7290 * Params: 7291 * resolver = a #GResolver 7292 * rrname = the DNS name to lookup the record for 7293 * recordType = the type of DNS record to lookup 7294 * cancellable = a #GCancellable, or %NULL 7295 * Return: a non-empty #GList of 7296 * #GVariant, or %NULL on error. You must free each of the records and the list 7297 * when you are done with it. (You can use g_list_free_full() with 7298 * g_variant_unref() to do this.) 7299 * 7300 * Throws: GException on failure. 7301 */ 7302 extern(C) GList* function(GResolver* resolver, const(char)* rrname, GResolverRecordType recordType, GCancellable* cancellable, GError** err) lookupRecords; 7303 /** */ 7304 extern(C) void function(GResolver* resolver, const(char)* rrname, GResolverRecordType recordType, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupRecordsAsync; 7305 /** 7306 * 7307 * Params: 7308 * resolver = a #GResolver 7309 * result = the result passed to your #GAsyncReadyCallback 7310 * Return: a non-empty #GList of 7311 * #GVariant, or %NULL on error. You must free each of the records and the list 7312 * when you are done with it. (You can use g_list_free_full() with 7313 * g_variant_unref() to do this.) 7314 * 7315 * Throws: GException on failure. 7316 */ 7317 extern(C) GList* function(GResolver* resolver, GAsyncResult* result, GError** err) lookupRecordsFinish; 7318 /** */ 7319 extern(C) void function() GReserved4; 7320 /** */ 7321 extern(C) void function() GReserved5; 7322 /** */ 7323 extern(C) void function() GReserved6; 7324 } 7325 7326 struct GResolverPrivate; 7327 7328 struct GResource; 7329 7330 struct GSeekable; 7331 7332 /** 7333 * Provides an interface for implementing seekable functionality on I/O Streams. 7334 */ 7335 struct GSeekableIface 7336 { 7337 /** 7338 * The parent interface. 7339 */ 7340 GTypeInterface gIface; 7341 /** 7342 * 7343 * Params: 7344 * seekable = a #GSeekable. 7345 * Return: the offset from the beginning of the buffer. 7346 */ 7347 extern(C) long function(GSeekable* seekable) tell; 7348 /** 7349 * 7350 * Params: 7351 * seekable = a #GSeekable. 7352 * Return: %TRUE if @seekable can be seeked. %FALSE otherwise. 7353 */ 7354 extern(C) int function(GSeekable* seekable) canSeek; 7355 /** 7356 * 7357 * Params: 7358 * seekable = a #GSeekable. 7359 * offset = a #goffset. 7360 * type = a #GSeekType. 7361 * cancellable = optional #GCancellable object, %NULL to ignore. 7362 * Return: %TRUE if successful. If an error 7363 * has occurred, this function will return %FALSE and set @error 7364 * appropriately if present. 7365 * 7366 * Throws: GException on failure. 7367 */ 7368 extern(C) int function(GSeekable* seekable, long offset, GSeekType type, GCancellable* cancellable, GError** err) seek; 7369 /** 7370 * 7371 * Params: 7372 * seekable = a #GSeekable. 7373 * Return: %TRUE if the stream can be truncated, %FALSE otherwise. 7374 */ 7375 extern(C) int function(GSeekable* seekable) canTruncate; 7376 /** 7377 * 7378 * Params: 7379 * seekable = a #GSeekable. 7380 * offset = a #goffset. 7381 * cancellable = optional #GCancellable object, %NULL to ignore. 7382 * Return: %TRUE if successful. If an error 7383 * has occurred, this function will return %FALSE and set @error 7384 * appropriately if present. 7385 * 7386 * Throws: GException on failure. 7387 */ 7388 extern(C) int function(GSeekable* seekable, long offset, GCancellable* cancellable, GError** err) truncateFn; 7389 } 7390 7391 struct GSettings 7392 { 7393 GObject parentInstance; 7394 GSettingsPrivate* priv; 7395 } 7396 7397 /** 7398 * The #GSettingsBackend interface defines a generic interface for 7399 * non-strictly-typed data that is stored in a hierarchy. To implement 7400 * an alternative storage backend for #GSettings, you need to implement 7401 * the #GSettingsBackend interface and then make it implement the 7402 * extension point #G_SETTINGS_BACKEND_EXTENSION_POINT_NAME. 7403 * 7404 * The interface defines methods for reading and writing values, a 7405 * method for determining if writing of certain values will fail 7406 * (lockdown) and a change notification mechanism. 7407 * 7408 * The semantics of the interface are very precisely defined and 7409 * implementations must carefully adhere to the expectations of 7410 * callers that are documented on each of the interface methods. 7411 * 7412 * Some of the GSettingsBackend functions accept or return a #GTree. 7413 * These trees always have strings as keys and #GVariant as values. 7414 * g_settings_backend_create_tree() is a convenience function to create 7415 * suitable trees. 7416 * 7417 * The GSettingsBackend API is exported to allow third-party 7418 * implementations, but does not carry the same stability guarantees 7419 * as the public GIO API. For this reason, you have to define the 7420 * C preprocessor symbol %G_SETTINGS_ENABLE_BACKEND before including 7421 * `gio/gsettingsbackend.h`. 7422 */ 7423 struct GSettingsBackend; 7424 7425 struct GSettingsClass 7426 { 7427 GObjectClass parentClass; 7428 /** */ 7429 extern(C) void function(GSettings* settings, const(char)* key) writableChanged; 7430 /** */ 7431 extern(C) void function(GSettings* settings, const(char)* key) changed; 7432 /** */ 7433 extern(C) int function(GSettings* settings, GQuark key) writableChangeEvent; 7434 /** */ 7435 extern(C) int function(GSettings* settings, GQuark* keys, int nKeys) changeEvent; 7436 void*[20] padding; 7437 } 7438 7439 struct GSettingsPrivate; 7440 7441 struct GSettingsSchema; 7442 7443 struct GSettingsSchemaKey; 7444 7445 struct GSettingsSchemaSource; 7446 7447 struct GSimpleAction; 7448 7449 struct GSimpleActionGroup 7450 { 7451 GObject parentInstance; 7452 GSimpleActionGroupPrivate* priv; 7453 } 7454 7455 struct GSimpleActionGroupClass 7456 { 7457 GObjectClass parentClass; 7458 void*[12] padding; 7459 } 7460 7461 struct GSimpleActionGroupPrivate; 7462 7463 struct GSimpleAsyncResult; 7464 7465 struct GSimpleAsyncResultClass; 7466 7467 struct GSimpleIOStream; 7468 7469 struct GSimplePermission; 7470 7471 struct GSimpleProxyResolver 7472 { 7473 GObject parentInstance; 7474 GSimpleProxyResolverPrivate* priv; 7475 } 7476 7477 struct GSimpleProxyResolverClass 7478 { 7479 GObjectClass parentClass; 7480 /** */ 7481 extern(C) void function() GReserved1; 7482 /** */ 7483 extern(C) void function() GReserved2; 7484 /** */ 7485 extern(C) void function() GReserved3; 7486 /** */ 7487 extern(C) void function() GReserved4; 7488 /** */ 7489 extern(C) void function() GReserved5; 7490 } 7491 7492 struct GSimpleProxyResolverPrivate; 7493 7494 struct GSocket 7495 { 7496 GObject parentInstance; 7497 GSocketPrivate* priv; 7498 } 7499 7500 struct GSocketAddress 7501 { 7502 GObject parentInstance; 7503 } 7504 7505 struct GSocketAddressClass 7506 { 7507 GObjectClass parentClass; 7508 /** 7509 * 7510 * Params: 7511 * address = a #GSocketAddress 7512 * Return: the socket family type of @address 7513 */ 7514 extern(C) GSocketFamily function(GSocketAddress* address) getFamily; 7515 /** 7516 * 7517 * Params: 7518 * address = a #GSocketAddress 7519 * Return: the size of the native struct sockaddr that 7520 * @address represents 7521 */ 7522 extern(C) ptrdiff_t function(GSocketAddress* address) getNativeSize; 7523 /** 7524 * 7525 * Params: 7526 * address = a #GSocketAddress 7527 * dest = a pointer to a memory location that will contain the native 7528 * struct sockaddr 7529 * destlen = the size of @dest. Must be at least as large as 7530 * g_socket_address_get_native_size() 7531 * Return: %TRUE if @dest was filled in, %FALSE on error 7532 * 7533 * Throws: GException on failure. 7534 */ 7535 extern(C) int function(GSocketAddress* address, void* dest, size_t destlen, GError** err) toNative; 7536 } 7537 7538 struct GSocketAddressEnumerator 7539 { 7540 GObject parentInstance; 7541 } 7542 7543 struct GSocketAddressEnumeratorClass 7544 { 7545 GObjectClass parentClass; 7546 /** 7547 * 7548 * Params: 7549 * enumerator = a #GSocketAddressEnumerator 7550 * cancellable = optional #GCancellable object, %NULL to ignore. 7551 * Return: a #GSocketAddress (owned by the caller), or %NULL on 7552 * error (in which case *@error will be set) or if there are no 7553 * more addresses. 7554 * 7555 * Throws: GException on failure. 7556 */ 7557 extern(C) GSocketAddress* function(GSocketAddressEnumerator* enumerator, GCancellable* cancellable, GError** err) next; 7558 /** */ 7559 extern(C) void function(GSocketAddressEnumerator* enumerator, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) nextAsync; 7560 /** 7561 * 7562 * Params: 7563 * enumerator = a #GSocketAddressEnumerator 7564 * result = a #GAsyncResult 7565 * Return: a #GSocketAddress (owned by the caller), or %NULL on 7566 * error (in which case *@error will be set) or if there are no 7567 * more addresses. 7568 * 7569 * Throws: GException on failure. 7570 */ 7571 extern(C) GSocketAddress* function(GSocketAddressEnumerator* enumerator, GAsyncResult* result, GError** err) nextFinish; 7572 } 7573 7574 struct GSocketClass 7575 { 7576 GObjectClass parentClass; 7577 /** */ 7578 extern(C) void function() GReserved1; 7579 /** */ 7580 extern(C) void function() GReserved2; 7581 /** */ 7582 extern(C) void function() GReserved3; 7583 /** */ 7584 extern(C) void function() GReserved4; 7585 /** */ 7586 extern(C) void function() GReserved5; 7587 /** */ 7588 extern(C) void function() GReserved6; 7589 /** */ 7590 extern(C) void function() GReserved7; 7591 /** */ 7592 extern(C) void function() GReserved8; 7593 /** */ 7594 extern(C) void function() GReserved9; 7595 /** */ 7596 extern(C) void function() GReserved10; 7597 } 7598 7599 struct GSocketClient 7600 { 7601 GObject parentInstance; 7602 GSocketClientPrivate* priv; 7603 } 7604 7605 struct GSocketClientClass 7606 { 7607 GObjectClass parentClass; 7608 /** */ 7609 extern(C) void function(GSocketClient* client, GSocketClientEvent event, GSocketConnectable* connectable, GIOStream* connection) event; 7610 /** */ 7611 extern(C) void function() GReserved1; 7612 /** */ 7613 extern(C) void function() GReserved2; 7614 /** */ 7615 extern(C) void function() GReserved3; 7616 /** */ 7617 extern(C) void function() GReserved4; 7618 } 7619 7620 struct GSocketClientPrivate; 7621 7622 struct GSocketConnectable; 7623 7624 /** 7625 * Provides an interface for returning a #GSocketAddressEnumerator 7626 * and #GProxyAddressEnumerator 7627 */ 7628 struct GSocketConnectableIface 7629 { 7630 /** 7631 * The parent interface. 7632 */ 7633 GTypeInterface gIface; 7634 /** 7635 * 7636 * Params: 7637 * connectable = a #GSocketConnectable 7638 * Return: a new #GSocketAddressEnumerator. 7639 */ 7640 extern(C) GSocketAddressEnumerator* function(GSocketConnectable* connectable) enumerate; 7641 /** 7642 * 7643 * Params: 7644 * connectable = a #GSocketConnectable 7645 * Return: a new #GSocketAddressEnumerator. 7646 */ 7647 extern(C) GSocketAddressEnumerator* function(GSocketConnectable* connectable) proxyEnumerate; 7648 } 7649 7650 struct GSocketConnection 7651 { 7652 GIOStream parentInstance; 7653 GSocketConnectionPrivate* priv; 7654 } 7655 7656 struct GSocketConnectionClass 7657 { 7658 GIOStreamClass parentClass; 7659 /** */ 7660 extern(C) void function() GReserved1; 7661 /** */ 7662 extern(C) void function() GReserved2; 7663 /** */ 7664 extern(C) void function() GReserved3; 7665 /** */ 7666 extern(C) void function() GReserved4; 7667 /** */ 7668 extern(C) void function() GReserved5; 7669 /** */ 7670 extern(C) void function() GReserved6; 7671 } 7672 7673 struct GSocketConnectionPrivate; 7674 7675 struct GSocketControlMessage 7676 { 7677 GObject parentInstance; 7678 GSocketControlMessagePrivate* priv; 7679 } 7680 7681 /** 7682 * Class structure for #GSocketControlMessage. 7683 */ 7684 struct GSocketControlMessageClass 7685 { 7686 GObjectClass parentClass; 7687 /** 7688 * 7689 * Params: 7690 * message = a #GSocketControlMessage 7691 * Return: The number of bytes required. 7692 */ 7693 extern(C) size_t function(GSocketControlMessage* message) getSize; 7694 /** 7695 * 7696 * Params: 7697 * message = a #GSocketControlMessage 7698 * Return: an integer describing the level 7699 */ 7700 extern(C) int function(GSocketControlMessage* message) getLevel; 7701 /** */ 7702 extern(C) int function(GSocketControlMessage* message) getType; 7703 /** */ 7704 extern(C) void function(GSocketControlMessage* message, void* data) serialize; 7705 /** */ 7706 extern(C) GSocketControlMessage* function(int level, int type, size_t size, void* data) deserialize; 7707 /** */ 7708 extern(C) void function() GReserved1; 7709 /** */ 7710 extern(C) void function() GReserved2; 7711 /** */ 7712 extern(C) void function() GReserved3; 7713 /** */ 7714 extern(C) void function() GReserved4; 7715 /** */ 7716 extern(C) void function() GReserved5; 7717 } 7718 7719 struct GSocketControlMessagePrivate; 7720 7721 struct GSocketListener 7722 { 7723 GObject parentInstance; 7724 GSocketListenerPrivate* priv; 7725 } 7726 7727 /** 7728 * Class structure for #GSocketListener. 7729 */ 7730 struct GSocketListenerClass 7731 { 7732 GObjectClass parentClass; 7733 /** */ 7734 extern(C) void function(GSocketListener* listener) changed; 7735 /** */ 7736 extern(C) void function(GSocketListener* listener, GSocketListenerEvent* event, GSocket* socket) event; 7737 /** */ 7738 extern(C) void function() GReserved2; 7739 /** */ 7740 extern(C) void function() GReserved3; 7741 /** */ 7742 extern(C) void function() GReserved4; 7743 /** */ 7744 extern(C) void function() GReserved5; 7745 /** */ 7746 extern(C) void function() GReserved6; 7747 } 7748 7749 struct GSocketListenerPrivate; 7750 7751 struct GSocketPrivate; 7752 7753 struct GSocketService 7754 { 7755 GSocketListener parentInstance; 7756 GSocketServicePrivate* priv; 7757 } 7758 7759 /** 7760 * Class structure for #GSocketService. 7761 */ 7762 struct GSocketServiceClass 7763 { 7764 GSocketListenerClass parentClass; 7765 /** */ 7766 extern(C) int function(GSocketService* service, GSocketConnection* connection, GObject* sourceObject) incoming; 7767 /** */ 7768 extern(C) void function() GReserved1; 7769 /** */ 7770 extern(C) void function() GReserved2; 7771 /** */ 7772 extern(C) void function() GReserved3; 7773 /** */ 7774 extern(C) void function() GReserved4; 7775 /** */ 7776 extern(C) void function() GReserved5; 7777 /** */ 7778 extern(C) void function() GReserved6; 7779 } 7780 7781 struct GSocketServicePrivate; 7782 7783 struct GSrvTarget; 7784 7785 struct GStaticResource 7786 { 7787 ubyte* data; 7788 size_t dataLen; 7789 GResource* resource; 7790 GStaticResource* next; 7791 void* padding; 7792 } 7793 7794 struct GSubprocess; 7795 7796 struct GSubprocessLauncher; 7797 7798 struct GTask; 7799 7800 struct GTaskClass; 7801 7802 struct GTcpConnection 7803 { 7804 GSocketConnection parentInstance; 7805 GTcpConnectionPrivate* priv; 7806 } 7807 7808 struct GTcpConnectionClass 7809 { 7810 GSocketConnectionClass parentClass; 7811 } 7812 7813 struct GTcpConnectionPrivate; 7814 7815 struct GTcpWrapperConnection 7816 { 7817 GTcpConnection parentInstance; 7818 GTcpWrapperConnectionPrivate* priv; 7819 } 7820 7821 struct GTcpWrapperConnectionClass 7822 { 7823 GTcpConnectionClass parentClass; 7824 } 7825 7826 struct GTcpWrapperConnectionPrivate; 7827 7828 struct GTestDBus; 7829 7830 struct GThemedIcon; 7831 7832 struct GThemedIconClass; 7833 7834 struct GThreadedSocketService 7835 { 7836 GSocketService parentInstance; 7837 GThreadedSocketServicePrivate* priv; 7838 } 7839 7840 struct GThreadedSocketServiceClass 7841 { 7842 GSocketServiceClass parentClass; 7843 /** */ 7844 extern(C) int function(GThreadedSocketService* service, GSocketConnection* connection, GObject* sourceObject) run; 7845 /** */ 7846 extern(C) void function() GReserved1; 7847 /** */ 7848 extern(C) void function() GReserved2; 7849 /** */ 7850 extern(C) void function() GReserved3; 7851 /** */ 7852 extern(C) void function() GReserved4; 7853 /** */ 7854 extern(C) void function() GReserved5; 7855 } 7856 7857 struct GThreadedSocketServicePrivate; 7858 7859 struct GTlsBackend; 7860 7861 /** 7862 * Provides an interface for describing TLS-related types. 7863 * 7864 * Since: 2.28 7865 */ 7866 struct GTlsBackendInterface 7867 { 7868 /** 7869 * The parent interface. 7870 */ 7871 GTypeInterface gIface; 7872 /** 7873 * 7874 * Params: 7875 * backend = the #GTlsBackend 7876 * Return: whether or not TLS is supported 7877 */ 7878 extern(C) int function(GTlsBackend* backend) supportsTls; 7879 /** */ 7880 extern(C) GType function() getCertificateType; 7881 /** */ 7882 extern(C) GType function() getClientConnectionType; 7883 /** */ 7884 extern(C) GType function() getServerConnectionType; 7885 /** */ 7886 extern(C) GType function() getFileDatabaseType; 7887 /** 7888 * 7889 * Params: 7890 * backend = the #GTlsBackend 7891 * Return: the default database, which should be 7892 * unreffed when done. 7893 */ 7894 extern(C) GTlsDatabase* function(GTlsBackend* backend) getDefaultDatabase; 7895 } 7896 7897 struct GTlsCertificate 7898 { 7899 GObject parentInstance; 7900 GTlsCertificatePrivate* priv; 7901 } 7902 7903 struct GTlsCertificateClass 7904 { 7905 GObjectClass parentClass; 7906 /** 7907 * 7908 * Params: 7909 * cert = a #GTlsCertificate 7910 * identity = the expected peer identity 7911 * trustedCa = the certificate of a trusted authority 7912 * Return: the appropriate #GTlsCertificateFlags 7913 */ 7914 extern(C) GTlsCertificateFlags function(GTlsCertificate* cert, GSocketConnectable* identity, GTlsCertificate* trustedCa) verify; 7915 void*[8] padding; 7916 } 7917 7918 struct GTlsCertificatePrivate; 7919 7920 struct GTlsClientConnection; 7921 7922 /** 7923 * vtable for a #GTlsClientConnection implementation. 7924 * 7925 * Since: 2.26 7926 */ 7927 struct GTlsClientConnectionInterface 7928 { 7929 /** 7930 * The parent interface. 7931 */ 7932 GTypeInterface gIface; 7933 /** */ 7934 extern(C) void function(GTlsClientConnection* conn, GTlsClientConnection* source) copySessionState; 7935 } 7936 7937 struct GTlsConnection 7938 { 7939 GIOStream parentInstance; 7940 GTlsConnectionPrivate* priv; 7941 } 7942 7943 struct GTlsConnectionClass 7944 { 7945 GIOStreamClass parentClass; 7946 /** */ 7947 extern(C) int function(GTlsConnection* connection, GTlsCertificate* peerCert, GTlsCertificateFlags errors) acceptCertificate; 7948 /** 7949 * 7950 * Params: 7951 * conn = a #GTlsConnection 7952 * cancellable = a #GCancellable, or %NULL 7953 * Return: success or failure 7954 * 7955 * Throws: GException on failure. 7956 */ 7957 extern(C) int function(GTlsConnection* conn, GCancellable* cancellable, GError** err) handshake; 7958 /** */ 7959 extern(C) void function(GTlsConnection* conn, int ioPriority, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) handshakeAsync; 7960 /** 7961 * 7962 * Params: 7963 * conn = a #GTlsConnection 7964 * result = a #GAsyncResult. 7965 * Return: %TRUE on success, %FALSE on failure, in which 7966 * case @error will be set. 7967 * 7968 * Throws: GException on failure. 7969 */ 7970 extern(C) int function(GTlsConnection* conn, GAsyncResult* result, GError** err) handshakeFinish; 7971 void*[8] padding; 7972 } 7973 7974 struct GTlsConnectionPrivate; 7975 7976 struct GTlsDatabase 7977 { 7978 GObject parentInstance; 7979 GTlsDatabasePrivate* priv; 7980 } 7981 7982 /** 7983 * The class for #GTlsDatabase. Derived classes should implement the various 7984 * virtual methods. _async and _finish methods have a default 7985 * implementation that runs the corresponding sync method in a thread. 7986 * 7987 * Since: 2.30 7988 */ 7989 struct GTlsDatabaseClass 7990 { 7991 GObjectClass parentClass; 7992 /** 7993 * 7994 * Params: 7995 * self = a #GTlsDatabase 7996 * chain = a #GTlsCertificate chain 7997 * purpose = the purpose that this certificate chain will be used for. 7998 * identity = the expected peer identity 7999 * interaction = used to interact with the user if necessary 8000 * flags = additional verify flags 8001 * cancellable = a #GCancellable, or %NULL 8002 * Return: the appropriate #GTlsCertificateFlags which represents the 8003 * result of verification. 8004 * 8005 * Throws: GException on failure. 8006 */ 8007 extern(C) GTlsCertificateFlags function(GTlsDatabase* self, GTlsCertificate* chain, const(char)* purpose, GSocketConnectable* identity, GTlsInteraction* interaction, GTlsDatabaseVerifyFlags flags, GCancellable* cancellable, GError** err) verifyChain; 8008 /** */ 8009 extern(C) void function(GTlsDatabase* self, GTlsCertificate* chain, const(char)* purpose, GSocketConnectable* identity, GTlsInteraction* interaction, GTlsDatabaseVerifyFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) verifyChainAsync; 8010 /** 8011 * 8012 * Params: 8013 * self = a #GTlsDatabase 8014 * result = a #GAsyncResult. 8015 * Return: the appropriate #GTlsCertificateFlags which represents the 8016 * result of verification. 8017 * 8018 * Throws: GException on failure. 8019 */ 8020 extern(C) GTlsCertificateFlags function(GTlsDatabase* self, GAsyncResult* result, GError** err) verifyChainFinish; 8021 /** 8022 * 8023 * Params: 8024 * self = a #GTlsDatabase 8025 * certificate = certificate for which to create a handle. 8026 * Return: a newly allocated string containing the 8027 * handle. 8028 */ 8029 extern(C) char* function(GTlsDatabase* self, GTlsCertificate* certificate) createCertificateHandle; 8030 /** 8031 * 8032 * Params: 8033 * self = a #GTlsDatabase 8034 * handle = a certificate handle 8035 * interaction = used to interact with the user if necessary 8036 * flags = Flags which affect the lookup. 8037 * cancellable = a #GCancellable, or %NULL 8038 * Return: a newly allocated 8039 * #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate. 8040 * 8041 * Throws: GException on failure. 8042 */ 8043 extern(C) GTlsCertificate* function(GTlsDatabase* self, const(char)* handle, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificateForHandle; 8044 /** */ 8045 extern(C) void function(GTlsDatabase* self, const(char)* handle, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificateForHandleAsync; 8046 /** 8047 * 8048 * Params: 8049 * self = a #GTlsDatabase 8050 * result = a #GAsyncResult. 8051 * Return: a newly allocated #GTlsCertificate object. 8052 * Use g_object_unref() to release the certificate. 8053 * 8054 * Throws: GException on failure. 8055 */ 8056 extern(C) GTlsCertificate* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificateForHandleFinish; 8057 /** 8058 * 8059 * Params: 8060 * self = a #GTlsDatabase 8061 * certificate = a #GTlsCertificate 8062 * interaction = used to interact with the user if necessary 8063 * flags = flags which affect the lookup operation 8064 * cancellable = a #GCancellable, or %NULL 8065 * Return: a newly allocated issuer #GTlsCertificate, 8066 * or %NULL. Use g_object_unref() to release the certificate. 8067 * 8068 * Throws: GException on failure. 8069 */ 8070 extern(C) GTlsCertificate* function(GTlsDatabase* self, GTlsCertificate* certificate, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificateIssuer; 8071 /** */ 8072 extern(C) void function(GTlsDatabase* self, GTlsCertificate* certificate, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificateIssuerAsync; 8073 /** 8074 * 8075 * Params: 8076 * self = a #GTlsDatabase 8077 * result = a #GAsyncResult. 8078 * Return: a newly allocated issuer #GTlsCertificate, 8079 * or %NULL. Use g_object_unref() to release the certificate. 8080 * 8081 * Throws: GException on failure. 8082 */ 8083 extern(C) GTlsCertificate* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificateIssuerFinish; 8084 /** 8085 * 8086 * Params: 8087 * self = a #GTlsDatabase 8088 * issuerRawDn = a #GByteArray which holds the DER encoded issuer DN. 8089 * interaction = used to interact with the user if necessary 8090 * flags = Flags which affect the lookup operation. 8091 * cancellable = a #GCancellable, or %NULL 8092 * Return: a newly allocated list of #GTlsCertificate 8093 * objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. 8094 * 8095 * Throws: GException on failure. 8096 */ 8097 extern(C) GList* function(GTlsDatabase* self, GByteArray* issuerRawDn, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GError** err) lookupCertificatesIssuedBy; 8098 /** */ 8099 extern(C) void function(GTlsDatabase* self, GByteArray* issuerRawDn, GTlsInteraction* interaction, GTlsDatabaseLookupFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) lookupCertificatesIssuedByAsync; 8100 /** 8101 * 8102 * Params: 8103 * self = a #GTlsDatabase 8104 * result = a #GAsyncResult. 8105 * Return: a newly allocated list of #GTlsCertificate 8106 * objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list. 8107 * 8108 * Throws: GException on failure. 8109 */ 8110 extern(C) GList* function(GTlsDatabase* self, GAsyncResult* result, GError** err) lookupCertificatesIssuedByFinish; 8111 void*[16] padding; 8112 } 8113 8114 struct GTlsDatabasePrivate; 8115 8116 struct GTlsFileDatabase; 8117 8118 /** 8119 * Provides an interface for #GTlsFileDatabase implementations. 8120 */ 8121 struct GTlsFileDatabaseInterface 8122 { 8123 /** 8124 * The parent interface. 8125 */ 8126 GTypeInterface gIface; 8127 void*[8] padding; 8128 } 8129 8130 struct GTlsInteraction 8131 { 8132 GObject parentInstance; 8133 GTlsInteractionPrivate* priv; 8134 } 8135 8136 /** 8137 * The class for #GTlsInteraction. Derived classes implement the various 8138 * virtual interaction methods to handle TLS interactions. 8139 * 8140 * Derived classes can choose to implement whichever interactions methods they'd 8141 * like to support by overriding those virtual methods in their class 8142 * initialization function. If a derived class implements an async method, 8143 * it must also implement the corresponding finish method. 8144 * 8145 * The synchronous interaction methods should implement to display modal dialogs, 8146 * and the asynchronous methods to display modeless dialogs. 8147 * 8148 * If the user cancels an interaction, then the result should be 8149 * %G_TLS_INTERACTION_FAILED and the error should be set with a domain of 8150 * %G_IO_ERROR and code of %G_IO_ERROR_CANCELLED. 8151 * 8152 * Since: 2.30 8153 */ 8154 struct GTlsInteractionClass 8155 { 8156 GObjectClass parentClass; 8157 /** 8158 * 8159 * Params: 8160 * interaction = a #GTlsInteraction object 8161 * password = a #GTlsPassword object 8162 * cancellable = an optional #GCancellable cancellation object 8163 * Return: The status of the ask password interaction. 8164 * 8165 * Throws: GException on failure. 8166 */ 8167 extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GError** err) askPassword; 8168 /** */ 8169 extern(C) void function(GTlsInteraction* interaction, GTlsPassword* password, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) askPasswordAsync; 8170 /** 8171 * 8172 * Params: 8173 * interaction = a #GTlsInteraction object 8174 * result = the result passed to the callback 8175 * Return: The status of the ask password interaction. 8176 * 8177 * Throws: GException on failure. 8178 */ 8179 extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GAsyncResult* result, GError** err) askPasswordFinish; 8180 /** 8181 * 8182 * Params: 8183 * interaction = a #GTlsInteraction object 8184 * connection = a #GTlsConnection object 8185 * flags = flags providing more information about the request 8186 * cancellable = an optional #GCancellable cancellation object 8187 * Return: The status of the request certificate interaction. 8188 * 8189 * Throws: GException on failure. 8190 */ 8191 extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GError** err) requestCertificate; 8192 /** */ 8193 extern(C) void function(GTlsInteraction* interaction, GTlsConnection* connection, GTlsCertificateRequestFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) requestCertificateAsync; 8194 /** 8195 * 8196 * Params: 8197 * interaction = a #GTlsInteraction object 8198 * result = the result passed to the callback 8199 * Return: The status of the request certificate interaction. 8200 * 8201 * Throws: GException on failure. 8202 */ 8203 extern(C) GTlsInteractionResult function(GTlsInteraction* interaction, GAsyncResult* result, GError** err) requestCertificateFinish; 8204 void*[21] padding; 8205 } 8206 8207 struct GTlsInteractionPrivate; 8208 8209 struct GTlsPassword 8210 { 8211 GObject parentInstance; 8212 GTlsPasswordPrivate* priv; 8213 } 8214 8215 /** 8216 * Class structure for #GTlsPassword. 8217 */ 8218 struct GTlsPasswordClass 8219 { 8220 GObjectClass parentClass; 8221 /** 8222 * 8223 * Params: 8224 * password = a #GTlsPassword object 8225 * length = location to place the length of the password. 8226 * Return: The password value (owned by the password object). 8227 */ 8228 extern(C) char* function(GTlsPassword* password, size_t* length) getValue; 8229 /** */ 8230 extern(C) void function(GTlsPassword* password, char* value, ptrdiff_t length, GDestroyNotify destroy) setValue; 8231 /** */ 8232 extern(C) const(char)* function(GTlsPassword* password) getDefaultWarning; 8233 void*[4] padding; 8234 } 8235 8236 struct GTlsPasswordPrivate; 8237 8238 struct GTlsServerConnection; 8239 8240 /** 8241 * vtable for a #GTlsServerConnection implementation. 8242 * 8243 * Since: 2.26 8244 */ 8245 struct GTlsServerConnectionInterface 8246 { 8247 /** 8248 * The parent interface. 8249 */ 8250 GTypeInterface gIface; 8251 } 8252 8253 struct GUnixConnection 8254 { 8255 GSocketConnection parentInstance; 8256 GUnixConnectionPrivate* priv; 8257 } 8258 8259 struct GUnixConnectionClass 8260 { 8261 GSocketConnectionClass parentClass; 8262 } 8263 8264 struct GUnixConnectionPrivate; 8265 8266 struct GUnixCredentialsMessage 8267 { 8268 GSocketControlMessage parentInstance; 8269 GUnixCredentialsMessagePrivate* priv; 8270 } 8271 8272 /** 8273 * Class structure for #GUnixCredentialsMessage. 8274 * 8275 * Since: 2.26 8276 */ 8277 struct GUnixCredentialsMessageClass 8278 { 8279 GSocketControlMessageClass parentClass; 8280 /** */ 8281 extern(C) void function() GReserved1; 8282 /** */ 8283 extern(C) void function() GReserved2; 8284 } 8285 8286 struct GUnixCredentialsMessagePrivate; 8287 8288 struct GUnixFDList 8289 { 8290 GObject parentInstance; 8291 GUnixFDListPrivate* priv; 8292 } 8293 8294 struct GUnixFDListClass 8295 { 8296 GObjectClass parentClass; 8297 /** */ 8298 extern(C) void function() GReserved1; 8299 /** */ 8300 extern(C) void function() GReserved2; 8301 /** */ 8302 extern(C) void function() GReserved3; 8303 /** */ 8304 extern(C) void function() GReserved4; 8305 /** */ 8306 extern(C) void function() GReserved5; 8307 } 8308 8309 struct GUnixFDListPrivate; 8310 8311 struct GUnixFDMessage 8312 { 8313 GSocketControlMessage parentInstance; 8314 GUnixFDMessagePrivate* priv; 8315 } 8316 8317 struct GUnixFDMessageClass 8318 { 8319 GSocketControlMessageClass parentClass; 8320 /** */ 8321 extern(C) void function() GReserved1; 8322 /** */ 8323 extern(C) void function() GReserved2; 8324 } 8325 8326 struct GUnixFDMessagePrivate; 8327 8328 struct GUnixInputStream 8329 { 8330 GInputStream parentInstance; 8331 GUnixInputStreamPrivate* priv; 8332 } 8333 8334 struct GUnixInputStreamClass 8335 { 8336 GInputStreamClass parentClass; 8337 /** */ 8338 extern(C) void function() GReserved1; 8339 /** */ 8340 extern(C) void function() GReserved2; 8341 /** */ 8342 extern(C) void function() GReserved3; 8343 /** */ 8344 extern(C) void function() GReserved4; 8345 /** */ 8346 extern(C) void function() GReserved5; 8347 } 8348 8349 struct GUnixInputStreamPrivate; 8350 8351 /** 8352 * Defines a Unix mount entry (e.g. <filename>/media/cdrom</filename>). 8353 * This corresponds roughly to a mtab entry. 8354 */ 8355 struct GUnixMountEntry; 8356 8357 struct GUnixMountMonitor; 8358 8359 struct GUnixMountMonitorClass; 8360 8361 struct GUnixMountPoint; 8362 8363 struct GUnixOutputStream 8364 { 8365 GOutputStream parentInstance; 8366 GUnixOutputStreamPrivate* priv; 8367 } 8368 8369 struct GUnixOutputStreamClass 8370 { 8371 GOutputStreamClass parentClass; 8372 /** */ 8373 extern(C) void function() GReserved1; 8374 /** */ 8375 extern(C) void function() GReserved2; 8376 /** */ 8377 extern(C) void function() GReserved3; 8378 /** */ 8379 extern(C) void function() GReserved4; 8380 /** */ 8381 extern(C) void function() GReserved5; 8382 } 8383 8384 struct GUnixOutputStreamPrivate; 8385 8386 struct GUnixSocketAddress 8387 { 8388 GSocketAddress parentInstance; 8389 GUnixSocketAddressPrivate* priv; 8390 } 8391 8392 struct GUnixSocketAddressClass 8393 { 8394 GSocketAddressClass parentClass; 8395 } 8396 8397 struct GUnixSocketAddressPrivate; 8398 8399 struct GVfs 8400 { 8401 GObject parentInstance; 8402 } 8403 8404 struct GVfsClass 8405 { 8406 GObjectClass parentClass; 8407 /** 8408 * 8409 * Params: 8410 * vfs = a #GVfs. 8411 * Return: %TRUE if construction of the @vfs was successful 8412 * and it is now active. 8413 */ 8414 extern(C) int function(GVfs* vfs) isActive; 8415 /** 8416 * 8417 * Params: 8418 * vfs = a #GVfs. 8419 * path = a string containing a VFS path. 8420 * Return: a #GFile. 8421 * Free the returned object with g_object_unref(). 8422 */ 8423 extern(C) GFile* function(GVfs* vfs, const(char)* path) getFileForPath; 8424 /** 8425 * 8426 * Params: 8427 * vfs = a#GVfs. 8428 * uri = a string containing a URI 8429 * Return: a #GFile. 8430 * Free the returned object with g_object_unref(). 8431 */ 8432 extern(C) GFile* function(GVfs* vfs, const(char)* uri) getFileForUri; 8433 /** 8434 * 8435 * Params: 8436 * vfs = a #GVfs. 8437 * Return: a %NULL-terminated array of strings. 8438 * The returned array belongs to GIO and must 8439 * not be freed or modified. 8440 */ 8441 extern(C) char** function(GVfs* vfs) getSupportedUriSchemes; 8442 /** 8443 * 8444 * Params: 8445 * vfs = a #GVfs. 8446 * parseName = a string to be parsed by the VFS module. 8447 * Return: a #GFile for the given @parse_name. 8448 * Free the returned object with g_object_unref(). 8449 */ 8450 extern(C) GFile* function(GVfs* vfs, const(char)* parseName) parseName; 8451 /** */ 8452 extern(C) void function(GVfs* vfs, const(char)* filename, ulong device, GFileAttributeMatcher* attributeMatcher, GFileInfo* info, GCancellable* cancellable, void** extraData, GDestroyNotify* freeExtraData) localFileAddInfo; 8453 /** */ 8454 extern(C) void function(GVfs* vfs, GFileAttributeInfoList* list) addWritableNamespaces; 8455 /** */ 8456 extern(C) int function(GVfs* vfs, const(char)* filename, GFileInfo* info, GFileQueryInfoFlags flags, GCancellable* cancellable, GError** err) localFileSetAttributes; 8457 /** */ 8458 extern(C) void function(GVfs* vfs, const(char)* filename) localFileRemoved; 8459 /** */ 8460 extern(C) void function(GVfs* vfs, const(char)* source, const(char)* dest) localFileMoved; 8461 /** */ 8462 extern(C) GIcon* function(GVfs* vfs, GVariant* value) deserializeIcon; 8463 /** */ 8464 extern(C) void function() GReserved1; 8465 /** */ 8466 extern(C) void function() GReserved2; 8467 /** */ 8468 extern(C) void function() GReserved3; 8469 /** */ 8470 extern(C) void function() GReserved4; 8471 /** */ 8472 extern(C) void function() GReserved5; 8473 /** */ 8474 extern(C) void function() GReserved6; 8475 } 8476 8477 struct GVolume; 8478 8479 /** 8480 * Interface for implementing operations for mountable volumes. 8481 */ 8482 struct GVolumeIface 8483 { 8484 /** 8485 * The parent interface. 8486 */ 8487 GTypeInterface gIface; 8488 /** */ 8489 extern(C) void function(GVolume* volume) changed; 8490 /** */ 8491 extern(C) void function(GVolume* volume) removed; 8492 /** 8493 * 8494 * Params: 8495 * volume = a #GVolume 8496 * Return: the name for the given @volume. The returned string should 8497 * be freed with g_free() when no longer needed. 8498 */ 8499 extern(C) char* function(GVolume* volume) getName; 8500 /** 8501 * 8502 * Params: 8503 * volume = a #GVolume 8504 * Return: a #GIcon. 8505 * The returned object should be unreffed with g_object_unref() 8506 * when no longer needed. 8507 */ 8508 extern(C) GIcon* function(GVolume* volume) getIcon; 8509 /** 8510 * 8511 * Params: 8512 * volume = a #GVolume 8513 * Return: the UUID for @volume or %NULL if no UUID can be computed. 8514 * The returned string should be freed with g_free() 8515 * when no longer needed. 8516 */ 8517 extern(C) char* function(GVolume* volume) getUuid; 8518 /** 8519 * 8520 * Params: 8521 * volume = a #GVolume 8522 * Return: a #GDrive or %NULL if @volume is not 8523 * associated with a drive. The returned object should be unreffed 8524 * with g_object_unref() when no longer needed. 8525 */ 8526 extern(C) GDrive* function(GVolume* volume) getDrive; 8527 /** 8528 * 8529 * Params: 8530 * volume = a #GVolume 8531 * Return: a #GMount or %NULL if @volume isn't mounted. 8532 * The returned object should be unreffed with g_object_unref() 8533 * when no longer needed. 8534 */ 8535 extern(C) GMount* function(GVolume* volume) getMount; 8536 /** 8537 * 8538 * Params: 8539 * volume = a #GVolume 8540 * Return: %TRUE if the @volume can be mounted. %FALSE otherwise 8541 */ 8542 extern(C) int function(GVolume* volume) canMount; 8543 /** 8544 * 8545 * Params: 8546 * volume = a #GVolume 8547 * Return: %TRUE if the @volume can be ejected. %FALSE otherwise 8548 */ 8549 extern(C) int function(GVolume* volume) canEject; 8550 /** */ 8551 extern(C) void function(GVolume* volume, GMountMountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) mountFn; 8552 /** 8553 * 8554 * Params: 8555 * volume = a #GVolume 8556 * result = a #GAsyncResult 8557 * Return: %TRUE, %FALSE if operation failed 8558 * 8559 * Throws: GException on failure. 8560 */ 8561 extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) mountFinish; 8562 /** */ 8563 extern(C) void function(GVolume* volume, GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) eject; 8564 /** 8565 * 8566 * Params: 8567 * volume = pointer to a #GVolume 8568 * result = a #GAsyncResult 8569 * Return: %TRUE, %FALSE if operation failed 8570 * 8571 * Throws: GException on failure. 8572 */ 8573 extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) ejectFinish; 8574 /** 8575 * 8576 * Params: 8577 * volume = a #GVolume 8578 * kind = the kind of identifier to return 8579 * Return: a newly allocated string containing the 8580 * requested identfier, or %NULL if the #GVolume 8581 * doesn't have this kind of identifier 8582 */ 8583 extern(C) char* function(GVolume* volume, const(char)* kind) getIdentifier; 8584 /** 8585 * 8586 * Params: 8587 * volume = a #GVolume 8588 * Return: a %NULL-terminated array 8589 * of strings containing kinds of identifiers. Use g_strfreev() to free. 8590 */ 8591 extern(C) char** function(GVolume* volume) enumerateIdentifiers; 8592 /** 8593 * 8594 * Params: 8595 * volume = a #GVolume 8596 * Return: %TRUE if the volume should be automatically mounted 8597 */ 8598 extern(C) int function(GVolume* volume) shouldAutomount; 8599 /** 8600 * 8601 * Params: 8602 * volume = a #GVolume 8603 * Return: the activation root of @volume 8604 * or %NULL. Use g_object_unref() to free. 8605 */ 8606 extern(C) GFile* function(GVolume* volume) getActivationRoot; 8607 /** */ 8608 extern(C) void function(GVolume* volume, GMountUnmountFlags flags, GMountOperation* mountOperation, GCancellable* cancellable, GAsyncReadyCallback callback, void* userData) ejectWithOperation; 8609 /** 8610 * 8611 * Params: 8612 * volume = a #GVolume 8613 * result = a #GAsyncResult 8614 * Return: %TRUE if the volume was successfully ejected. %FALSE otherwise 8615 * 8616 * Throws: GException on failure. 8617 */ 8618 extern(C) int function(GVolume* volume, GAsyncResult* result, GError** err) ejectWithOperationFinish; 8619 /** 8620 * 8621 * Params: 8622 * volume = a #GVolume 8623 * Return: Sorting key for @volume or %NULL if no such key is available 8624 */ 8625 extern(C) const(char)* function(GVolume* volume) getSortKey; 8626 /** 8627 * 8628 * Params: 8629 * volume = a #GVolume 8630 * Return: a #GIcon. 8631 * The returned object should be unreffed with g_object_unref() 8632 * when no longer needed. 8633 */ 8634 extern(C) GIcon* function(GVolume* volume) getSymbolicIcon; 8635 } 8636 8637 struct GVolumeMonitor 8638 { 8639 GObject parentInstance; 8640 void* priv; 8641 } 8642 8643 struct GVolumeMonitorClass 8644 { 8645 GObjectClass parentClass; 8646 /** */ 8647 extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeAdded; 8648 /** */ 8649 extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeRemoved; 8650 /** */ 8651 extern(C) void function(GVolumeMonitor* volumeMonitor, GVolume* volume) volumeChanged; 8652 /** */ 8653 extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountAdded; 8654 /** */ 8655 extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountRemoved; 8656 /** */ 8657 extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountPreUnmount; 8658 /** */ 8659 extern(C) void function(GVolumeMonitor* volumeMonitor, GMount* mount) mountChanged; 8660 /** */ 8661 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveConnected; 8662 /** */ 8663 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveDisconnected; 8664 /** */ 8665 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveChanged; 8666 /** */ 8667 extern(C) int function() isSupported; 8668 /** 8669 * 8670 * Params: 8671 * volumeMonitor = a #GVolumeMonitor. 8672 * Return: a #GList of connected #GDrive objects. 8673 */ 8674 extern(C) GList* function(GVolumeMonitor* volumeMonitor) getConnectedDrives; 8675 /** 8676 * 8677 * Params: 8678 * volumeMonitor = a #GVolumeMonitor. 8679 * Return: a #GList of #GVolume objects. 8680 */ 8681 extern(C) GList* function(GVolumeMonitor* volumeMonitor) getVolumes; 8682 /** 8683 * 8684 * Params: 8685 * volumeMonitor = a #GVolumeMonitor. 8686 * Return: a #GList of #GMount objects. 8687 */ 8688 extern(C) GList* function(GVolumeMonitor* volumeMonitor) getMounts; 8689 /** 8690 * 8691 * Params: 8692 * volumeMonitor = a #GVolumeMonitor. 8693 * uuid = the UUID to look for 8694 * Return: a #GVolume or %NULL if no such volume is available. 8695 * Free the returned object with g_object_unref(). 8696 */ 8697 extern(C) GVolume* function(GVolumeMonitor* volumeMonitor, const(char)* uuid) getVolumeForUuid; 8698 /** 8699 * 8700 * Params: 8701 * volumeMonitor = a #GVolumeMonitor. 8702 * uuid = the UUID to look for 8703 * Return: a #GMount or %NULL if no such mount is available. 8704 * Free the returned object with g_object_unref(). 8705 */ 8706 extern(C) GMount* function(GVolumeMonitor* volumeMonitor, const(char)* uuid) getMountForUuid; 8707 /** */ 8708 extern(C) GVolume* function(GMount* mount, GVolumeMonitor* volumeMonitor) adoptOrphanMount; 8709 /** */ 8710 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveEjectButton; 8711 /** */ 8712 extern(C) void function(GVolumeMonitor* volumeMonitor, GDrive* drive) driveStopButton; 8713 /** */ 8714 extern(C) void function() GReserved1; 8715 /** */ 8716 extern(C) void function() GReserved2; 8717 /** */ 8718 extern(C) void function() GReserved3; 8719 /** */ 8720 extern(C) void function() GReserved4; 8721 /** */ 8722 extern(C) void function() GReserved5; 8723 /** */ 8724 extern(C) void function() GReserved6; 8725 } 8726 8727 struct GZlibCompressor; 8728 8729 struct GZlibCompressorClass 8730 { 8731 GObjectClass parentClass; 8732 } 8733 8734 struct GZlibDecompressor; 8735 8736 struct GZlibDecompressorClass 8737 { 8738 GObjectClass parentClass; 8739 } 8740 8741 /** 8742 * Type definition for a function that will be called back when an asynchronous 8743 * operation within GIO has been completed. 8744 * 8745 * Params: 8746 * sourceObject = the object the asynchronous operation was started with. 8747 * res = a #GAsyncResult. 8748 * userData = user data passed to the callback. 8749 */ 8750 public alias extern(C) void function(GObject* sourceObject, GAsyncResult* res, void* userData) GAsyncReadyCallback; 8751 8752 /** 8753 * Invoked when a connection to a message bus has been obtained. 8754 * 8755 * Params: 8756 * connection = The #GDBusConnection to a message bus. 8757 * name = The name that is requested to be owned. 8758 * userData = User data passed to g_bus_own_name(). 8759 * 8760 * Since: 2.26 8761 */ 8762 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusAcquiredCallback; 8763 8764 /** 8765 * Invoked when the name is acquired. 8766 * 8767 * Params: 8768 * connection = The #GDBusConnection on which to acquired the name. 8769 * name = The name being owned. 8770 * userData = User data passed to g_bus_own_name() or g_bus_own_name_on_connection(). 8771 * 8772 * Since: 2.26 8773 */ 8774 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameAcquiredCallback; 8775 8776 /** 8777 * Invoked when the name being watched is known to have to have a owner. 8778 * 8779 * Params: 8780 * connection = The #GDBusConnection the name is being watched on. 8781 * name = The name being watched. 8782 * nameOwner = Unique name of the owner of the name being watched. 8783 * userData = User data passed to g_bus_watch_name(). 8784 * 8785 * Since: 2.26 8786 */ 8787 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, const(char)* nameOwner, void* userData) GBusNameAppearedCallback; 8788 8789 /** 8790 * Invoked when the name is lost or @connection has been closed. 8791 * 8792 * Params: 8793 * connection = The #GDBusConnection on which to acquire the name or %NULL if 8794 * the connection was disconnected. 8795 * name = The name being owned. 8796 * userData = User data passed to g_bus_own_name() or g_bus_own_name_on_connection(). 8797 * 8798 * Since: 2.26 8799 */ 8800 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameLostCallback; 8801 8802 /** 8803 * Invoked when the name being watched is known not to have to have a owner. 8804 * 8805 * This is also invoked when the #GDBusConection on which the watch was 8806 * established has been closed. In that case, @connection will be 8807 * %NULL. 8808 * 8809 * Params: 8810 * connection = The #GDBusConnection the name is being watched on, or 8811 * %NULL. 8812 * name = The name being watched. 8813 * userData = User data passed to g_bus_watch_name(). 8814 * 8815 * Since: 2.26 8816 */ 8817 public alias extern(C) void function(GDBusConnection* connection, const(char)* name, void* userData) GBusNameVanishedCallback; 8818 8819 /** 8820 * This is the function type of the callback used for the #GSource 8821 * returned by g_cancellable_source_new(). 8822 * 8823 * Params: 8824 * cancellable = the #GCancellable 8825 * userData = data passed in by the user. 8826 * 8827 * Return: it should return %FALSE if the source should be removed. 8828 * 8829 * Since: 2.28 8830 */ 8831 public alias extern(C) int function(GCancellable* cancellable, void* userData) GCancellableSourceFunc; 8832 8833 /** 8834 * The type of the @get_property function in #GDBusInterfaceVTable. 8835 * 8836 * Params: 8837 * connection = A #GDBusConnection. 8838 * sender = The unique bus name of the remote caller. 8839 * objectPath = The object path that the method was invoked on. 8840 * interfaceName = The D-Bus interface name for the property. 8841 * propertyName = The name of the property to get the value of. 8842 * error = Return location for error. 8843 * userData = The @user_data #gpointer passed to g_dbus_connection_register_object(). 8844 * 8845 * Return: A #GVariant with the value for @property_name or %NULL if 8846 * @error is set. If the returned #GVariant is floating, it is 8847 * consumed - otherwise its reference count is decreased by one. 8848 * 8849 * Since: 2.26 8850 */ 8851 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; 8852 8853 /** 8854 * The type of the @method_call function in #GDBusInterfaceVTable. 8855 * 8856 * Params: 8857 * connection = A #GDBusConnection. 8858 * sender = The unique bus name of the remote caller. 8859 * objectPath = The object path that the method was invoked on. 8860 * interfaceName = The D-Bus interface name the method was invoked on. 8861 * methodName = The name of the method that was invoked. 8862 * parameters = A #GVariant tuple with parameters. 8863 * invocation = A #GDBusMethodInvocation object that must be used to return a value or error. 8864 * userData = The @user_data #gpointer passed to g_dbus_connection_register_object(). 8865 * 8866 * Since: 2.26 8867 */ 8868 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; 8869 8870 /** 8871 * The type of the @set_property function in #GDBusInterfaceVTable. 8872 * 8873 * Params: 8874 * connection = A #GDBusConnection. 8875 * sender = The unique bus name of the remote caller. 8876 * objectPath = The object path that the method was invoked on. 8877 * interfaceName = The D-Bus interface name for the property. 8878 * propertyName = The name of the property to get the value of. 8879 * value = The value to set the property to. 8880 * error = Return location for error. 8881 * userData = The @user_data #gpointer passed to g_dbus_connection_register_object(). 8882 * 8883 * Return: %TRUE if the property was set to @value, %FALSE if @error is set. 8884 * 8885 * Since: 2.26 8886 */ 8887 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; 8888 8889 /** 8890 * Signature for function used in g_dbus_connection_add_filter(). 8891 * 8892 * A filter function is passed a #GDBusMessage and expected to return 8893 * a #GDBusMessage too. Passive filter functions that don't modify the 8894 * message can simply return the @message object: 8895 * |[ 8896 * static GDBusMessage * 8897 * passive_filter (GDBusConnection *connection 8898 * GDBusMessage *message, 8899 * gboolean incoming, 8900 * gpointer user_data) 8901 * { 8902 * /<!-- -->* inspect @message *<!-- -->/ 8903 * return message; 8904 * } 8905 * ]| 8906 * Filter functions that wants to drop a message can simply return %NULL: 8907 * |[ 8908 * static GDBusMessage * 8909 * drop_filter (GDBusConnection *connection 8910 * GDBusMessage *message, 8911 * gboolean incoming, 8912 * gpointer user_data) 8913 * { 8914 * if (should_drop_message) 8915 * { 8916 * g_object_unref (message); 8917 * message = NULL; 8918 * } 8919 * return message; 8920 * } 8921 * ]| 8922 * Finally, a filter function may modify a message by copying it: 8923 * |[ 8924 * static GDBusMessage * 8925 * modifying_filter (GDBusConnection *connection 8926 * GDBusMessage *message, 8927 * gboolean incoming, 8928 * gpointer user_data) 8929 * { 8930 * GDBusMessage *copy; 8931 * GError *error; 8932 * 8933 * error = NULL; 8934 * copy = g_dbus_message_copy (message, &error); 8935 * /<!-- -->* handle @error being is set *<!-- -->/ 8936 * g_object_unref (message); 8937 * 8938 * /<!-- -->* modify @copy *<!-- -->/ 8939 * 8940 * return copy; 8941 * } 8942 * ]| 8943 * If the returned #GDBusMessage is different from @message and cannot 8944 * be sent on @connection (it could use features, such as file 8945 * descriptors, not compatible with @connection), then a warning is 8946 * logged to <emphasis>standard error</emphasis>. Applications can 8947 * check this ahead of time using g_dbus_message_to_blob() passing a 8948 * #GDBusCapabilityFlags value obtained from @connection. 8949 * 8950 * Params: 8951 * connection = A #GDBusConnection. 8952 * message = A locked #GDBusMessage that the filter function takes ownership of. 8953 * incoming = %TRUE if it is a message received from the other peer, %FALSE if it is 8954 * a message to be sent to the other peer. 8955 * userData = User data passed when adding the filter. 8956 * 8957 * Return: A #GDBusMessage that will be freed with 8958 * g_object_unref() or %NULL to drop the message. Passive filter 8959 * functions can simply return the passed @message object. 8960 * 8961 * Since: 2.26 8962 */ 8963 public alias extern(C) GDBusMessage* function(GDBusConnection* connection, GDBusMessage* message, int incoming, void* userData) GDBusMessageFilterFunction; 8964 8965 /** 8966 * Function signature for a function used to determine the #GType to 8967 * use for an interface proxy (if @interface_name is not %NULL) or 8968 * object proxy (if @interface_name is %NULL). 8969 * 8970 * This function is called in the 8971 * [thread-default main loop][g-main-context-push-thread-default] 8972 * that @manager was constructed in. 8973 * 8974 * Params: 8975 * manager = A #GDBusObjectManagerClient. 8976 * objectPath = The object path of the remote object. 8977 * interfaceName = The interface name of the remote object or %NULL if a #GDBusObjectProxy #GType is requested. 8978 * userData = User data. 8979 * 8980 * Return: A #GType to use for the remote object. The returned type 8981 * must be a #GDBusProxy<!-- -->- or #GDBusObjectProxy<!-- -->-derived 8982 * type. 8983 * 8984 * Since: 2.30 8985 */ 8986 public alias extern(C) GType function(GDBusObjectManagerClient* manager, const(char)* objectPath, const(char)* interfaceName, void* userData) GDBusProxyTypeFunc; 8987 8988 /** 8989 * Signature for callback function used in g_dbus_connection_signal_subscribe(). 8990 * 8991 * Params: 8992 * connection = A #GDBusConnection. 8993 * senderName = The unique bus name of the sender of the signal. 8994 * objectPath = The object path that the signal was emitted on. 8995 * interfaceName = The name of the interface. 8996 * signalName = The name of the signal. 8997 * parameters = A #GVariant tuple with parameters for the signal. 8998 * userData = User data passed when subscribing to the signal. 8999 * 9000 * Since: 2.26 9001 */ 9002 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; 9003 9004 /** 9005 * The type of the @dispatch function in #GDBusSubtreeVTable. 9006 * 9007 * Subtrees are flat. @node, if non-%NULL, is always exactly one 9008 * segment of the object path (ie: it never contains a slash). 9009 * 9010 * Params: 9011 * connection = A #GDBusConnection. 9012 * sender = The unique bus name of the remote caller. 9013 * objectPath = The object path that was registered with g_dbus_connection_register_subtree(). 9014 * interfaceName = The D-Bus interface name that the method call or property access is for. 9015 * node = A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree. 9016 * outUserData = Return location for user data to pass to functions in the returned #GDBusInterfaceVTable (never %NULL). 9017 * userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree(). 9018 * 9019 * Return: A #GDBusInterfaceVTable or %NULL if you don't want to handle the methods. 9020 * 9021 * Since: 2.26 9022 */ 9023 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; 9024 9025 /** 9026 * The type of the @enumerate function in #GDBusSubtreeVTable. 9027 * 9028 * This function is called when generating introspection data and also 9029 * when preparing to dispatch incoming messages in the event that the 9030 * %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not 9031 * specified (ie: to verify that the object path is valid). 9032 * 9033 * Hierarchies are not supported; the items that you return should not 9034 * contain the '/' character. 9035 * 9036 * The return value will be freed with g_strfreev(). 9037 * 9038 * Params: 9039 * connection = A #GDBusConnection. 9040 * sender = The unique bus name of the remote caller. 9041 * objectPath = The object path that was registered with g_dbus_connection_register_subtree(). 9042 * userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree(). 9043 * 9044 * Return: A newly allocated array of strings for node names that are children of @object_path. 9045 * 9046 * Since: 2.26 9047 */ 9048 public alias extern(C) char** function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, void* userData) GDBusSubtreeEnumerateFunc; 9049 9050 /** 9051 * The type of the @introspect function in #GDBusSubtreeVTable. 9052 * 9053 * Subtrees are flat. @node, if non-%NULL, is always exactly one 9054 * segment of the object path (ie: it never contains a slash). 9055 * 9056 * This function should return %NULL to indicate that there is no object 9057 * at this node. 9058 * 9059 * If this function returns non-%NULL, the return value is expected to 9060 * be a %NULL-terminated array of pointers to #GDBusInterfaceInfo 9061 * structures describing the interfaces implemented by @node. This 9062 * array will have g_dbus_interface_info_unref() called on each item 9063 * before being freed with g_free(). 9064 * 9065 * The difference between returning %NULL and an array containing zero 9066 * items is that the standard DBus interfaces will returned to the 9067 * remote introspector in the empty array case, but not in the %NULL 9068 * case. 9069 * 9070 * Params: 9071 * connection = A #GDBusConnection. 9072 * sender = The unique bus name of the remote caller. 9073 * objectPath = The object path that was registered with g_dbus_connection_register_subtree(). 9074 * node = A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree. 9075 * userData = The @user_data #gpointer passed to g_dbus_connection_register_subtree(). 9076 * 9077 * Return: A %NULL-terminated array of pointers to #GDBusInterfaceInfo, or %NULL. 9078 * 9079 * Since: 2.26 9080 */ 9081 public alias extern(C) GDBusInterfaceInfo** function(GDBusConnection* connection, const(char)* sender, const(char)* objectPath, const(char)* node, void* userData) GDBusSubtreeIntrospectFunc; 9082 9083 /** 9084 * During invocation, g_desktop_app_info_launch_uris_as_manager() may 9085 * create one or more child processes. This callback is invoked once 9086 * for each, providing the process ID. 9087 * 9088 * Params: 9089 * appinfo = a #GDesktopAppInfo 9090 * pid = Process identifier 9091 * userData = User data 9092 */ 9093 public alias extern(C) void function(GDesktopAppInfo* appinfo, GPid pid, void* userData) GDesktopAppLaunchCallback; 9094 9095 /** 9096 * This callback type is used by g_file_measure_disk_usage() to make 9097 * periodic progress reports when measuring the amount of disk spaced 9098 * used by a directory. 9099 * 9100 * These calls are made on a best-effort basis and not all types of 9101 * #GFile will support them. At the minimum, however, one call will 9102 * always be made immediately. 9103 * 9104 * In the case that there is no support, @reporting will be set to 9105 * %FALSE (and the other values undefined) and no further calls will be 9106 * made. Otherwise, the @reporting will be %TRUE and the other values 9107 * all-zeros during the first (immediate) call. In this way, you can 9108 * know which type of progress UI to show without a delay. 9109 * 9110 * For g_file_measure_disk_usage() the callback is made directly. For 9111 * g_file_measure_disk_usage_async() the callback is made via the 9112 * default main context of the calling thread (ie: the same way that the 9113 * final async result would be reported). 9114 * 9115 * @current_size is in the same units as requested by the operation (see 9116 * %G_FILE_DISK_USAGE_APPARENT_SIZE). 9117 * 9118 * The frequency of the updates is implementation defined, but is 9119 * ideally about once every 200ms. 9120 * 9121 * The last progress callback may or may not be equal to the final 9122 * result. Always check the async result to get the final value. 9123 * 9124 * Params: 9125 * reporting = %TRUE if more reports will come 9126 * currentSize = the current cumulative size measurement 9127 * numDirs = the number of directories visited so far 9128 * numFiles = the number of non-directory files encountered 9129 * userData = the data passed to the original request for this callback 9130 * 9131 * Since: 2.38 9132 */ 9133 public alias extern(C) void function(int reporting, ulong currentSize, ulong numDirs, ulong numFiles, void* userData) GFileMeasureProgressCallback; 9134 9135 /** 9136 * When doing file operations that may take a while, such as moving 9137 * a file or copying a file, a progress callback is used to pass how 9138 * far along that operation is to the application. 9139 * 9140 * Params: 9141 * currentNumBytes = the current number of bytes in the operation. 9142 * totalNumBytes = the total number of bytes in the operation. 9143 * userData = user data passed to the callback. 9144 */ 9145 public alias extern(C) void function(long currentNumBytes, long totalNumBytes, void* userData) GFileProgressCallback; 9146 9147 /** 9148 * When loading the partial contents of a file with g_file_load_partial_contents_async(), 9149 * it may become necessary to determine if any more data from the file should be loaded. 9150 * A #GFileReadMoreCallback function facilitates this by returning %TRUE if more data 9151 * should be read, or %FALSE otherwise. 9152 * 9153 * Params: 9154 * fileContents = the data as currently read. 9155 * fileSize = the size of the data currently read. 9156 * callbackData = data passed to the callback. 9157 * 9158 * Return: %TRUE if more data should be read back. %FALSE otherwise. 9159 */ 9160 public alias extern(C) int function(const(char)* fileContents, long fileSize, void* callbackData) GFileReadMoreCallback; 9161 9162 /** 9163 * I/O Job function. 9164 * 9165 * Long-running jobs should periodically check the @cancellable 9166 * to see if they have been cancelled. 9167 * 9168 * Params: 9169 * job = a #GIOSchedulerJob. 9170 * cancellable = optional #GCancellable object, %NULL to ignore. 9171 * userData = the data to pass to callback function 9172 * 9173 * Return: %TRUE if this function should be called again to 9174 * complete the job, %FALSE if the job is complete (or cancelled) 9175 */ 9176 public alias extern(C) int function(GIOSchedulerJob* job, GCancellable* cancellable, void* userData) GIOSchedulerJobFunc; 9177 9178 /** 9179 * This is the function type of the callback used for the #GSource 9180 * returned by g_pollable_input_stream_create_source() and 9181 * g_pollable_output_stream_create_source(). 9182 * 9183 * Params: 9184 * pollableStream = the #GPollableInputStream or #GPollableOutputStream 9185 * userData = data passed in by the user. 9186 * 9187 * Return: it should return %FALSE if the source should be removed. 9188 * 9189 * Since: 2.28 9190 */ 9191 public alias extern(C) int function(GObject* pollableStream, void* userData) GPollableSourceFunc; 9192 9193 /** 9194 * Changes the size of the memory block pointed to by @data to 9195 * @size bytes. 9196 * 9197 * The function should have the same semantics as realloc(). 9198 * 9199 * Params: 9200 * data = memory block to reallocate 9201 * size = size to reallocate @data to 9202 * 9203 * Return: a pointer to the reallocated memory 9204 */ 9205 public alias extern(C) void* function(void* data, size_t size) GReallocFunc; 9206 9207 /** 9208 * The type for the function that is used to convert from #GSettings to 9209 * an object property. The @value is already initialized to hold values 9210 * of the appropriate type. 9211 * 9212 * Params: 9213 * value = return location for the property value 9214 * variant = the #GVariant 9215 * userData = user data that was specified when the binding was created 9216 * 9217 * Return: %TRUE if the conversion succeeded, %FALSE in case of an error 9218 */ 9219 public alias extern(C) int function(GValue* value, GVariant* variant, void* userData) GSettingsBindGetMapping; 9220 9221 /** 9222 * The type for the function that is used to convert an object property 9223 * value to a #GVariant for storing it in #GSettings. 9224 * 9225 * Params: 9226 * value = a #GValue containing the property value to map 9227 * expectedType = the #GVariantType to create 9228 * userData = user data that was specified when the binding was created 9229 * 9230 * Return: a new #GVariant holding the data from @value, 9231 * or %NULL in case of an error 9232 */ 9233 public alias extern(C) GVariant* function(GValue* value, GVariantType* expectedType, void* userData) GSettingsBindSetMapping; 9234 9235 /** 9236 * The type of the function that is used to convert from a value stored 9237 * in a #GSettings to a value that is useful to the application. 9238 * 9239 * If the value is successfully mapped, the result should be stored at 9240 * @result and %TRUE returned. If mapping fails (for example, if @value 9241 * is not in the right format) then %FALSE should be returned. 9242 * 9243 * If @value is %NULL then it means that the mapping function is being 9244 * given a "last chance" to successfully return a valid value. %TRUE 9245 * must be returned in this case. 9246 * 9247 * Params: 9248 * value = the #GVariant to map, or %NULL 9249 * result = the result of the mapping 9250 * userData = the user data that was passed to 9251 * g_settings_get_mapped() 9252 * 9253 * Return: %TRUE if the conversion succeeded, %FALSE in case of an error 9254 */ 9255 public alias extern(C) int function(GVariant* value, void** result, void* userData) GSettingsGetMapping; 9256 9257 /** 9258 * Simple thread function that runs an asynchronous operation and 9259 * checks for cancellation. 9260 * 9261 * Params: 9262 * res = a #GSimpleAsyncResult. 9263 * object = a #GObject. 9264 * cancellable = optional #GCancellable object, %NULL to ignore. 9265 */ 9266 public alias extern(C) void function(GSimpleAsyncResult* res, GObject* object, GCancellable* cancellable) GSimpleAsyncThreadFunc; 9267 9268 /** 9269 * This is the function type of the callback used for the #GSource 9270 * returned by g_socket_create_source(). 9271 * 9272 * Params: 9273 * socket = the #GSocket 9274 * condition = the current condition at the source fired. 9275 * userData = data passed in by the user. 9276 * 9277 * Return: it should return %FALSE if the source should be removed. 9278 * 9279 * Since: 2.22 9280 */ 9281 public alias extern(C) int function(GSocket* socket, GIOCondition condition, void* userData) GSocketSourceFunc; 9282 9283 /** 9284 * The prototype for a task function to be run in a thread via 9285 * g_task_run_in_thread() or g_task_run_in_thread_sync(). 9286 * 9287 * If the return-on-cancel flag is set on @task, and @cancellable gets 9288 * cancelled, then the #GTask will be completed immediately (as though 9289 * g_task_return_error_if_cancelled() had been called), without 9290 * waiting for the task function to complete. However, the task 9291 * function will continue running in its thread in the background. The 9292 * function therefore needs to be careful about how it uses 9293 * externally-visible state in this case. See 9294 * g_task_set_return_on_cancel() for more details. 9295 * 9296 * Other than in that case, @task will be completed when the 9297 * #GTaskThreadFunc returns, not when it calls a 9298 * `g_task_return_` function. 9299 * 9300 * Params: 9301 * task = the #GTask 9302 * sourceObject = @task's source object 9303 * taskData = @task's task data 9304 * cancellable = @task's #GCancellable, or %NULL 9305 * 9306 * Since: 2.36 9307 */ 9308 public alias extern(C) void function(GTask* task, void* sourceObject, void* taskData, GCancellable* cancellable) GTaskThreadFunc;