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