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