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