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